From 0f4d81e0917c51257d4d746c607f806913376356 Mon Sep 17 00:00:00 2001
From: Sumit Kalra <44450797+sumit-kalra@users.noreply.github.com>
Date: Tue, 24 Sep 2019 09:34:19 -0700
Subject: [PATCH 001/155] Adding config to specify allowed inbound IP addresses
 and CIDR blocks (#1)

* Adding config to specify allowed inbound IP addresses

* Also allowing CIDR blocks in addition to IP addresses
---
 builder/azure/arm/config.go                |  29 +++++-
 builder/azure/arm/config_test.go           | 102 +++++++++++++++++++++
 website/source/docs/builders/azure.html.md |   5 +
 3 files changed, 131 insertions(+), 5 deletions(-)

diff --git a/builder/azure/arm/config.go b/builder/azure/arm/config.go
index 5e9b8905c..aafd1bca4 100644
--- a/builder/azure/arm/config.go
+++ b/builder/azure/arm/config.go
@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"math/big"
+	"net"
 	"regexp"
 	"strings"
 	"time"
@@ -129,11 +130,12 @@ type Config struct {
 	TempResourceGroupName             string             `mapstructure:"temp_resource_group_name"`
 	BuildResourceGroupName            string             `mapstructure:"build_resource_group_name"`
 	storageAccountBlobEndpoint        string
-	PrivateVirtualNetworkWithPublicIp bool   `mapstructure:"private_virtual_network_with_public_ip"`
-	VirtualNetworkName                string `mapstructure:"virtual_network_name"`
-	VirtualNetworkSubnetName          string `mapstructure:"virtual_network_subnet_name"`
-	VirtualNetworkResourceGroupName   string `mapstructure:"virtual_network_resource_group_name"`
-	CustomDataFile                    string `mapstructure:"custom_data_file"`
+	PrivateVirtualNetworkWithPublicIp bool     `mapstructure:"private_virtual_network_with_public_ip"`
+	VirtualNetworkName                string   `mapstructure:"virtual_network_name"`
+	VirtualNetworkSubnetName          string   `mapstructure:"virtual_network_subnet_name"`
+	VirtualNetworkResourceGroupName   string   `mapstructure:"virtual_network_resource_group_name"`
+	AllowedInboundIpAddresses         []string `mapstructure:"allowed_inbound_ip_addresses"`
+	CustomDataFile                    string   `mapstructure:"custom_data_file"`
 	customData                        string
 	PlanInfo                          PlanInformation `mapstructure:"plan_info"`
 
@@ -673,6 +675,12 @@ func assertRequiredParametersSet(c *Config, errs *packer.MultiError) {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("If virtual_network_subnet_name is specified, so must virtual_network_name"))
 	}
 
+	if c.AllowedInboundIpAddresses != nil && len(c.AllowedInboundIpAddresses) >= 1 {
+		if ok, err := assertAllowedInboundIpAddresses(c.AllowedInboundIpAddresses, "allowed_inbound_ip_addresses"); !ok {
+			errs = packer.MultiErrorAppend(errs, err)
+		}
+	}
+
 	/////////////////////////////////////////////
 	// Plan Info
 	if c.PlanInfo.PlanName != "" || c.PlanInfo.PlanProduct != "" || c.PlanInfo.PlanPublisher != "" || c.PlanInfo.PlanPromotionCode != "" {
@@ -744,6 +752,17 @@ func assertManagedImageDataDiskSnapshotName(name, setting string) (bool, error)
 	return true, nil
 }
 
+func assertAllowedInboundIpAddresses(ipAddresses []string, setting string) (bool, error) {
+	for _, ipAddress := range ipAddresses {
+		if net.ParseIP(ipAddress) == nil {
+			if _, _, err := net.ParseCIDR(ipAddress); err != nil {
+				return false, fmt.Errorf("The setting %s must only contain valid IP addresses or CIDR blocks", setting)
+			}
+		}
+	}
+	return true, nil
+}
+
 func assertResourceGroupName(rgn, setting string) (bool, error) {
 	if !isValidAzureName(reResourceGroupName, rgn) {
 		return false, fmt.Errorf("The setting %s must match the regular expression %q, and not end with a '-' or '.'.", setting, validResourceGroupNameRe)
diff --git a/builder/azure/arm/config_test.go b/builder/azure/arm/config_test.go
index ef5c9fb93..9175c3d26 100644
--- a/builder/azure/arm/config_test.go
+++ b/builder/azure/arm/config_test.go
@@ -270,6 +270,108 @@ func TestConfigVirtualNetworkSubnetNameMustBeSetWithVirtualNetworkName(t *testin
 	}
 }
 
+func TestConfigAllowedInboundIpAddressesIsOptional(t *testing.T) {
+	config := map[string]string{
+		"capture_name_prefix":    "ignore",
+		"capture_container_name": "ignore",
+		"location":               "ignore",
+		"image_url":              "ignore",
+		"storage_account":        "ignore",
+		"resource_group_name":    "ignore",
+		"subscription_id":        "ignore",
+		"os_type":                constants.Target_Linux,
+		"communicator":           "none",
+		"virtual_network_name":   "MyVirtualNetwork",
+	}
+
+	c, _, err := newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.AllowedInboundIpAddresses != nil {
+		t.Errorf("Expected Config to set allowed_inbound_ip_addresses to nil, but got %v", c.AllowedInboundIpAddresses)
+	}
+}
+
+func TestConfigShouldAcceptCorrectInboundIpAddresses(t *testing.T) {
+	ipValue0 := "127.0.0.1"
+	ipValue1 := "127.0.0.2"
+	cidrValue2 := "192.168.100.0/24"
+	cidrValue3 := "10.10.1.16/32"
+	config := map[string]interface{}{
+		"capture_name_prefix":    "ignore",
+		"capture_container_name": "ignore",
+		"location":               "ignore",
+		"image_url":              "ignore",
+		"storage_account":        "ignore",
+		"resource_group_name":    "ignore",
+		"subscription_id":        "ignore",
+		"os_type":                constants.Target_Linux,
+		"communicator":           "none",
+		"virtual_network_name":   "MyVirtualNetwork",
+	}
+
+	config["allowed_inbound_ip_addresses"] = ipValue0
+	c, _, err := newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.AllowedInboundIpAddresses == nil || len(c.AllowedInboundIpAddresses) != 1 ||
+		c.AllowedInboundIpAddresses[0] != ipValue0 {
+		t.Errorf("Expected 'allowed_inbound_ip_addresses' to have one element (%s), but got '%v'.", ipValue0, c.AllowedInboundIpAddresses)
+	}
+
+	config["allowed_inbound_ip_addresses"] = cidrValue2
+	c, _, err = newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.AllowedInboundIpAddresses == nil || len(c.AllowedInboundIpAddresses) != 1 ||
+		c.AllowedInboundIpAddresses[0] != cidrValue2 {
+		t.Errorf("Expected 'allowed_inbound_ip_addresses' to have one element (%s), but got '%v'.", cidrValue2, c.AllowedInboundIpAddresses)
+	}
+
+	config["allowed_inbound_ip_addresses"] = []string{ipValue0, cidrValue2, ipValue1, cidrValue3}
+	c, _, err = newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.AllowedInboundIpAddresses == nil || len(c.AllowedInboundIpAddresses) != 4 ||
+		c.AllowedInboundIpAddresses[0] != ipValue0 || c.AllowedInboundIpAddresses[1] != cidrValue2 ||
+		c.AllowedInboundIpAddresses[2] != ipValue1 || c.AllowedInboundIpAddresses[3] != cidrValue3 {
+		t.Errorf("Expected 'allowed_inbound_ip_addresses' to have four elements (%s %s %s %s), but got '%v'.", ipValue0, cidrValue2, ipValue1,
+			cidrValue3, c.AllowedInboundIpAddresses)
+	}
+}
+
+func TestConfigShouldRejectIncorrectInboundIpAddresses(t *testing.T) {
+	config := map[string]interface{}{
+		"capture_name_prefix":    "ignore",
+		"capture_container_name": "ignore",
+		"location":               "ignore",
+		"image_url":              "ignore",
+		"storage_account":        "ignore",
+		"resource_group_name":    "ignore",
+		"subscription_id":        "ignore",
+		"os_type":                constants.Target_Linux,
+		"communicator":           "none",
+		"virtual_network_name":   "MyVirtualNetwork",
+	}
+
+	config["allowed_inbound_ip_addresses"] = []string{"127.0.0.1", "127.0.0.two"}
+	c, _, err := newConfig(config, getPackerConfiguration())
+	if err == nil {
+		t.Errorf("Expected configuration creation to fail, but it succeeded with the malformed allowed_inbound_ip_addresses set to %v", c.AllowedInboundIpAddresses)
+	}
+
+	config["allowed_inbound_ip_addresses"] = []string{"192.168.100.1000/24", "10.10.1.16/32"}
+	c, _, err = newConfig(config, getPackerConfiguration())
+	if err == nil {
+		// 192.168.100.1000/24 is invalid
+		t.Errorf("Expected configuration creation to fail, but it succeeded with the malformed allowed_inbound_ip_addresses set to %v", c.AllowedInboundIpAddresses)
+	}
+}
+
 func TestConfigShouldDefaultToPublicCloud(t *testing.T) {
 	c, _, _ := newConfig(getArmBuilderConfiguration(), getPackerConfiguration())
 
diff --git a/website/source/docs/builders/azure.html.md b/website/source/docs/builders/azure.html.md
index aa741d675..37c62eda1 100644
--- a/website/source/docs/builders/azure.html.md
+++ b/website/source/docs/builders/azure.html.md
@@ -336,6 +336,11 @@ Providing `temp_resource_group_name` or `location` in combination with
     containing the virtual network. If the resource group cannot be found, or
     it cannot be disambiguated, this value should be set.
 
+-   `allowed_inbound_ip_addresses` (array of strings) list of IP addresses and
+    CIDR blocks that should be allowed access to the VM. If provided, an Azure
+    Network Security Group will be created with corresponding rules and be bound 
+    to the NIC attached to the VM. 
+
 -   `virtual_network_subnet_name` (string) If virtual\_network\_name is set,
     this value **may** also be set. If virtual\_network\_name is set, and this
     value is not set the builder attempts to determine the subnet to use with

From 45840ffc3fd8be633f4a8eed3e7ba4a1f568f0a1 Mon Sep 17 00:00:00 2001
From: Sumit Kalra <44450797+sumit-kalra@users.noreply.github.com>
Date: Thu, 26 Sep 2019 15:35:55 -0700
Subject: [PATCH 002/155] Ensuring that specifying allowed inbound IP and VNet
 are mutually exclusive (#2)

---
 builder/azure/arm/config.go                |  8 +++++--
 builder/azure/arm/config_test.go           | 28 ++++++++++++++++++++--
 website/source/docs/builders/azure.html.md |  3 +++
 3 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/builder/azure/arm/config.go b/builder/azure/arm/config.go
index aafd1bca4..9e7234e09 100644
--- a/builder/azure/arm/config.go
+++ b/builder/azure/arm/config.go
@@ -676,8 +676,12 @@ func assertRequiredParametersSet(c *Config, errs *packer.MultiError) {
 	}
 
 	if c.AllowedInboundIpAddresses != nil && len(c.AllowedInboundIpAddresses) >= 1 {
-		if ok, err := assertAllowedInboundIpAddresses(c.AllowedInboundIpAddresses, "allowed_inbound_ip_addresses"); !ok {
-			errs = packer.MultiErrorAppend(errs, err)
+		if c.VirtualNetworkName != "" {
+			errs = packer.MultiErrorAppend(errs, fmt.Errorf("If virtual_network_name is specified, allowed_inbound_ip_addresses cannot be specified"))
+		} else {
+			if ok, err := assertAllowedInboundIpAddresses(c.AllowedInboundIpAddresses, "allowed_inbound_ip_addresses"); !ok {
+				errs = packer.MultiErrorAppend(errs, err)
+			}
 		}
 	}
 
diff --git a/builder/azure/arm/config_test.go b/builder/azure/arm/config_test.go
index 9175c3d26..a3617dc19 100644
--- a/builder/azure/arm/config_test.go
+++ b/builder/azure/arm/config_test.go
@@ -308,7 +308,6 @@ func TestConfigShouldAcceptCorrectInboundIpAddresses(t *testing.T) {
 		"subscription_id":        "ignore",
 		"os_type":                constants.Target_Linux,
 		"communicator":           "none",
-		"virtual_network_name":   "MyVirtualNetwork",
 	}
 
 	config["allowed_inbound_ip_addresses"] = ipValue0
@@ -355,7 +354,6 @@ func TestConfigShouldRejectIncorrectInboundIpAddresses(t *testing.T) {
 		"subscription_id":        "ignore",
 		"os_type":                constants.Target_Linux,
 		"communicator":           "none",
-		"virtual_network_name":   "MyVirtualNetwork",
 	}
 
 	config["allowed_inbound_ip_addresses"] = []string{"127.0.0.1", "127.0.0.two"}
@@ -372,6 +370,32 @@ func TestConfigShouldRejectIncorrectInboundIpAddresses(t *testing.T) {
 	}
 }
 
+func TestConfigShouldRejectInboundIpAddressesWithVirtualNetwork(t *testing.T) {
+	config := map[string]interface{}{
+		"capture_name_prefix":          "ignore",
+		"capture_container_name":       "ignore",
+		"location":                     "ignore",
+		"image_url":                    "ignore",
+		"storage_account":              "ignore",
+		"resource_group_name":          "ignore",
+		"subscription_id":              "ignore",
+		"os_type":                      constants.Target_Linux,
+		"communicator":                 "none",
+		"allowed_inbound_ip_addresses": "127.0.0.1",
+	}
+
+	_, _, err := newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	config["virtual_network_name"] = "some_vnet_name"
+	_, _, err = newConfig(config, getPackerConfiguration())
+	if err == nil {
+		t.Errorf("Expected configuration creation to fail, but it succeeded with allowed_inbound_ip_addresses and virtual_network_name both specified")
+	}
+}
+
 func TestConfigShouldDefaultToPublicCloud(t *testing.T) {
 	c, _, _ := newConfig(getArmBuilderConfiguration(), getPackerConfiguration())
 
diff --git a/website/source/docs/builders/azure.html.md b/website/source/docs/builders/azure.html.md
index 37c62eda1..6b6c09218 100644
--- a/website/source/docs/builders/azure.html.md
+++ b/website/source/docs/builders/azure.html.md
@@ -341,6 +341,9 @@ Providing `temp_resource_group_name` or `location` in combination with
     Network Security Group will be created with corresponding rules and be bound 
     to the NIC attached to the VM. 
 
+    Providing `allowed_inbound_ip_addresses` in combination with
+    `virtual_network_name` is not allowed.
+
 -   `virtual_network_subnet_name` (string) If virtual\_network\_name is set,
     this value **may** also be set. If virtual\_network\_name is set, and this
     value is not set the builder attempts to determine the subnet to use with

From 132779c343676568778c56de6b4438664e55ab16 Mon Sep 17 00:00:00 2001
From: Sumit Kalra <44450797+sumit-kalra@users.noreply.github.com>
Date: Tue, 24 Sep 2019 09:34:19 -0700
Subject: [PATCH 003/155] Adding config to specify allowed inbound IP addresses
 and CIDR blocks (#1)

* Adding config to specify allowed inbound IP addresses

* Also allowing CIDR blocks in addition to IP addresses
---
 builder/azure/arm/config.go      |  23 +++++++
 builder/azure/arm/config_test.go | 102 +++++++++++++++++++++++++++++++
 2 files changed, 125 insertions(+)

diff --git a/builder/azure/arm/config.go b/builder/azure/arm/config.go
index 7243bd2a8..6744287cc 100644
--- a/builder/azure/arm/config.go
+++ b/builder/azure/arm/config.go
@@ -12,6 +12,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"math/big"
+	"net"
 	"regexp"
 	"strings"
 	"time"
@@ -342,6 +343,11 @@ type Config struct {
 	// are None, ReadOnly, and ReadWrite. The default value is ReadWrite.
 	DiskCachingType string `mapstructure:"disk_caching_type" required:"false"`
 	diskCachingType compute.CachingTypes
+	// Specify the list of IP addresses and CIDR blocks that should be
+	// allowed access to the VM. If provided, an Azure Network Security
+	// Group will be created with corresponding rules and be bound to
+	// the NIC attached to the VM.
+	AllowedInboundIpAddresses         []string `mapstructure:"allowed_inbound_ip_addresses"`
 
 	// Runtime Values
 	UserName               string
@@ -872,6 +878,12 @@ func assertRequiredParametersSet(c *Config, errs *packer.MultiError) {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("If virtual_network_subnet_name is specified, so must virtual_network_name"))
 	}
 
+	if c.AllowedInboundIpAddresses != nil && len(c.AllowedInboundIpAddresses) >= 1 {
+		if ok, err := assertAllowedInboundIpAddresses(c.AllowedInboundIpAddresses, "allowed_inbound_ip_addresses"); !ok {
+			errs = packer.MultiErrorAppend(errs, err)
+		}
+	}
+
 	/////////////////////////////////////////////
 	// Plan Info
 	if c.PlanInfo.PlanName != "" || c.PlanInfo.PlanProduct != "" || c.PlanInfo.PlanPublisher != "" || c.PlanInfo.PlanPromotionCode != "" {
@@ -943,6 +955,17 @@ func assertManagedImageDataDiskSnapshotName(name, setting string) (bool, error)
 	return true, nil
 }
 
+func assertAllowedInboundIpAddresses(ipAddresses []string, setting string) (bool, error) {
+	for _, ipAddress := range ipAddresses {
+		if net.ParseIP(ipAddress) == nil {
+			if _, _, err := net.ParseCIDR(ipAddress); err != nil {
+				return false, fmt.Errorf("The setting %s must only contain valid IP addresses or CIDR blocks", setting)
+			}
+		}
+	}
+	return true, nil
+}
+
 func assertResourceGroupName(rgn, setting string) (bool, error) {
 	if !isValidAzureName(reResourceGroupName, rgn) {
 		return false, fmt.Errorf("The setting %s must match the regular expression %q, and not end with a '-' or '.'.", setting, validResourceGroupNameRe)
diff --git a/builder/azure/arm/config_test.go b/builder/azure/arm/config_test.go
index 9ed25fffa..ce446b246 100644
--- a/builder/azure/arm/config_test.go
+++ b/builder/azure/arm/config_test.go
@@ -270,6 +270,108 @@ func TestConfigVirtualNetworkSubnetNameMustBeSetWithVirtualNetworkName(t *testin
 	}
 }
 
+func TestConfigAllowedInboundIpAddressesIsOptional(t *testing.T) {
+	config := map[string]string{
+		"capture_name_prefix":    "ignore",
+		"capture_container_name": "ignore",
+		"location":               "ignore",
+		"image_url":              "ignore",
+		"storage_account":        "ignore",
+		"resource_group_name":    "ignore",
+		"subscription_id":        "ignore",
+		"os_type":                constants.Target_Linux,
+		"communicator":           "none",
+		"virtual_network_name":   "MyVirtualNetwork",
+	}
+
+	c, _, err := newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.AllowedInboundIpAddresses != nil {
+		t.Errorf("Expected Config to set allowed_inbound_ip_addresses to nil, but got %v", c.AllowedInboundIpAddresses)
+	}
+}
+
+func TestConfigShouldAcceptCorrectInboundIpAddresses(t *testing.T) {
+	ipValue0 := "127.0.0.1"
+	ipValue1 := "127.0.0.2"
+	cidrValue2 := "192.168.100.0/24"
+	cidrValue3 := "10.10.1.16/32"
+	config := map[string]interface{}{
+		"capture_name_prefix":    "ignore",
+		"capture_container_name": "ignore",
+		"location":               "ignore",
+		"image_url":              "ignore",
+		"storage_account":        "ignore",
+		"resource_group_name":    "ignore",
+		"subscription_id":        "ignore",
+		"os_type":                constants.Target_Linux,
+		"communicator":           "none",
+		"virtual_network_name":   "MyVirtualNetwork",
+	}
+
+	config["allowed_inbound_ip_addresses"] = ipValue0
+	c, _, err := newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.AllowedInboundIpAddresses == nil || len(c.AllowedInboundIpAddresses) != 1 ||
+		c.AllowedInboundIpAddresses[0] != ipValue0 {
+		t.Errorf("Expected 'allowed_inbound_ip_addresses' to have one element (%s), but got '%v'.", ipValue0, c.AllowedInboundIpAddresses)
+	}
+
+	config["allowed_inbound_ip_addresses"] = cidrValue2
+	c, _, err = newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.AllowedInboundIpAddresses == nil || len(c.AllowedInboundIpAddresses) != 1 ||
+		c.AllowedInboundIpAddresses[0] != cidrValue2 {
+		t.Errorf("Expected 'allowed_inbound_ip_addresses' to have one element (%s), but got '%v'.", cidrValue2, c.AllowedInboundIpAddresses)
+	}
+
+	config["allowed_inbound_ip_addresses"] = []string{ipValue0, cidrValue2, ipValue1, cidrValue3}
+	c, _, err = newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.AllowedInboundIpAddresses == nil || len(c.AllowedInboundIpAddresses) != 4 ||
+		c.AllowedInboundIpAddresses[0] != ipValue0 || c.AllowedInboundIpAddresses[1] != cidrValue2 ||
+		c.AllowedInboundIpAddresses[2] != ipValue1 || c.AllowedInboundIpAddresses[3] != cidrValue3 {
+		t.Errorf("Expected 'allowed_inbound_ip_addresses' to have four elements (%s %s %s %s), but got '%v'.", ipValue0, cidrValue2, ipValue1,
+			cidrValue3, c.AllowedInboundIpAddresses)
+	}
+}
+
+func TestConfigShouldRejectIncorrectInboundIpAddresses(t *testing.T) {
+	config := map[string]interface{}{
+		"capture_name_prefix":    "ignore",
+		"capture_container_name": "ignore",
+		"location":               "ignore",
+		"image_url":              "ignore",
+		"storage_account":        "ignore",
+		"resource_group_name":    "ignore",
+		"subscription_id":        "ignore",
+		"os_type":                constants.Target_Linux,
+		"communicator":           "none",
+		"virtual_network_name":   "MyVirtualNetwork",
+	}
+
+	config["allowed_inbound_ip_addresses"] = []string{"127.0.0.1", "127.0.0.two"}
+	c, _, err := newConfig(config, getPackerConfiguration())
+	if err == nil {
+		t.Errorf("Expected configuration creation to fail, but it succeeded with the malformed allowed_inbound_ip_addresses set to %v", c.AllowedInboundIpAddresses)
+	}
+
+	config["allowed_inbound_ip_addresses"] = []string{"192.168.100.1000/24", "10.10.1.16/32"}
+	c, _, err = newConfig(config, getPackerConfiguration())
+	if err == nil {
+		// 192.168.100.1000/24 is invalid
+		t.Errorf("Expected configuration creation to fail, but it succeeded with the malformed allowed_inbound_ip_addresses set to %v", c.AllowedInboundIpAddresses)
+	}
+}
+
 func TestConfigShouldDefaultToPublicCloud(t *testing.T) {
 	c, _, _ := newConfig(getArmBuilderConfiguration(), getPackerConfiguration())
 

From 91d19adcd7ea9eb1c154ea514301740060bc7e83 Mon Sep 17 00:00:00 2001
From: Sumit Kalra <44450797+sumit-kalra@users.noreply.github.com>
Date: Thu, 26 Sep 2019 15:35:55 -0700
Subject: [PATCH 004/155] Ensuring that specifying allowed inbound IP and VNet
 are mutually exclusive (#2)

---
 builder/azure/arm/config.go      |  8 ++++++--
 builder/azure/arm/config_test.go | 28 ++++++++++++++++++++++++++--
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/builder/azure/arm/config.go b/builder/azure/arm/config.go
index 6744287cc..eef7599a0 100644
--- a/builder/azure/arm/config.go
+++ b/builder/azure/arm/config.go
@@ -879,8 +879,12 @@ func assertRequiredParametersSet(c *Config, errs *packer.MultiError) {
 	}
 
 	if c.AllowedInboundIpAddresses != nil && len(c.AllowedInboundIpAddresses) >= 1 {
-		if ok, err := assertAllowedInboundIpAddresses(c.AllowedInboundIpAddresses, "allowed_inbound_ip_addresses"); !ok {
-			errs = packer.MultiErrorAppend(errs, err)
+		if c.VirtualNetworkName != "" {
+			errs = packer.MultiErrorAppend(errs, fmt.Errorf("If virtual_network_name is specified, allowed_inbound_ip_addresses cannot be specified"))
+		} else {
+			if ok, err := assertAllowedInboundIpAddresses(c.AllowedInboundIpAddresses, "allowed_inbound_ip_addresses"); !ok {
+				errs = packer.MultiErrorAppend(errs, err)
+			}
 		}
 	}
 
diff --git a/builder/azure/arm/config_test.go b/builder/azure/arm/config_test.go
index ce446b246..d90e31f44 100644
--- a/builder/azure/arm/config_test.go
+++ b/builder/azure/arm/config_test.go
@@ -308,7 +308,6 @@ func TestConfigShouldAcceptCorrectInboundIpAddresses(t *testing.T) {
 		"subscription_id":        "ignore",
 		"os_type":                constants.Target_Linux,
 		"communicator":           "none",
-		"virtual_network_name":   "MyVirtualNetwork",
 	}
 
 	config["allowed_inbound_ip_addresses"] = ipValue0
@@ -355,7 +354,6 @@ func TestConfigShouldRejectIncorrectInboundIpAddresses(t *testing.T) {
 		"subscription_id":        "ignore",
 		"os_type":                constants.Target_Linux,
 		"communicator":           "none",
-		"virtual_network_name":   "MyVirtualNetwork",
 	}
 
 	config["allowed_inbound_ip_addresses"] = []string{"127.0.0.1", "127.0.0.two"}
@@ -372,6 +370,32 @@ func TestConfigShouldRejectIncorrectInboundIpAddresses(t *testing.T) {
 	}
 }
 
+func TestConfigShouldRejectInboundIpAddressesWithVirtualNetwork(t *testing.T) {
+	config := map[string]interface{}{
+		"capture_name_prefix":          "ignore",
+		"capture_container_name":       "ignore",
+		"location":                     "ignore",
+		"image_url":                    "ignore",
+		"storage_account":              "ignore",
+		"resource_group_name":          "ignore",
+		"subscription_id":              "ignore",
+		"os_type":                      constants.Target_Linux,
+		"communicator":                 "none",
+		"allowed_inbound_ip_addresses": "127.0.0.1",
+	}
+
+	_, _, err := newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	config["virtual_network_name"] = "some_vnet_name"
+	_, _, err = newConfig(config, getPackerConfiguration())
+	if err == nil {
+		t.Errorf("Expected configuration creation to fail, but it succeeded with allowed_inbound_ip_addresses and virtual_network_name both specified")
+	}
+}
+
 func TestConfigShouldDefaultToPublicCloud(t *testing.T) {
 	c, _, _ := newConfig(getArmBuilderConfiguration(), getPackerConfiguration())
 

From 70b2d300e6fae83cda07ce845f9c43f3542c9edb Mon Sep 17 00:00:00 2001
From: Robert Neumayer <neumayer@protonmail.com>
Date: Fri, 27 Sep 2019 14:49:37 +0200
Subject: [PATCH 005/155] Support defined tags for oci builder

---
 builder/oracle/oci/config.go                    |  6 +++++-
 builder/oracle/oci/config_test.go               |  3 +++
 builder/oracle/oci/driver_oci.go                |  1 +
 website/source/docs/builders/oracle-oci.html.md | 13 +++++++++++++
 4 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/builder/oracle/oci/config.go b/builder/oracle/oci/config.go
index d83fa6c15..e0681d8e9 100644
--- a/builder/oracle/oci/config.go
+++ b/builder/oracle/oci/config.go
@@ -63,7 +63,8 @@ type Config struct {
 	SubnetID string `mapstructure:"subnet_ocid"`
 
 	// Tagging
-	Tags map[string]string `mapstructure:"tags"`
+	Tags        map[string]string                 `mapstructure:"tags"`
+	DefinedTags map[string]map[string]interface{} `mapstructure:"defined_tags"`
 
 	ctx interpolate.Context
 }
@@ -207,6 +208,9 @@ func NewConfig(raws ...interface{}) (*Config, error) {
 		}
 	}
 
+	//if c.DefinedTags != nil {
+	//	}
+
 	if c.ImageName == "" {
 		name, err := interpolate.Render("packer-{{timestamp}}", nil)
 		if err != nil {
diff --git a/builder/oracle/oci/config_test.go b/builder/oracle/oci/config_test.go
index a5b67d384..7084df61a 100644
--- a/builder/oracle/oci/config_test.go
+++ b/builder/oracle/oci/config_test.go
@@ -32,6 +32,9 @@ func testConfig(accessConfFile *os.File) map[string]interface{} {
 		"metadata": map[string]string{
 			"key": "value",
 		},
+		"defined_tags": map[string]map[string]interface{}{
+			"namespace": {"key": "value"},
+		},
 	}
 }
 
diff --git a/builder/oracle/oci/driver_oci.go b/builder/oracle/oci/driver_oci.go
index db0f2fbc1..3f02aaab0 100644
--- a/builder/oracle/oci/driver_oci.go
+++ b/builder/oracle/oci/driver_oci.go
@@ -81,6 +81,7 @@ func (d *driverOCI) CreateImage(ctx context.Context, id string) (core.Image, err
 		InstanceId:    &id,
 		DisplayName:   &d.cfg.ImageName,
 		FreeformTags:  d.cfg.Tags,
+		DefinedTags:   d.cfg.DefinedTags,
 	}})
 
 	if err != nil {
diff --git a/website/source/docs/builders/oracle-oci.html.md b/website/source/docs/builders/oracle-oci.html.md
index dad452dcc..c931167d4 100644
--- a/website/source/docs/builders/oracle-oci.html.md
+++ b/website/source/docs/builders/oracle-oci.html.md
@@ -161,6 +161,19 @@ builder.
   "tag2": "value2"
 ```
 
+-   `defined_tags` (map of map of strings) - Add one or more defined tags for a given namespace to the resulting
+    custom image. See [the Oracle
+    docs](https://docs.cloud.oracle.com/iaas/Content/Identity/Concepts/taggingoverview.htm)
+    for more details. Example:
+
+``` {.yaml}
+"tags":
+  "namespace": {
+    "tag1": "value1",
+    "tag2": "value2"
+  }
+```
+
 ## Basic Example
 
 Here is a basic example. Note that account specific configuration has been

From 7dd579f6301c3322c0f3201c2b1dafd8415540e9 Mon Sep 17 00:00:00 2001
From: Robert Neumayer <neumayer@protonmail.com>
Date: Mon, 30 Sep 2019 12:17:47 +0200
Subject: [PATCH 006/155] Remove commented code

---
 builder/oracle/oci/config.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/builder/oracle/oci/config.go b/builder/oracle/oci/config.go
index e0681d8e9..014b9d207 100644
--- a/builder/oracle/oci/config.go
+++ b/builder/oracle/oci/config.go
@@ -208,9 +208,6 @@ func NewConfig(raws ...interface{}) (*Config, error) {
 		}
 	}
 
-	//if c.DefinedTags != nil {
-	//	}
-
 	if c.ImageName == "" {
 		name, err := interpolate.Render("packer-{{timestamp}}", nil)
 		if err != nil {

From 23c320d59e503df08adca4df26aff69681578934 Mon Sep 17 00:00:00 2001
From: larohra <larohra@microsoft.com>
Date: Mon, 30 Sep 2019 16:17:22 -0700
Subject: [PATCH 007/155] Increased the default polling duration to 60mins

---
 builder/azure/arm/azure_client.go | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/builder/azure/arm/azure_client.go b/builder/azure/arm/azure_client.go
index ab4330e37..130eba2a0 100644
--- a/builder/azure/arm/azure_client.go
+++ b/builder/azure/arm/azure_client.go
@@ -139,72 +139,84 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.DeploymentsClient.RequestInspector = withInspection(maxlen)
 	azureClient.DeploymentsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.DeploymentsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.DeploymentsClient.UserAgent)
+	azureClient.DeploymentsClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.DeploymentOperationsClient = resources.NewDeploymentOperationsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.DeploymentOperationsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.DeploymentOperationsClient.RequestInspector = withInspection(maxlen)
 	azureClient.DeploymentOperationsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.DeploymentOperationsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.DeploymentOperationsClient.UserAgent)
+	azureClient.DeploymentOperationsClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.DisksClient = compute.NewDisksClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.DisksClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.DisksClient.RequestInspector = withInspection(maxlen)
 	azureClient.DisksClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.DisksClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.DisksClient.UserAgent)
+	azureClient.DisksClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.GroupsClient = resources.NewGroupsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.GroupsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.GroupsClient.RequestInspector = withInspection(maxlen)
 	azureClient.GroupsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.GroupsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.GroupsClient.UserAgent)
+	azureClient.GroupsClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.ImagesClient = compute.NewImagesClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.ImagesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.ImagesClient.RequestInspector = withInspection(maxlen)
 	azureClient.ImagesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.ImagesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.ImagesClient.UserAgent)
+	azureClient.ImagesClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.InterfacesClient = network.NewInterfacesClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.InterfacesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.InterfacesClient.RequestInspector = withInspection(maxlen)
 	azureClient.InterfacesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.InterfacesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.InterfacesClient.UserAgent)
+	azureClient.InterfacesClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.SubnetsClient = network.NewSubnetsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.SubnetsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.SubnetsClient.RequestInspector = withInspection(maxlen)
 	azureClient.SubnetsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.SubnetsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.SubnetsClient.UserAgent)
+	azureClient.SubnetsClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.VirtualNetworksClient = network.NewVirtualNetworksClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.VirtualNetworksClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.VirtualNetworksClient.RequestInspector = withInspection(maxlen)
 	azureClient.VirtualNetworksClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.VirtualNetworksClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VirtualNetworksClient.UserAgent)
+	azureClient.VirtualNetworksClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.PublicIPAddressesClient = network.NewPublicIPAddressesClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.PublicIPAddressesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.PublicIPAddressesClient.RequestInspector = withInspection(maxlen)
 	azureClient.PublicIPAddressesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.PublicIPAddressesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.PublicIPAddressesClient.UserAgent)
+	azureClient.PublicIPAddressesClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.VirtualMachinesClient = compute.NewVirtualMachinesClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.VirtualMachinesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.VirtualMachinesClient.RequestInspector = withInspection(maxlen)
 	azureClient.VirtualMachinesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), templateCapture(azureClient), errorCapture(azureClient))
 	azureClient.VirtualMachinesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VirtualMachinesClient.UserAgent)
+	azureClient.VirtualMachinesClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.SnapshotsClient = compute.NewSnapshotsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.SnapshotsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.SnapshotsClient.RequestInspector = withInspection(maxlen)
 	azureClient.SnapshotsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.SnapshotsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.SnapshotsClient.UserAgent)
+	azureClient.SnapshotsClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.AccountsClient = armStorage.NewAccountsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.AccountsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.AccountsClient.RequestInspector = withInspection(maxlen)
 	azureClient.AccountsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.AccountsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.AccountsClient.UserAgent)
+	azureClient.AccountsClient.Client.PollingDuration = SharedGalleryTimeout
 
 	azureClient.GalleryImageVersionsClient = newCompute.NewGalleryImageVersionsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.GalleryImageVersionsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
@@ -218,6 +230,7 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.GalleryImagesClient.RequestInspector = withInspection(maxlen)
 	azureClient.GalleryImagesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.GalleryImagesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.GalleryImagesClient.UserAgent)
+	azureClient.GalleryImageVersionsClient.Client.PollingDuration = SharedGalleryTimeout
 
 	keyVaultURL, err := url.Parse(cloud.KeyVaultEndpoint)
 	if err != nil {
@@ -229,6 +242,7 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.VaultClient.RequestInspector = withInspection(maxlen)
 	azureClient.VaultClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.VaultClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VaultClient.UserAgent)
+	azureClient.VaultClient.Client.PollingDuration = SharedGalleryTimeout
 
 	// TODO(boumenot) - SDK still does not have a full KeyVault client.
 	// There are two ways that KeyVault has to be accessed, and each one has their own SPN.  An authenticated SPN
@@ -243,6 +257,7 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.VaultClientDelete.RequestInspector = withInspection(maxlen)
 	azureClient.VaultClientDelete.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.VaultClientDelete.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VaultClientDelete.UserAgent)
+	azureClient.VaultClientDelete.Client.PollingDuration = SharedGalleryTimeout
 
 	// If this is a managed disk build, this should be ignored.
 	if resourceGroupName != "" && storageAccountName != "" {

From 859e2524593deab2fb4fb33a31559d24fdff0548 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Tue, 1 Oct 2019 11:49:29 -0700
Subject: [PATCH 008/155] update to version 1.5.0-dev

---
 version/version.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/version/version.go b/version/version.go
index 7500feda8..9755bac10 100644
--- a/version/version.go
+++ b/version/version.go
@@ -9,12 +9,12 @@ import (
 var GitCommit string
 
 // The main version number that is being run at the moment.
-const Version = "1.4.4"
+const Version = "1.5.0"
 
 // A pre-release marker for the version. If this is "" (empty string)
 // then it means that it is a final release. Otherwise, this is a pre-release
 // such as "dev" (in development), "beta", "rc1", etc.
-const VersionPrerelease = ""
+const VersionPrerelease = "dev"
 
 func FormattedVersion() string {
 	var versionString bytes.Buffer

From 1ecfa032ba0e0e320f279a79394b6118c775dfb7 Mon Sep 17 00:00:00 2001
From: Kevin Faulkner <kondor6c@lazytree.us>
Date: Sun, 21 Apr 2019 20:35:45 -0400
Subject: [PATCH 009/155] Qemu builder disk size as a string

---
 builder/qemu/builder.go                       | 10 ++++------
 builder/qemu/builder_test.go                  | 10 +++++-----
 builder/qemu/step_create_disk.go              |  2 +-
 builder/qemu/step_resize_disk.go              |  3 +--
 website/source/docs/builders/qemu.html.md.erb |  2 +-
 5 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/builder/qemu/builder.go b/builder/qemu/builder.go
index a277e1d45..0ee680f56 100644
--- a/builder/qemu/builder.go
+++ b/builder/qemu/builder.go
@@ -148,7 +148,7 @@ type Config struct {
 	DiskInterface string `mapstructure:"disk_interface" required:"false"`
 	// The size, in megabytes, of the hard disk to create
 	// for the VM. By default, this is 40960 (40 GB).
-	DiskSize uint `mapstructure:"disk_size" required:"false"`
+	DiskSize string `mapstructure:"disk_size" required:"false"`
 	// The cache mode to use for disk. Allowed values include any of
 	// `writethrough`, `writeback`, `none`, `unsafe` or `directsync`. By
 	// default, this is set to `writeback`.
@@ -316,7 +316,6 @@ type Config struct {
 	// "BUILDNAME" is the name of the build. Currently, no file extension will be
 	// used unless it is specified in this option.
 	VMName string `mapstructure:"vm_name" required:"false"`
-
 	// These are deprecated, but we keep them around for BC
 	// TODO(@mitchellh): remove
 	SSHWaitTimeout time.Duration `mapstructure:"ssh_wait_timeout" required:"false"`
@@ -344,11 +343,10 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 
 	var errs *packer.MultiError
 	warnings := make([]string, 0)
-
 	errs = packer.MultiErrorAppend(errs, b.config.ShutdownConfig.Prepare(&b.config.ctx)...)
 
-	if b.config.DiskSize == 0 {
-		b.config.DiskSize = 40960
+	if b.config.DiskSize == "" || b.config.DiskSize == "0" {
+		b.config.DiskSize = "40960M"
 	}
 
 	if b.config.DiskCache == "" {
@@ -700,7 +698,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		artifact.state["diskPaths"] = diskpaths
 	}
 	artifact.state["diskType"] = b.config.Format
-	artifact.state["diskSize"] = uint64(b.config.DiskSize)
+	artifact.state["diskSize"] = b.config.DiskSize
 	artifact.state["domainType"] = b.config.Accelerator
 
 	return artifact, nil
diff --git a/builder/qemu/builder_test.go b/builder/qemu/builder_test.go
index 122caa754..15f3db8b3 100644
--- a/builder/qemu/builder_test.go
+++ b/builder/qemu/builder_test.go
@@ -169,11 +169,11 @@ func TestBuilderPrepare_DiskSize(t *testing.T) {
 		t.Fatalf("bad err: %s", err)
 	}
 
-	if b.config.DiskSize != 40960 {
-		t.Fatalf("bad size: %d", b.config.DiskSize)
+	if b.config.DiskSize != "40960M" {
+		t.Fatalf("bad size: %s", b.config.DiskSize)
 	}
 
-	config["disk_size"] = 60000
+	config["disk_size"] = "60000M"
 	b = Builder{}
 	warns, err = b.Prepare(config)
 	if len(warns) > 0 {
@@ -183,8 +183,8 @@ func TestBuilderPrepare_DiskSize(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.DiskSize != 60000 {
-		t.Fatalf("bad size: %d", b.config.DiskSize)
+	if b.config.DiskSize != "60000M" {
+		t.Fatalf("bad size: %s", b.config.DiskSize)
 	}
 }
 
diff --git a/builder/qemu/step_create_disk.go b/builder/qemu/step_create_disk.go
index 8fb18d025..12041565c 100644
--- a/builder/qemu/step_create_disk.go
+++ b/builder/qemu/step_create_disk.go
@@ -29,7 +29,7 @@ func (s *stepCreateDisk) Run(ctx context.Context, state multistep.StateBag) mult
 	ui.Say("Creating required virtual machine disks")
 	// The 'main' or 'default' disk
 	diskFullPaths = append(diskFullPaths, filepath.Join(config.OutputDir, name))
-	diskSizes = append(diskSizes, fmt.Sprintf("%dM", uint64(config.DiskSize)))
+	diskSizes = append(diskSizes, fmt.Sprintf("%s", config.DiskSize))
 	// Additional disks
 	if len(config.AdditionalDiskSize) > 0 {
 		for i, diskSize := range config.AdditionalDiskSize {
diff --git a/builder/qemu/step_resize_disk.go b/builder/qemu/step_resize_disk.go
index d25ffaff4..f9dd5693e 100644
--- a/builder/qemu/step_resize_disk.go
+++ b/builder/qemu/step_resize_disk.go
@@ -23,9 +23,8 @@ func (s *stepResizeDisk) Run(ctx context.Context, state multistep.StateBag) mult
 		"resize",
 		"-f", config.Format,
 		path,
-		fmt.Sprintf("%vM", config.DiskSize),
+		fmt.Sprintf("%s", config.DiskSize),
 	}
-
 	if config.DiskImage == false {
 		return multistep.ActionContinue
 	}
diff --git a/website/source/docs/builders/qemu.html.md.erb b/website/source/docs/builders/qemu.html.md.erb
index 78cf5f013..2e7db1dfc 100644
--- a/website/source/docs/builders/qemu.html.md.erb
+++ b/website/source/docs/builders/qemu.html.md.erb
@@ -37,7 +37,7 @@ to files, URLS for ISOs and checksums.
       "iso_checksum_type": "md5",
       "output_directory": "output_centos_tdhtest",
       "shutdown_command": "echo 'packer' | sudo -S shutdown -P now",
-      "disk_size": 5000,
+      "disk_size": "5000M",
       "format": "qcow2",
       "accelerator": "kvm",
       "http_directory": "path/to/httpdir",

From 19a9d7149f2c902e0ae3e6b1681438224ebd9999 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Tue, 1 Oct 2019 13:36:55 -0700
Subject: [PATCH 010/155] fix structs and regenerate partials

---
 builder/qemu/builder.go                                     | 6 ++++--
 .../partials/builder/qemu/_Config-not-required.html.md      | 6 ++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/builder/qemu/builder.go b/builder/qemu/builder.go
index 0ee680f56..10c821b7e 100644
--- a/builder/qemu/builder.go
+++ b/builder/qemu/builder.go
@@ -146,8 +146,10 @@ type Config struct {
 	// one of the other listed interfaces. Using the `scsi` interface under
 	// these circumstances will cause the build to fail.
 	DiskInterface string `mapstructure:"disk_interface" required:"false"`
-	// The size, in megabytes, of the hard disk to create
-	// for the VM. By default, this is 40960 (40 GB).
+	// The size in bytes, suffixes of the first letter of common byte types
+	// like "k" or "K", "M" for megabytes, G for gigabytes, T for terabytes.
+	// Will create the of the hard disk of the VM. By default, this is
+	// `40960M` (40 GB).
 	DiskSize string `mapstructure:"disk_size" required:"false"`
 	// The cache mode to use for disk. Allowed values include any of
 	// `writethrough`, `writeback`, `none`, `unsafe` or `directsync`. By
diff --git a/website/source/partials/builder/qemu/_Config-not-required.html.md b/website/source/partials/builder/qemu/_Config-not-required.html.md
index 07ac4256a..723c53276 100644
--- a/website/source/partials/builder/qemu/_Config-not-required.html.md
+++ b/website/source/partials/builder/qemu/_Config-not-required.html.md
@@ -47,8 +47,10 @@
     one of the other listed interfaces. Using the `scsi` interface under
     these circumstances will cause the build to fail.
     
--   `disk_size` (uint) - The size, in megabytes, of the hard disk to create
-    for the VM. By default, this is 40960 (40 GB).
+-   `disk_size` (string) - The size in bytes, suffixes of the first letter of common byte types
+    like "k" or "K", "M" for megabytes, G for gigabytes, T for terabytes.
+    Will create the of the hard disk of the VM. By default, this is
+    `40960M` (40 GB).
     
 -   `disk_cache` (string) - The cache mode to use for disk. Allowed values include any of
     `writethrough`, `writeback`, `none`, `unsafe` or `directsync`. By

From 4a3a011310c196c4740ebd9db950c2560c01e54e Mon Sep 17 00:00:00 2001
From: Lars Lehtonen <lars.lehtonen@gmail.com>
Date: Tue, 1 Oct 2019 15:54:28 -0700
Subject: [PATCH 011/155] builder/virtualbox/vm: fix dropped error

---
 builder/virtualbox/vm/step_set_snapshot.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/builder/virtualbox/vm/step_set_snapshot.go b/builder/virtualbox/vm/step_set_snapshot.go
index 515d9b2a0..401bacf15 100644
--- a/builder/virtualbox/vm/step_set_snapshot.go
+++ b/builder/virtualbox/vm/step_set_snapshot.go
@@ -71,6 +71,12 @@ func (s *StepSetSnapshot) Cleanup(state multistep.StateBag) {
 		} else {
 			ui.Say(fmt.Sprintf("Reverting to snapshot %s on virtual machine %s", s.revertToSnapshot, s.Name))
 			snapshotTree, err := driver.LoadSnapshots(s.Name)
+			if err != nil {
+				err := fmt.Errorf("error loading virtual machine %s snapshots: %v", s.Name, err)
+				state.Put("error", err)
+				ui.Error(err.Error())
+				return
+			}
 			revertTo := snapshotTree.GetSnapshotByUUID(s.revertToSnapshot)
 			if nil == revertTo {
 				err := fmt.Errorf("Snapshot with UUID %s not found for VM %s", s.revertToSnapshot, s.Name)

From ae1bb856a31d0e0846b4dce3db38850831470e90 Mon Sep 17 00:00:00 2001
From: Andrew Starr-Bochicchio <a.starr.b@gmail.com>
Date: Tue, 1 Oct 2019 21:14:15 -0400
Subject: [PATCH 012/155] digitalocean-import: Fix panic when 'image_regions'
 not set (Fixes: #7843).

---
 post-processor/digitalocean-import/post-processor.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/post-processor/digitalocean-import/post-processor.go b/post-processor/digitalocean-import/post-processor.go
index e20ea2380..80e1d13a8 100644
--- a/post-processor/digitalocean-import/post-processor.go
+++ b/post-processor/digitalocean-import/post-processor.go
@@ -119,7 +119,6 @@ func (p *PostProcessor) Configure(raws ...interface{}) error {
 		"spaces_region": &p.config.SpacesRegion,
 		"space_name":    &p.config.SpaceName,
 		"image_name":    &p.config.Name,
-		"image_regions": &p.config.ImageRegions[0],
 	}
 	for key, ptr := range requiredArgs {
 		if *ptr == "" {
@@ -128,6 +127,11 @@ func (p *PostProcessor) Configure(raws ...interface{}) error {
 		}
 	}
 
+	if len(p.config.ImageRegions) == 0 {
+		errs = packer.MultiErrorAppend(
+			errs, fmt.Errorf("image_regions must be set"))
+	}
+
 	if len(errs.Errors) > 0 {
 		return errs
 	}

From 7e6f58f69999492ebf34215e970409d4db8e967d Mon Sep 17 00:00:00 2001
From: Marek Winkler <mwinkler@redhat.com>
Date: Tue, 1 Oct 2019 15:04:49 +0200
Subject: [PATCH 013/155] builder/openstack: fix issue 5575 - support shutdown
 by Sysprep

---
 builder/openstack/step_stop_server.go | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/builder/openstack/step_stop_server.go b/builder/openstack/step_stop_server.go
index 9b3deb0ec..9e6f35b74 100644
--- a/builder/openstack/step_stop_server.go
+++ b/builder/openstack/step_stop_server.go
@@ -3,7 +3,9 @@ package openstack
 import (
 	"context"
 	"fmt"
+	"log"
 
+	"github.com/gophercloud/gophercloud"
 	"github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/startstop"
 	"github.com/gophercloud/gophercloud/openstack/compute/v2/servers"
 	"github.com/hashicorp/packer/helper/multistep"
@@ -27,9 +29,15 @@ func (s *StepStopServer) Run(ctx context.Context, state multistep.StateBag) mult
 
 	ui.Say(fmt.Sprintf("Stopping server: %s ...", server.ID))
 	if err := startstop.Stop(client, server.ID).ExtractErr(); err != nil {
-		err = fmt.Errorf("Error stopping server: %s", err)
-		state.Put("error", err)
-		return multistep.ActionHalt
+		if _, ok := err.(gophercloud.ErrDefault409); ok {
+			// The server might have already been shut down by Windows Sysprep
+			log.Printf("[WARN] 409 on stopping an already stopped server, continuing")
+			return multistep.ActionContinue
+		} else {
+			err = fmt.Errorf("Error stopping server: %s", err)
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
 	}
 
 	ui.Message(fmt.Sprintf("Waiting for server to stop: %s ...", server.ID))
@@ -45,7 +53,6 @@ func (s *StepStopServer) Run(ctx context.Context, state multistep.StateBag) mult
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
-
 	return multistep.ActionContinue
 }
 

From 0bd256326fb5aebf98c98682c13ba0a4d16a1c16 Mon Sep 17 00:00:00 2001
From: Marek Winkler <mwinkler@redhat.com>
Date: Wed, 2 Oct 2019 22:16:18 +0200
Subject: [PATCH 014/155] builder/openstack: Fix interface conversion panic
 when attempting to find a volume when not using volumes

---
 builder/openstack/step_create_image.go | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/builder/openstack/step_create_image.go b/builder/openstack/step_create_image.go
index 1b8b02b9e..d70527c31 100644
--- a/builder/openstack/step_create_image.go
+++ b/builder/openstack/step_create_image.go
@@ -92,16 +92,18 @@ func (s *stepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
 		return multistep.ActionHalt
 	}
 
-	volume := state.Get("volume_id").(string)
-	if len(config.ImageMetadata) > 0 && s.UseBlockStorageVolume {
-		err = volumeactions.SetImageMetadata(blockStorageClient, volume, volumeactions.ImageMetadataOpts{
-			Metadata: config.ImageMetadata,
-		}).ExtractErr()
-		if err != nil {
-			err := fmt.Errorf("Error setting image metadata: %s", err)
-			state.Put("error", err)
-			ui.Error(err.Error())
-			return multistep.ActionHalt
+	if s.UseBlockStorageVolume {
+		volume := state.Get("volume_id").(string)
+		if len(config.ImageMetadata) > 0 {
+			err = volumeactions.SetImageMetadata(blockStorageClient, volume, volumeactions.ImageMetadataOpts{
+				Metadata: config.ImageMetadata,
+			}).ExtractErr()
+			if err != nil {
+				err := fmt.Errorf("Error setting image metadata: %s", err)
+				state.Put("error", err)
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			}
 		}
 	}
 

From e16fb19bfc5e0a098a7d5dc7f9bcbc1fd3e51dd3 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Wed, 2 Oct 2019 14:06:30 -0700
Subject: [PATCH 015/155] don't abort on a single error if another availability
 zone was able to create the instance

---
 .../amazon/common/step_run_spot_instance.go   | 21 ++++++++++++-------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/builder/amazon/common/step_run_spot_instance.go b/builder/amazon/common/step_run_spot_instance.go
index ab15bdff3..d8b1118cd 100644
--- a/builder/amazon/common/step_run_spot_instance.go
+++ b/builder/amazon/common/step_run_spot_instance.go
@@ -274,15 +274,20 @@ func (s *StepRunSpotInstance) Run(ctx context.Context, state multistep.StateBag)
 		return multistep.ActionHalt
 	}
 
-	if len(createOutput.Errors) > 0 {
-		errString := fmt.Sprintf("Error waiting for fleet request (%s) to become ready:", *createOutput.FleetId)
-		for _, outErr := range createOutput.Errors {
-			errString = errString + fmt.Sprintf("%s", *outErr.ErrorMessage)
+	if len(createOutput.Instances) == 0 {
+		// We can end up with errors because one of the allowed availability
+		// zones doesn't have one of the allowed instance types; as long as
+		// an instance is launched, these errors aren't important.
+		if len(createOutput.Errors) > 0 {
+			errString := fmt.Sprintf("Error waiting for fleet request (%s) to become ready:", *createOutput.FleetId)
+			for _, outErr := range createOutput.Errors {
+				errString = errString + fmt.Sprintf("%s", *outErr.ErrorMessage)
+			}
+			err = fmt.Errorf(errString)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
 		}
-		err = fmt.Errorf(errString)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
 	}
 
 	instanceId = *createOutput.Instances[0].InstanceIds[0]

From 9d17a7f1368f3e7cc86e8d26aeb520c4bebd6d28 Mon Sep 17 00:00:00 2001
From: Ash Jindal <ajorpheus@users.noreply.github.com>
Date: Thu, 3 Oct 2019 11:36:10 +0100
Subject: [PATCH 016/155] Fixed CPE in description of `file` builder

The description seems to be a CPE from the `null` builder.
---
 website/source/docs/builders/file.html.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/website/source/docs/builders/file.html.md b/website/source/docs/builders/file.html.md
index 7a84fc3f3..8dc0a36b7 100644
--- a/website/source/docs/builders/file.html.md
+++ b/website/source/docs/builders/file.html.md
@@ -18,8 +18,8 @@ wait times.
 
 ## Basic Example
 
-Below is a fully functioning example. It doesn't do anything useful, since no
-provisioners are defined, but it will connect to the specified host via ssh.
+Below is a fully functioning example. It create a file at `target` with the
+specified `content`.
 
 ``` json
 {

From 0fcc4688f1115af87741721fa90d9bd21116bb22 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Thu, 3 Oct 2019 17:49:30 +0200
Subject: [PATCH 017/155] default labels per ISSUE_TEMPLATE type

---
 .github/ISSUE_TEMPLATE/bug_report.md       | 2 +-
 .github/ISSUE_TEMPLATE/feature_requests.md | 2 +-
 .github/ISSUE_TEMPLATE/question.md         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 611a2c421..e73c0e177 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,7 +1,7 @@
 ---
 name: Bug Report
 about: You're experiencing an issue with Packer that is different than the documented behavior.
-
+labels: bug
 ---
 
 When filing a bug, please include the following headings if possible. Any
diff --git a/.github/ISSUE_TEMPLATE/feature_requests.md b/.github/ISSUE_TEMPLATE/feature_requests.md
index ff2a6fb3d..a9a2cdeba 100644
--- a/.github/ISSUE_TEMPLATE/feature_requests.md
+++ b/.github/ISSUE_TEMPLATE/feature_requests.md
@@ -1,7 +1,7 @@
 ---
 name: Feature Request
 about: If you have something you think Packer could improve or add support for.
-
+labels: enhancement
 ---
 
 Please search the existing issues for relevant feature requests, and use the
diff --git a/.github/ISSUE_TEMPLATE/question.md b/.github/ISSUE_TEMPLATE/question.md
index 79537bfad..09ebbe85d 100644
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.github/ISSUE_TEMPLATE/question.md
@@ -1,7 +1,7 @@
 ---
 name: Question
 about: If you have a question, please check out our other community resources instead of opening an issue.
-
+labels: question
 ---
 
 Issues on GitHub are intended to be related to bugs or feature requests, so we

From 3951267963c9539600ecca669ae158eaea3d7fc6 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Thu, 3 Oct 2019 17:59:25 +0200
Subject: [PATCH 018/155] Create ssh_or_winrm_times_out.md

---
 .../ISSUE_TEMPLATE/ssh_or_winrm_times_out.md  | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 .github/ISSUE_TEMPLATE/ssh_or_winrm_times_out.md

diff --git a/.github/ISSUE_TEMPLATE/ssh_or_winrm_times_out.md b/.github/ISSUE_TEMPLATE/ssh_or_winrm_times_out.md
new file mode 100644
index 000000000..8fdc88b0b
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/ssh_or_winrm_times_out.md
@@ -0,0 +1,24 @@
+---
+name: SSH or WinRM times out
+about: I have a waiting SSH or WinRM error.
+labels: communicator-question
+---
+
+Got one of the following errors ? See if the related guides can help.
+
+* `Waiting for WinRM to become available` ?
+
+  - See our basic WinRm Packer guide: https://www.packer.io/guides/automatic-operating-system-installs/autounattend_windows.html
+
+* `Waiting for SSH to become available` ?
+
+  - See our basic SSH Packer guide: https://www.packer.io/guides/automatic-operating-system-installs/preseed_ubuntu.html
+
+
+Issues on GitHub are intended to be related to bugs or feature requests, so we recommend using our other community resources instead of asking here if you have a question.
+
+- Packer Guides: https://www.packer.io/guides/index.html
+- Discussion List: https://groups.google.com/group/packer-tool
+- Any other questions can be sent to the packer section of the HashiCorp
+  forum: https://discuss.hashicorp.com/c/packer
+- Packer community links: https://www.packer.io/community.html

From ccf58f0c98e754a7e761c70a13cded318b8a3a0e Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Tue, 1 Oct 2019 08:59:48 -0700
Subject: [PATCH 019/155] major rework of communicator docs and addition of
 preseed guides

---
 examples/preseeds/ubuntu_preseed.cfg          |  61 ++++++
 .../source/docs/communicators/index.html.md   |  32 +++
 .../ssh.html.md}                              | 123 ++++-------
 .../source/docs/communicators/ssh.html.md.erb |  87 ++++++++
 .../source/docs/communicators/winrm.html.md   | 160 ++++++++++++++
 .../docs/communicators/winrm.html.md.erb      | 198 ++++++++++++++++++
 .../docs/templates/communicator.html.md.erb   |  85 +++-----
 .../autounattend_windows.html.md              |  97 +++++++++
 .../index.html.md                             |  26 +++
 .../preseed_ubuntu.html.md                    | 179 ++++++++++++++++
 .../workflow-tips-and-tricks/index.html.md    |  13 ++
 .../isotime-template-function.html.md         |   2 +-
 .../use-packer-with-comment.html.md           |   2 +-
 .../veewee-to-packer.html.md                  |   2 +-
 website/source/layouts/docs.erb               |  12 ++
 website/source/layouts/guides.erb             |  32 ++-
 16 files changed, 962 insertions(+), 149 deletions(-)
 create mode 100644 examples/preseeds/ubuntu_preseed.cfg
 create mode 100644 website/source/docs/communicators/index.html.md
 rename website/source/docs/{templates/communicator.html.md => communicators/ssh.html.md} (60%)
 create mode 100644 website/source/docs/communicators/ssh.html.md.erb
 create mode 100644 website/source/docs/communicators/winrm.html.md
 create mode 100644 website/source/docs/communicators/winrm.html.md.erb
 create mode 100644 website/source/guides/automatic-operating-system-installs/autounattend_windows.html.md
 create mode 100644 website/source/guides/automatic-operating-system-installs/index.html.md
 create mode 100644 website/source/guides/automatic-operating-system-installs/preseed_ubuntu.html.md
 create mode 100644 website/source/guides/workflow-tips-and-tricks/index.html.md
 rename website/source/guides/{ => workflow-tips-and-tricks}/isotime-template-function.html.md (96%)
 rename website/source/guides/{ => workflow-tips-and-tricks}/use-packer-with-comment.html.md (96%)
 rename website/source/guides/{ => workflow-tips-and-tricks}/veewee-to-packer.html.md (97%)

diff --git a/examples/preseeds/ubuntu_preseed.cfg b/examples/preseeds/ubuntu_preseed.cfg
new file mode 100644
index 000000000..1786445fd
--- /dev/null
+++ b/examples/preseeds/ubuntu_preseed.cfg
@@ -0,0 +1,61 @@
+# Preseeding only locale sets language, country and locale.
+d-i debian-installer/locale string en_US
+
+# Keyboard selection.
+d-i console-setup/ask_detect boolean false
+d-i keyboard-configuration/xkb-keymap select us
+
+choose-mirror-bin mirror/http/proxy string
+
+### Clock and time zone setup
+d-i clock-setup/utc boolean true
+d-i time/zone string UTC
+
+# Avoid that last message about the install being complete.
+d-i finish-install/reboot_in_progress note
+
+# This is fairly safe to set, it makes grub install automatically to the MBR
+# if no other operating system is detected on the machine.
+d-i grub-installer/only_debian boolean true
+
+# This one makes grub-installer install to the MBR if it also finds some other
+# OS, which is less safe as it might not be able to boot that other OS.
+d-i grub-installer/with_other_os boolean true
+
+### Mirror settings
+# If you select ftp, the mirror/country string does not need to be set.
+d-i mirror/country string manual
+d-i mirror/http/directory string /ubuntu/
+d-i mirror/http/hostname string archive.ubuntu.com
+d-i mirror/http/proxy string
+
+### Partitioning
+d-i partman-auto/method string lvm
+
+# This makes partman automatically partition without confirmation.
+d-i partman-md/confirm boolean true
+d-i partman-partitioning/confirm_write_new_label boolean true
+d-i partman/choose_partition select finish
+d-i partman/confirm boolean true
+d-i partman/confirm_nooverwrite boolean true
+
+### Account setup
+d-i passwd/user-fullname string vagrant
+d-i passwd/user-uid string 1000
+d-i passwd/user-password password vagrant
+d-i passwd/user-password-again password vagrant
+d-i passwd/username string vagrant
+
+# The installer will warn about weak passwords. If you are sure you know
+# what you're doing and want to override it, uncomment this.
+d-i user-setup/allow-password-weak boolean true
+d-i user-setup/encrypt-home boolean false
+
+### Package selection
+tasksel tasksel/first standard
+d-i pkgsel/include string openssh-server build-essential
+d-i pkgsel/install-language-support boolean false
+
+# disable automatic package updates
+d-i pkgsel/update-policy select none
+d-i pkgsel/upgrade select full-upgrade
\ No newline at end of file
diff --git a/website/source/docs/communicators/index.html.md b/website/source/docs/communicators/index.html.md
new file mode 100644
index 000000000..802d79fdf
--- /dev/null
+++ b/website/source/docs/communicators/index.html.md
@@ -0,0 +1,32 @@
+---
+description: |
+    Communicators are the mechanism Packer uses to upload files, execute
+    scripts, etc. with the machine being created.
+layout: docs
+page_title: Communicators
+sidebar_current: 'docs-communicators'
+---
+
+# Communicators
+
+Communicators are the mechanism Packer uses to upload files, execute scripts,
+etc. with the machine being created.
+
+Communicators are configured within the
+[builder](/docs/templates/builders.html) section. Packer currently supports
+three kinds of communicators:
+
+-   `none` - No communicator will be used. If this is set, most provisioners
+    also can't be used.
+
+-   [ssh](/docs/communicators/ssh.html) - An SSH connection will be established to the machine. This is
+    usually the default.
+
+-   [winrm](/docs/communicators/winrm.html) - A WinRM connection will be established.
+
+In addition to the above, some builders have custom communicators they can use.
+For example, the Docker builder has a "docker" communicator that uses
+`docker exec` and `docker cp` to execute scripts and copy files.
+
+For more details on how to use each communicator, click the links above to be
+taken to each communicator's page.
\ No newline at end of file
diff --git a/website/source/docs/templates/communicator.html.md b/website/source/docs/communicators/ssh.html.md
similarity index 60%
rename from website/source/docs/templates/communicator.html.md
rename to website/source/docs/communicators/ssh.html.md
index de5c91c43..2065d2dd4 100644
--- a/website/source/docs/templates/communicator.html.md
+++ b/website/source/docs/communicators/ssh.html.md
@@ -1,41 +1,60 @@
 ---
 description: |
-    Communicators are the mechanism Packer uses to upload files, execute scripts,
-    etc. with the machine being created.
+    The SSH communicator uses SSH to upload files, execute scripts, etc. on
+    the machine being created.
 layout: docs
-page_title: 'Communicators - Templates'
-sidebar_current: 'docs-templates-communicators'
+page_title: 'Communicators - SSH'
+sidebar_current: 'docs-communicators-ssh'
 ---
 
-# Template Communicators
+# SSH Communicator
 
 Communicators are the mechanism Packer uses to upload files, execute scripts,
-etc. with the machine being created.
+etc. on the machine being created, and ar configured within the
+[builder](/docs/templates/builders.html) section.
 
-Communicators are configured within the
-[builder](/docs/templates/builders.html) section. Packer currently supports
-three kinds of communicators:
+The SSH communicator does this by using the SSH protocol. It is the default
+communicator for a majority of builders.
 
--   `none` - No communicator will be used. If this is set, most provisioners
-    also can't be used.
+If you have an SSH agent configured on the host running Packer, and SSH agent
+authentication is enabled in the communicator config, Packer will automatically
+forward the SSH agent to the remote host.
 
--   `ssh` - An SSH connection will be established to the machine. This is
-    usually the default.
+## Getting Ready to Use the SSH Communicator
 
--   `winrm` - A WinRM connection will be established.
+The SSH communicator is the default communicator for a majority of builders, but
+depending on your builder it may not work "out of the box".
 
-In addition to the above, some builders have custom communicators they can use.
-For example, the Docker builder has a "docker" communicator that uses
-`docker exec` and `docker cp` to execute scripts and copy files.
+If you are building from a cloud image (for example, building on Amazon), there
+is a good chance that your cloud provider has already preconfigured SSH on the
+image for you, meaning that all you have to do is configure the communicator in
+the Packer template.
 
-## Using a Communicator
+However, if you are building from a brand-new and unconfigured operating system
+image, you will almost always have to perform some extra work to configure SSH
+on the guest machine. For most operating system distributions, this work will
+be performed by a
+(boot command)[/docs/builders/vmware-iso.html#boot-configuration]
+that references a file which provides answers to the normally-interactive
+questions you get asked when installing an operating system. The name of this
+file varies by operating system; some common examples are the "preseed" file
+required by Debian, the "kickstart" file required by CentOS or the
+"answer file", also known as the Autounattend.xml file, required by Windows.
+For simplicity's sake, we'll refer to this file as the "preseed" file in the
+rest of the documentation.
 
-By default, the SSH communicator is usually used. Additional configuration may
-not even be necessary, since some builders such as Amazon automatically
-configure everything.
+If you are unfamiliar with how to use a preseed file for automatic
+bootstrapping of an image, please either take a look at our [quick guides](/guides/automatic-operating-system-installs/index.html) to
+image bootstrapping, or research automatic configuration for your specific
+guest operating system. Knowing how to automatically initalize your operating
+system is critical for being able to successfully use Packer.
 
-However, to specify a communicator, you set the `communicator` key within a
-build. Multiple builds can have different communicators. Example:
+## Using The SSH Communicator
+
+To specify a communicator, you set the `communicator` key within a
+build. If your template contains multiple builds, you can have a different
+communicator configured for each. Here's an extremely basic example of
+configuring the SSH communicator for an Amazon builder:
 
 ``` json
 {
@@ -48,10 +67,10 @@ build. Multiple builds can have different communicators. Example:
 }
 ```
 
-After specifying the `communicator`, you can specify a number of other
+After specifying the `communicator` type, you can specify a number of other
 configuration parameters for that communicator. These are documented below.
 
-## SSH Communicator
+## SSH Communicator Options
 
 The SSH communicator connects to the host via SSH. If you have an SSH agent
 configured on the host running Packer, and SSH agent authentication is enabled
@@ -176,58 +195,4 @@ And the following MACs:
 -   hmac-sha2-256
 -   `hmac-sha2-256-etm@openssh.com`
 
-## WinRM Communicator
-
-The WinRM communicator has the following options.
-
--   `winrm_host` (string) - The address for WinRM to connect to.
-
-    NOTE: If using an Amazon EBS builder, you can specify the interface WinRM
-    connects to via
-    [`ssh_interface`](https://www.packer.io/docs/builders/amazon-ebs.html#ssh_interface)
-
--   `winrm_insecure` (boolean) - If `true`, do not check server certificate
-    chain and host name.
-
--   `winrm_password` (string) - The password to use to connect to WinRM.
-
--   `winrm_port` (number) - The WinRM port to connect to. This defaults to
-    `5985` for plain unencrypted connection and `5986` for SSL when
-    `winrm_use_ssl` is set to true.
-
--   `winrm_timeout` (string) - The amount of time to wait for WinRM to become
-    available. This defaults to `30m` since setting up a Windows machine
-    generally takes a long time.
-
--   `winrm_use_ntlm` (boolean) - If `true`, NTLMv2 authentication (with session
-    security) will be used for WinRM, rather than default (basic
-    authentication), removing the requirement for basic authentication to be
-    enabled within the target guest. Further reading for remote connection
-    authentication can be found
-    [here](https://msdn.microsoft.com/en-us/library/aa384295(v=vs.85).aspx).
-
--   `winrm_use_ssl` (boolean) - If `true`, use HTTPS for WinRM.
-
--   `winrm_username` (string) - The username to use to connect to WinRM.
-
-## Pausing Before Connecting
-We recommend that you enable SSH or WinRM as the very last step in your
-guest's bootstrap script, but sometimes you may have a race condition where
-you need Packer to wait before attempting to connect to your guest.
-
-If you end up in this situation, you can use the template option
-`pause_before_connecting`. By default, there is no pause. For example:
-
-```
-{
-  "communicator": "ssh",
-  "ssh_username": "myuser",
-  "pause_before_connecting": "10m"
-}
-```
-
-In this example, Packer will check whether it can connect, as normal. But once
-a connection attempt is successful, it will disconnect and then wait 10 minutes
-before connecting to the guest and beginning provisioning.
-
 
diff --git a/website/source/docs/communicators/ssh.html.md.erb b/website/source/docs/communicators/ssh.html.md.erb
new file mode 100644
index 000000000..988870816
--- /dev/null
+++ b/website/source/docs/communicators/ssh.html.md.erb
@@ -0,0 +1,87 @@
+---
+description: |
+    The SSH communicator uses SSH to upload files, execute scripts, etc. on
+    the machine being created.
+layout: docs
+page_title: 'Communicators - SSH'
+sidebar_current: 'docs-communicators-ssh'
+---
+
+# SSH Communicator
+
+Communicators are the mechanism Packer uses to upload files, execute scripts,
+etc. on the machine being created, and ar configured within the
+[builder](/docs/templates/builders.html) section.
+
+The SSH communicator does this by using the SSH protocol. It is the default
+communicator for a majority of builders.
+
+If you have an SSH agent configured on the host running Packer, and SSH agent
+authentication is enabled in the communicator config, Packer will automatically
+forward the SSH agent to the remote host.
+
+## Getting Ready to Use the SSH Communicator
+
+The SSH communicator is the default communicator for a majority of builders, but
+depending on your builder it may not work "out of the box".
+
+If you are building from a cloud image (for example, building on Amazon), there
+is a good chance that your cloud provider has already preconfigured SSH on the
+image for you, meaning that all you have to do is configure the communicator in
+the Packer template.
+
+However, if you are building from a brand-new and unconfigured operating system
+image, you will almost always have to perform some extra work to configure SSH
+on the guest machine. For most operating system distributions, this work will
+be performed by a [boot command](/docs/builders/vmware-iso.html#boot-configuration)
+that references a file which provides answers to the normally-interactive
+questions you get asked when installing an operating system. The name of this
+file varies by operating system; some common examples are the "preseed" file
+required by Debian, the "kickstart" file required by CentOS or the
+"answer file", also known as the Autounattend.xml file, required by Windows.
+For simplicity's sake, we'll refer to this file as the "preseed" file in the
+rest of the documentation.
+
+If you are unfamiliar with how to use a preseed file for automatic
+bootstrapping of an image, please either take a look at our
+[quick guides](/guides/automatic-operating-system-installs/index.html) to
+image bootstrapping, or research automatic configuration for your specific
+guest operating system. Knowing how to automatically initalize your operating
+system is critical for being able to successfully use Packer.
+
+## SSH Communicator
+
+The SSH communicator connects to the host via SSH. If you have an SSH agent
+configured on the host running Packer, and SSH agent authentication is enabled
+in the communicator config, Packer will automatically forward the SSH agent to
+the remote host.
+
+The SSH communicator has the following options:
+
+<%= partial "partials/helper/communicator/SSH-not-required" %>
+
+### SSH Communicator Details
+
+Packer will only use one authentication method, either `publickey` or if
+`ssh_password` is used packer will offer `password` and `keyboard-interactive`
+both sending the password. In other words Packer will not work with *sshd*
+configured with more than one configured authentication method using
+`AuthenticationMethods`.
+
+Packer supports the following ciphers:
+
+-   aes128-ctr
+-   aes192-ctr
+-   aes256-ctr
+-   arcfour128
+-   arcfour256
+-   arcfour
+-   `es128-gcm@openssh.com`
+-   `acha20-poly1305@openssh.com`
+
+And the following MACs:
+
+-   hmac-sha1
+-   hmac-sha1-96
+-   hmac-sha2-256
+-   `hmac-sha2-256-etm@openssh.com`
\ No newline at end of file
diff --git a/website/source/docs/communicators/winrm.html.md b/website/source/docs/communicators/winrm.html.md
new file mode 100644
index 000000000..6918b4115
--- /dev/null
+++ b/website/source/docs/communicators/winrm.html.md
@@ -0,0 +1,160 @@
+---
+description: |
+    Communicators are the mechanism Packer uses to upload files, execute scripts,
+    etc. with the machine being created.
+layout: docs
+page_title: 'Communicators - Templates'
+sidebar_current: 'docs-templates-communicators'
+---
+
+# Template Communicators
+
+Communicators are the mechanism Packer uses to upload files, execute scripts,
+etc. with the machine being created.
+
+Communicators are configured within the
+[builder](/docs/templates/builders.html) section. Packer currently supports
+three kinds of communicators:
+
+-   `none` - No communicator will be used. If this is set, most provisioners
+    also can't be used.
+
+-   `ssh` - An SSH connection will be established to the machine. This is
+    usually the default.
+
+-   `winrm` - A WinRM connection will be established.
+
+In addition to the above, some builders have custom communicators they can use.
+For example, the Docker builder has a "docker" communicator that uses
+`docker exec` and `docker cp` to execute scripts and copy files.
+
+## Using a Communicator
+
+By default, the SSH communicator is usually used. Additional configuration may
+not even be necessary, since some builders such as Amazon automatically
+configure everything.
+
+However, to specify a communicator, you set the `communicator` key within a
+build. Multiple builds can have different communicators. Example:
+
+``` json
+{
+  "builders": [
+    {
+      "type": "amazon-ebs",
+      "communicator": "ssh"
+    }
+  ]
+}
+```
+
+After specifying the `communicator`, you can specify a number of other
+configuration parameters for that communicator. These are documented below.
+
+## WinRM Communicator
+
+The WinRM communicator has the following options.
+
+-   `winrm_host` (string) - The address for WinRM to connect to.
+
+    NOTE: If using an Amazon EBS builder, you can specify the interface WinRM
+    connects to via
+    [`ssh_interface`](https://www.packer.io/docs/builders/amazon-ebs.html#ssh_interface)
+
+-   `winrm_insecure` (boolean) - If `true`, do not check server certificate
+    chain and host name.
+
+-   `winrm_password` (string) - The password to use to connect to WinRM.
+
+-   `winrm_port` (number) - The WinRM port to connect to. This defaults to
+    `5985` for plain unencrypted connection and `5986` for SSL when
+    `winrm_use_ssl` is set to true.
+
+-   `winrm_timeout` (string) - The amount of time to wait for WinRM to become
+    available. This defaults to `30m` since setting up a Windows machine
+    generally takes a long time.
+
+-   `winrm_use_ntlm` (boolean) - If `true`, NTLMv2 authentication (with session
+    security) will be used for WinRM, rather than default (basic
+    authentication), removing the requirement for basic authentication to be
+    enabled within the target guest. Further reading for remote connection
+    authentication can be found
+    [here](https://msdn.microsoft.com/en-us/library/aa384295(v=vs.85).aspx).
+
+-   `winrm_use_ssl` (boolean) - If `true`, use HTTPS for WinRM.
+
+-   `winrm_username` (string) - The username to use to connect to WinRM.
+
+## Pausing Before Connecting
+We recommend that you enable SSH or WinRM as the very last step in your
+guest's bootstrap script, but sometimes you may have a race condition where
+you need Packer to wait before attempting to connect to your guest.
+
+If you end up in this situation, you can use the template option
+`pause_before_connecting`. By default, there is no pause. For example:
+
+```
+{
+  "communicator": "ssh",
+  "ssh_username": "myuser",
+  "pause_before_connecting": "10m"
+}
+```
+
+In this example, Packer will check whether it can connect, as normal. But once
+a connection attempt is successful, it will disconnect and then wait 10 minutes
+before connecting to the guest and beginning provisioning.
+
+
+## Configuring WinRM as part of an Autounattend File
+
+You can add a batch file to your autounattend that contains the commands for
+configuring winrm. Depending on your winrm setup, this could be a complex batch
+file, or a very simple one.
+
+``` xml
+<FirstLogonCommands>
+  ...
+  <SynchronousCommand wcm:action="add">
+      <CommandLine>cmd.exe /c a:\winrmConfig.bat</CommandLine>
+      <Description>Configure WinRM</Description>
+      <Order>3</Order>
+      <RequiresUserInput>true</RequiresUserInput>
+  </SynchronousCommand>
+  ...
+</FirstLogonCommands>
+```
+
+The winrmConfig.bat referenced above can be as simple as
+
+```
+rem basic config for winrm
+cmd.exe /c winrm quickconfig -q
+
+rem allow unencrypted traffic, and configure auth to use basic username/password auth
+cmd.exe /c winrm set winrm/config/service @{AllowUnencrypted="true"}
+cmd.exe /c winrm set winrm/config/service/auth @{Basic="true"}
+
+rem update firewall rules to open the right port and to allow remote administration
+cmd.exe /c netsh advfirewall firewall set rule group="remote administration" new enable=yes
+
+rem restart winrm
+cmd.exe /c net stop winrm
+cmd.exe /c net start winrm
+```
+
+This batch file will only work for http connections, not https, but will enable
+you to connect using only the username and password created earlier in the
+Autounattend file. The above batchfile will allow you to connect using a very
+simple Packer config:
+
+```json
+        ...
+        "communicator": "winrm",
+        "winrm_username": "packeruser",
+        "winrm_password": "SecretPassword"
+        ...
+```
+
+If you want to set winRM up for https, things will be a bit more complicated.
+We'll explore
\ No newline at end of file
diff --git a/website/source/docs/communicators/winrm.html.md.erb b/website/source/docs/communicators/winrm.html.md.erb
new file mode 100644
index 000000000..af32caedd
--- /dev/null
+++ b/website/source/docs/communicators/winrm.html.md.erb
@@ -0,0 +1,198 @@
+---
+description: |
+    Communicators are the mechanism Packer uses to upload files, execute scripts,
+    etc. with the machine being created.
+layout: docs
+page_title: 'Communicators - Templates'
+sidebar_current: 'docs-communicators-winrm'
+---
+
+# WinRM Communicator
+
+Communicators are the mechanism Packer uses to upload files, execute scripts,
+etc. with the machine being created. The WinRM communicator uses the
+Windows Remote Management protocol to do this.
+
+## Getting Ready to Use the WinRM Communicator
+
+The WinRM communicator is not the default communicator, so you will always have
+to set the `"communicator": "winrm",` template option explicitly. In addition,
+you will almost always have to provide a pre-run script that enables and
+configures WinRM on the guest machine. This will generally be in the form of a
+powershell script or a batch file.
+
+If you are building from a brand-new and unconfigured operating system
+image, you will need to provide this pre-run script as part of your
+Autounattend.xml file, required by Windows for automatic operating system
+installation. If you are building in a cloud or from a pre-installed image, your
+method for providing this pre-run script will vary based on the builder. Please
+refer to each builder's documentation for more information on how to supply the
+winrm configuration script.
+
+If you are unfamiliar with how to use an autounattend file, take a look at our
+[quick guides](/guides/automatic-operating-system-installs/index.html); knowing
+how to automatically initalize your operating system is critical for being able
+to successfully use Packer to build from an iso.
+
+## WinRM Communicator Options
+
+<%= partial "partials/helper/communicator/WinRM-not-required" %>
+
+## Examples
+
+### Basics of WinRM Connection
+
+Please note that WinRM is not a Packer-specific protocol. Microsoft has a great
+deal of documentation about WinRM. If you find after reading this guide that
+you are still not able to connect via WinRM, check the
+[Microsoft documentation](https://docs.microsoft.com/en-us/windows/win32/winrm/installation-and-configuration-for-windows-remote-management)
+to make sure there isn't anything you're missing.
+
+There are some steps that you will normally need to take in order for Packer
+to be able to connect via WinRM
+
+1. Set up a username and password that Packer to connect with.
+2. Make any necesary registry edits to enable remote execution
+	(and remote execution with elevated privileges, if needed)
+3. Start WinRM, setting any config needed for allowing basic auth
+4. Open ports 5985 and/or 5986 depending on how you're connecting
+5. launch WinRM and set it to automatically launch when the computer restarts
+6. If necessary, generate a self-signed certificate or provide a real certificate
+	to the WinRM listener.
+
+#### Configuring WinRM in VMWare
+
+If you are configuring WinRM using an Autounattend.xml, the simplest way to set
+up WinRM is to put the configuration commands directly into the Autounattend
+file as shown [here](https://github.com/StefanScherer/packer-windows/blob/6e603e904e9b280eeb97f7eb542940a043954112/answer_files/2008_r2_core/Autounattend.xml#L157-L234)
+
+Instead of entering each line individually, you can also add a batch file to
+your autounattend that contains the commands for configuring winrm. Depending
+on your winrm setup, this could be a complex batch file, or a very simple one.
+
+Below is an example of how we would call a batch file from inside the
+Autounattend file.
+
+``` xml
+<FirstLogonCommands>
+  ...
+  <SynchronousCommand wcm:action="add">
+      <CommandLine>cmd.exe /c a:\winrmConfig.bat</CommandLine>
+      <Description>Configure WinRM</Description>
+      <Order>3</Order>
+      <RequiresUserInput>true</RequiresUserInput>
+  </SynchronousCommand>
+  ...
+</FirstLogonCommands>
+```
+It is also possible to call powershell scripts in a similar manner.
+
+The winrmConfig.bat referenced above can be as simple as
+
+```
+rem basic config for winrm
+cmd.exe /c winrm quickconfig -q
+
+rem allow unencrypted traffic, and configure auth to use basic username/password auth
+cmd.exe /c winrm set winrm/config/service @{AllowUnencrypted="true"}
+cmd.exe /c winrm set winrm/config/service/auth @{Basic="true"}
+
+rem update firewall rules to open the right port and to allow remote administration
+cmd.exe /c netsh advfirewall firewall set rule group="remote administration" new enable=yes
+
+rem restart winrm
+cmd.exe /c net stop winrm
+cmd.exe /c net start winrm
+```
+
+Please note that the above batch file is _extremely_ simplistic, and not secure.
+It is intended to be an example of the bare minimum configuration. Below, you'll
+find a more complicated example of a more secure WinRM configuration process.
+
+This batch file will only work for http connections, not https, but will enable
+you to connect using only the username and password created earlier in the
+Autounattend file. The above batchfile will allow you to connect using a very
+simple Packer config:
+
+```json
+        "communicator": "winrm",
+        "winrm_username": "packeruser",
+        "winrm_password": "SecretPassword"
+```
+
+A more complex example of a powershell script used for configuration can be seen
+below.
+
+```powershell
+# A Packer config that works with this example would be:
+#
+#
+#    "winrm_username": "Administrator",
+#    "winrm_password": "SuperS3cr3t!!!",
+#    "winrm_insecure": true,
+#    "winrm_use_ssl": true
+#
+#
+
+# Create username and password
+net user Administrator SuperS3cr3t!!!
+wmic useraccount where "name='Administrator'" set PasswordExpires=FALSE
+
+Set-ExecutionPolicy Unrestricted -Scope LocalMachine -Force -ErrorAction Ignore
+
+# Don't set this before Set-ExecutionPolicy as it throws an error
+$ErrorActionPreference = "stop"
+
+# Remove HTTP listener
+Remove-Item -Path WSMan:\Localhost\listener\listener* -Recurse
+
+# Create a self-signed certificate to let ssl work
+$Cert = New-SelfSignedCertificate -CertstoreLocation Cert:\LocalMachine\My -DnsName "packer"
+New-Item -Path WSMan:\LocalHost\Listener -Transport HTTPS -Address * -CertificateThumbPrint $Cert.Thumbprint -Force
+
+# WinRM
+write-output "Setting up WinRM"
+write-host "(host) setting up WinRM"
+
+# Configure WinRM to allow unencrypted communication, and provide the
+# self-signed cert to the WinRM listener.
+cmd.exe /c winrm quickconfig -q
+cmd.exe /c winrm set "winrm/config/service" '@{AllowUnencrypted="true"}'
+cmd.exe /c winrm set "winrm/config/client" '@{AllowUnencrypted="true"}'
+cmd.exe /c winrm set "winrm/config/service/auth" '@{Basic="true"}'
+cmd.exe /c winrm set "winrm/config/client/auth" '@{Basic="true"}'
+cmd.exe /c winrm set "winrm/config/service/auth" '@{CredSSP="true"}'
+cmd.exe /c winrm set "winrm/config/listener?Address=*+Transport=HTTPS" "@{Port=`"5986`";Hostname=`"packer`";CertificateThumbprint=`"$($Cert.Thumbprint)`"}"
+
+# Make sure appropriate firewall port openings exist
+cmd.exe /c netsh advfirewall firewall set rule group="remote administration" new enable=yes
+cmd.exe /c netsh firewall add portopening TCP 5986 "Port 5986"
+
+# Restart WinRM, and set it so that it auto-launches on startup.
+cmd.exe /c net stop winrm
+cmd.exe /c sc config winrm start= auto
+cmd.exe /c net start winrm
+```
+
+Please note that having WinRM auto-launch on all start ups may not be the right
+choice for you, if you don't need the server to recieve WinRM connections in the
+future. Clean up after yourself and close unnecesary firewall ports at a final
+provisioning step to make sure your image is secure.
+
+#### Configuring WinRM in the Cloud
+
+Most clouds allow you to provide a configuration script that runs when the
+instance is launched. In AWS, this is the
+[user_data_file](/docs/builders/amazon-ebs.html#user_data_file). In Google
+Cloud, this is provided using the `windows-startup-script-cmd`
+[metadata](/docs/builders/googlecompute.html#metadata) tag.
+[Example](/docs/builders/googlecompute.html#windows-example)
+
+Essentially, these files are powershell or cmd scripts that configure winrm,
+without having to be wrapped in an Autounattend. Provide the script in the
+format requested by each cloud, and make sure you manually configure any
+firewall rules that the cloud doesn't allow you to manage internally. More
+specific details for each cloud can be found in the builder sections.
+
+The above examples will work in cloud prep too, but may be overkill depending on
+how much preconfiguration the cloud has done for you.
\ No newline at end of file
diff --git a/website/source/docs/templates/communicator.html.md.erb b/website/source/docs/templates/communicator.html.md.erb
index 6d801e467..8e7fefc40 100644
--- a/website/source/docs/templates/communicator.html.md.erb
+++ b/website/source/docs/templates/communicator.html.md.erb
@@ -13,73 +13,40 @@ Communicators are the mechanism Packer uses to upload files, execute scripts,
 etc. with the machine being created.
 
 Communicators are configured within the
-[builder](/docs/templates/builders.html) section. 
+[builder](/docs/templates/builders.html) section.
 
 All communicators have the following options:
 
 <%= partial "partials/helper/communicator/Config-not-required" %>
 
-## Using a Communicator
+## Getting Ready to Use the Communicator
 
-By default, the SSH communicator is usually used. Additional configuration may
-not even be necessary, since some builders such as Amazon automatically
-configure everything.
+Depending on your builder, your communicator may not have all it needs in order
+to work "out of the box".
 
-However, to specify a communicator, you set the `communicator` key within a
-build. Multiple builds can have different communicators. Example:
+If you are building from a cloud image (for example, building on Amazon), there
+is a good chance that your cloud provider has already preconfigured SSH on the
+image for you, meaning that all you have to do is configure the communicator in
+the Packer template.
 
-``` json
-{
-  "builders": [
-    {
-      "type": "amazon-ebs",
-      "communicator": "ssh"
-    }
-  ]
-}
-```
+However, if you are building from a brand-new and unconfigured operating system
+image, you will almost always have to perform some extra work to configure SSH
+on the guest machine. For most operating system distributions, this work will
+be performed by a [boot_command](/docs/builders/vmware-iso.html#boot-command) that references a file which
+provides answers to the normally-interactive questions you get asked when
+installing an operating system. The name of this file varies by operating
+system; some common examples are the "preseed" file required by Debian, the
+"kickstart" file required by CentOS or the "answer file", also known as the
+Autounattend.xml file, required by Windows. For simplicity's sake, we'll refer
+to this file as the "preseed" file in the rest of the documentation.
 
-After specifying the `communicator`, you can specify a number of other
-configuration parameters for that communicator. These are documented below.
+If you are unfamiliar with how to use a preseed file for automatic
+bootstrapping of an image, please either take a look at our quick guides to
+image bootstrapping, or research automatic configuration for your specific
+guest operating system. Knowing how to automatically initalize your operating
+system is critical for being able to successfully use Packer.
 
+## Communicator-Specific Options
 
-## SSH Communicator
-
-The SSH communicator connects to the host via SSH. If you have an SSH agent
-configured on the host running Packer, and SSH agent authentication is enabled
-in the communicator config, Packer will automatically forward the SSH agent to
-the remote host.
-
-The SSH communicator has the following options:
-
-<%= partial "partials/helper/communicator/SSH-not-required" %>
-
-### SSH Communicator Details
-
-Packer will only use one authentication method, either `publickey` or if
-`ssh_password` is used packer will offer `password` and `keyboard-interactive`
-both sending the password. In other words Packer will not work with *sshd*
-configured with more than one configured authentication method using
-`AuthenticationMethods`.
-
-Packer supports the following ciphers:
-
--   aes128-ctr
--   aes192-ctr
--   aes256-ctr
--   arcfour128
--   arcfour256
--   arcfour
--   `es128-gcm@openssh.com`
--   `acha20-poly1305@openssh.com`
-
-And the following MACs:
-
--   hmac-sha1
--   hmac-sha1-96
--   hmac-sha2-256
--   `hmac-sha2-256-etm@openssh.com`
-
-## WinRM Communicator
-
-<%= partial "partials/helper/communicator/WinRM-not-required" %>
+For more details on how to use each communicator, visit the
+[communicators](/docs/communicators/index.html) page.
\ No newline at end of file
diff --git a/website/source/guides/automatic-operating-system-installs/autounattend_windows.html.md b/website/source/guides/automatic-operating-system-installs/autounattend_windows.html.md
new file mode 100644
index 000000000..0f6404ff8
--- /dev/null
+++ b/website/source/guides/automatic-operating-system-installs/autounattend_windows.html.md
@@ -0,0 +1,97 @@
+---
+layout: guides
+sidebar_current: automatic-operating-system-installs-unattended-installation-windows
+page_title: Unattended Windows Installation
+description: |-
+  Learn how to use an autounattend file to automatically answer installation
+  questions and enable Packer to connect to your windows instnace.
+---
+
+# Unattended Installation for Windows
+
+Unattended Windows installation is done via "Answer Files", or "Unattend files".
+
+These files are generally named "autounattend.xml".  They are not
+Packer-specific tools, though we do make use of them.
+
+If, after following this guide, you're still having issues getting an answer
+file working, We recommend you read the official documentation on
+[answer files](https://docs.microsoft.com/en-us/windows-hardware/manufacture/desktop/update-windows-settings-and-scripts-create-your-own-answer-file-sxs).
+
+The guide here is hopefully enough to get you started, but isn't a replacement
+for the official documentation.
+
+## When To Use an Answer File
+
+If you are installing the Windows Operating System from a mounted iso as part of
+your Packer build, you will need to use an Answer file. For example, you're
+building an image from scratch using the [vmware-iso](/docs/builders/vmware-iso.html),
+[virtualbox-iso](/docs/builders/virtualbox-iso.html), or
+[hyperv-iso](/docs/builders/hyperv-iso.html) builders.
+
+If you are not installing the operating system, you won't need to provide an
+answer file. If you are using a pre-built image
+in a cloud, you don't need to worry about Answer files.
+
+## How to make an Answer File
+
+You can either start from an example answer file from a known repo (take a look
+at the examples links below), or you can generate one using an answer file
+wizard by selecting New File > New Answer file on a Windows machine.
+A comprehensive list of all the options you can set in an answer file can be
+found [here](https://docs.microsoft.com/en-us/windows-hardware/customize/desktop/unattend/components-b-unattend)
+
+## Where to put the Answer File
+
+Windows will automatically look for an autounattend.xml file on mounted drives.
+Many users use the `floppy_files` option or a secondary mounted iso for
+providing the answer file to their iso builders.
+
+You can also specify an unattend file to use by using the /unattend: option when
+running Windows Setup (setup.exe) in your `boot_command`.
+
+## What does Packer _need_ the Answer File to do?
+
+Packer needs the Answer File to handle any questions that would normally be
+answered interactively during a Windows installation.
+
+If you want to be able to use provisioners, the Answer file must also contain
+a script that sets up SSH or WinRM so that Packer can connect to the instance.
+
+Finally, your Packer build will be much smoother if the Answer File handles or
+disables windows updates rather than you tyring to run them using a Packer
+provisioner. This is because the winrm communicator does not handle the
+disconnects caused by automatic reboots in Windows updates well, and the
+disconnections can fail a build.
+
+## Examples
+
+The chef-maintained bento boxes are a great example of a windows build that
+sets up openssh as part of the unattended installation so that Packer can
+connect using the ssh communicator. They functioning answer files for every
+modern Windows version.
+https://github.com/chef/bento/tree/master/packer_templates/windows/answer_files
+
+Stefan Scherer's packer-windows repo is a great example of windows builds that
+set up WinRM as part of the unattended installation so that Packer can connect
+using the winrm communicator:
+https://github.com/StefanScherer/packer-windows
+
+``` json
+      {
+        "type": "virtualbox-iso",
+        "guest_os_type": "Windows2008_64",
+        "iso_url": "https://download.microsoft.com/download/7/5/E/75EC4E54-5B02-42D6-8879-D8D3A25FBEF7/7601.17514.101119-1850_x64fre_server_eval_en-us-GRMSXEVAL_EN_DVD.iso",
+        "iso_checksum": "30832AD76CCFA4CE48CCB936EDEFE02079D42FB1DA32201BF9E3A880C8ED6312",
+        "iso_checksum_type": "sha256",
+        "shutdown_command": "shutdown /s /t 10 /f /d p:4:1 /c Packer_Provisioning_Shutdown",
+        "guest_additions_mode": "attach",
+        "floppy_files": [
+          "./scripts/Autounattend.xml",
+          "./scripts/openssh.ps1"
+        ],
+        "communicator": "winrm",
+        "winrm_username": "vagrant",
+        "winrm_password": "vagrant"
+      }
+```
\ No newline at end of file
diff --git a/website/source/guides/automatic-operating-system-installs/index.html.md b/website/source/guides/automatic-operating-system-installs/index.html.md
new file mode 100644
index 000000000..b5f711e2e
--- /dev/null
+++ b/website/source/guides/automatic-operating-system-installs/index.html.md
@@ -0,0 +1,26 @@
+---
+layout: guides
+sidebar_current: automatic-operating-system-installs
+page_title: Automatic OS Installs
+description: |-
+  Learn how to use preseed, kickstart, and autounattend files to automatically
+  answer installation questions and enable Packer to connect to your instnace.
+---
+
+# Automatic OS Installs
+
+If you are building from a brand-new and unconfigured operating system
+image, Packer will need you to perform the operating system install before it
+can connect to and configure your image using its provisioners. Most operating
+system distributions have a mechanism for performing the normally-interactive
+installation in an automated way. For Debian operating systems, this is done
+using a preseed file; for Windows, it's done using an Autounattend.xml. We have
+compiled some simple guides here for common operating system distributions.
+
+These guides are meant to give you a quick introduction to how to use automated
+installation answer files in order to perfom those installs; we don't mean to
+be a comprehensive guide on each operating system, but we hope to give you
+enough context to be able to more easily find any further information you need.
+
+Please use the left-hand navigation to find instructions for the operating
+system that is relevant to you.
\ No newline at end of file
diff --git a/website/source/guides/automatic-operating-system-installs/preseed_ubuntu.html.md b/website/source/guides/automatic-operating-system-installs/preseed_ubuntu.html.md
new file mode 100644
index 000000000..3c55c4162
--- /dev/null
+++ b/website/source/guides/automatic-operating-system-installs/preseed_ubuntu.html.md
@@ -0,0 +1,179 @@
+---
+layout: guides
+sidebar_current: automatic-operating-system-installs-unattended-installation-debian
+page_title: Unattended Debian/Ubuntu Installation
+description: |-
+  Learn how to use a preseed file to automatically answer installation
+  questions and enable Packer to connect to your Debian instnace.
+---
+
+# Unattended Installation for Debian
+
+Unattended Debian/Ubuntu installation is done via "preseed" files
+
+These files are generally named "preseed.cfg".  They are not
+Packer-specific tools, though we do make use of them.
+
+If, after following this guide, you're still having issues getting a preseed
+file working, We recommend you read the official documentation on
+[preseed files](https://wiki.debian.org/DebianInstaller/Preseed).
+
+The guide here is hopefully enough to get you started, but isn't a replacement
+for the official documentation.
+
+## When To Use a Preseed File
+
+If you are installing the operating system from a mounted iso as part of
+your Packer build, you will need to use a preseed file. For example, you're
+building an image from scratch using the [vmware-iso](/docs/builders/vmware-iso.html),
+[virtualbox-iso](/docs/builders/virtualbox-iso.html), or
+[hyperv-iso](/docs/builders/hyperv-iso.html) builders.
+
+If you are not installing the operating system, you won't need to provide a
+preseed file. If you are using a pre-built image in a cloud, you don't need to
+worry about preseed files.
+
+## How to make a Preseed File
+
+You can either start from an example preseed file from a known repo (take a look
+at the examples links below), or you can start with the official [example
+preseed](https://www.debian.org/releases/stable/example-preseed.txt), and
+comment or uncomment the options as you need them.
+
+## Where to put the preseed file
+
+The `-iso` builders mentioned above all have an `http_dir` option. Any file
+inside of your `http_dir` will be served on a local fileserver for your virtual
+machine to be able to access. One very common use for this directory is to use
+it to provide your preseed file.
+
+You then reference the file using a `boot_command` to kick off the installation.
+In the example below, see how the `preseed/url` command line option is being
+used in the `/install/vmlinuz command`.  The `{{ .HTTPIP }}` and
+`{{ .HTTPPort }}` options are special Packer template options that will get set
+by Packer to point to the http server we create, so that your boot command can
+access it. For an example of a working boot_command, see the Examples section
+below. For more information on how boot_command works, see the
+boot_command section of the docs for whatever builder you are using.
+
+## What does Packer _need_ the preseed file to do?
+
+Packer needs the preseed file to handle any questions that would normally be
+answered interactively during a Debian installation.
+
+If you want to be able to use provisioners, the preseed file must also install
+SSH so that Packer can connect to the instance.
+
+## Examples
+
+A very minimal example of a preseed file can be found below. Much of this was
+copied from the official example-preseed shared above. Notice that we are
+installing ssh via `d-i pkgsel/include string openssh-server` and configuring
+a username so that Packer will be able to connect.
+
+You need to make sure that your mirror settings are properly configured for your
+specific distribution of Debian.
+
+```
+# Preseeding only locale sets language, country and locale.
+d-i debian-installer/locale string en_US
+
+# Keyboard selection.
+d-i console-setup/ask_detect boolean false
+d-i keyboard-configuration/xkb-keymap select us
+
+choose-mirror-bin mirror/http/proxy string
+
+### Clock and time zone setup
+d-i clock-setup/utc boolean true
+d-i time/zone string UTC
+
+# Avoid that last message about the install being complete.
+d-i finish-install/reboot_in_progress note
+
+# This is fairly safe to set, it makes grub install automatically to the MBR
+# if no other operating system is detected on the machine.
+d-i grub-installer/only_debian boolean true
+
+# This one makes grub-installer install to the MBR if it also finds some other
+# OS, which is less safe as it might not be able to boot that other OS.
+d-i grub-installer/with_other_os boolean true
+
+### Mirror settings
+# If you select ftp, the mirror/country string does not need to be set.
+d-i mirror/country string manual
+d-i mirror/http/directory string /ubuntu/
+d-i mirror/http/hostname string archive.ubuntu.com
+d-i mirror/http/proxy string
+
+### Partitioning
+d-i partman-auto/method string lvm
+
+# This makes partman automatically partition without confirmation.
+d-i partman-md/confirm boolean true
+d-i partman-partitioning/confirm_write_new_label boolean true
+d-i partman/choose_partition select finish
+d-i partman/confirm boolean true
+d-i partman/confirm_nooverwrite boolean true
+
+### Account setup
+d-i passwd/user-fullname string vagrant
+d-i passwd/user-uid string 1000
+d-i passwd/user-password password vagrant
+d-i passwd/user-password-again password vagrant
+d-i passwd/username string vagrant
+
+# The installer will warn about weak passwords. If you are sure you know
+# what you're doing and want to override it, uncomment this.
+d-i user-setup/allow-password-weak boolean true
+d-i user-setup/encrypt-home boolean false
+
+### Package selection
+tasksel tasksel/first standard
+d-i pkgsel/include string openssh-server build-essential
+d-i pkgsel/install-language-support boolean false
+
+# disable automatic package updates
+d-i pkgsel/update-policy select none
+d-i pkgsel/upgrade select full-upgrade
+```
+
+Here's an example of the vmware-iso builder being used to call this preseed.
+In this case, it is assumed that the file is saved as preseed.cfg inside of a
+directory called "http", and Packer is being called from the directory
+containing the "http" directory.
+
+```
+  "builders": [
+    {
+      "boot_command": [
+        "<esc><wait>",
+        "<esc><wait>",
+        "<enter><wait>",
+        "/install/vmlinuz<wait>",
+        " initrd=/install/initrd.gz",
+        " auto-install/enable=true",
+        " debconf/priority=critical",
+        " preseed/url=http://{{ .HTTPIP }}:{{ .HTTPPort }}/preseed_2.cfg<wait>",
+        " -- <wait>",
+        "<enter><wait>"
+      ],
+      "boot_wait": "10s",
+      "guest_os_type": "ubuntu-64",
+      "http_directory": "http",
+      "iso_checksum_type": "sha256",
+      "iso_checksum_url": "file:///Users/mmarsh/dev/repro_cases/packer_cache/shasums.txt",
+      "iso_url": "http://old-releases.ubuntu.com/releases/14.04.1/ubuntu-14.04.1-server-amd64.iso",
+      "shutdown_command": "echo 'vagrant' | sudo -S shutdown -P now",
+      "ssh_password": "vagrant",
+      "ssh_username": "vagrant",
+      "ssh_wait_timeout": "10000s",
+      "tools_upload_flavor": "linux",
+      "type": "vmware-iso"
+    }
+  ],
+```
+
+For more functional examples of a debian preseeded installation, you can see the
+Chef-maintained bento boxes for [Debian](https://github.com/chef/bento/tree/master/packer_templates/debian)
+and [Ubuntu](https://github.com/chef/bento/tree/master/packer_templates/ubuntu)
\ No newline at end of file
diff --git a/website/source/guides/workflow-tips-and-tricks/index.html.md b/website/source/guides/workflow-tips-and-tricks/index.html.md
new file mode 100644
index 000000000..6a513ea28
--- /dev/null
+++ b/website/source/guides/workflow-tips-and-tricks/index.html.md
@@ -0,0 +1,13 @@
+---
+layout: guides
+sidebar_current: workflow-tips-and-tricks
+page_title: Tips and Tricks
+description: |-
+  The guides stored in this section are miscellanious tips and tricks that might
+  make your experience of using Packer easier
+---
+
+# Tips and Tricks
+
+Click the sidebar navigation to check out the miscellaneous guides we have for
+making your life with Packer just a bit easier.
diff --git a/website/source/guides/isotime-template-function.html.md b/website/source/guides/workflow-tips-and-tricks/isotime-template-function.html.md
similarity index 96%
rename from website/source/guides/isotime-template-function.html.md
rename to website/source/guides/workflow-tips-and-tricks/isotime-template-function.html.md
index 48c084704..7eacf521e 100644
--- a/website/source/guides/isotime-template-function.html.md
+++ b/website/source/guides/workflow-tips-and-tricks/isotime-template-function.html.md
@@ -1,6 +1,6 @@
 ---
 layout: guides
-sidebar_current: isotime-template-function
+sidebar_current: workflow-tips-and-tricks-isotime-template-function
 page_title: Using the isotime template function - Guides
 description: |-
   It can be a bit confusing to figure out how to format your isotime using the
diff --git a/website/source/guides/use-packer-with-comment.html.md b/website/source/guides/workflow-tips-and-tricks/use-packer-with-comment.html.md
similarity index 96%
rename from website/source/guides/use-packer-with-comment.html.md
rename to website/source/guides/workflow-tips-and-tricks/use-packer-with-comment.html.md
index 52fbaa7dc..e3176653e 100644
--- a/website/source/guides/use-packer-with-comment.html.md
+++ b/website/source/guides/workflow-tips-and-tricks/use-packer-with-comment.html.md
@@ -1,6 +1,6 @@
 ---
 layout: guides
-sidebar_current: use-packer-with-comment
+sidebar_current: workflow-tips-and-tricks-use-packer-with-comment
 page_title: Use jq and Packer to comment your templates - Guides
 description: |-
   You can add detailed comments beyond the root-level underscore-prefixed field
diff --git a/website/source/guides/veewee-to-packer.html.md b/website/source/guides/workflow-tips-and-tricks/veewee-to-packer.html.md
similarity index 97%
rename from website/source/guides/veewee-to-packer.html.md
rename to website/source/guides/workflow-tips-and-tricks/veewee-to-packer.html.md
index 710cbae72..5c4c7a3d7 100644
--- a/website/source/guides/veewee-to-packer.html.md
+++ b/website/source/guides/workflow-tips-and-tricks/veewee-to-packer.html.md
@@ -1,6 +1,6 @@
 ---
 layout: guides
-sidebar_current: guides-veewee-to-packer
+sidebar_current: workflow-tips-and-tricks-guides-veewee-to-packer
 page_title: Convert Veewee Definitions to Packer Templates - Guides
 description: |-
   If you are or were a user of Veewee, then there is an official tool called
diff --git a/website/source/layouts/docs.erb b/website/source/layouts/docs.erb
index 11c9f8a49..6593ae9f9 100644
--- a/website/source/layouts/docs.erb
+++ b/website/source/layouts/docs.erb
@@ -53,6 +53,18 @@
 
       <hr>
 
+      <li<%= sidebar_current("docs-communicators") %>>
+        <a href="/docs/communicators/index.html">Communicators</a>
+        <ul class="nav">
+          <li<%= sidebar_current("docs-communicators-ssh") %>>
+            <a href="/docs/communicators/ssh.html">SSH</a>
+          </li>
+          <li<%= sidebar_current("docs-communicators-winrm") %>>
+            <a href="/docs/communicators/winrm.html">WINRM</a>
+          </li>
+        </ul>
+      </li>
+
       <li<%= sidebar_current("docs-builders") %>>
         <a href="/docs/builders/index.html">Builders</a>
         <ul class="nav">
diff --git a/website/source/layouts/guides.erb b/website/source/layouts/guides.erb
index 7b8990bfa..41a4dc1a0 100644
--- a/website/source/layouts/guides.erb
+++ b/website/source/layouts/guides.erb
@@ -1,14 +1,30 @@
 <% wrap_layout :inner do %>
   <% content_for :sidebar do %>
     <ul class="nav docs-sidenav">
-      <li<%= sidebar_current("isotime-template-function") %>>
-        <a href="/guides/isotime-template-function.html">Isotime Template Function</a>
+      <li<%= sidebar_current("automatic-operating-system-installs") %>>
+        <a href="/guides/automatic-operating-system-installs/index.html">Automatic OS Installs</a>
+        <ul class="nav">
+          <li<%= sidebar_current("automatic-operating-system-installs-unattended-installation-windows") %>>
+            <a href="/guides/automatic-operating-system-installs/autounattend_windows.html">Unattended Installation for Windows</a>
+          </li>
+          <li<%= sidebar_current("automatic-operating-system-installs-unattended-installation-debian") %>>
+            <a href="/guides/automatic-operating-system-installs/preseed_ubuntu.html">Unattended Installation for Debian</a>
+          </li>
+        </ul>
       </li>
-      <li<%= sidebar_current("guides-veewee-to-packer") %>>
-        <a href="/guides/veewee-to-packer.html">Veewee to Packer</a>
-      </li>
-      <li<%= sidebar_current("use-packer-with-comment") %>>
-        <a href="/guides/use-packer-with-comment.html">Use jq to strip comments from a Packer template</a>
+      <li<%= sidebar_current("workflow-tips-and-tricks") %>>
+        <a href="/guides/workflow-tips-and-tricks/index.html">Workflow Tips and Tricks</a>
+        <ul class="nav">
+          <li<%= sidebar_current("workflow-tips-and-tricks-isotime-template-function") %>>
+            <a href="/guides/workflow-tips-and-tricks/isotime-template-function.html">Isotime Template Function</a>
+          </li>
+          <li<%= sidebar_current("workflow-tips-and-tricks-guides-veewee-to-packer") %>>
+            <a href="/guides/workflow-tips-and-tricks/veewee-to-packer.html">Veewee to Packer</a>
+          </li>
+          <li<%= sidebar_current("workflow-tips-and-tricks-use-packer-with-comment") %>>
+            <a href="/guides/workflow-tips-and-tricks/use-packer-with-comment.html">Use jq to strip comments from a Packer template</a>
+          </li>
+        </ul>
       </li>
       <li<%= sidebar_current("guides-packer-on-cicd") %>>
         <a href="/guides/packer-on-cicd/index.html">Build Immutable Infrastructure with Packer in CI/CD</a>
@@ -31,4 +47,4 @@
   <% end %>
 
   <%= yield %>
-<% end %>
+<% end %>
\ No newline at end of file

From 7c41244e1504f7b20d76bf1248bd78519b1cc15c Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Thu, 3 Oct 2019 14:50:53 -0700
Subject: [PATCH 020/155] use a unique temp dir for each build to prevent
 concurrent builds from stomping on each other

---
 builder/docker/step_temp_dir.go | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/builder/docker/step_temp_dir.go b/builder/docker/step_temp_dir.go
index c9578076e..72236dd96 100644
--- a/builder/docker/step_temp_dir.go
+++ b/builder/docker/step_temp_dir.go
@@ -3,6 +3,7 @@ package docker
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"os"
 	"path/filepath"
@@ -34,16 +35,7 @@ func ConfigTmpDir() (string, error) {
 		configdir = fp
 	}
 
-	td := filepath.Join(configdir, "tmp")
-	_, err = os.Stat(td)
-	if os.IsNotExist(err) {
-		log.Printf("Creating tempdir in %s", td)
-		if err = os.MkdirAll(td, 0755); err != nil {
-			return "", err
-		}
-	} else if err != nil {
-		return "", err
-	}
+	td, err := ioutil.TempDir(configdir, "tmp")
 	log.Printf("Set Packer temp dir to %s", td)
 	return td, nil
 }

From 7f040dfed8d6c597c14f6f81e78db0646a58e126 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Thu, 3 Oct 2019 15:06:01 -0700
Subject: [PATCH 021/155] update tests

---
 builder/docker/step_temp_dir.go      | 4 ++++
 builder/docker/step_temp_dir_test.go | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/builder/docker/step_temp_dir.go b/builder/docker/step_temp_dir.go
index 72236dd96..d9c0ed6c7 100644
--- a/builder/docker/step_temp_dir.go
+++ b/builder/docker/step_temp_dir.go
@@ -36,6 +36,10 @@ func ConfigTmpDir() (string, error) {
 	}
 
 	td, err := ioutil.TempDir(configdir, "tmp")
+	if err != nil {
+		return "", fmt.Errorf("Error creating temp dir: %s", err)
+
+	}
 	log.Printf("Set Packer temp dir to %s", td)
 	return td, nil
 }
diff --git a/builder/docker/step_temp_dir_test.go b/builder/docker/step_temp_dir_test.go
index a573726ec..ee7245150 100644
--- a/builder/docker/step_temp_dir_test.go
+++ b/builder/docker/step_temp_dir_test.go
@@ -35,7 +35,7 @@ func testStepTempDir_impl(t *testing.T) string {
 	dir := dirRaw.(string)
 
 	if _, err := os.Stat(dir); err != nil {
-		t.Fatalf("err: %s", err)
+		t.Fatalf("Stat for %s failed: err: %s", err, dir)
 	}
 
 	// Cleanup

From de8e8557ae059b444f2dad53ac6a62c61376a78b Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Thu, 3 Oct 2019 15:16:27 -0700
Subject: [PATCH 022/155] make config dir if it doens't exist.

---
 builder/docker/step_temp_dir.go | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/builder/docker/step_temp_dir.go b/builder/docker/step_temp_dir.go
index d9c0ed6c7..39808cdd2 100644
--- a/builder/docker/step_temp_dir.go
+++ b/builder/docker/step_temp_dir.go
@@ -35,6 +35,16 @@ func ConfigTmpDir() (string, error) {
 		configdir = fp
 	}
 
+	_, err = os.Stat(configdir)
+	if os.IsNotExist(err) {
+		log.Printf("Config dir %s does not exist; creating...", configdir)
+		if err = os.MkdirAll(configdir, 0755); err != nil {
+			return "", err
+		}
+	} else if err != nil {
+		return "", err
+	}
+
 	td, err := ioutil.TempDir(configdir, "tmp")
 	if err != nil {
 		return "", fmt.Errorf("Error creating temp dir: %s", err)

From 0026792d2f60f03abc04239640065e967581310c Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Thu, 3 Oct 2019 15:48:17 -0700
Subject: [PATCH 023/155] remove clean_ami_name and clean_image_name; complete
 the deprecation for these functions in favor of clean_resource_name

---
 builder/amazon/common/template_funcs.go      |  1 -
 builder/azure/common/template_funcs.go       |  1 -
 builder/googlecompute/template_funcs.go      |  1 -
 website/source/docs/templates/engine.html.md | 17 ++++++++++-------
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/builder/amazon/common/template_funcs.go b/builder/amazon/common/template_funcs.go
index 246a288e0..eee77dca2 100644
--- a/builder/amazon/common/template_funcs.go
+++ b/builder/amazon/common/template_funcs.go
@@ -39,5 +39,4 @@ func templateCleanAMIName(s string) string {
 
 var TemplateFuncs = template.FuncMap{
 	"clean_resource_name": templateCleanAMIName,
-	"clean_ami_name":      packertpl.DeprecatedTemplateFunc("clean_ami_name", "clean_resource_name", templateCleanAMIName),
 }
diff --git a/builder/azure/common/template_funcs.go b/builder/azure/common/template_funcs.go
index 1a399b53f..b9b8fe1cb 100644
--- a/builder/azure/common/template_funcs.go
+++ b/builder/azure/common/template_funcs.go
@@ -39,5 +39,4 @@ func templateCleanImageName(s string) string {
 
 var TemplateFuncs = template.FuncMap{
 	"clean_resource_name": templateCleanImageName,
-	"clean_image_name":    packertpl.DeprecatedTemplateFunc("clean_image_name", "clean_resource_name", templateCleanImageName),
 }
diff --git a/builder/googlecompute/template_funcs.go b/builder/googlecompute/template_funcs.go
index bf57f3d96..3b8129861 100644
--- a/builder/googlecompute/template_funcs.go
+++ b/builder/googlecompute/template_funcs.go
@@ -37,5 +37,4 @@ func templateCleanImageName(s string) string {
 
 var TemplateFuncs = template.FuncMap{
 	"clean_resource_name": templateCleanImageName,
-	"clean_image_name":    packertpl.DeprecatedTemplateFunc("clean_image_name", "clean_resource_name", templateCleanImageName),
 }
diff --git a/website/source/docs/templates/engine.html.md b/website/source/docs/templates/engine.html.md
index 821799193..06681e921 100644
--- a/website/source/docs/templates/engine.html.md
+++ b/website/source/docs/templates/engine.html.md
@@ -41,7 +41,7 @@ Here is a full list of the available functions for reference.
     will convert upper cases to lower cases and replace illegal characters with
     a "-" character.  Example:
 
-   `"mybuild-{{isotime | clean_image_name}}"` will become
+   `"mybuild-{{isotime | clean_resource_name}}"` will become
     `mybuild-2017-10-18t02-06-30z`.
 
     Note: Valid Azure image names must match the regex
@@ -57,6 +57,9 @@ Here is a full list of the available functions for reference.
     clean_resource_name}}"` will cause your build to fail because the image
     name will start with a number, which is why in the above example we prepend
     the isotime with "mybuild".
+    Exact behavior of `clean_resource_name` will depend on which builder it is
+    being applied to; refer to build-specific docs below for more detail on how
+    each function will behave.
 -   `env` - Returns environment variables. See example in [using home
     variable](/docs/templates/user-variables.html#using-home-variable)
 -   `isotime [FORMAT]` - UTC time, which can be
@@ -80,19 +83,19 @@ Here is a full list of the available functions for reference.
 
 #### Specific to Amazon builders:
 
--   `clean_ami_name` - DEPRECATED use `clean_resource_name` instead - AMI names
+-   `clean_resource_name` - AMI names
     can only contain certain characters. This function will replace illegal
     characters with a '-" character. Example usage since ":" is not a legal AMI
-    name is: `{{isotime | clean_ami_name}}`.
+    name is: `{{isotime | clean_resource_name}}`.
 
 #### Specific to Google Compute builders:
 
--   `clean_image_name` - DEPRECATED use `clean_resource_name` instead - GCE
+-   `clean_resource_name` - GCE
     image names can only contain certain characters and the maximum length is
     63. This function will convert upper cases to lower cases and replace
         illegal characters with a "-" character. Example:
 
-    `"mybuild-{{isotime | clean_image_name}}"` will become
+    `"mybuild-{{isotime | clean_resource_name}}"` will become
     `mybuild-2017-10-18t02-06-30z`.
 
     Note: Valid GCE image names must match the regex
@@ -107,12 +110,12 @@ Here is a full list of the available functions for reference.
 
 #### Specific to Azure builders:
 
--   `clean_image_name` - DEPRECATED use `clean_resource_name` instead - Azure
+-   `clean_resource_name` - Azure
     managed image names can only contain certain characters and the maximum
     length is 80. This function will replace illegal characters with a "-"
     character. Example:
 
-    `"mybuild-{{isotime | clean_image_name}}"` will become
+    `"mybuild-{{isotime | clean_resource_name}}"` will become
     `mybuild-2017-10-18t02-06-30z`.
 
     Note: Valid Azure image names must match the regex

From d4600a7716cd729c6b246745aae7c279691e947c Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Fri, 4 Oct 2019 11:19:45 +0200
Subject: [PATCH 024/155] fix go imports

---
 builder/amazon/common/template_funcs.go | 2 --
 builder/azure/common/template_funcs.go  | 2 --
 builder/googlecompute/template_funcs.go | 2 --
 3 files changed, 6 deletions(-)

diff --git a/builder/amazon/common/template_funcs.go b/builder/amazon/common/template_funcs.go
index eee77dca2..14dd65d83 100644
--- a/builder/amazon/common/template_funcs.go
+++ b/builder/amazon/common/template_funcs.go
@@ -3,8 +3,6 @@ package common
 import (
 	"bytes"
 	"text/template"
-
-	packertpl "github.com/hashicorp/packer/common/template"
 )
 
 func isalphanumeric(b byte) bool {
diff --git a/builder/azure/common/template_funcs.go b/builder/azure/common/template_funcs.go
index b9b8fe1cb..faccd4f07 100644
--- a/builder/azure/common/template_funcs.go
+++ b/builder/azure/common/template_funcs.go
@@ -3,8 +3,6 @@ package common
 import (
 	"bytes"
 	"text/template"
-
-	packertpl "github.com/hashicorp/packer/common/template"
 )
 
 func isValidByteValue(b byte) bool {
diff --git a/builder/googlecompute/template_funcs.go b/builder/googlecompute/template_funcs.go
index 3b8129861..37557180f 100644
--- a/builder/googlecompute/template_funcs.go
+++ b/builder/googlecompute/template_funcs.go
@@ -3,8 +3,6 @@ package googlecompute
 import (
 	"strings"
 	"text/template"
-
-	packertpl "github.com/hashicorp/packer/common/template"
 )
 
 func isalphanumeric(b byte) bool {

From 3a4079f97adc1435bc2ab0001794f778c14860b2 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Fri, 4 Oct 2019 11:31:33 +0200
Subject: [PATCH 025/155] yandex: use clean_resource_name too

---
 builder/yandex/template_func.go | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/builder/yandex/template_func.go b/builder/yandex/template_func.go
index 91f83a9d5..144ed14e3 100644
--- a/builder/yandex/template_func.go
+++ b/builder/yandex/template_func.go
@@ -1,7 +1,9 @@
 package yandex
 
-import "strings"
-import "text/template"
+import (
+	"strings"
+	"text/template"
+)
 
 func isalphanumeric(b byte) bool {
 	if '0' <= b && b <= '9' {
@@ -13,9 +15,9 @@ func isalphanumeric(b byte) bool {
 	return false
 }
 
-// Clean up image name by replacing invalid characters with "-"
+// Clean up resource name by replacing invalid characters with "-"
 // and converting upper cases to lower cases
-func templateCleanImageName(s string) string {
+func templateCleanResourceName(s string) string {
 	if reImageFamily.MatchString(s) {
 		return s
 	}
@@ -32,5 +34,5 @@ func templateCleanImageName(s string) string {
 }
 
 var TemplateFuncs = template.FuncMap{
-	"clean_image_name": templateCleanImageName,
+	"clean_resource_name": templateCleanResourceName,
 }

From 843986c2d40283806d20a353a13afeac8c826902 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Fri, 4 Oct 2019 10:41:12 -0700
Subject: [PATCH 026/155] missing bracket

---
 common/powershell/hyperv/hyperv.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/powershell/hyperv/hyperv.go b/common/powershell/hyperv/hyperv.go
index 15d8d92b1..dc5d455c8 100644
--- a/common/powershell/hyperv/hyperv.go
+++ b/common/powershell/hyperv/hyperv.go
@@ -38,7 +38,7 @@ if ($HostVMAdapter){
   if ($HostNetAdapter){
     $HostNetAdapterIfIndex = @()
     $HostNetAdapterIfIndex += $HostNetAdapter.ifIndex
-    $HostNetAdapterConfiguration = @(get-wmiobject win32_networkadapterconfiguration -filter "IPEnabled = 'TRUE'") | Where-Object { $HostNetAdapterIfIndex.Contains($_.InterfaceIndex)
+    $HostNetAdapterConfiguration = @(get-wmiobject win32_networkadapterconfiguration -filter "IPEnabled = 'TRUE'") | Where-Object { $HostNetAdapterIfIndex.Contains($_.InterfaceIndex)}
     if ($HostNetAdapterConfiguration){
       return @($HostNetAdapterConfiguration.IpAddress)[$addressIndex]
     }

From 9c91857d285faac9bad587c77419c0461d7bf53b Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Fri, 4 Oct 2019 10:57:30 -0700
Subject: [PATCH 027/155] update changelog

---
 CHANGELOG.md | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 17c00878e..25b0900f1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,25 @@
+## 1.5.0 (Upcoming)
+
+### IMPROVEMENTS:
+* builder/oracle-oci: Support defined tags for oci builder [GH-8172]
+
+### BUG FIXES:
+* builder/amazon: Fix spot instance bug where builder would fail if one
+    availability zone could not support the requested spot instance type, even
+    if another AZ could do so. [GH-8184]
+* builder/docker: Use a unique temp dir for each build to prevent concurrent
+    builds from stomping on each other [GH-8192]
+* builder/openstack: Warn instead of failing on terminate if instance is
+    already shut down [GH-8176]
+* post-processor/digitalocean-import: Fix panic when 'image_regions' not set
+    [GH-8179]
+
+### BACKWARDS INCOMPATIBILITIES:
+* builder/qemu: Provide disk size as a string [GH-7546]
+* core: Finish deprecating old tempalte functions clean_ami_name and
+    clean_image_name in favor of generic clean_resource_name [GH-8193]
+
+
 ## 1.4.4 (October 1, 2019)
 
 ### IMPROVEMENTS:

From 7dbcefaf20ce714c7549b3af610861a227c3dee5 Mon Sep 17 00:00:00 2001
From: amree <mohd.amree@gmail.com>
Date: Sun, 6 Oct 2019 04:25:48 +0800
Subject: [PATCH 028/155] Update "Build an Image" Documentation

We defined a user variable for the region but we're not using it. This
PR will update the template to use that particular variable
---
 website/source/intro/getting-started/build-image.html.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/source/intro/getting-started/build-image.html.md b/website/source/intro/getting-started/build-image.html.md
index 6ddd59914..cf4233b7c 100644
--- a/website/source/intro/getting-started/build-image.html.md
+++ b/website/source/intro/getting-started/build-image.html.md
@@ -235,7 +235,7 @@ Now save the following text in a file named `firstrun.json`:
             "access_key": "{{user `aws_access_key`}}",
             "ami_name": "packer-linux-aws-demo-{{timestamp}}",
             "instance_type": "t2.micro",
-            "region": "us-east-1",
+            "region": "{{user `region`}}",
             "secret_key": "{{user `aws_secret_key`}}",
             "source_ami_filter": {
               "filters": {

From d3f369494a6063fdc559b11b677bb2354a92b978 Mon Sep 17 00:00:00 2001
From: Samuel Noordhuis <samuelnhuis@gmail.com>
Date: Sun, 6 Oct 2019 20:14:04 +1100
Subject: [PATCH 029/155] Add support for SCSI controller selection

---
 builder/proxmox/config.go                    | 21 ++++++++++++--------
 builder/proxmox/config_test.go               |  4 ++++
 builder/proxmox/step_start_vm.go             |  1 +
 website/source/docs/builders/proxmox.html.md |  4 ++++
 4 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/builder/proxmox/config.go b/builder/proxmox/config.go
index 6889c8c07..05dd32b66 100644
--- a/builder/proxmox/config.go
+++ b/builder/proxmox/config.go
@@ -37,14 +37,15 @@ type Config struct {
 	VMName string `mapstructure:"vm_name"`
 	VMID   int    `mapstructure:"vm_id"`
 
-	Memory  int          `mapstructure:"memory"`
-	Cores   int          `mapstructure:"cores"`
-	Sockets int          `mapstructure:"sockets"`
-	OS      string       `mapstructure:"os"`
-	NICs    []nicConfig  `mapstructure:"network_adapters"`
-	Disks   []diskConfig `mapstructure:"disks"`
-	ISOFile string       `mapstructure:"iso_file"`
-	Agent   bool         `mapstructure:"qemu_agent"`
+	Memory         int          `mapstructure:"memory"`
+	Cores          int          `mapstructure:"cores"`
+	Sockets        int          `mapstructure:"sockets"`
+	OS             string       `mapstructure:"os"`
+	NICs           []nicConfig  `mapstructure:"network_adapters"`
+	Disks          []diskConfig `mapstructure:"disks"`
+	ISOFile        string       `mapstructure:"iso_file"`
+	Agent          bool         `mapstructure:"qemu_agent"`
+	SCSIController string       `mapstructure:"scsi_controller"`
 
 	TemplateName        string `mapstructure:"template_name"`
 	TemplateDescription string `mapstructure:"template_description"`
@@ -159,6 +160,10 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 			errs = packer.MultiErrorAppend(errs, errors.New(fmt.Sprintf("disk format must be specified for pool type %q", c.Disks[idx].StoragePoolType)))
 		}
 	}
+	if c.SCSIController == "" {
+		log.Printf("SCSI controller not set, using default 'lsi'")
+		c.SCSIController = "lsi"
+	}
 
 	errs = packer.MultiErrorAppend(errs, c.Comm.Prepare(&c.ctx)...)
 	errs = packer.MultiErrorAppend(errs, c.BootConfig.Prepare(&c.ctx)...)
diff --git a/builder/proxmox/config_test.go b/builder/proxmox/config_test.go
index ec654dc54..ce6041ddd 100644
--- a/builder/proxmox/config_test.go
+++ b/builder/proxmox/config_test.go
@@ -94,6 +94,7 @@ func TestBasicExampleFromDocsIsValid(t *testing.T) {
 	// NIC 0 model not set, using default 'e1000'
 	// Disk 0 cache mode not set, using default 'none'
 	// Agent not set, default is true
+	// SCSI controller not set, using default 'lsi'
 
 	if b.config.Memory != 512 {
 		t.Errorf("Expected Memory to be 512, got %d", b.config.Memory)
@@ -116,6 +117,9 @@ func TestBasicExampleFromDocsIsValid(t *testing.T) {
 	if b.config.Agent != true {
 		t.Errorf("Expected Agent to be true, got %t", b.config.Agent)
 	}
+	if b.config.SCSIController != "lsi" {
+		t.Errorf("Expected SCSI controller to be 'lsi', got %s", b.config.SCSIController)
+	}
 }
 
 func TestAgentSetToFalse(t *testing.T) {
diff --git a/builder/proxmox/step_start_vm.go b/builder/proxmox/step_start_vm.go
index 76663b33f..71e3fa15f 100644
--- a/builder/proxmox/step_start_vm.go
+++ b/builder/proxmox/step_start_vm.go
@@ -40,6 +40,7 @@ func (s *stepStartVM) Run(ctx context.Context, state multistep.StateBag) multist
 		QemuIso:      c.ISOFile,
 		QemuNetworks: generateProxmoxNetworkAdapters(c.NICs),
 		QemuDisks:    generateProxmoxDisks(c.Disks),
+		Scsihw:       c.SCSIController,
 	}
 
 	if c.VMID == 0 {
diff --git a/website/source/docs/builders/proxmox.html.md b/website/source/docs/builders/proxmox.html.md
index ca7c99ea3..3c5c8db55 100644
--- a/website/source/docs/builders/proxmox.html.md
+++ b/website/source/docs/builders/proxmox.html.md
@@ -152,6 +152,10 @@ builder.
     then `qemu-guest-agent` must be installed on the guest. When disabled, then 
     `ssh_host` should be used. Defaults to `true`.
 
+-   `scsi_controller` (string) - The SCSI controller model to emulate. Can be `lsi`,
+    `lsi53c810`, `virtio-scsi-pci`, `virtio-scsi-single`, `megasas`, or `pvscsi`.
+    Defaults to `lsi`.
+
 ## Example: Fedora with kickstart
 
 Here is a basic example creating a Fedora 29 server image with a Kickstart

From 5add6cc6c86864acea29092a66916ca19c5fd051 Mon Sep 17 00:00:00 2001
From: Samuel Noordhuis <samuelnhuis@gmail.com>
Date: Sun, 6 Oct 2019 21:39:53 +1100
Subject: [PATCH 030/155] Add ability to select CPU type

---
 builder/proxmox/config.go                    | 5 +++++
 builder/proxmox/config_test.go               | 4 ++++
 builder/proxmox/step_start_vm.go             | 2 +-
 website/source/docs/builders/proxmox.html.md | 4 ++++
 4 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/builder/proxmox/config.go b/builder/proxmox/config.go
index 6889c8c07..9b478672c 100644
--- a/builder/proxmox/config.go
+++ b/builder/proxmox/config.go
@@ -40,6 +40,7 @@ type Config struct {
 	Memory  int          `mapstructure:"memory"`
 	Cores   int          `mapstructure:"cores"`
 	Sockets int          `mapstructure:"sockets"`
+	CPUType string       `mapstructure:"cpu_type"`
 	OS      string       `mapstructure:"os"`
 	NICs    []nicConfig  `mapstructure:"network_adapters"`
 	Disks   []diskConfig `mapstructure:"disks"`
@@ -129,6 +130,10 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 		log.Printf("Number of sockets %d is too small, using default: 1", c.Sockets)
 		c.Sockets = 1
 	}
+	if c.CPUType == "" {
+		log.Printf("CPU type not set, using default 'kvm64'")
+		c.CPUType = "kvm64"
+	}
 	if c.OS == "" {
 		log.Printf("OS not set, using default 'other'")
 		c.OS = "other"
diff --git a/builder/proxmox/config_test.go b/builder/proxmox/config_test.go
index ec654dc54..65d9df9d9 100644
--- a/builder/proxmox/config_test.go
+++ b/builder/proxmox/config_test.go
@@ -90,6 +90,7 @@ func TestBasicExampleFromDocsIsValid(t *testing.T) {
 	// Memory 0 is too small, using default: 512
 	// Number of cores 0 is too small, using default: 1
 	// Number of sockets 0 is too small, using default: 1
+	// CPU type not set, using default 'kvm64'
 	// OS not set, using default 'other'
 	// NIC 0 model not set, using default 'e1000'
 	// Disk 0 cache mode not set, using default 'none'
@@ -104,6 +105,9 @@ func TestBasicExampleFromDocsIsValid(t *testing.T) {
 	if b.config.Sockets != 1 {
 		t.Errorf("Expected Sockets to be 1, got %d", b.config.Sockets)
 	}
+	if b.config.CPUType != "kvm64" {
+		t.Errorf("Expected CPU type to be 'kvm64', got %s", b.config.CPUType)
+	}
 	if b.config.OS != "other" {
 		t.Errorf("Expected OS to be 'other', got %s", b.config.OS)
 	}
diff --git a/builder/proxmox/step_start_vm.go b/builder/proxmox/step_start_vm.go
index 76663b33f..ee67ca7df 100644
--- a/builder/proxmox/step_start_vm.go
+++ b/builder/proxmox/step_start_vm.go
@@ -31,7 +31,7 @@ func (s *stepStartVM) Run(ctx context.Context, state multistep.StateBag) multist
 		Name:         c.VMName,
 		Agent:        agent,
 		Boot:         "cdn", // Boot priority, c:CDROM -> d:Disk -> n:Network
-		QemuCpu:      "host",
+		QemuCpu:      c.CPUType,
 		Description:  "Packer ephemeral build VM",
 		Memory:       c.Memory,
 		QemuCores:    c.Cores,
diff --git a/website/source/docs/builders/proxmox.html.md b/website/source/docs/builders/proxmox.html.md
index ca7c99ea3..68e5aa5a7 100644
--- a/website/source/docs/builders/proxmox.html.md
+++ b/website/source/docs/builders/proxmox.html.md
@@ -73,6 +73,10 @@ builder.
 -   `sockets` (int) - How many CPU sockets to give the virtual machine.
     Defaults to `1`
 
+-   `cpu_type` (string) - The CPU type to emulate. See the Proxmox API
+    documentation for the complete list of accepted values. For best
+    performance, set this to `host`. Defaults to `kvm64`.
+
 -   `os` (string) - The operating system. Can be `wxp`, `w2k`, `w2k3`, `w2k8`,
     `wvista`, `win7`, `win8`, `win10`, `l24` (Linux 2.4), `l26` (Linux 2.6+),
     `solaris` or `other`. Defaults to `other`.

From eecac683b869683baa1335deb858cb5a489174ff Mon Sep 17 00:00:00 2001
From: Samuel Noordhuis <samuelnhuis@gmail.com>
Date: Tue, 8 Oct 2019 19:45:15 +1100
Subject: [PATCH 031/155] Update builder/proxmox/config.go

Co-Authored-By: Adrien Delorme <azr@users.noreply.github.com>
---
 builder/proxmox/config.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/builder/proxmox/config.go b/builder/proxmox/config.go
index 3f516beb7..766d3e71d 100644
--- a/builder/proxmox/config.go
+++ b/builder/proxmox/config.go
@@ -39,7 +39,7 @@ type Config struct {
 
 	Memory         int          `mapstructure:"memory"`
 	Cores          int          `mapstructure:"cores"`
-  CPUType        string       `mapstructure:"cpu_type"`
+	CPUType        string       `mapstructure:"cpu_type"`
 	Sockets        int          `mapstructure:"sockets"`
 	OS             string       `mapstructure:"os"`
 	NICs           []nicConfig  `mapstructure:"network_adapters"`

From 2c6df3017f8ff85d6ef3daa70e9d5df0ff4f6a42 Mon Sep 17 00:00:00 2001
From: Calle Pettersson <calle@cape.nu>
Date: Tue, 8 Oct 2019 11:04:42 +0200
Subject: [PATCH 032/155] Add builder CODEOWNERS to respective docs

---
 CODEOWNERS | 72 +++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 55 insertions(+), 17 deletions(-)

diff --git a/CODEOWNERS b/CODEOWNERS
index 0bbc1d4b7..c814a4e94 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -3,24 +3,62 @@
 # builders
 
 /builder/alicloud/                      @chhaj5236
-/builder/azure/                         @paulmey
-/builder/hyperv/                        @taliesins
-/builder/jdcloud/                       @XiaohanLiang @remrain
-/builder/linode/                        @displague @ctreatma @stvnjacobs
-/builder/lxc/                           @ChrisLundquist
-/builder/lxd/                           @ChrisLundquist
-/builder/oneandone/                     @jasmingacic
-/builder/oracle/                        @prydie @owainlewis
-/builder/profitbricks/                  @jasmingacic
-/builder/triton/                        @sean-
-/builder/ncloud/                        @YuSungDuk
-/builder/proxmox/                       @carlpett
+/website/source/docs/builders/alicloud* @chhaj5236
+
+/builder/azure/                      @paulmey
+/website/source/docs/builders/azure* @paulmey
+
+/builder/hyperv/                      @taliesins
+/website/source/docs/builders/hyperv* @taliesins
+
+/builder/jdcloud/                      @XiaohanLiang @remrain
+/website/source/docs/builders/jdcloud* @XiaohanLiang @remrain
+
+/builder/linode/                      @displague @ctreatma @stvnjacobs
+/website/source/docs/builders/linode* @displague @ctreatma @stvnjacobs
+
+/builder/lxc/                      @ChrisLundquist
+/website/source/docs/builders/lxc* @ChrisLundquist
+
+/builder/lxd/                      @ChrisLundquist
+/website/source/docs/builders/lxd* @ChrisLundquist
+
+/builder/oneandone/                      @jasmingacic
+/website/source/docs/builders/oneandone* @jasmingacic
+
+/builder/oracle/                      @prydie @owainlewis
+/website/source/docs/builders/oracle* @prydie @owainlewis
+
+/builder/profitbricks/                      @jasmingacic
+/website/source/docs/builders/profitbricks* @jasmingacic
+
+/builder/triton/                      @sean-
+/website/source/docs/builders/triton* @sean-
+
+/builder/ncloud/                      @YuSungDuk
+/website/source/docs/builders/ncloud* @YuSungDuk
+
+/builder/proxmox/                      @carlpett
+/website/source/docs/builders/proxmox* @carlpett
+
 /builder/scaleway/                      @sieben @mvaude @jqueuniet @fflorens @brmzkw
-/builder/hcloud/                        @LKaemmerling
-/builder/hyperone                       @m110 @gregorybrzeski @ad-m
-/builder/ucloud/                        @shawnmssu
-/builder/yandex                         @GennadySpb @alexanderKhaustov @seukyaso
-/builder/osc                            @marinsalinas
+/website/source/docs/builders/scaleway* @sieben @mvaude @jqueuniet @fflorens @brmzkw
+
+/builder/hcloud/                      @LKaemmerling
+/website/source/docs/builders/hcloud* @LKaemmerling
+
+/builder/hyperone/                      @m110 @gregorybrzeski @ad-m
+/website/source/docs/builders/hyperone* @m110 @gregorybrzeski @ad-m
+
+/builder/ucloud/                      @shawnmssu
+/website/source/docs/builders/ucloud* @shawnmssu
+
+/builder/yandex/                      @GennadySpb @alexanderKhaustov @seukyaso
+/website/source/docs/builders/yandex* @GennadySpb @alexanderKhaustov @seukyaso
+
+/builder/osc/                      @marinsalinas
+/website/source/docs/builders/osc* @marinsalinas
+
 
 # provisioners
 

From 595b103bbeefd556f1a71ebf2b7650cc610cdf5e Mon Sep 17 00:00:00 2001
From: Sumit Kalra <44450797+sumit-kalra@users.noreply.github.com>
Date: Tue, 8 Oct 2019 14:56:43 -0700
Subject: [PATCH 033/155] Adding NSG to the ARM deployment template when needed
 (#3)

* Adding NSG to the ARM eployment template when needed

* Adding tests and fixing bugs

* Removing denyall rule

* Fixing logic to determine which port to open

* Fixing config description
---
 builder/azure/arm/azure_client.go             |   7 +
 builder/azure/arm/config.go                   |   6 +-
 builder/azure/arm/config_test.go              |   4 +
 builder/azure/arm/step_deploy_template.go     |   6 +
 builder/azure/arm/template_factory.go         |   8 +
 ..._factory_test.TestPlanInfo01.approved.json |   4 +
 ..._factory_test.TestPlanInfo02.approved.json |   4 +
 ...stVirtualMachineDeployment03.approved.json |   4 +
 ...stVirtualMachineDeployment04.approved.json |   4 +
 ...stVirtualMachineDeployment05.approved.json |   4 +
 ...stVirtualMachineDeployment06.approved.json |   4 +
 ...stVirtualMachineDeployment07.approved.json |   4 +
 ...stVirtualMachineDeployment08.approved.json |   4 +
 ...stVirtualMachineDeployment09.approved.json |   4 +
 ...stVirtualMachineDeployment10.approved.json |   4 +
 ...stVirtualMachineDeployment11.approved.json |   4 +
 ...stVirtualMachineDeployment12.approved.json |   4 +
 ...stVirtualMachineDeployment13.approved.json | 227 ++++++++++++++++++
 builder/azure/arm/template_factory_test.go    |  34 +++
 builder/azure/arm/tempname.go                 |   2 +
 builder/azure/arm/tempname_test.go            |   8 +
 builder/azure/common/template/template.go     |   9 +-
 .../azure/common/template/template_builder.go | 103 +++++++-
 ...uilder_test.TestBuildLinux00.approved.json |   4 +
 ...uilder_test.TestBuildLinux01.approved.json |   4 +
 ...uilder_test.TestBuildLinux02.approved.json |   4 +
 ...lder_test.TestBuildWindows00.approved.json |   4 +
 ...lder_test.TestBuildWindows01.approved.json |   4 +
 ...lder_test.TestBuildWindows02.approved.json |   4 +
 ...t.TestNetworkSecurityGroup00.approved.json | 212 ++++++++++++++++
 ...est.TestSharedImageGallery00.approved.json |   4 +
 .../common/template/template_builder_test.go  |  33 +++
 .../common/template/template_parameters.go    |   1 +
 .../template/template_parameters_test.go      |   3 +
 34 files changed, 729 insertions(+), 10 deletions(-)
 create mode 100644 builder/azure/arm/template_factory_test.TestVirtualMachineDeployment13.approved.json
 create mode 100644 builder/azure/common/template/template_builder_test.TestNetworkSecurityGroup00.approved.json

diff --git a/builder/azure/arm/azure_client.go b/builder/azure/arm/azure_client.go
index ab4330e37..22acda3f6 100644
--- a/builder/azure/arm/azure_client.go
+++ b/builder/azure/arm/azure_client.go
@@ -37,6 +37,7 @@ type AzureClient struct {
 	network.InterfacesClient
 	network.SubnetsClient
 	network.VirtualNetworksClient
+	network.SecurityGroupsClient
 	compute.ImagesClient
 	compute.VirtualMachinesClient
 	common.VaultClient
@@ -182,6 +183,12 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.VirtualNetworksClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.VirtualNetworksClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VirtualNetworksClient.UserAgent)
 
+	azureClient.SecurityGroupsClient = network.NewSecurityGroupsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
+	azureClient.SecurityGroupsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
+	azureClient.SecurityGroupsClient.RequestInspector = withInspection(maxlen)
+	azureClient.SecurityGroupsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
+	azureClient.SecurityGroupsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.SecurityGroupsClient.UserAgent)
+
 	azureClient.PublicIPAddressesClient = network.NewPublicIPAddressesClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.PublicIPAddressesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.PublicIPAddressesClient.RequestInspector = withInspection(maxlen)
diff --git a/builder/azure/arm/config.go b/builder/azure/arm/config.go
index eef7599a0..bf072d5da 100644
--- a/builder/azure/arm/config.go
+++ b/builder/azure/arm/config.go
@@ -347,7 +347,9 @@ type Config struct {
 	// allowed access to the VM. If provided, an Azure Network Security
 	// Group will be created with corresponding rules and be bound to
 	// the NIC attached to the VM.
-	AllowedInboundIpAddresses         []string `mapstructure:"allowed_inbound_ip_addresses"`
+	// Providing `allowed_inbound_ip_addresses` in combination with
+	// `virtual_network_name` is not allowed.
+	AllowedInboundIpAddresses []string `mapstructure:"allowed_inbound_ip_addresses"`
 
 	// Runtime Values
 	UserName               string
@@ -363,6 +365,7 @@ type Config struct {
 	tmpOSDiskName          string
 	tmpSubnetName          string
 	tmpVirtualNetworkName  string
+	tmpNsgName             string
 	tmpWinRMCertificateUrl string
 
 	// Authentication with the VM via SSH
@@ -610,6 +613,7 @@ func setRuntimeValues(c *Config) {
 	c.tmpOSDiskName = tempName.OSDiskName
 	c.tmpSubnetName = tempName.SubnetName
 	c.tmpVirtualNetworkName = tempName.VirtualNetworkName
+	c.tmpNsgName = tempName.NsgName
 	c.tmpKeyVaultName = tempName.KeyVaultName
 }
 
diff --git a/builder/azure/arm/config_test.go b/builder/azure/arm/config_test.go
index d90e31f44..d541b2f9f 100644
--- a/builder/azure/arm/config_test.go
+++ b/builder/azure/arm/config_test.go
@@ -506,6 +506,10 @@ func TestSystemShouldDefineRuntimeValues(t *testing.T) {
 	if c.tmpOSDiskName == "" {
 		t.Errorf("Expected tmpOSDiskName to not be empty, but it was '%s'!", c.tmpOSDiskName)
 	}
+
+	if c.tmpNsgName == "" {
+		t.Errorf("Expected tmpNsgName to not be empty, but it was '%s'!", c.tmpNsgName)
+	}
 }
 
 func TestConfigShouldTransformToVirtualMachineCaptureParameters(t *testing.T) {
diff --git a/builder/azure/arm/step_deploy_template.go b/builder/azure/arm/step_deploy_template.go
index c20e4630d..759017526 100644
--- a/builder/azure/arm/step_deploy_template.go
+++ b/builder/azure/arm/step_deploy_template.go
@@ -115,6 +115,12 @@ func deleteResource(ctx context.Context, client *AzureClient, resourceType strin
 			err = f.WaitForCompletionRef(ctx, client.VirtualNetworksClient.Client)
 		}
 		return err
+	case "Microsoft.Network/networkSecurityGroups":
+		f, err := client.SecurityGroupsClient.Delete(ctx, resourceGroupName, resourceName)
+		if err == nil {
+			err = f.WaitForCompletionRef(ctx, client.SecurityGroupsClient.Client)
+		}
+		return err
 	case "Microsoft.Network/publicIPAddresses":
 		f, err := client.PublicIPAddressesClient.Delete(ctx, resourceGroupName, resourceName)
 		if err == nil {
diff --git a/builder/azure/arm/template_factory.go b/builder/azure/arm/template_factory.go
index 0401f9f9b..80dd296a5 100644
--- a/builder/azure/arm/template_factory.go
+++ b/builder/azure/arm/template_factory.go
@@ -40,6 +40,7 @@ func GetVirtualMachineDeployment(config *Config) (*resources.Deployment, error)
 		SubnetName:                 &template.TemplateParameter{Value: config.tmpSubnetName},
 		StorageAccountBlobEndpoint: &template.TemplateParameter{Value: config.storageAccountBlobEndpoint},
 		VirtualNetworkName:         &template.TemplateParameter{Value: config.tmpVirtualNetworkName},
+		NsgName:                    &template.TemplateParameter{Value: config.tmpNsgName},
 		VMSize:                     &template.TemplateParameter{Value: config.VMSize},
 		VMName:                     &template.TemplateParameter{Value: config.tmpComputeName},
 	}
@@ -117,6 +118,13 @@ func GetVirtualMachineDeployment(config *Config) (*resources.Deployment, error)
 			config.VirtualNetworkSubnetName)
 	}
 
+	if config.AllowedInboundIpAddresses != nil && len(config.AllowedInboundIpAddresses) >= 1 && config.Comm.Port() != 0 {
+		err = builder.SetNetworkSecurityGroup(config.AllowedInboundIpAddresses, config.Comm.Port())
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	builder.SetTags(&config.AzureTags)
 	doc, _ := builder.ToJSON()
 	return createDeploymentParameters(*doc, params)
diff --git a/builder/azure/arm/template_factory_test.TestPlanInfo01.approved.json b/builder/azure/arm/template_factory_test.TestPlanInfo01.approved.json
index 392dc0ec9..30ede3ae4 100644
--- a/builder/azure/arm/template_factory_test.TestPlanInfo01.approved.json
+++ b/builder/azure/arm/template_factory_test.TestPlanInfo01.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -189,6 +192,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestPlanInfo02.approved.json b/builder/azure/arm/template_factory_test.TestPlanInfo02.approved.json
index b29616711..657af585d 100644
--- a/builder/azure/arm/template_factory_test.TestPlanInfo02.approved.json
+++ b/builder/azure/arm/template_factory_test.TestPlanInfo02.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -194,6 +197,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment03.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment03.approved.json
index 463a9e473..cda8c56dc 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment03.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment03.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -160,6 +163,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment04.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment04.approved.json
index ee78c0825..8c922bfa5 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment04.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment04.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -158,6 +161,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment05.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment05.approved.json
index 51301ea4e..9e66583fb 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment05.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment05.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -119,6 +122,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment06.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment06.approved.json
index b7e8d9ba5..ce8b43ed8 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment06.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment06.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -178,6 +181,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment07.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment07.approved.json
index 7208af852..66cf47288 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment07.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment07.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -159,6 +162,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment08.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment08.approved.json
index d7f3aa148..cdabe3c93 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment08.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment08.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -158,6 +161,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment09.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment09.approved.json
index 784e7ce4d..5af5b01bc 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment09.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment09.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -161,6 +164,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment10.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment10.approved.json
index 0c7903a3d..a9c3d267c 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment10.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment10.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -139,6 +142,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment11.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment11.approved.json
index bf94c8581..5ac3905c0 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment11.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment11.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -172,6 +175,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment12.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment12.approved.json
index dc1ec1509..4339b1864 100644
--- a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment12.approved.json
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment12.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -173,6 +176,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment13.approved.json b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment13.approved.json
new file mode 100644
index 000000000..9127c3bac
--- /dev/null
+++ b/builder/azure/arm/template_factory_test.TestVirtualMachineDeployment13.approved.json
@@ -0,0 +1,227 @@
+{
+  "$schema": "http://schema.management.azure.com/schemas/2014-04-01-preview/deploymentTemplate.json",
+  "contentVersion": "1.0.0.0",
+  "parameters": {
+    "adminPassword": {
+      "type": "string"
+    },
+    "adminUsername": {
+      "type": "string"
+    },
+    "dnsNameForPublicIP": {
+      "type": "string"
+    },
+    "nicName": {
+      "type": "string"
+    },
+    "nsgName": {
+      "type": "string"
+    },
+    "osDiskName": {
+      "type": "string"
+    },
+    "publicIPAddressName": {
+      "type": "string"
+    },
+    "storageAccountBlobEndpoint": {
+      "type": "string"
+    },
+    "subnetName": {
+      "type": "string"
+    },
+    "virtualNetworkName": {
+      "type": "string"
+    },
+    "vmName": {
+      "type": "string"
+    },
+    "vmSize": {
+      "type": "string"
+    }
+  },
+  "resources": [
+    {
+      "apiVersion": "[variables('publicIPAddressApiVersion')]",
+      "location": "[variables('location')]",
+      "name": "[parameters('publicIPAddressName')]",
+      "properties": {
+        "dnsSettings": {
+          "domainNameLabel": "[parameters('dnsNameForPublicIP')]"
+        },
+        "publicIPAllocationMethod": "[variables('publicIPAddressType')]"
+      },
+      "type": "Microsoft.Network/publicIPAddresses"
+    },
+    {
+      "apiVersion": "[variables('networkInterfacesApiVersion')]",
+      "dependsOn": [
+        "[concat('Microsoft.Network/publicIPAddresses/', parameters('publicIPAddressName'))]",
+        "[concat('Microsoft.Network/virtualNetworks/', variables('virtualNetworkName'))]"
+      ],
+      "location": "[variables('location')]",
+      "name": "[parameters('nicName')]",
+      "properties": {
+        "ipConfigurations": [
+          {
+            "name": "ipconfig",
+            "properties": {
+              "privateIPAllocationMethod": "Dynamic",
+              "publicIPAddress": {
+                "id": "[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicIPAddressName'))]"
+              },
+              "subnet": {
+                "id": "[variables('subnetRef')]"
+              }
+            }
+          }
+        ]
+      },
+      "type": "Microsoft.Network/networkInterfaces"
+    },
+    {
+      "apiVersion": "[variables('apiVersion')]",
+      "dependsOn": [
+        "[concat('Microsoft.Network/networkInterfaces/', parameters('nicName'))]"
+      ],
+      "location": "[variables('location')]",
+      "name": "[parameters('vmName')]",
+      "properties": {
+        "diagnosticsProfile": {
+          "bootDiagnostics": {
+            "enabled": false
+          }
+        },
+        "hardwareProfile": {
+          "vmSize": "[parameters('vmSize')]"
+        },
+        "networkProfile": {
+          "networkInterfaces": [
+            {
+              "id": "[resourceId('Microsoft.Network/networkInterfaces', parameters('nicName'))]"
+            }
+          ]
+        },
+        "osProfile": {
+          "adminPassword": "[parameters('adminPassword')]",
+          "adminUsername": "[parameters('adminUsername')]",
+          "computerName": "[parameters('vmName')]",
+          "secrets": [
+            {
+              "sourceVault": {
+                "id": "[resourceId(resourceGroup().name, 'Microsoft.KeyVault/vaults', '--keyvault-name--')]"
+              },
+              "vaultCertificates": [
+                {
+                  "certificateStore": "My",
+                  "certificateUrl": ""
+                }
+              ]
+            }
+          ],
+          "windowsConfiguration": {
+            "provisionVMAgent": true,
+            "winRM": {
+              "listeners": [
+                {
+                  "certificateUrl": "",
+                  "protocol": "https"
+                }
+              ]
+            }
+          }
+        },
+        "storageProfile": {
+          "imageReference": {
+            "offer": "--image-offer--",
+            "publisher": "--image-publisher--",
+            "sku": "--image-sku--",
+            "version": "--version--"
+          },
+          "osDisk": {
+            "caching": "ReadWrite",
+            "createOption": "FromImage",
+            "managedDisk": {
+              "storageAccountType": "Standard_LRS"
+            },
+            "name": "[parameters('osDiskName')]",
+            "osType": "Windows"
+          }
+        }
+      },
+      "type": "Microsoft.Compute/virtualMachines"
+    },
+    {
+      "apiVersion": "[variables('networkSecurityGroupsApiVersion')]",
+      "location": "[variables('location')]",
+      "name": "[parameters('nsgName')]",
+      "properties": {
+        "securityRules": [
+          {
+            "name": "AllowIPsToSshWinRMInbound",
+            "properties": {
+              "access": "Allow",
+              "description": "Allow inbound traffic from specified IP addresses",
+              "destinationAddressPrefix": "VirtualNetwork",
+              "destinationPortRange": "5985",
+              "direction": "Inbound",
+              "priority": 100,
+              "protocol": "Tcp",
+              "sourceAddressPrefixes": [
+                "127.0.0.1",
+                "192.168.100.0/24"
+              ],
+              "sourcePortRange": "*"
+            }
+          }
+        ]
+      },
+      "type": "Microsoft.Network/networkSecurityGroups"
+    },
+    {
+      "apiVersion": "[variables('virtualNetworksApiVersion')]",
+      "dependsOn": [
+        "[concat('Microsoft.Network/networkSecurityGroups/', parameters('nsgName'))]"
+      ],
+      "location": "[variables('location')]",
+      "name": "[variables('virtualNetworkName')]",
+      "properties": {
+        "addressSpace": {
+          "addressPrefixes": [
+            "[variables('addressPrefix')]"
+          ]
+        },
+        "subnets": [
+          {
+            "name": "[variables('subnetName')]",
+            "properties": {
+              "addressPrefix": "[variables('subnetAddressPrefix')]",
+              "networkSecurityGroup": {
+                "id": "[resourceId('Microsoft.Network/networkSecurityGroups', parameters('nsgName'))]"
+              }
+            }
+          }
+        ]
+      },
+      "type": "Microsoft.Network/virtualNetworks"
+    }
+  ],
+  "variables": {
+    "addressPrefix": "10.0.0.0/16",
+    "apiVersion": "2017-03-30",
+    "location": "[resourceGroup().location]",
+    "managedDiskApiVersion": "2017-03-30",
+    "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
+    "publicIPAddressApiVersion": "2017-04-01",
+    "publicIPAddressType": "Dynamic",
+    "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
+    "subnetAddressPrefix": "10.0.0.0/24",
+    "subnetName": "[parameters('subnetName')]",
+    "subnetRef": "[concat(variables('vnetID'),'/subnets/',variables('subnetName'))]",
+    "virtualNetworkName": "[parameters('virtualNetworkName')]",
+    "virtualNetworkResourceGroup": "[resourceGroup().name]",
+    "virtualNetworksApiVersion": "2017-04-01",
+    "vmStorageAccountContainerName": "images",
+    "vnetID": "[resourceId(variables('virtualNetworkResourceGroup'), 'Microsoft.Network/virtualNetworks', variables('virtualNetworkName'))]"
+  }
+}
\ No newline at end of file
diff --git a/builder/azure/arm/template_factory_test.go b/builder/azure/arm/template_factory_test.go
index 382a0b490..069415893 100644
--- a/builder/azure/arm/template_factory_test.go
+++ b/builder/azure/arm/template_factory_test.go
@@ -425,6 +425,40 @@ func TestVirtualMachineDeployment12(t *testing.T) {
 	}
 }
 
+// Ensure the VM template is correct when building with list of allowed IP addresses
+func TestVirtualMachineDeployment13(t *testing.T) {
+	config := map[string]interface{}{
+		"location":                          "ignore",
+		"subscription_id":                   "ignore",
+		"os_type":                           constants.Target_Windows,
+		"communicator":                      "winrm",
+		"winrm_username":                    "ignore",
+		"image_publisher":                   "--image-publisher--",
+		"image_offer":                       "--image-offer--",
+		"image_sku":                         "--image-sku--",
+		"image_version":                     "--version--",
+		"managed_image_name":                "ManagedImageName",
+		"managed_image_resource_group_name": "ManagedImageResourceGroupName",
+		"allowed_inbound_ip_addresses":      []string{"127.0.0.1", "192.168.100.0/24"},
+	}
+
+	c, _, err := newConfig(config, getPackerConfiguration())
+	if err != nil {
+		t.Fatal(err)
+	}
+	c.tmpKeyVaultName = "--keyvault-name--"
+
+	deployment, err := GetVirtualMachineDeployment(c)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = approvaltests.VerifyJSONStruct(t, deployment.Properties.Template)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
 // Ensure the link values are not set, and the concrete values are set.
 func TestKeyVaultDeployment00(t *testing.T) {
 	c, _, _ := newConfig(getArmBuilderConfiguration(), getPackerConfiguration())
diff --git a/builder/azure/arm/tempname.go b/builder/azure/arm/tempname.go
index b5289d450..45fb97e63 100644
--- a/builder/azure/arm/tempname.go
+++ b/builder/azure/arm/tempname.go
@@ -19,6 +19,7 @@ type TempName struct {
 	SubnetName          string
 	PublicIPAddressName string
 	VirtualNetworkName  string
+	NsgName             string
 }
 
 func NewTempName() *TempName {
@@ -33,6 +34,7 @@ func NewTempName() *TempName {
 	tempName.PublicIPAddressName = fmt.Sprintf("pkrip%s", suffix)
 	tempName.SubnetName = fmt.Sprintf("pkrsn%s", suffix)
 	tempName.VirtualNetworkName = fmt.Sprintf("pkrvn%s", suffix)
+	tempName.NsgName = fmt.Sprintf("pkrsg%s", suffix)
 	tempName.ResourceGroupName = fmt.Sprintf("packer-Resource-Group-%s", suffix)
 
 	tempName.AdminPassword = generatePassword()
diff --git a/builder/azure/arm/tempname_test.go b/builder/azure/arm/tempname_test.go
index 0b3608e18..e6a6fd236 100644
--- a/builder/azure/arm/tempname_test.go
+++ b/builder/azure/arm/tempname_test.go
@@ -41,6 +41,10 @@ func TestTempNameShouldCreatePrefixedRandomNames(t *testing.T) {
 	if strings.Index(tempName.VirtualNetworkName, "pkrvn") != 0 {
 		t.Errorf("Expected VirtualNetworkName to begin with 'pkrvn', but got '%s'!", tempName.VirtualNetworkName)
 	}
+
+	if strings.Index(tempName.NsgName, "pkrsg") != 0 {
+		t.Errorf("Expected NsgName to begin with 'pkrsg', but got '%s'!", tempName.NsgName)
+	}
 }
 
 func TestTempAdminPassword(t *testing.T) {
@@ -92,4 +96,8 @@ func TestTempNameShouldHaveSameSuffix(t *testing.T) {
 	if strings.HasSuffix(tempName.VirtualNetworkName, suffix) != true {
 		t.Errorf("Expected VirtualNetworkName to end with '%s', but the value is '%s'!", suffix, tempName.VirtualNetworkName)
 	}
+
+	if strings.HasSuffix(tempName.NsgName, suffix) != true {
+		t.Errorf("Expected NsgName to end with '%s', but the value is '%s'!", suffix, tempName.NsgName)
+	}
 }
diff --git a/builder/azure/common/template/template.go b/builder/azure/common/template/template.go
index 6c4429c34..b90d0104b 100644
--- a/builder/azure/common/template/template.go
+++ b/builder/azure/common/template/template.go
@@ -91,10 +91,11 @@ type Properties struct {
 	PublicIPAllocatedMethod      *network.IPAllocationMethod         `json:"publicIPAllocationMethod,omitempty"`
 	Sku                          *Sku                                `json:"sku,omitempty"`
 	//StorageProfile3              *compute.StorageProfile             `json:"storageProfile,omitempty"`
-	StorageProfile *StorageProfileUnion `json:"storageProfile,omitempty"`
-	Subnets        *[]network.Subnet    `json:"subnets,omitempty"`
-	TenantId       *string              `json:"tenantId,omitempty"`
-	Value          *string              `json:"value,omitempty"`
+	StorageProfile *StorageProfileUnion    `json:"storageProfile,omitempty"`
+	Subnets        *[]network.Subnet       `json:"subnets,omitempty"`
+	SecurityRules  *[]network.SecurityRule `json:"securityRules,omitempty"`
+	TenantId       *string                 `json:"tenantId,omitempty"`
+	Value          *string                 `json:"value,omitempty"`
 }
 
 type AccessPolicies struct {
diff --git a/builder/azure/common/template/template_builder.go b/builder/azure/common/template/template_builder.go
index 188fdaf7b..1e1eb53d4 100644
--- a/builder/azure/common/template/template_builder.go
+++ b/builder/azure/common/template/template_builder.go
@@ -3,9 +3,11 @@ package template
 import (
 	"encoding/json"
 	"fmt"
+	"strconv"
 	"strings"
 
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-04-01/compute"
+	"github.com/Azure/azure-sdk-for-go/services/network/mgmt/2018-01-01/network"
 	"github.com/Azure/go-autorest/autorest/to"
 )
 
@@ -13,11 +15,12 @@ const (
 	jsonPrefix = ""
 	jsonIndent = "  "
 
-	resourceKeyVaults         = "Microsoft.KeyVault/vaults"
-	resourceNetworkInterfaces = "Microsoft.Network/networkInterfaces"
-	resourcePublicIPAddresses = "Microsoft.Network/publicIPAddresses"
-	resourceVirtualMachine    = "Microsoft.Compute/virtualMachines"
-	resourceVirtualNetworks   = "Microsoft.Network/virtualNetworks"
+	resourceKeyVaults             = "Microsoft.KeyVault/vaults"
+	resourceNetworkInterfaces     = "Microsoft.Network/networkInterfaces"
+	resourcePublicIPAddresses     = "Microsoft.Network/publicIPAddresses"
+	resourceVirtualMachine        = "Microsoft.Compute/virtualMachines"
+	resourceVirtualNetworks       = "Microsoft.Network/virtualNetworks"
+	resourceNetworkSecurityGroups = "Microsoft.Network/networkSecurityGroups"
 
 	variableSshKeyPath = "sshKeyPath"
 )
@@ -309,6 +312,39 @@ func (s *TemplateBuilder) SetPrivateVirtualNetworkWithPublicIp(virtualNetworkRes
 	return nil
 }
 
+func (s *TemplateBuilder) SetNetworkSecurityGroup(ipAddresses []string, port int) error {
+	nsgResource, dependency, resourceId := s.createNsgResource(ipAddresses, port)
+	if err := s.addResource(nsgResource); err != nil {
+		return err
+	}
+
+	vnetResource, err := s.getResourceByType(resourceVirtualNetworks)
+	if err != nil {
+		return err
+	}
+	s.deleteResourceByType(resourceVirtualNetworks)
+
+	s.addResourceDependency(vnetResource, dependency)
+
+	if vnetResource.Properties == nil || vnetResource.Properties.Subnets == nil || len(*vnetResource.Properties.Subnets) != 1 {
+		return fmt.Errorf("template: could not find virtual network/subnet to add default network security group to")
+	}
+	subnet := ((*vnetResource.Properties.Subnets)[0])
+	if subnet.SubnetPropertiesFormat == nil {
+		subnet.SubnetPropertiesFormat = &network.SubnetPropertiesFormat{}
+	}
+	if subnet.SubnetPropertiesFormat.NetworkSecurityGroup != nil {
+		return fmt.Errorf("template: subnet already has an associated network security group")
+	}
+	subnet.SubnetPropertiesFormat.NetworkSecurityGroup = &network.SecurityGroup{
+		ID: to.StringPtr(resourceId),
+	}
+
+	s.addResource(vnetResource)
+
+	return nil
+}
+
 func (s *TemplateBuilder) SetTags(tags *map[string]*string) error {
 	if tags == nil || len(*tags) == 0 {
 		return nil
@@ -366,6 +402,18 @@ func (s *TemplateBuilder) toVariable(name string) string {
 	return fmt.Sprintf("[variables('%s')]", name)
 }
 
+func (s *TemplateBuilder) addResource(newResource *Resource) error {
+	for _, resource := range *s.template.Resources {
+		if *resource.Type == *newResource.Type {
+			return fmt.Errorf("template: found an existing resource of type %s", *resource.Type)
+		}
+	}
+
+	resources := append(*s.template.Resources, *newResource)
+	s.template.Resources = &resources
+	return nil
+}
+
 func (s *TemplateBuilder) deleteResourceByType(resourceType string) {
 	resources := make([]Resource, 0)
 
@@ -379,6 +427,15 @@ func (s *TemplateBuilder) deleteResourceByType(resourceType string) {
 	s.template.Resources = &resources
 }
 
+func (s *TemplateBuilder) addResourceDependency(resource *Resource, dep string) {
+	if resource.DependsOn != nil {
+		deps := append(*resource.DependsOn, dep)
+		resource.DependsOn = &deps
+	} else {
+		resource.DependsOn = &[]string{dep}
+	}
+}
+
 func (s *TemplateBuilder) deleteResourceDependency(resource *Resource, predicate func(string) bool) {
 	deps := make([]string, 0)
 
@@ -391,6 +448,38 @@ func (s *TemplateBuilder) deleteResourceDependency(resource *Resource, predicate
 	*resource.DependsOn = deps
 }
 
+func (s *TemplateBuilder) createNsgResource(srcIpAddresses []string, port int) (*Resource, string, string) {
+	resource := &Resource{
+		ApiVersion: to.StringPtr("[variables('networkSecurityGroupsApiVersion')]"),
+		Name:       to.StringPtr("[parameters('nsgName')]"),
+		Type:       to.StringPtr(resourceNetworkSecurityGroups),
+		Location:   to.StringPtr("[variables('location')]"),
+		Properties: &Properties{
+			SecurityRules: &[]network.SecurityRule{
+				{
+					Name: to.StringPtr("AllowIPsToSshWinRMInbound"),
+					SecurityRulePropertiesFormat: &network.SecurityRulePropertiesFormat{
+						Description:              to.StringPtr("Allow inbound traffic from specified IP addresses"),
+						Protocol:                 network.SecurityRuleProtocolTCP,
+						Priority:                 to.Int32Ptr(100),
+						Access:                   network.SecurityRuleAccessAllow,
+						Direction:                network.SecurityRuleDirectionInbound,
+						SourceAddressPrefixes:    &srcIpAddresses,
+						SourcePortRange:          to.StringPtr("*"),
+						DestinationAddressPrefix: to.StringPtr("VirtualNetwork"),
+						DestinationPortRange:     to.StringPtr(strconv.Itoa(port)),
+					},
+				},
+			},
+		},
+	}
+
+	dependency := fmt.Sprintf("[concat('%s/', parameters('nsgName'))]", resourceNetworkSecurityGroups)
+	resourceId := fmt.Sprintf("[resourceId('%s', parameters('nsgName'))]", resourceNetworkSecurityGroups)
+
+	return resource, dependency, resourceId
+}
+
 // See https://github.com/Azure/azure-quickstart-templates for a extensive list of templates.
 
 // Template to deploy a KeyVault.
@@ -496,6 +585,9 @@ const BasicTemplate = `{
 	"virtualNetworkName": {
       "type": "string"
 	},
+    "nsgName": {
+      "type": "string"
+    },
     "vmSize": {
       "type": "string"
     },
@@ -510,6 +602,7 @@ const BasicTemplate = `{
     "networkInterfacesApiVersion": "2017-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "virtualNetworksApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "location": "[resourceGroup().location]",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/common/template/template_builder_test.TestBuildLinux00.approved.json b/builder/azure/common/template/template_builder_test.TestBuildLinux00.approved.json
index b1550d5b5..4ba861566 100644
--- a/builder/azure/common/template/template_builder_test.TestBuildLinux00.approved.json
+++ b/builder/azure/common/template/template_builder_test.TestBuildLinux00.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -160,6 +163,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/common/template/template_builder_test.TestBuildLinux01.approved.json b/builder/azure/common/template/template_builder_test.TestBuildLinux01.approved.json
index c8e1455e5..5e5b2ea05 100644
--- a/builder/azure/common/template/template_builder_test.TestBuildLinux01.approved.json
+++ b/builder/azure/common/template/template_builder_test.TestBuildLinux01.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -158,6 +161,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/common/template/template_builder_test.TestBuildLinux02.approved.json b/builder/azure/common/template/template_builder_test.TestBuildLinux02.approved.json
index a27074962..b3a2e1e73 100644
--- a/builder/azure/common/template/template_builder_test.TestBuildLinux02.approved.json
+++ b/builder/azure/common/template/template_builder_test.TestBuildLinux02.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -120,6 +123,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/common/template/template_builder_test.TestBuildWindows00.approved.json b/builder/azure/common/template/template_builder_test.TestBuildWindows00.approved.json
index 13a581f92..797081807 100644
--- a/builder/azure/common/template/template_builder_test.TestBuildWindows00.approved.json
+++ b/builder/azure/common/template/template_builder_test.TestBuildWindows00.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -174,6 +177,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/common/template/template_builder_test.TestBuildWindows01.approved.json b/builder/azure/common/template/template_builder_test.TestBuildWindows01.approved.json
index 3add40537..a7230706d 100644
--- a/builder/azure/common/template/template_builder_test.TestBuildWindows01.approved.json
+++ b/builder/azure/common/template/template_builder_test.TestBuildWindows01.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -197,6 +200,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/common/template/template_builder_test.TestBuildWindows02.approved.json b/builder/azure/common/template/template_builder_test.TestBuildWindows02.approved.json
index 7c44163c3..ad8d94bfb 100644
--- a/builder/azure/common/template/template_builder_test.TestBuildWindows02.approved.json
+++ b/builder/azure/common/template/template_builder_test.TestBuildWindows02.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -190,6 +193,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/common/template/template_builder_test.TestNetworkSecurityGroup00.approved.json b/builder/azure/common/template/template_builder_test.TestNetworkSecurityGroup00.approved.json
new file mode 100644
index 000000000..b318164a3
--- /dev/null
+++ b/builder/azure/common/template/template_builder_test.TestNetworkSecurityGroup00.approved.json
@@ -0,0 +1,212 @@
+{
+  "$schema": "http://schema.management.azure.com/schemas/2014-04-01-preview/deploymentTemplate.json",
+  "contentVersion": "1.0.0.0",
+  "parameters": {
+    "adminPassword": {
+      "type": "string"
+    },
+    "adminUsername": {
+      "type": "string"
+    },
+    "dnsNameForPublicIP": {
+      "type": "string"
+    },
+    "nicName": {
+      "type": "string"
+    },
+    "nsgName": {
+      "type": "string"
+    },
+    "osDiskName": {
+      "type": "string"
+    },
+    "publicIPAddressName": {
+      "type": "string"
+    },
+    "storageAccountBlobEndpoint": {
+      "type": "string"
+    },
+    "subnetName": {
+      "type": "string"
+    },
+    "virtualNetworkName": {
+      "type": "string"
+    },
+    "vmName": {
+      "type": "string"
+    },
+    "vmSize": {
+      "type": "string"
+    }
+  },
+  "resources": [
+    {
+      "apiVersion": "[variables('publicIPAddressApiVersion')]",
+      "location": "[variables('location')]",
+      "name": "[parameters('publicIPAddressName')]",
+      "properties": {
+        "dnsSettings": {
+          "domainNameLabel": "[parameters('dnsNameForPublicIP')]"
+        },
+        "publicIPAllocationMethod": "[variables('publicIPAddressType')]"
+      },
+      "type": "Microsoft.Network/publicIPAddresses"
+    },
+    {
+      "apiVersion": "[variables('networkInterfacesApiVersion')]",
+      "dependsOn": [
+        "[concat('Microsoft.Network/publicIPAddresses/', parameters('publicIPAddressName'))]",
+        "[concat('Microsoft.Network/virtualNetworks/', variables('virtualNetworkName'))]"
+      ],
+      "location": "[variables('location')]",
+      "name": "[parameters('nicName')]",
+      "properties": {
+        "ipConfigurations": [
+          {
+            "name": "ipconfig",
+            "properties": {
+              "privateIPAllocationMethod": "Dynamic",
+              "publicIPAddress": {
+                "id": "[resourceId('Microsoft.Network/publicIPAddresses', parameters('publicIPAddressName'))]"
+              },
+              "subnet": {
+                "id": "[variables('subnetRef')]"
+              }
+            }
+          }
+        ]
+      },
+      "type": "Microsoft.Network/networkInterfaces"
+    },
+    {
+      "apiVersion": "[variables('apiVersion')]",
+      "dependsOn": [
+        "[concat('Microsoft.Network/networkInterfaces/', parameters('nicName'))]"
+      ],
+      "location": "[variables('location')]",
+      "name": "[parameters('vmName')]",
+      "properties": {
+        "diagnosticsProfile": {
+          "bootDiagnostics": {
+            "enabled": false
+          }
+        },
+        "hardwareProfile": {
+          "vmSize": "[parameters('vmSize')]"
+        },
+        "networkProfile": {
+          "networkInterfaces": [
+            {
+              "id": "[resourceId('Microsoft.Network/networkInterfaces', parameters('nicName'))]"
+            }
+          ]
+        },
+        "osProfile": {
+          "adminPassword": "[parameters('adminPassword')]",
+          "adminUsername": "[parameters('adminUsername')]",
+          "computerName": "[parameters('vmName')]",
+          "linuxConfiguration": {
+            "ssh": {
+              "publicKeys": [
+                {
+                  "keyData": "--test-ssh-authorized-key--",
+                  "path": "[variables('sshKeyPath')]"
+                }
+              ]
+            }
+          }
+        },
+        "storageProfile": {
+          "imageReference": {
+            "offer": "UbuntuServer",
+            "publisher": "Canonical",
+            "sku": "16.04",
+            "version": "latest"
+          },
+          "osDisk": {
+            "caching": "ReadWrite",
+            "createOption": "FromImage",
+            "name": "[parameters('osDiskName')]",
+            "vhd": {
+              "uri": "[concat(parameters('storageAccountBlobEndpoint'),variables('vmStorageAccountContainerName'),'/', parameters('osDiskName'),'.vhd')]"
+            }
+          }
+        }
+      },
+      "type": "Microsoft.Compute/virtualMachines"
+    },
+    {
+      "apiVersion": "[variables('networkSecurityGroupsApiVersion')]",
+      "location": "[variables('location')]",
+      "name": "[parameters('nsgName')]",
+      "properties": {
+        "securityRules": [
+          {
+            "name": "AllowIPsToSshWinRMInbound",
+            "properties": {
+              "access": "Allow",
+              "description": "Allow inbound traffic from specified IP addresses",
+              "destinationAddressPrefix": "VirtualNetwork",
+              "destinationPortRange": "123",
+              "direction": "Inbound",
+              "priority": 100,
+              "protocol": "Tcp",
+              "sourceAddressPrefixes": [
+                "127.0.0.1",
+                "192.168.100.0/24"
+              ],
+              "sourcePortRange": "*"
+            }
+          }
+        ]
+      },
+      "type": "Microsoft.Network/networkSecurityGroups"
+    },
+    {
+      "apiVersion": "[variables('virtualNetworksApiVersion')]",
+      "dependsOn": [
+        "[concat('Microsoft.Network/networkSecurityGroups/', parameters('nsgName'))]"
+      ],
+      "location": "[variables('location')]",
+      "name": "[variables('virtualNetworkName')]",
+      "properties": {
+        "addressSpace": {
+          "addressPrefixes": [
+            "[variables('addressPrefix')]"
+          ]
+        },
+        "subnets": [
+          {
+            "name": "[variables('subnetName')]",
+            "properties": {
+              "addressPrefix": "[variables('subnetAddressPrefix')]",
+              "networkSecurityGroup": {
+                "id": "[resourceId('Microsoft.Network/networkSecurityGroups', parameters('nsgName'))]"
+              }
+            }
+          }
+        ]
+      },
+      "type": "Microsoft.Network/virtualNetworks"
+    }
+  ],
+  "variables": {
+    "addressPrefix": "10.0.0.0/16",
+    "apiVersion": "2017-03-30",
+    "location": "[resourceGroup().location]",
+    "managedDiskApiVersion": "2017-03-30",
+    "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
+    "publicIPAddressApiVersion": "2017-04-01",
+    "publicIPAddressType": "Dynamic",
+    "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
+    "subnetAddressPrefix": "10.0.0.0/24",
+    "subnetName": "[parameters('subnetName')]",
+    "subnetRef": "[concat(variables('vnetID'),'/subnets/',variables('subnetName'))]",
+    "virtualNetworkName": "[parameters('virtualNetworkName')]",
+    "virtualNetworkResourceGroup": "[resourceGroup().name]",
+    "virtualNetworksApiVersion": "2017-04-01",
+    "vmStorageAccountContainerName": "images",
+    "vnetID": "[resourceId(variables('virtualNetworkResourceGroup'), 'Microsoft.Network/virtualNetworks', variables('virtualNetworkName'))]"
+  }
+}
\ No newline at end of file
diff --git a/builder/azure/common/template/template_builder_test.TestSharedImageGallery00.approved.json b/builder/azure/common/template/template_builder_test.TestSharedImageGallery00.approved.json
index c180e1e16..49f2a72a4 100644
--- a/builder/azure/common/template/template_builder_test.TestSharedImageGallery00.approved.json
+++ b/builder/azure/common/template/template_builder_test.TestSharedImageGallery00.approved.json
@@ -14,6 +14,9 @@
     "nicName": {
       "type": "string"
     },
+    "nsgName": {
+      "type": "string"
+    },
     "osDiskName": {
       "type": "string"
     },
@@ -155,6 +158,7 @@
     "location": "[resourceGroup().location]",
     "managedDiskApiVersion": "2017-03-30",
     "networkInterfacesApiVersion": "2017-04-01",
+    "networkSecurityGroupsApiVersion": "2019-04-01",
     "publicIPAddressApiVersion": "2017-04-01",
     "publicIPAddressType": "Dynamic",
     "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]",
diff --git a/builder/azure/common/template/template_builder_test.go b/builder/azure/common/template/template_builder_test.go
index 482107c34..b39af103f 100644
--- a/builder/azure/common/template/template_builder_test.go
+++ b/builder/azure/common/template/template_builder_test.go
@@ -210,3 +210,36 @@ func TestSharedImageGallery00(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+// Linux build with Network Security Group
+func TestNetworkSecurityGroup00(t *testing.T) {
+	testSubject, err := NewTemplateBuilder(BasicTemplate)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = testSubject.BuildLinux("--test-ssh-authorized-key--")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = testSubject.SetMarketPlaceImage("Canonical", "UbuntuServer", "16.04", "latest", compute.CachingTypesReadWrite)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = testSubject.SetNetworkSecurityGroup([]string{"127.0.0.1", "192.168.100.0/24"}, 123)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	doc, err := testSubject.ToJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = approvaltests.VerifyJSONBytes(t, []byte(*doc))
+	if err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/builder/azure/common/template/template_parameters.go b/builder/azure/common/template/template_parameters.go
index 65bc55e75..74b0562a7 100644
--- a/builder/azure/common/template/template_parameters.go
+++ b/builder/azure/common/template/template_parameters.go
@@ -31,6 +31,7 @@ type TemplateParameters struct {
 	SubnetName                 *TemplateParameter `json:"subnetName,omitempty"`
 	TenantId                   *TemplateParameter `json:"tenantId,omitempty"`
 	VirtualNetworkName         *TemplateParameter `json:"virtualNetworkName,omitempty"`
+	NsgName                    *TemplateParameter `json:"nsgName,omitempty"`
 	VMSize                     *TemplateParameter `json:"vmSize,omitempty"`
 	VMName                     *TemplateParameter `json:"vmName,omitempty"`
 }
diff --git a/builder/azure/common/template/template_parameters_test.go b/builder/azure/common/template/template_parameters_test.go
index 9dbb9f243..7a321128f 100644
--- a/builder/azure/common/template/template_parameters_test.go
+++ b/builder/azure/common/template/template_parameters_test.go
@@ -16,6 +16,7 @@ func TestTemplateParametersShouldHaveExpectedKeys(t *testing.T) {
 		StorageAccountBlobEndpoint: &TemplateParameter{Value: "sentinel"},
 		VMName:                     &TemplateParameter{Value: "sentinel"},
 		VMSize:                     &TemplateParameter{Value: "sentinel"},
+		NsgName:                    &TemplateParameter{Value: "sentinel"},
 	}
 
 	bs, err := json.Marshal(params)
@@ -38,6 +39,7 @@ func TestTemplateParametersShouldHaveExpectedKeys(t *testing.T) {
 		"storageAccountBlobEndpoint",
 		"vmSize",
 		"vmName",
+		"nsgName",
 	}
 
 	for _, expectedKey := range expectedKeys {
@@ -57,6 +59,7 @@ func TestParameterValuesShouldBeSet(t *testing.T) {
 		StorageAccountBlobEndpoint: &TemplateParameter{Value: "storageaccountblobendpoint00"},
 		VMName:                     &TemplateParameter{Value: "vmname00"},
 		VMSize:                     &TemplateParameter{Value: "vmsize00"},
+		NsgName:                    &TemplateParameter{Value: "nsgname00"},
 	}
 
 	bs, err := json.Marshal(params)

From 97f33647da2b0385e139494f2efd8eac2d3feb8a Mon Sep 17 00:00:00 2001
From: Sumit Kalra <44450797+sumit-kalra@users.noreply.github.com>
Date: Tue, 8 Oct 2019 16:02:39 -0700
Subject: [PATCH 034/155] Adding auto-generated documentation (#5)

---
 .../builder/azure/arm/_Config-not-required.html.md         | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/website/source/partials/builder/azure/arm/_Config-not-required.html.md b/website/source/partials/builder/azure/arm/_Config-not-required.html.md
index af8816b87..5113e3db6 100644
--- a/website/source/partials/builder/azure/arm/_Config-not-required.html.md
+++ b/website/source/partials/builder/azure/arm/_Config-not-required.html.md
@@ -217,6 +217,13 @@
 -   `disk_caching_type` (string) - Specify the disk caching type. Valid values
     are None, ReadOnly, and ReadWrite. The default value is ReadWrite.
     
+-   `allowed_inbound_ip_addresses` ([]string) - Specify the list of IP addresses and CIDR blocks that should be
+    allowed access to the VM. If provided, an Azure Network Security
+    Group will be created with corresponding rules and be bound to
+    the NIC attached to the VM.
+    Providing `allowed_inbound_ip_addresses` in combination with
+    `virtual_network_name` is not allowed.
+    
 -   `async_resourcegroup_delete` (bool) - If you want packer to delete the
     temporary resource group asynchronously set this value. It's a boolean
     value and defaults to false. Important Setting this true means that

From 50262ba0b8610d8803cf2652ca1a5296b281d5cd Mon Sep 17 00:00:00 2001
From: Davor Kapsa <davor.kapsa@gmail.com>
Date: Wed, 9 Oct 2019 13:17:43 +0200
Subject: [PATCH 035/155] Remove explicit err var declaration

---
 builder/hyperv/common/step_create_external_switch.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/builder/hyperv/common/step_create_external_switch.go b/builder/hyperv/common/step_create_external_switch.go
index c5ebd43bf..df1776a63 100644
--- a/builder/hyperv/common/step_create_external_switch.go
+++ b/builder/hyperv/common/step_create_external_switch.go
@@ -84,8 +84,6 @@ func (s *StepCreateExternalSwitch) Cleanup(state multistep.StateBag) {
 
 	ui.Say("Unregistering and deleting external switch...")
 
-	var err error = nil
-
 	errMsg := "Error deleting external switch: %s"
 
 	// connect the vm to the old switch
@@ -94,7 +92,7 @@ func (s *StepCreateExternalSwitch) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	err = driver.ConnectVirtualMachineNetworkAdapterToSwitch(vmName, s.oldSwitchName)
+	err := driver.ConnectVirtualMachineNetworkAdapterToSwitch(vmName, s.oldSwitchName)
 	if err != nil {
 		ui.Error(fmt.Sprintf(errMsg, err))
 		return

From 49e4a2d9ef6b156a0074a4052ed59914a4cd67c7 Mon Sep 17 00:00:00 2001
From: Davor Kapsa <davor.kapsa@gmail.com>
Date: Wed, 9 Oct 2019 15:55:07 +0200
Subject: [PATCH 036/155] Add error check

---
 common/powershell/hyperv/hyperv.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/common/powershell/hyperv/hyperv.go b/common/powershell/hyperv/hyperv.go
index dc5d455c8..ecfb40ec2 100644
--- a/common/powershell/hyperv/hyperv.go
+++ b/common/powershell/hyperv/hyperv.go
@@ -283,6 +283,9 @@ Hyper-V\New-VM -Name "{{ .VMName }}" -Path "{{ .Path }}" -MemoryStartupBytes {{
 	}
 	final := regex.ReplaceAllString(b.String(), "")
 	regex, err = regexp.Compile("\n\n")
+	if err != nil {
+		return "", err
+	}
 	final = regex.ReplaceAllString(final, "\n")
 
 	return final, nil

From fb267dd1dc3bcf1f4f89b4ba6e94dacb1c6cf30a Mon Sep 17 00:00:00 2001
From: Davor Kapsa <davor.kapsa@gmail.com>
Date: Wed, 9 Oct 2019 21:08:40 +0200
Subject: [PATCH 037/155] Add error check

---
 builder/azure/arm/step_delete_resource_group.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/builder/azure/arm/step_delete_resource_group.go b/builder/azure/arm/step_delete_resource_group.go
index 8e873c2d7..8490dbc58 100644
--- a/builder/azure/arm/step_delete_resource_group.go
+++ b/builder/azure/arm/step_delete_resource_group.go
@@ -108,6 +108,9 @@ func (s *StepDeleteResourceGroup) deleteDeploymentResources(ctx context.Context,
 			}
 			return err
 		})
+		if err != nil {
+			return err
+		}
 
 		if err = deploymentOperations.Next(); err != nil {
 			return err

From 3eb075b9fc3cb7bf8aadd094f632d3870f480643 Mon Sep 17 00:00:00 2001
From: Davor Kapsa <davor.kapsa@gmail.com>
Date: Wed, 9 Oct 2019 21:18:46 +0200
Subject: [PATCH 038/155] Consolidate receiver name

---
 builder/jdcloud/credential_config.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/builder/jdcloud/credential_config.go b/builder/jdcloud/credential_config.go
index 75d07309d..e7c12baf8 100644
--- a/builder/jdcloud/credential_config.go
+++ b/builder/jdcloud/credential_config.go
@@ -67,19 +67,19 @@ func (jd *JDCloudCredentialConfig) ValidateKeyPair() error {
 	return nil
 }
 
-func (config *JDCloudCredentialConfig) validateRegion() error {
+func (jd *JDCloudCredentialConfig) validateRegion() error {
 	regionArray := []string{"cn-north-1", "cn-south-1", "cn-east-1", "cn-east-2"}
 	for _, item := range regionArray {
-		if item == config.RegionId {
+		if item == jd.RegionId {
 			return nil
 		}
 	}
 	return fmt.Errorf("[PRE-FLIGHT] Invalid RegionId:%s. "+
-		"Legit RegionId are: {cn-north-1, cn-south-1, cn-east-1, cn-east-2}", config.RegionId)
+		"Legit RegionId are: {cn-north-1, cn-south-1, cn-east-1, cn-east-2}", jd.RegionId)
 }
 
-func (config *JDCloudCredentialConfig) validateAz() error {
-	if len(config.Az) == 0 {
+func (jd *JDCloudCredentialConfig) validateAz() error {
+	if len(jd.Az) == 0 {
 		return fmt.Errorf("[PRE-FLIGHT] az info missing")
 	}
 	return nil

From 469af8e5920e99d137a7eaf22132c033dd921c6b Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Wed, 9 Oct 2019 16:02:37 -0700
Subject: [PATCH 039/155] ebssurrogate builds didn't keep up with recent
 optimizations to region encryption in the ebs builder, and that was causing
 bugs with the common ami region copy step

---
 builder/amazon/ebssurrogate/builder.go        |  1 +
 .../amazon/ebssurrogate/step_register_ami.go  | 21 ++++++++++++++++++-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/builder/amazon/ebssurrogate/builder.go b/builder/amazon/ebssurrogate/builder.go
index f1e2c8122..a7f2cd902 100644
--- a/builder/amazon/ebssurrogate/builder.go
+++ b/builder/amazon/ebssurrogate/builder.go
@@ -308,6 +308,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EnableAMIENASupport:      b.config.AMIENASupport,
 			Architecture:             b.config.Architecture,
 			LaunchOmitMap:            b.config.LaunchMappings.GetOmissions(),
+			AMISkipBuildRegion:       b.config.AMISkipBuildRegion,
 		},
 		&awscommon.StepAMIRegionCopy{
 			AccessConfig:      &b.config.AccessConfig,
diff --git a/builder/amazon/ebssurrogate/step_register_ami.go b/builder/amazon/ebssurrogate/step_register_ami.go
index 6886b49bd..1a6760089 100644
--- a/builder/amazon/ebssurrogate/step_register_ami.go
+++ b/builder/amazon/ebssurrogate/step_register_ami.go
@@ -7,6 +7,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
+	"github.com/hashicorp/packer/common/random"
 	confighelper "github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -22,6 +23,7 @@ type StepRegisterAMI struct {
 	Architecture             string
 	image                    *ec2.Image
 	LaunchOmitMap            map[string]bool
+	AMISkipBuildRegion       bool
 }
 
 func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
@@ -34,8 +36,25 @@ func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) mul
 
 	blockDevices := s.combineDevices(snapshotIds)
 
+	// Create the image
+	amiName := config.AMIName
+	state.Put("intermediary_image", false)
+	if config.AMIEncryptBootVolume.True() || s.AMISkipBuildRegion {
+		state.Put("intermediary_image", true)
+
+		// From AWS SDK docs: You can encrypt a copy of an unencrypted snapshot,
+		// but you cannot use it to create an unencrypted copy of an encrypted
+		// snapshot. Your default CMK for EBS is used unless you specify a
+		// non-default key using KmsKeyId.
+
+		// If encrypt_boot is nil or true, we need to create a temporary image
+		// so that in step_region_copy, we can copy it with the correct
+		// encryption
+		amiName = random.AlphaNum(7)
+	}
+
 	registerOpts := &ec2.RegisterImageInput{
-		Name:                &config.AMIName,
+		Name:                &amiName,
 		Architecture:        aws.String(s.Architecture),
 		RootDeviceName:      aws.String(s.RootDevice.DeviceName),
 		VirtualizationType:  aws.String(config.AMIVirtType),

From e283023d9b9a0477299facfe1b7dffafa7efd34d Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Wed, 9 Oct 2019 16:52:41 -0700
Subject: [PATCH 040/155] make sure step_register_ami in chroot builder
 respects encryption and ami skip build retion values once the copy happens

---
 builder/amazon/chroot/builder.go           |  1 +
 builder/amazon/chroot/step_register_ami.go | 33 +++++++++++++++++-----
 2 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/builder/amazon/chroot/builder.go b/builder/amazon/chroot/builder.go
index 7459ee6b4..f51ae9255 100644
--- a/builder/amazon/chroot/builder.go
+++ b/builder/amazon/chroot/builder.go
@@ -408,6 +408,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			RootVolumeSize:           b.config.RootVolumeSize,
 			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
 			EnableAMIENASupport:      b.config.AMIENASupport,
+			AMISkipBuildRegion:       b.config.AMISkipBuildRegion,
 		},
 		&awscommon.StepAMIRegionCopy{
 			AccessConfig:      &b.config.AccessConfig,
diff --git a/builder/amazon/chroot/step_register_ami.go b/builder/amazon/chroot/step_register_ami.go
index c8976dc6f..e38ad83ee 100644
--- a/builder/amazon/chroot/step_register_ami.go
+++ b/builder/amazon/chroot/step_register_ami.go
@@ -7,6 +7,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
+	"github.com/hashicorp/packer/common/random"
 	confighelper "github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -17,6 +18,7 @@ type StepRegisterAMI struct {
 	RootVolumeSize           int64
 	EnableAMIENASupport      confighelper.Trilean
 	EnableAMISriovNetSupport bool
+	AMISkipBuildRegion       bool
 }
 
 func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
@@ -29,12 +31,29 @@ func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) mul
 
 	var registerOpts *ec2.RegisterImageInput
 
+	// Create the image
+	amiName := config.AMIName
+	state.Put("intermediary_image", false)
+	if config.AMIEncryptBootVolume.True() || s.AMISkipBuildRegion {
+		state.Put("intermediary_image", true)
+
+		// From AWS SDK docs: You can encrypt a copy of an unencrypted snapshot,
+		// but you cannot use it to create an unencrypted copy of an encrypted
+		// snapshot. Your default CMK for EBS is used unless you specify a
+		// non-default key using KmsKeyId.
+
+		// If encrypt_boot is nil or true, we need to create a temporary image
+		// so that in step_region_copy, we can copy it with the correct
+		// encryption
+		amiName = random.AlphaNum(7)
+	}
+
 	// Source Image is only required to be passed if the image is not from scratch
 	if config.FromScratch {
-		registerOpts = buildBaseRegisterOpts(config, nil, s.RootVolumeSize, snapshotID)
+		registerOpts = buildBaseRegisterOpts(config, nil, s.RootVolumeSize, snapshotID, amiName)
 	} else {
 		image := state.Get("source_image").(*ec2.Image)
-		registerOpts = buildBaseRegisterOpts(config, image, s.RootVolumeSize, snapshotID)
+		registerOpts = buildBaseRegisterOpts(config, image, s.RootVolumeSize, snapshotID, amiName)
 	}
 
 	if s.EnableAMISriovNetSupport {
@@ -75,7 +94,7 @@ func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) mul
 func (s *StepRegisterAMI) Cleanup(state multistep.StateBag) {}
 
 // Builds the base register opts with architecture, name, root block device, mappings, virtualizationtype
-func buildBaseRegisterOpts(config *Config, sourceImage *ec2.Image, rootVolumeSize int64, snapshotID string) *ec2.RegisterImageInput {
+func buildBaseRegisterOpts(config *Config, sourceImage *ec2.Image, rootVolumeSize int64, snapshotID string, amiName string) *ec2.RegisterImageInput {
 	var (
 		mappings       []*ec2.BlockDeviceMapping
 		rootDeviceName string
@@ -117,7 +136,7 @@ func buildBaseRegisterOpts(config *Config, sourceImage *ec2.Image, rootVolumeSiz
 
 	if config.FromScratch {
 		return &ec2.RegisterImageInput{
-			Name:                &config.AMIName,
+			Name:                &amiName,
 			Architecture:        aws.String(config.Architecture),
 			RootDeviceName:      aws.String(rootDeviceName),
 			VirtualizationType:  aws.String(config.AMIVirtType),
@@ -125,12 +144,12 @@ func buildBaseRegisterOpts(config *Config, sourceImage *ec2.Image, rootVolumeSiz
 		}
 	}
 
-	return buildRegisterOptsFromExistingImage(config, sourceImage, newMappings, rootDeviceName)
+	return buildRegisterOptsFromExistingImage(config, sourceImage, newMappings, rootDeviceName, amiName)
 }
 
-func buildRegisterOptsFromExistingImage(config *Config, image *ec2.Image, mappings []*ec2.BlockDeviceMapping, rootDeviceName string) *ec2.RegisterImageInput {
+func buildRegisterOptsFromExistingImage(config *Config, image *ec2.Image, mappings []*ec2.BlockDeviceMapping, rootDeviceName string, amiName string) *ec2.RegisterImageInput {
 	registerOpts := &ec2.RegisterImageInput{
-		Name:                &config.AMIName,
+		Name:                &amiName,
 		Architecture:        image.Architecture,
 		RootDeviceName:      &rootDeviceName,
 		BlockDeviceMappings: mappings,

From 4bc381183dc7d533c6c300584c0224ba9a644c0a Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Wed, 9 Oct 2019 16:59:51 -0700
Subject: [PATCH 041/155] make aws instsance builder work with recent changes
 for volume copy

---
 builder/amazon/instance/builder.go           |  1 +
 builder/amazon/instance/step_register_ami.go | 22 +++++++++++++++++++-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/builder/amazon/instance/builder.go b/builder/amazon/instance/builder.go
index bcdb00d91..766bb4b81 100644
--- a/builder/amazon/instance/builder.go
+++ b/builder/amazon/instance/builder.go
@@ -350,6 +350,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&StepRegisterAMI{
 			EnableAMISriovNetSupport: b.config.AMISriovNetSupport,
 			EnableAMIENASupport:      b.config.AMIENASupport,
+			AMISkipBuildRegion:       b.config.AMISkipBuildRegion,
 		},
 		&awscommon.StepAMIRegionCopy{
 			AccessConfig:      &b.config.AccessConfig,
diff --git a/builder/amazon/instance/step_register_ami.go b/builder/amazon/instance/step_register_ami.go
index 1240064d2..9abee7a51 100644
--- a/builder/amazon/instance/step_register_ami.go
+++ b/builder/amazon/instance/step_register_ami.go
@@ -7,6 +7,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
+	"github.com/hashicorp/packer/common/random"
 	confighelper "github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -15,6 +16,7 @@ import (
 type StepRegisterAMI struct {
 	EnableAMIENASupport      confighelper.Trilean
 	EnableAMISriovNetSupport bool
+	AMISkipBuildRegion       bool
 }
 
 func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
@@ -24,9 +26,27 @@ func (s *StepRegisterAMI) Run(ctx context.Context, state multistep.StateBag) mul
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Registering the AMI...")
+
+	// Create the image
+	amiName := config.AMIName
+	state.Put("intermediary_image", false)
+	if config.AMIEncryptBootVolume.True() || s.AMISkipBuildRegion {
+		state.Put("intermediary_image", true)
+
+		// From AWS SDK docs: You can encrypt a copy of an unencrypted snapshot,
+		// but you cannot use it to create an unencrypted copy of an encrypted
+		// snapshot. Your default CMK for EBS is used unless you specify a
+		// non-default key using KmsKeyId.
+
+		// If encrypt_boot is nil or true, we need to create a temporary image
+		// so that in step_region_copy, we can copy it with the correct
+		// encryption
+		amiName = random.AlphaNum(7)
+	}
+
 	registerOpts := &ec2.RegisterImageInput{
 		ImageLocation:       &manifestPath,
-		Name:                aws.String(config.AMIName),
+		Name:                aws.String(amiName),
 		BlockDeviceMappings: config.AMIMappings.BuildEC2BlockDeviceMappings(),
 	}
 

From 8bb7d8dc169e120c286794484105376879d06df9 Mon Sep 17 00:00:00 2001
From: Chris Roberts <croberts@hashicorp.com>
Date: Wed, 9 Oct 2019 17:55:16 -0700
Subject: [PATCH 042/155] Prevent busy loop while waiting for WinRM connection

Set first run variable outside conditional so it will properly be
updated during the first run and pause on subsequent runs.
---
 helper/communicator/step_connect_winrm.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/helper/communicator/step_connect_winrm.go b/helper/communicator/step_connect_winrm.go
index f1e30820a..275468bc1 100644
--- a/helper/communicator/step_connect_winrm.go
+++ b/helper/communicator/step_connect_winrm.go
@@ -95,8 +95,8 @@ func (s *StepConnectWinRM) waitForWinRM(state multistep.StateBag, ctx context.Co
 				return nil, errors.New("WinRM wait cancelled")
 			case <-time.After(5 * time.Second):
 			}
-			first = false
 		}
+		first = false
 
 		host, err := s.Host(state)
 		if err != nil {

From 7fd2006d350cf3ec8d0842dcd1e9415346d89939 Mon Sep 17 00:00:00 2001
From: Li Kexian <doyenli@tencent.com>
Date: Thu, 10 Oct 2019 17:06:21 +0800
Subject: [PATCH 043/155] change links to english version

---
 website/source/docs/builders/tencentcloud-cvm.html.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/website/source/docs/builders/tencentcloud-cvm.html.md b/website/source/docs/builders/tencentcloud-cvm.html.md
index dc48cebef..72405ba90 100644
--- a/website/source/docs/builders/tencentcloud-cvm.html.md
+++ b/website/source/docs/builders/tencentcloud-cvm.html.md
@@ -30,15 +30,15 @@ builder.
     or set the `TENCENTCLOUD_SECRET_KEY` environment variable.
 
 -   `region` (string) - The region where your cvm will be launch. You should
-    reference [Region and Zone](https://cloud.tencent.com/document/product/213/6091)
+    reference [Region and Zone](https://intl.cloud.tencent.com/document/product/213/6091)
      for parameter taking.
 
 -   `zone` (string) - The zone where your cvm will be launch. You should
-    reference [Region and Zone](https://cloud.tencent.com/document/product/213/6091)
+    reference [Region and Zone](https://intl.cloud.tencent.com/document/product/213/6091)
      for parameter taking.
 
 -   `instance_type` (string) - The instance type your cvm will be launched by.
-    You should reference [Instace Type](https://cloud.tencent.com/document/product/213/11518)
+    You should reference [Instace Type](https://intl.cloud.tencent.com/document/product/213/11518)
      for parameter taking.
 
 -   `source_image_id` (string) - The base image id of Image you want to create
@@ -81,7 +81,7 @@ builder.
 -   `instance_name` (string) - Instance name.
 
 -   `disk_type` (string) - Root disk type your cvm will be launched by. you could
-    reference [Disk Type](https://cloud.tencent.com/document/api/213/15753#SystemDisk)
+    reference [Disk Type](https://intl.cloud.tencent.com/document/product/213/15753#SystemDisk)
     for parameter taking.
 
 -   `disk_size` (number) - Root disk size your cvm will be launched by. values range(in GB):

From 4c615341ef5f9a02481339cb98c0fb016861b033 Mon Sep 17 00:00:00 2001
From: Davor Kapsa <davor.kapsa@gmail.com>
Date: Thu, 10 Oct 2019 17:33:24 +0200
Subject: [PATCH 044/155] Ignore retry.Config var

retry.Config is struct.
Call it err is wrong.
---
 builder/azure/arm/step_delete_resource_group.go | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/builder/azure/arm/step_delete_resource_group.go b/builder/azure/arm/step_delete_resource_group.go
index 8490dbc58..572b22884 100644
--- a/builder/azure/arm/step_delete_resource_group.go
+++ b/builder/azure/arm/step_delete_resource_group.go
@@ -95,7 +95,7 @@ func (s *StepDeleteResourceGroup) deleteDeploymentResources(ctx context.Context,
 			resourceType,
 			resourceName))
 
-		err := retry.Config{
+		_ = retry.Config{
 			Tries:      10,
 			RetryDelay: (&retry.Backoff{InitialBackoff: 10 * time.Second, MaxBackoff: 600 * time.Second, Multiplier: 2}).Linear,
 		}.Run(ctx, func(ctx context.Context) error {
@@ -108,9 +108,6 @@ func (s *StepDeleteResourceGroup) deleteDeploymentResources(ctx context.Context,
 			}
 			return err
 		})
-		if err != nil {
-			return err
-		}
 
 		if err = deploymentOperations.Next(); err != nil {
 			return err

From 4bd09f381ef5da833a6ee78adb30db1fbf6268ae Mon Sep 17 00:00:00 2001
From: Sumit Kalra <44450797+sumit-kalra@users.noreply.github.com>
Date: Thu, 10 Oct 2019 11:30:28 -0700
Subject: [PATCH 045/155] Fixing documentation (#6)

---
 builder/azure/arm/config.go                                     | 2 +-
 .../partials/builder/azure/arm/_Config-not-required.html.md     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/builder/azure/arm/config.go b/builder/azure/arm/config.go
index bf072d5da..5ece275a7 100644
--- a/builder/azure/arm/config.go
+++ b/builder/azure/arm/config.go
@@ -346,7 +346,7 @@ type Config struct {
 	// Specify the list of IP addresses and CIDR blocks that should be
 	// allowed access to the VM. If provided, an Azure Network Security
 	// Group will be created with corresponding rules and be bound to
-	// the NIC attached to the VM.
+	// the subnet of the VM.
 	// Providing `allowed_inbound_ip_addresses` in combination with
 	// `virtual_network_name` is not allowed.
 	AllowedInboundIpAddresses []string `mapstructure:"allowed_inbound_ip_addresses"`
diff --git a/website/source/partials/builder/azure/arm/_Config-not-required.html.md b/website/source/partials/builder/azure/arm/_Config-not-required.html.md
index 5113e3db6..e70606434 100644
--- a/website/source/partials/builder/azure/arm/_Config-not-required.html.md
+++ b/website/source/partials/builder/azure/arm/_Config-not-required.html.md
@@ -220,7 +220,7 @@
 -   `allowed_inbound_ip_addresses` ([]string) - Specify the list of IP addresses and CIDR blocks that should be
     allowed access to the VM. If provided, an Azure Network Security
     Group will be created with corresponding rules and be bound to
-    the NIC attached to the VM.
+    the subnet of the VM.
     Providing `allowed_inbound_ip_addresses` in combination with
     `virtual_network_name` is not allowed.
     

From 29a6938de6541b73e9534589a8ce2619cd9769ae Mon Sep 17 00:00:00 2001
From: Davor Kapsa <davor.kapsa@gmail.com>
Date: Thu, 10 Oct 2019 20:48:26 +0200
Subject: [PATCH 046/155] clean and return nil for retry.Config

---
 builder/azure/arm/step_delete_resource_group.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/builder/azure/arm/step_delete_resource_group.go b/builder/azure/arm/step_delete_resource_group.go
index 572b22884..aac1c4b91 100644
--- a/builder/azure/arm/step_delete_resource_group.go
+++ b/builder/azure/arm/step_delete_resource_group.go
@@ -95,7 +95,7 @@ func (s *StepDeleteResourceGroup) deleteDeploymentResources(ctx context.Context,
 			resourceType,
 			resourceName))
 
-		_ = retry.Config{
+		retry.Config{
 			Tries:      10,
 			RetryDelay: (&retry.Backoff{InitialBackoff: 10 * time.Second, MaxBackoff: 600 * time.Second, Multiplier: 2}).Linear,
 		}.Run(ctx, func(ctx context.Context) error {
@@ -106,7 +106,7 @@ func (s *StepDeleteResourceGroup) deleteDeploymentResources(ctx context.Context,
 			if err != nil {
 				s.reportIfError(err, resourceName)
 			}
-			return err
+			return nil
 		})
 
 		if err = deploymentOperations.Next(); err != nil {

From 6492995a209392ecd3eae39d150b176440b7afa5 Mon Sep 17 00:00:00 2001
From: psinghal20 <psinghal20@gmail.com>
Date: Wed, 9 Oct 2019 22:07:11 +0530
Subject: [PATCH 047/155] feat: add strftime function in templates

This commit adds strfttime function in templates to provide conventional format for ISO time based on C standard.

Signed-off-by: psinghal20 <psinghal20@gmail.com>
---
 go.mod                                        |    2 +
 go.sum                                        |    2 +
 template/interpolate/funcs.go                 |    8 +
 template/interpolate/funcs_test.go            |   19 +
 .../github.com/jehiah/go-strftime/.gitignore  |   22 +
 vendor/github.com/jehiah/go-strftime/LICENSE  |   19 +
 .../github.com/jehiah/go-strftime/README.md   |   26 +
 .../github.com/jehiah/go-strftime/strftime.go |   72 +
 .../klauspost/compress/flate/gen.go           |  265 +++
 .../github.com/klauspost/cpuid/private-gen.go |  476 ++++++
 vendor/github.com/linode/linodego/template.go |  167 ++
 .../azure-sdk-for-go/core/http/triv.go        |  141 ++
 .../core/tls/generate_cert.go                 |  118 ++
 .../shirou/gopsutil/host/types_darwin.go      |   17 +
 .../shirou/gopsutil/host/types_freebsd.go     |   44 +
 .../shirou/gopsutil/host/types_linux.go       |   42 +
 .../shirou/gopsutil/host/types_openbsd.go     |   43 +
 .../shirou/gopsutil/mem/types_openbsd.go      |   34 +
 .../shirou/gopsutil/process/types_darwin.go   |  160 ++
 .../shirou/gopsutil/process/types_freebsd.go  |   95 ++
 .../shirou/gopsutil/process/types_openbsd.go  |  103 ++
 vendor/github.com/ulikunitz/xz/example.go     |   40 +
 vendor/golang.org/x/net/html/atom/gen.go      |  712 ++++++++
 vendor/golang.org/x/net/publicsuffix/gen.go   |  717 ++++++++
 vendor/golang.org/x/sys/unix/mkasm_darwin.go  |   61 +
 vendor/golang.org/x/sys/unix/mkpost.go        |  122 ++
 vendor/golang.org/x/sys/unix/mksyscall.go     |  407 +++++
 .../x/sys/unix/mksyscall_aix_ppc.go           |  415 +++++
 .../x/sys/unix/mksyscall_aix_ppc64.go         |  614 +++++++
 .../x/sys/unix/mksyscall_solaris.go           |  335 ++++
 .../golang.org/x/sys/unix/mksysctl_openbsd.go |  355 ++++
 vendor/golang.org/x/sys/unix/mksysnum.go      |  190 +++
 vendor/golang.org/x/sys/unix/types_aix.go     |  237 +++
 vendor/golang.org/x/sys/unix/types_darwin.go  |  283 +++
 .../golang.org/x/sys/unix/types_dragonfly.go  |  263 +++
 vendor/golang.org/x/sys/unix/types_freebsd.go |  400 +++++
 vendor/golang.org/x/sys/unix/types_netbsd.go  |  290 ++++
 vendor/golang.org/x/sys/unix/types_openbsd.go |  283 +++
 vendor/golang.org/x/sys/unix/types_solaris.go |  266 +++
 .../x/text/encoding/charmap/maketables.go     |  556 ++++++
 .../x/text/encoding/htmlindex/gen.go          |  173 ++
 .../text/encoding/internal/identifier/gen.go  |  142 ++
 .../x/text/encoding/japanese/maketables.go    |  161 ++
 .../x/text/encoding/korean/maketables.go      |  143 ++
 .../encoding/simplifiedchinese/maketables.go  |  161 ++
 .../encoding/traditionalchinese/maketables.go |  140 ++
 .../x/text/internal/language/compact/gen.go   |   64 +
 .../internal/language/compact/gen_index.go    |  113 ++
 .../internal/language/compact/gen_parents.go  |   54 +
 .../x/text/internal/language/gen.go           | 1520 +++++++++++++++++
 .../x/text/internal/language/gen_common.go    |   20 +
 vendor/golang.org/x/text/language/gen.go      |  305 ++++
 vendor/golang.org/x/text/unicode/bidi/gen.go  |  133 ++
 .../x/text/unicode/bidi/gen_ranges.go         |   57 +
 .../x/text/unicode/bidi/gen_trieval.go        |   64 +
 .../x/text/unicode/norm/maketables.go         |  986 +++++++++++
 .../golang.org/x/text/unicode/norm/triegen.go |  117 ++
 vendor/modules.txt                            |  328 ++--
 website/source/docs/templates/engine.html.md  |    4 +
 59 files changed, 12943 insertions(+), 163 deletions(-)
 create mode 100644 vendor/github.com/jehiah/go-strftime/.gitignore
 create mode 100644 vendor/github.com/jehiah/go-strftime/LICENSE
 create mode 100644 vendor/github.com/jehiah/go-strftime/README.md
 create mode 100644 vendor/github.com/jehiah/go-strftime/strftime.go
 create mode 100644 vendor/github.com/klauspost/compress/flate/gen.go
 create mode 100644 vendor/github.com/klauspost/cpuid/private-gen.go
 create mode 100644 vendor/github.com/linode/linodego/template.go
 create mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/triv.go
 create mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/generate_cert.go
 create mode 100644 vendor/github.com/shirou/gopsutil/host/types_darwin.go
 create mode 100644 vendor/github.com/shirou/gopsutil/host/types_freebsd.go
 create mode 100644 vendor/github.com/shirou/gopsutil/host/types_linux.go
 create mode 100644 vendor/github.com/shirou/gopsutil/host/types_openbsd.go
 create mode 100644 vendor/github.com/shirou/gopsutil/mem/types_openbsd.go
 create mode 100644 vendor/github.com/shirou/gopsutil/process/types_darwin.go
 create mode 100644 vendor/github.com/shirou/gopsutil/process/types_freebsd.go
 create mode 100644 vendor/github.com/shirou/gopsutil/process/types_openbsd.go
 create mode 100644 vendor/github.com/ulikunitz/xz/example.go
 create mode 100644 vendor/golang.org/x/net/html/atom/gen.go
 create mode 100644 vendor/golang.org/x/net/publicsuffix/gen.go
 create mode 100644 vendor/golang.org/x/sys/unix/mkasm_darwin.go
 create mode 100644 vendor/golang.org/x/sys/unix/mkpost.go
 create mode 100644 vendor/golang.org/x/sys/unix/mksyscall.go
 create mode 100644 vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go
 create mode 100644 vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go
 create mode 100644 vendor/golang.org/x/sys/unix/mksyscall_solaris.go
 create mode 100644 vendor/golang.org/x/sys/unix/mksysctl_openbsd.go
 create mode 100644 vendor/golang.org/x/sys/unix/mksysnum.go
 create mode 100644 vendor/golang.org/x/sys/unix/types_aix.go
 create mode 100644 vendor/golang.org/x/sys/unix/types_darwin.go
 create mode 100644 vendor/golang.org/x/sys/unix/types_dragonfly.go
 create mode 100644 vendor/golang.org/x/sys/unix/types_freebsd.go
 create mode 100644 vendor/golang.org/x/sys/unix/types_netbsd.go
 create mode 100644 vendor/golang.org/x/sys/unix/types_openbsd.go
 create mode 100644 vendor/golang.org/x/sys/unix/types_solaris.go
 create mode 100644 vendor/golang.org/x/text/encoding/charmap/maketables.go
 create mode 100644 vendor/golang.org/x/text/encoding/htmlindex/gen.go
 create mode 100644 vendor/golang.org/x/text/encoding/internal/identifier/gen.go
 create mode 100644 vendor/golang.org/x/text/encoding/japanese/maketables.go
 create mode 100644 vendor/golang.org/x/text/encoding/korean/maketables.go
 create mode 100644 vendor/golang.org/x/text/encoding/simplifiedchinese/maketables.go
 create mode 100644 vendor/golang.org/x/text/encoding/traditionalchinese/maketables.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compact/gen.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compact/gen_index.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compact/gen_parents.go
 create mode 100644 vendor/golang.org/x/text/internal/language/gen.go
 create mode 100644 vendor/golang.org/x/text/internal/language/gen_common.go
 create mode 100644 vendor/golang.org/x/text/language/gen.go
 create mode 100644 vendor/golang.org/x/text/unicode/bidi/gen.go
 create mode 100644 vendor/golang.org/x/text/unicode/bidi/gen_ranges.go
 create mode 100644 vendor/golang.org/x/text/unicode/bidi/gen_trieval.go
 create mode 100644 vendor/golang.org/x/text/unicode/norm/maketables.go
 create mode 100644 vendor/golang.org/x/text/unicode/norm/triegen.go

diff --git a/go.mod b/go.mod
index f6fb13583..2d09a5bf6 100644
--- a/go.mod
+++ b/go.mod
@@ -49,6 +49,7 @@ require (
 	github.com/gofrs/flock v0.7.1
 	github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
 	github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
+	github.com/google/btree v1.0.0 // indirect
 	github.com/google/go-cmp v0.3.0
 	github.com/google/go-querystring v1.0.0 // indirect
 	github.com/google/shlex v0.0.0-20150127133951-6f45313302b9
@@ -76,6 +77,7 @@ require (
 	github.com/hetznercloud/hcloud-go v1.15.1
 	github.com/hyperonecom/h1-client-go v0.0.0-20190122232013-cf38e8387775
 	github.com/jdcloud-api/jdcloud-sdk-go v1.9.1-0.20190605102154-3d81a50ca961
+	github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869
 	github.com/joyent/triton-go v0.0.0-20180116165742-545edbe0d564
 	github.com/json-iterator/go v1.1.6 // indirect
 	github.com/jtolds/gls v4.2.1+incompatible // indirect
diff --git a/go.sum b/go.sum
index 227d12cb6..b2b1398d5 100644
--- a/go.sum
+++ b/go.sum
@@ -238,6 +238,8 @@ github.com/hyperonecom/h1-client-go v0.0.0-20190122232013-cf38e8387775 h1:MIteIo
 github.com/hyperonecom/h1-client-go v0.0.0-20190122232013-cf38e8387775/go.mod h1:R9rU87RxxmcD3DkspW9JqGBXiJyg5MA+WNCtJrBtnXs=
 github.com/jdcloud-api/jdcloud-sdk-go v1.9.1-0.20190605102154-3d81a50ca961 h1:a2/K4HRhg31A5vafiz5yYiGMjaCxwRpyjJStfVquKds=
 github.com/jdcloud-api/jdcloud-sdk-go v1.9.1-0.20190605102154-3d81a50ca961/go.mod h1:UrKjuULIWLjHFlG6aSPunArE5QX57LftMmStAZJBEX8=
+github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869 h1:IPJ3dvxmJ4uczJe5YQdrYB16oTJlGSC/OyZDqUk9xX4=
+github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869/go.mod h1:cJ6Cj7dQo+O6GJNiMx+Pa94qKj+TG8ONdKHgMNIyyag=
 github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af h1:pmfjZENx5imkbgOkpRUYLnmbU7UEFbjtDA2hxJ1ichM=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
diff --git a/template/interpolate/funcs.go b/template/interpolate/funcs.go
index eaf2f8e39..609d35f4a 100644
--- a/template/interpolate/funcs.go
+++ b/template/interpolate/funcs.go
@@ -14,6 +14,7 @@ import (
 	"github.com/hashicorp/packer/common/uuid"
 	"github.com/hashicorp/packer/version"
 	vaultapi "github.com/hashicorp/vault/api"
+	strftime "github.com/jehiah/go-strftime"
 )
 
 // InitTime is the UTC time when this package was initialized. It is
@@ -31,6 +32,7 @@ var FuncGens = map[string]interface{}{
 	"build_type":     funcGenBuildType,
 	"env":            funcGenEnv,
 	"isotime":        funcGenIsotime,
+	"strftime":       funcGenStrftime,
 	"pwd":            funcGenPwd,
 	"split":          funcGenSplitter,
 	"template_dir":   funcGenTemplateDir,
@@ -133,6 +135,12 @@ func funcGenIsotime(ctx *Context) interface{} {
 	}
 }
 
+func funcGenStrftime(ctx *Context) interface{} {
+	return func(format string) string {
+		return strftime.Format(format, InitTime)
+	}
+}
+
 func funcGenPwd(ctx *Context) interface{} {
 	return func() (string, error) {
 		return os.Getwd()
diff --git a/template/interpolate/funcs_test.go b/template/interpolate/funcs_test.go
index 6be19af69..f02e5678e 100644
--- a/template/interpolate/funcs_test.go
+++ b/template/interpolate/funcs_test.go
@@ -141,6 +141,25 @@ func TestFuncIsotime(t *testing.T) {
 	}
 }
 
+func TestFuncStrftime(t *testing.T) {
+	ctx := &Context{}
+	i := &I{Value: "{{strftime \"%Y-%m-%dT%H:%M:%S%z\"}}"}
+	result, err := i.Render(ctx)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	val, err := time.Parse("2006-01-02T15:04:05-0700", result)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	currentTime := time.Now().UTC()
+	if currentTime.Sub(val) > 2*time.Second {
+		t.Fatalf("val: %v (current: %v)", val, currentTime)
+	}
+}
+
 func TestFuncPwd(t *testing.T) {
 	wd, err := os.Getwd()
 	if err != nil {
diff --git a/vendor/github.com/jehiah/go-strftime/.gitignore b/vendor/github.com/jehiah/go-strftime/.gitignore
new file mode 100644
index 000000000..00268614f
--- /dev/null
+++ b/vendor/github.com/jehiah/go-strftime/.gitignore
@@ -0,0 +1,22 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
diff --git a/vendor/github.com/jehiah/go-strftime/LICENSE b/vendor/github.com/jehiah/go-strftime/LICENSE
new file mode 100644
index 000000000..a49216f13
--- /dev/null
+++ b/vendor/github.com/jehiah/go-strftime/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2012 Jehiah Czebotar
+
+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/github.com/jehiah/go-strftime/README.md b/vendor/github.com/jehiah/go-strftime/README.md
new file mode 100644
index 000000000..10b06f4af
--- /dev/null
+++ b/vendor/github.com/jehiah/go-strftime/README.md
@@ -0,0 +1,26 @@
+go-strftime
+===========
+
+go implementation of strftime
+
+## Example
+
+```
+package main
+
+import (
+	"fmt"
+	"time"
+
+	strftime "github.com/jehiah/go-strftime"
+)
+
+func main() {
+	t := time.Unix(1340244776, 0)
+	utc, _ := time.LoadLocation("UTC")
+	t = t.In(utc)
+	fmt.Println(strftime.Format("%Y-%m-%d %H:%M:%S", t))
+	// Output:
+	// 2012-06-21 02:12:56
+}
+```
diff --git a/vendor/github.com/jehiah/go-strftime/strftime.go b/vendor/github.com/jehiah/go-strftime/strftime.go
new file mode 100644
index 000000000..bf2eeab48
--- /dev/null
+++ b/vendor/github.com/jehiah/go-strftime/strftime.go
@@ -0,0 +1,72 @@
+// go implementation of strftime
+package strftime
+
+import (
+	"strings"
+	"time"
+)
+
+// taken from time/format.go
+var conversion = map[rune]string{
+	/*stdLongMonth      */ 'B': "January",
+	/*stdMonth          */ 'b': "Jan",
+	// stdNumMonth       */ 'm': "1",
+	/*stdZeroMonth      */ 'm': "01",
+	/*stdLongWeekDay    */ 'A': "Monday",
+	/*stdWeekDay        */ 'a': "Mon",
+	// stdDay            */ 'd': "2",
+	// stdUnderDay       */ 'd': "_2",
+	/*stdZeroDay        */ 'd': "02",
+	/*stdHour           */ 'H': "15",
+	// stdHour12         */ 'I': "3",
+	/*stdZeroHour12     */ 'I': "03",
+	// stdMinute         */ 'M': "4",
+	/*stdZeroMinute     */ 'M': "04",
+	// stdSecond         */ 'S': "5",
+	/*stdZeroSecond     */ 'S': "05",
+	/*stdLongYear       */ 'Y': "2006",
+	/*stdYear           */ 'y': "06",
+	/*stdPM             */ 'p': "PM",
+	// stdpm             */ 'p': "pm",
+	/*stdTZ             */ 'Z': "MST",
+	// stdISO8601TZ      */ 'z': "Z0700",  // prints Z for UTC
+	// stdISO8601ColonTZ */ 'z': "Z07:00", // prints Z for UTC
+	/*stdNumTZ          */ 'z': "-0700", // always numeric
+	// stdNumShortTZ     */ 'b': "-07",    // always numeric
+	// stdNumColonTZ     */ 'b': "-07:00", // always numeric
+	/* nonStdMilli		 */ 'L': ".000",
+}
+
+// This is an alternative to time.Format because no one knows
+// what date 040305 is supposed to create when used as a 'layout' string
+// this takes standard strftime format options. For a complete list
+// of format options see http://strftime.org/
+func Format(format string, t time.Time) string {
+	retval := make([]byte, 0, len(format))
+	for i, ni := 0, 0; i < len(format); i = ni + 2 {
+		ni = strings.IndexByte(format[i:], '%')
+		if ni < 0 {
+			ni = len(format)
+		} else {
+			ni += i
+		}
+		retval = append(retval, []byte(format[i:ni])...)
+		if ni+1 < len(format) {
+			c := format[ni+1]
+			if c == '%' {
+				retval = append(retval, '%')
+			} else {
+				if layoutCmd, ok := conversion[rune(c)]; ok {
+					retval = append(retval, []byte(t.Format(layoutCmd))...)
+				} else {
+					retval = append(retval, '%', c)
+				}
+			}
+		} else {
+			if ni < len(format) {
+				retval = append(retval, '%')
+			}
+		}
+	}
+	return string(retval)
+}
diff --git a/vendor/github.com/klauspost/compress/flate/gen.go b/vendor/github.com/klauspost/compress/flate/gen.go
new file mode 100644
index 000000000..154c89a48
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/flate/gen.go
@@ -0,0 +1,265 @@
+// Copyright 2012 The Go 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 ignore
+
+// This program generates fixedhuff.go
+// Invoke as
+//
+//	go run gen.go -output fixedhuff.go
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io/ioutil"
+	"log"
+)
+
+var filename = flag.String("output", "fixedhuff.go", "output file name")
+
+const maxCodeLen = 16
+
+// Note: the definition of the huffmanDecoder struct is copied from
+// inflate.go, as it is private to the implementation.
+
+// chunk & 15 is number of bits
+// chunk >> 4 is value, including table link
+
+const (
+	huffmanChunkBits  = 9
+	huffmanNumChunks  = 1 << huffmanChunkBits
+	huffmanCountMask  = 15
+	huffmanValueShift = 4
+)
+
+type huffmanDecoder struct {
+	min      int                      // the minimum code length
+	chunks   [huffmanNumChunks]uint32 // chunks as described above
+	links    [][]uint32               // overflow links
+	linkMask uint32                   // mask the width of the link table
+}
+
+// Initialize Huffman decoding tables from array of code lengths.
+// Following this function, h is guaranteed to be initialized into a complete
+// tree (i.e., neither over-subscribed nor under-subscribed). The exception is a
+// degenerate case where the tree has only a single symbol with length 1. Empty
+// trees are permitted.
+func (h *huffmanDecoder) init(bits []int) bool {
+	// Sanity enables additional runtime tests during Huffman
+	// table construction.  It's intended to be used during
+	// development to supplement the currently ad-hoc unit tests.
+	const sanity = false
+
+	if h.min != 0 {
+		*h = huffmanDecoder{}
+	}
+
+	// Count number of codes of each length,
+	// compute min and max length.
+	var count [maxCodeLen]int
+	var min, max int
+	for _, n := range bits {
+		if n == 0 {
+			continue
+		}
+		if min == 0 || n < min {
+			min = n
+		}
+		if n > max {
+			max = n
+		}
+		count[n]++
+	}
+
+	// Empty tree. The decompressor.huffSym function will fail later if the tree
+	// is used. Technically, an empty tree is only valid for the HDIST tree and
+	// not the HCLEN and HLIT tree. However, a stream with an empty HCLEN tree
+	// is guaranteed to fail since it will attempt to use the tree to decode the
+	// codes for the HLIT and HDIST trees. Similarly, an empty HLIT tree is
+	// guaranteed to fail later since the compressed data section must be
+	// composed of at least one symbol (the end-of-block marker).
+	if max == 0 {
+		return true
+	}
+
+	code := 0
+	var nextcode [maxCodeLen]int
+	for i := min; i <= max; i++ {
+		code <<= 1
+		nextcode[i] = code
+		code += count[i]
+	}
+
+	// Check that the coding is complete (i.e., that we've
+	// assigned all 2-to-the-max possible bit sequences).
+	// Exception: To be compatible with zlib, we also need to
+	// accept degenerate single-code codings.  See also
+	// TestDegenerateHuffmanCoding.
+	if code != 1<<uint(max) && !(code == 1 && max == 1) {
+		return false
+	}
+
+	h.min = min
+	if max > huffmanChunkBits {
+		numLinks := 1 << (uint(max) - huffmanChunkBits)
+		h.linkMask = uint32(numLinks - 1)
+
+		// create link tables
+		link := nextcode[huffmanChunkBits+1] >> 1
+		h.links = make([][]uint32, huffmanNumChunks-link)
+		for j := uint(link); j < huffmanNumChunks; j++ {
+			reverse := int(reverseByte[j>>8]) | int(reverseByte[j&0xff])<<8
+			reverse >>= uint(16 - huffmanChunkBits)
+			off := j - uint(link)
+			if sanity && h.chunks[reverse] != 0 {
+				panic("impossible: overwriting existing chunk")
+			}
+			h.chunks[reverse] = uint32(off<<huffmanValueShift | (huffmanChunkBits + 1))
+			h.links[off] = make([]uint32, numLinks)
+		}
+	}
+
+	for i, n := range bits {
+		if n == 0 {
+			continue
+		}
+		code := nextcode[n]
+		nextcode[n]++
+		chunk := uint32(i<<huffmanValueShift | n)
+		reverse := int(reverseByte[code>>8]) | int(reverseByte[code&0xff])<<8
+		reverse >>= uint(16 - n)
+		if n <= huffmanChunkBits {
+			for off := reverse; off < len(h.chunks); off += 1 << uint(n) {
+				// We should never need to overwrite
+				// an existing chunk.  Also, 0 is
+				// never a valid chunk, because the
+				// lower 4 "count" bits should be
+				// between 1 and 15.
+				if sanity && h.chunks[off] != 0 {
+					panic("impossible: overwriting existing chunk")
+				}
+				h.chunks[off] = chunk
+			}
+		} else {
+			j := reverse & (huffmanNumChunks - 1)
+			if sanity && h.chunks[j]&huffmanCountMask != huffmanChunkBits+1 {
+				// Longer codes should have been
+				// associated with a link table above.
+				panic("impossible: not an indirect chunk")
+			}
+			value := h.chunks[j] >> huffmanValueShift
+			linktab := h.links[value]
+			reverse >>= huffmanChunkBits
+			for off := reverse; off < len(linktab); off += 1 << uint(n-huffmanChunkBits) {
+				if sanity && linktab[off] != 0 {
+					panic("impossible: overwriting existing chunk")
+				}
+				linktab[off] = chunk
+			}
+		}
+	}
+
+	if sanity {
+		// Above we've sanity checked that we never overwrote
+		// an existing entry.  Here we additionally check that
+		// we filled the tables completely.
+		for i, chunk := range h.chunks {
+			if chunk == 0 {
+				// As an exception, in the degenerate
+				// single-code case, we allow odd
+				// chunks to be missing.
+				if code == 1 && i%2 == 1 {
+					continue
+				}
+				panic("impossible: missing chunk")
+			}
+		}
+		for _, linktab := range h.links {
+			for _, chunk := range linktab {
+				if chunk == 0 {
+					panic("impossible: missing chunk")
+				}
+			}
+		}
+	}
+
+	return true
+}
+
+func main() {
+	flag.Parse()
+
+	var h huffmanDecoder
+	var bits [288]int
+	initReverseByte()
+	for i := 0; i < 144; i++ {
+		bits[i] = 8
+	}
+	for i := 144; i < 256; i++ {
+		bits[i] = 9
+	}
+	for i := 256; i < 280; i++ {
+		bits[i] = 7
+	}
+	for i := 280; i < 288; i++ {
+		bits[i] = 8
+	}
+	h.init(bits[:])
+	if h.links != nil {
+		log.Fatal("Unexpected links table in fixed Huffman decoder")
+	}
+
+	var buf bytes.Buffer
+
+	fmt.Fprintf(&buf, `// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.`+"\n\n")
+
+	fmt.Fprintln(&buf, "package flate")
+	fmt.Fprintln(&buf)
+	fmt.Fprintln(&buf, "// autogenerated by go run gen.go -output fixedhuff.go, DO NOT EDIT")
+	fmt.Fprintln(&buf)
+	fmt.Fprintln(&buf, "var fixedHuffmanDecoder = huffmanDecoder{")
+	fmt.Fprintf(&buf, "\t%d,\n", h.min)
+	fmt.Fprintln(&buf, "\t[huffmanNumChunks]uint32{")
+	for i := 0; i < huffmanNumChunks; i++ {
+		if i&7 == 0 {
+			fmt.Fprintf(&buf, "\t\t")
+		} else {
+			fmt.Fprintf(&buf, " ")
+		}
+		fmt.Fprintf(&buf, "0x%04x,", h.chunks[i])
+		if i&7 == 7 {
+			fmt.Fprintln(&buf)
+		}
+	}
+	fmt.Fprintln(&buf, "\t},")
+	fmt.Fprintln(&buf, "\tnil, 0,")
+	fmt.Fprintln(&buf, "}")
+
+	data, err := format.Source(buf.Bytes())
+	if err != nil {
+		log.Fatal(err)
+	}
+	err = ioutil.WriteFile(*filename, data, 0644)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+var reverseByte [256]byte
+
+func initReverseByte() {
+	for x := 0; x < 256; x++ {
+		var result byte
+		for i := uint(0); i < 8; i++ {
+			result |= byte(((x >> i) & 1) << (7 - i))
+		}
+		reverseByte[x] = result
+	}
+}
diff --git a/vendor/github.com/klauspost/cpuid/private-gen.go b/vendor/github.com/klauspost/cpuid/private-gen.go
new file mode 100644
index 000000000..437333d29
--- /dev/null
+++ b/vendor/github.com/klauspost/cpuid/private-gen.go
@@ -0,0 +1,476 @@
+// +build ignore
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"reflect"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+var inFiles = []string{"cpuid.go", "cpuid_test.go"}
+var copyFiles = []string{"cpuid_amd64.s", "cpuid_386.s", "detect_ref.go", "detect_intel.go"}
+var fileSet = token.NewFileSet()
+var reWrites = []rewrite{
+	initRewrite("CPUInfo -> cpuInfo"),
+	initRewrite("Vendor -> vendor"),
+	initRewrite("Flags -> flags"),
+	initRewrite("Detect -> detect"),
+	initRewrite("CPU -> cpu"),
+}
+var excludeNames = map[string]bool{"string": true, "join": true, "trim": true,
+	// cpuid_test.go
+	"t": true, "println": true, "logf": true, "log": true, "fatalf": true, "fatal": true,
+}
+
+var excludePrefixes = []string{"test", "benchmark"}
+
+func main() {
+	Package := "private"
+	parserMode := parser.ParseComments
+	exported := make(map[string]rewrite)
+	for _, file := range inFiles {
+		in, err := os.Open(file)
+		if err != nil {
+			log.Fatalf("opening input", err)
+		}
+
+		src, err := ioutil.ReadAll(in)
+		if err != nil {
+			log.Fatalf("reading input", err)
+		}
+
+		astfile, err := parser.ParseFile(fileSet, file, src, parserMode)
+		if err != nil {
+			log.Fatalf("parsing input", err)
+		}
+
+		for _, rw := range reWrites {
+			astfile = rw(astfile)
+		}
+
+		// Inspect the AST and print all identifiers and literals.
+		var startDecl token.Pos
+		var endDecl token.Pos
+		ast.Inspect(astfile, func(n ast.Node) bool {
+			var s string
+			switch x := n.(type) {
+			case *ast.Ident:
+				if x.IsExported() {
+					t := strings.ToLower(x.Name)
+					for _, pre := range excludePrefixes {
+						if strings.HasPrefix(t, pre) {
+							return true
+						}
+					}
+					if excludeNames[t] != true {
+						//if x.Pos() > startDecl && x.Pos() < endDecl {
+						exported[x.Name] = initRewrite(x.Name + " -> " + t)
+					}
+				}
+
+			case *ast.GenDecl:
+				if x.Tok == token.CONST && x.Lparen > 0 {
+					startDecl = x.Lparen
+					endDecl = x.Rparen
+					// fmt.Printf("Decl:%s -> %s\n", fileSet.Position(startDecl), fileSet.Position(endDecl))
+				}
+			}
+			if s != "" {
+				fmt.Printf("%s:\t%s\n", fileSet.Position(n.Pos()), s)
+			}
+			return true
+		})
+
+		for _, rw := range exported {
+			astfile = rw(astfile)
+		}
+
+		var buf bytes.Buffer
+
+		printer.Fprint(&buf, fileSet, astfile)
+
+		// Remove package documentation and insert information
+		s := buf.String()
+		ind := strings.Index(buf.String(), "\npackage cpuid")
+		s = s[ind:]
+		s = "// Generated, DO NOT EDIT,\n" +
+			"// but copy it to your own project and rename the package.\n" +
+			"// See more at http://github.com/klauspost/cpuid\n" +
+			s
+
+		outputName := Package + string(os.PathSeparator) + file
+
+		err = ioutil.WriteFile(outputName, []byte(s), 0644)
+		if err != nil {
+			log.Fatalf("writing output: %s", err)
+		}
+		log.Println("Generated", outputName)
+	}
+
+	for _, file := range copyFiles {
+		dst := ""
+		if strings.HasPrefix(file, "cpuid") {
+			dst = Package + string(os.PathSeparator) + file
+		} else {
+			dst = Package + string(os.PathSeparator) + "cpuid_" + file
+		}
+		err := copyFile(file, dst)
+		if err != nil {
+			log.Fatalf("copying file: %s", err)
+		}
+		log.Println("Copied", dst)
+	}
+}
+
+// CopyFile copies a file from src to dst. If src and dst files exist, and are
+// the same, then return success. Copy the file contents from src to dst.
+func copyFile(src, dst string) (err error) {
+	sfi, err := os.Stat(src)
+	if err != nil {
+		return
+	}
+	if !sfi.Mode().IsRegular() {
+		// cannot copy non-regular files (e.g., directories,
+		// symlinks, devices, etc.)
+		return fmt.Errorf("CopyFile: non-regular source file %s (%q)", sfi.Name(), sfi.Mode().String())
+	}
+	dfi, err := os.Stat(dst)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			return
+		}
+	} else {
+		if !(dfi.Mode().IsRegular()) {
+			return fmt.Errorf("CopyFile: non-regular destination file %s (%q)", dfi.Name(), dfi.Mode().String())
+		}
+		if os.SameFile(sfi, dfi) {
+			return
+		}
+	}
+	err = copyFileContents(src, dst)
+	return
+}
+
+// copyFileContents copies the contents of the file named src to the file named
+// by dst. The file will be created if it does not already exist. If the
+// destination file exists, all it's contents will be replaced by the contents
+// of the source file.
+func copyFileContents(src, dst string) (err error) {
+	in, err := os.Open(src)
+	if err != nil {
+		return
+	}
+	defer in.Close()
+	out, err := os.Create(dst)
+	if err != nil {
+		return
+	}
+	defer func() {
+		cerr := out.Close()
+		if err == nil {
+			err = cerr
+		}
+	}()
+	if _, err = io.Copy(out, in); err != nil {
+		return
+	}
+	err = out.Sync()
+	return
+}
+
+type rewrite func(*ast.File) *ast.File
+
+// Mostly copied from gofmt
+func initRewrite(rewriteRule string) rewrite {
+	f := strings.Split(rewriteRule, "->")
+	if len(f) != 2 {
+		fmt.Fprintf(os.Stderr, "rewrite rule must be of the form 'pattern -> replacement'\n")
+		os.Exit(2)
+	}
+	pattern := parseExpr(f[0], "pattern")
+	replace := parseExpr(f[1], "replacement")
+	return func(p *ast.File) *ast.File { return rewriteFile(pattern, replace, p) }
+}
+
+// parseExpr parses s as an expression.
+// It might make sense to expand this to allow statement patterns,
+// but there are problems with preserving formatting and also
+// with what a wildcard for a statement looks like.
+func parseExpr(s, what string) ast.Expr {
+	x, err := parser.ParseExpr(s)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "parsing %s %s at %s\n", what, s, err)
+		os.Exit(2)
+	}
+	return x
+}
+
+// Keep this function for debugging.
+/*
+func dump(msg string, val reflect.Value) {
+	fmt.Printf("%s:\n", msg)
+	ast.Print(fileSet, val.Interface())
+	fmt.Println()
+}
+*/
+
+// rewriteFile applies the rewrite rule 'pattern -> replace' to an entire file.
+func rewriteFile(pattern, replace ast.Expr, p *ast.File) *ast.File {
+	cmap := ast.NewCommentMap(fileSet, p, p.Comments)
+	m := make(map[string]reflect.Value)
+	pat := reflect.ValueOf(pattern)
+	repl := reflect.ValueOf(replace)
+
+	var rewriteVal func(val reflect.Value) reflect.Value
+	rewriteVal = func(val reflect.Value) reflect.Value {
+		// don't bother if val is invalid to start with
+		if !val.IsValid() {
+			return reflect.Value{}
+		}
+		for k := range m {
+			delete(m, k)
+		}
+		val = apply(rewriteVal, val)
+		if match(m, pat, val) {
+			val = subst(m, repl, reflect.ValueOf(val.Interface().(ast.Node).Pos()))
+		}
+		return val
+	}
+
+	r := apply(rewriteVal, reflect.ValueOf(p)).Interface().(*ast.File)
+	r.Comments = cmap.Filter(r).Comments() // recreate comments list
+	return r
+}
+
+// set is a wrapper for x.Set(y); it protects the caller from panics if x cannot be changed to y.
+func set(x, y reflect.Value) {
+	// don't bother if x cannot be set or y is invalid
+	if !x.CanSet() || !y.IsValid() {
+		return
+	}
+	defer func() {
+		if x := recover(); x != nil {
+			if s, ok := x.(string); ok &&
+				(strings.Contains(s, "type mismatch") || strings.Contains(s, "not assignable")) {
+				// x cannot be set to y - ignore this rewrite
+				return
+			}
+			panic(x)
+		}
+	}()
+	x.Set(y)
+}
+
+// Values/types for special cases.
+var (
+	objectPtrNil = reflect.ValueOf((*ast.Object)(nil))
+	scopePtrNil  = reflect.ValueOf((*ast.Scope)(nil))
+
+	identType     = reflect.TypeOf((*ast.Ident)(nil))
+	objectPtrType = reflect.TypeOf((*ast.Object)(nil))
+	positionType  = reflect.TypeOf(token.NoPos)
+	callExprType  = reflect.TypeOf((*ast.CallExpr)(nil))
+	scopePtrType  = reflect.TypeOf((*ast.Scope)(nil))
+)
+
+// apply replaces each AST field x in val with f(x), returning val.
+// To avoid extra conversions, f operates on the reflect.Value form.
+func apply(f func(reflect.Value) reflect.Value, val reflect.Value) reflect.Value {
+	if !val.IsValid() {
+		return reflect.Value{}
+	}
+
+	// *ast.Objects introduce cycles and are likely incorrect after
+	// rewrite; don't follow them but replace with nil instead
+	if val.Type() == objectPtrType {
+		return objectPtrNil
+	}
+
+	// similarly for scopes: they are likely incorrect after a rewrite;
+	// replace them with nil
+	if val.Type() == scopePtrType {
+		return scopePtrNil
+	}
+
+	switch v := reflect.Indirect(val); v.Kind() {
+	case reflect.Slice:
+		for i := 0; i < v.Len(); i++ {
+			e := v.Index(i)
+			set(e, f(e))
+		}
+	case reflect.Struct:
+		for i := 0; i < v.NumField(); i++ {
+			e := v.Field(i)
+			set(e, f(e))
+		}
+	case reflect.Interface:
+		e := v.Elem()
+		set(v, f(e))
+	}
+	return val
+}
+
+func isWildcard(s string) bool {
+	rune, size := utf8.DecodeRuneInString(s)
+	return size == len(s) && unicode.IsLower(rune)
+}
+
+// match returns true if pattern matches val,
+// recording wildcard submatches in m.
+// If m == nil, match checks whether pattern == val.
+func match(m map[string]reflect.Value, pattern, val reflect.Value) bool {
+	// Wildcard matches any expression.  If it appears multiple
+	// times in the pattern, it must match the same expression
+	// each time.
+	if m != nil && pattern.IsValid() && pattern.Type() == identType {
+		name := pattern.Interface().(*ast.Ident).Name
+		if isWildcard(name) && val.IsValid() {
+			// wildcards only match valid (non-nil) expressions.
+			if _, ok := val.Interface().(ast.Expr); ok && !val.IsNil() {
+				if old, ok := m[name]; ok {
+					return match(nil, old, val)
+				}
+				m[name] = val
+				return true
+			}
+		}
+	}
+
+	// Otherwise, pattern and val must match recursively.
+	if !pattern.IsValid() || !val.IsValid() {
+		return !pattern.IsValid() && !val.IsValid()
+	}
+	if pattern.Type() != val.Type() {
+		return false
+	}
+
+	// Special cases.
+	switch pattern.Type() {
+	case identType:
+		// For identifiers, only the names need to match
+		// (and none of the other *ast.Object information).
+		// This is a common case, handle it all here instead
+		// of recursing down any further via reflection.
+		p := pattern.Interface().(*ast.Ident)
+		v := val.Interface().(*ast.Ident)
+		return p == nil && v == nil || p != nil && v != nil && p.Name == v.Name
+	case objectPtrType, positionType:
+		// object pointers and token positions always match
+		return true
+	case callExprType:
+		// For calls, the Ellipsis fields (token.Position) must
+		// match since that is how f(x) and f(x...) are different.
+		// Check them here but fall through for the remaining fields.
+		p := pattern.Interface().(*ast.CallExpr)
+		v := val.Interface().(*ast.CallExpr)
+		if p.Ellipsis.IsValid() != v.Ellipsis.IsValid() {
+			return false
+		}
+	}
+
+	p := reflect.Indirect(pattern)
+	v := reflect.Indirect(val)
+	if !p.IsValid() || !v.IsValid() {
+		return !p.IsValid() && !v.IsValid()
+	}
+
+	switch p.Kind() {
+	case reflect.Slice:
+		if p.Len() != v.Len() {
+			return false
+		}
+		for i := 0; i < p.Len(); i++ {
+			if !match(m, p.Index(i), v.Index(i)) {
+				return false
+			}
+		}
+		return true
+
+	case reflect.Struct:
+		for i := 0; i < p.NumField(); i++ {
+			if !match(m, p.Field(i), v.Field(i)) {
+				return false
+			}
+		}
+		return true
+
+	case reflect.Interface:
+		return match(m, p.Elem(), v.Elem())
+	}
+
+	// Handle token integers, etc.
+	return p.Interface() == v.Interface()
+}
+
+// subst returns a copy of pattern with values from m substituted in place
+// of wildcards and pos used as the position of tokens from the pattern.
+// if m == nil, subst returns a copy of pattern and doesn't change the line
+// number information.
+func subst(m map[string]reflect.Value, pattern reflect.Value, pos reflect.Value) reflect.Value {
+	if !pattern.IsValid() {
+		return reflect.Value{}
+	}
+
+	// Wildcard gets replaced with map value.
+	if m != nil && pattern.Type() == identType {
+		name := pattern.Interface().(*ast.Ident).Name
+		if isWildcard(name) {
+			if old, ok := m[name]; ok {
+				return subst(nil, old, reflect.Value{})
+			}
+		}
+	}
+
+	if pos.IsValid() && pattern.Type() == positionType {
+		// use new position only if old position was valid in the first place
+		if old := pattern.Interface().(token.Pos); !old.IsValid() {
+			return pattern
+		}
+		return pos
+	}
+
+	// Otherwise copy.
+	switch p := pattern; p.Kind() {
+	case reflect.Slice:
+		v := reflect.MakeSlice(p.Type(), p.Len(), p.Len())
+		for i := 0; i < p.Len(); i++ {
+			v.Index(i).Set(subst(m, p.Index(i), pos))
+		}
+		return v
+
+	case reflect.Struct:
+		v := reflect.New(p.Type()).Elem()
+		for i := 0; i < p.NumField(); i++ {
+			v.Field(i).Set(subst(m, p.Field(i), pos))
+		}
+		return v
+
+	case reflect.Ptr:
+		v := reflect.New(p.Type()).Elem()
+		if elem := p.Elem(); elem.IsValid() {
+			v.Set(subst(m, elem, pos).Addr())
+		}
+		return v
+
+	case reflect.Interface:
+		v := reflect.New(p.Type()).Elem()
+		if elem := p.Elem(); elem.IsValid() {
+			v.Set(subst(m, elem, pos))
+		}
+		return v
+	}
+
+	return pattern
+}
diff --git a/vendor/github.com/linode/linodego/template.go b/vendor/github.com/linode/linodego/template.go
new file mode 100644
index 000000000..ed0616837
--- /dev/null
+++ b/vendor/github.com/linode/linodego/template.go
@@ -0,0 +1,167 @@
+// +build ignore
+
+package linodego
+
+/*
+ - replace "Template" with "NameOfResource"
+ - replace "template" with "nameOfResource"
+ - copy template_test.go and do the same
+ - When updating Template structs,
+   - use pointers where ever null'able would have a different meaning if the wrapper
+	 supplied "" or 0 instead
+ - Add "NameOfResource" to client.go, resources.go, pagination.go
+*/
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// Template represents a Template object
+type Template struct {
+	ID int `json:"id"`
+	// UpdatedStr string `json:"updated"`
+	// Updated *time.Time `json:"-"`
+}
+
+// TemplateCreateOptions fields are those accepted by CreateTemplate
+type TemplateCreateOptions struct {
+}
+
+// TemplateUpdateOptions fields are those accepted by UpdateTemplate
+type TemplateUpdateOptions struct {
+}
+
+// GetCreateOptions converts a Template to TemplateCreateOptions for use in CreateTemplate
+func (i Template) GetCreateOptions() (o TemplateCreateOptions) {
+	// o.Label = i.Label
+	// o.Description = copyString(i.Description)
+	return
+}
+
+// GetUpdateOptions converts a Template to TemplateUpdateOptions for use in UpdateTemplate
+func (i Template) GetUpdateOptions() (o TemplateUpdateOptions) {
+	// o.Label = i.Label
+	// o.Description = copyString(i.Description)
+	return
+}
+
+// TemplatesPagedResponse represents a paginated Template API response
+type TemplatesPagedResponse struct {
+	*PageOptions
+	Data []Template `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Template
+func (TemplatesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Templates.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Templates when processing paginated Template responses
+func (resp *TemplatesPagedResponse) appendData(r *TemplatesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListTemplates lists Templates
+func (c *Client) ListTemplates(ctx context.Context, opts *ListOptions) ([]Template, error) {
+	response := TemplatesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *Template) fixDates() *Template {
+	// i.Created, _ = parseDates(i.CreatedStr)
+	// i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetTemplate gets the template with the provided ID
+func (c *Client) GetTemplate(ctx context.Context, id int) (*Template, error) {
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Template{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Template).fixDates(), nil
+}
+
+// CreateTemplate creates a Template
+func (c *Client) CreateTemplate(ctx context.Context, createOpts TemplateCreateOptions) (*Template, error) {
+	var body string
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Template{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Template).fixDates(), nil
+}
+
+// UpdateTemplate updates the Template with the specified id
+func (c *Client) UpdateTemplate(ctx context.Context, id int, updateOpts TemplateUpdateOptions) (*Template, error) {
+	var body string
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Template{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Template).fixDates(), nil
+}
+
+// DeleteTemplate deletes the Template with the specified id
+func (c *Client) DeleteTemplate(ctx context.Context, id int) error {
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/triv.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/triv.go
new file mode 100644
index 000000000..232d65089
--- /dev/null
+++ b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/triv.go
@@ -0,0 +1,141 @@
+// Copyright 2009 The Go 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 ignore
+
+package main
+
+import (
+	"bytes"
+	"expvar"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"strconv"
+	"sync"
+)
+
+// hello world, the web server
+var helloRequests = expvar.NewInt("hello-requests")
+
+func HelloServer(w http.ResponseWriter, req *http.Request) {
+	helloRequests.Add(1)
+	io.WriteString(w, "hello, world!\n")
+}
+
+// Simple counter server. POSTing to it will set the value.
+type Counter struct {
+	mu sync.Mutex // protects n
+	n  int
+}
+
+// This makes Counter satisfy the expvar.Var interface, so we can export
+// it directly.
+func (ctr *Counter) String() string {
+	ctr.mu.Lock()
+	defer ctr.mu.Unlock()
+	return fmt.Sprintf("%d", ctr.n)
+}
+
+func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	ctr.mu.Lock()
+	defer ctr.mu.Unlock()
+	switch req.Method {
+	case "GET":
+		ctr.n++
+	case "POST":
+		buf := new(bytes.Buffer)
+		io.Copy(buf, req.Body)
+		body := buf.String()
+		if n, err := strconv.Atoi(body); err != nil {
+			fmt.Fprintf(w, "bad POST: %v\nbody: [%v]\n", err, body)
+		} else {
+			ctr.n = n
+			fmt.Fprint(w, "counter reset\n")
+		}
+	}
+	fmt.Fprintf(w, "counter = %d\n", ctr.n)
+}
+
+// simple flag server
+var booleanflag = flag.Bool("boolean", true, "another flag for testing")
+
+func FlagServer(w http.ResponseWriter, req *http.Request) {
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+	fmt.Fprint(w, "Flags:\n")
+	flag.VisitAll(func(f *flag.Flag) {
+		if f.Value.String() != f.DefValue {
+			fmt.Fprintf(w, "%s = %s [default = %s]\n", f.Name, f.Value.String(), f.DefValue)
+		} else {
+			fmt.Fprintf(w, "%s = %s\n", f.Name, f.Value.String())
+		}
+	})
+}
+
+// simple argument server
+func ArgServer(w http.ResponseWriter, req *http.Request) {
+	for _, s := range os.Args {
+		fmt.Fprint(w, s, " ")
+	}
+}
+
+// a channel (just for the fun of it)
+type Chan chan int
+
+func ChanCreate() Chan {
+	c := make(Chan)
+	go func(c Chan) {
+		for x := 0; ; x++ {
+			c <- x
+		}
+	}(c)
+	return c
+}
+
+func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	io.WriteString(w, fmt.Sprintf("channel send #%d\n", <-ch))
+}
+
+// exec a program, redirecting output
+func DateServer(rw http.ResponseWriter, req *http.Request) {
+	rw.Header().Set("Content-Type", "text/plain; charset=utf-8")
+
+	date, err := exec.Command("/bin/date").Output()
+	if err != nil {
+		http.Error(rw, err.Error(), 500)
+		return
+	}
+	rw.Write(date)
+}
+
+func Logger(w http.ResponseWriter, req *http.Request) {
+	log.Print(req.URL)
+	http.Error(w, "oops", 404)
+}
+
+var webroot = flag.String("root", os.Getenv("HOME"), "web root directory")
+
+func main() {
+	flag.Parse()
+
+	// The counter is published as a variable directly.
+	ctr := new(Counter)
+	expvar.Publish("counter", ctr)
+	http.Handle("/counter", ctr)
+	http.Handle("/", http.HandlerFunc(Logger))
+	http.Handle("/go/", http.StripPrefix("/go/", http.FileServer(http.Dir(*webroot))))
+	http.Handle("/chan", ChanCreate())
+	http.HandleFunc("/flags", FlagServer)
+	http.HandleFunc("/args", ArgServer)
+	http.HandleFunc("/go/hello", HelloServer)
+	http.HandleFunc("/date", DateServer)
+	err := http.ListenAndServe(":12345", nil)
+	if err != nil {
+		log.Panicln("ListenAndServe:", err)
+	}
+}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/generate_cert.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/generate_cert.go
new file mode 100644
index 000000000..b417ea464
--- /dev/null
+++ b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/generate_cert.go
@@ -0,0 +1,118 @@
+// Copyright 2009 The Go 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 ignore
+
+// Generate a self-signed X.509 certificate for a TLS server. Outputs to
+// 'cert.pem' and 'key.pem' and will overwrite existing files.
+
+package main
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"flag"
+	"fmt"
+	"log"
+	"math/big"
+	"net"
+	"os"
+	"strings"
+	"time"
+)
+
+var (
+	host      = flag.String("host", "", "Comma-separated hostnames and IPs to generate a certificate for")
+	validFrom = flag.String("start-date", "", "Creation date formatted as Jan 1 15:04:05 2011")
+	validFor  = flag.Duration("duration", 365*24*time.Hour, "Duration that certificate is valid for")
+	isCA      = flag.Bool("ca", false, "whether this cert should be its own Certificate Authority")
+	rsaBits   = flag.Int("rsa-bits", 2048, "Size of RSA key to generate")
+)
+
+func main() {
+	flag.Parse()
+
+	if len(*host) == 0 {
+		log.Fatalf("Missing required --host parameter")
+	}
+
+	priv, err := rsa.GenerateKey(rand.Reader, *rsaBits)
+	if err != nil {
+		log.Fatalf("failed to generate private key: %s", err)
+		return
+	}
+
+	var notBefore time.Time
+	if len(*validFrom) == 0 {
+		notBefore = time.Now()
+	} else {
+		notBefore, err = time.Parse("Jan 2 15:04:05 2006", *validFrom)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to parse creation date: %s\n", err)
+			os.Exit(1)
+		}
+	}
+
+	notAfter := notBefore.Add(*validFor)
+
+	// end of ASN.1 time
+	endOfTime := time.Date(2049, 12, 31, 23, 59, 59, 0, time.UTC)
+	if notAfter.After(endOfTime) {
+		notAfter = endOfTime
+	}
+
+	template := x509.Certificate{
+		SerialNumber: new(big.Int).SetInt64(0),
+		Subject: pkix.Name{
+			Organization: []string{"Acme Co"},
+		},
+		NotBefore: notBefore,
+		NotAfter:  notAfter,
+
+		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+		BasicConstraintsValid: true,
+	}
+
+	hosts := strings.Split(*host, ",")
+	for _, h := range hosts {
+		if ip := net.ParseIP(h); ip != nil {
+			template.IPAddresses = append(template.IPAddresses, ip)
+		} else {
+			template.DNSNames = append(template.DNSNames, h)
+		}
+	}
+
+	if *isCA {
+		template.IsCA = true
+		template.KeyUsage |= x509.KeyUsageCertSign
+	}
+
+	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
+	if err != nil {
+		log.Fatalf("Failed to create certificate: %s", err)
+		return
+	}
+
+	certOut, err := os.Create("cert.pem")
+	if err != nil {
+		log.Fatalf("failed to open cert.pem for writing: %s", err)
+		return
+	}
+	pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
+	certOut.Close()
+	log.Print("written cert.pem\n")
+
+	keyOut, err := os.OpenFile("key.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	if err != nil {
+		log.Print("failed to open key.pem for writing:", err)
+		return
+	}
+	pem.Encode(keyOut, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)})
+	keyOut.Close()
+	log.Print("written key.pem\n")
+}
diff --git a/vendor/github.com/shirou/gopsutil/host/types_darwin.go b/vendor/github.com/shirou/gopsutil/host/types_darwin.go
new file mode 100644
index 000000000..b85822788
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/host/types_darwin.go
@@ -0,0 +1,17 @@
+// +build ignore
+// plus hand editing about timeval
+
+/*
+Input to cgo -godefs.
+*/
+
+package host
+
+/*
+#include <sys/time.h>
+#include <utmpx.h>
+*/
+import "C"
+
+type Utmpx C.struct_utmpx
+type Timeval C.struct_timeval
diff --git a/vendor/github.com/shirou/gopsutil/host/types_freebsd.go b/vendor/github.com/shirou/gopsutil/host/types_freebsd.go
new file mode 100644
index 000000000..e70677f68
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/host/types_freebsd.go
@@ -0,0 +1,44 @@
+// +build ignore
+
+/*
+Input to cgo -godefs.
+*/
+
+package host
+
+/*
+#define KERNEL
+#include <sys/types.h>
+#include <sys/time.h>
+#include <utmpx.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+	sizeOfUtmpx    = C.sizeof_struct_utmpx
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+type Utmp C.struct_utmp
+type Utmpx C.struct_utmpx
+type Timeval C.struct_timeval
diff --git a/vendor/github.com/shirou/gopsutil/host/types_linux.go b/vendor/github.com/shirou/gopsutil/host/types_linux.go
new file mode 100644
index 000000000..8adecb6cf
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/host/types_linux.go
@@ -0,0 +1,42 @@
+// +build ignore
+
+/*
+Input to cgo -godefs.
+*/
+
+package host
+
+/*
+#include <sys/types.h>
+#include <utmp.h>
+
+enum {
+       sizeofPtr = sizeof(void*),
+};
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+	sizeOfUtmp     = C.sizeof_struct_utmp
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+type utmp C.struct_utmp
+type exit_status C.struct_exit_status
+type timeval C.struct_timeval
diff --git a/vendor/github.com/shirou/gopsutil/host/types_openbsd.go b/vendor/github.com/shirou/gopsutil/host/types_openbsd.go
new file mode 100644
index 000000000..9ebb97ce5
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/host/types_openbsd.go
@@ -0,0 +1,43 @@
+// +build ignore
+
+/*
+Input to cgo -godefs.
+*/
+
+package host
+
+/*
+#define KERNEL
+#include <sys/types.h>
+#include <sys/time.h>
+#include <utmp.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+	sizeOfUtmp     = C.sizeof_struct_utmp
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+type Utmp C.struct_utmp
+type Timeval C.struct_timeval
diff --git a/vendor/github.com/shirou/gopsutil/mem/types_openbsd.go b/vendor/github.com/shirou/gopsutil/mem/types_openbsd.go
new file mode 100644
index 000000000..83cb91a19
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/mem/types_openbsd.go
@@ -0,0 +1,34 @@
+// +build ignore
+
+/*
+Input to cgo -godefs.
+*/
+
+package mem
+
+/*
+#include <sys/types.h>
+#include <sys/mount.h>
+#include <sys/sysctl.h>
+#include <uvm/uvmexp.h>
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	CTLVm         = 2
+	CTLVfs        = 10
+	VmUvmexp      = 4 // get uvmexp
+	VfsGeneric    = 0
+	VfsBcacheStat = 3
+)
+
+const (
+	sizeOfUvmexp      = C.sizeof_struct_uvmexp
+	sizeOfBcachestats = C.sizeof_struct_bcachestats
+)
+
+type Uvmexp C.struct_uvmexp
+type Bcachestats C.struct_bcachestats
diff --git a/vendor/github.com/shirou/gopsutil/process/types_darwin.go b/vendor/github.com/shirou/gopsutil/process/types_darwin.go
new file mode 100644
index 000000000..21216cd09
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/process/types_darwin.go
@@ -0,0 +1,160 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Hand Writing
+// - all pointer in ExternProc to uint64
+
+// +build ignore
+
+/*
+Input to cgo -godefs.
+*/
+
+// +godefs map struct_in_addr [4]byte /* in_addr */
+// +godefs map struct_in6_addr [16]byte /* in6_addr */
+// +godefs map struct_ [16]byte /* in6_addr */
+
+package process
+
+/*
+#define __DARWIN_UNIX03 0
+#define KERNEL
+#define _DARWIN_USE_64_BIT_INODE
+#include <dirent.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <termios.h>
+#include <unistd.h>
+#include <mach/mach.h>
+#include <mach/message.h>
+#include <sys/event.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/select.h>
+#include <sys/signal.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <net/bpf.h>
+#include <net/if_dl.h>
+#include <net/if_var.h>
+#include <net/route.h>
+#include <netinet/in.h>
+
+#include <sys/sysctl.h>
+#include <sys/ucred.h>
+#include <sys/proc.h>
+#include <sys/time.h>
+#include <sys/_types/_timeval.h>
+#include <sys/appleapiopts.h>
+#include <sys/cdefs.h>
+#include <sys/param.h>
+#include <bsm/audit.h>
+#include <sys/queue.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+union sockaddr_all {
+	struct sockaddr s1;	// this one gets used for fields
+	struct sockaddr_in s2;	// these pad it out
+	struct sockaddr_in6 s3;
+	struct sockaddr_un s4;
+	struct sockaddr_dl s5;
+};
+
+struct sockaddr_any {
+	struct sockaddr addr;
+	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
+};
+
+struct ucred_queue {
+        struct ucred *tqe_next;
+        struct ucred **tqe_prev;
+        TRACEBUF
+};
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type UGid_t C.gid_t
+
+type KinfoProc C.struct_kinfo_proc
+
+type Eproc C.struct_eproc
+
+type Proc C.struct_proc
+
+type Session C.struct_session
+
+type ucred C.struct_ucred
+
+type Uucred C.struct__ucred
+
+type Upcred C.struct__pcred
+
+type Vmspace C.struct_vmspace
+
+type Sigacts C.struct_sigacts
+
+type ExternProc C.struct_extern_proc
+
+type Itimerval C.struct_itimerval
+
+type Vnode C.struct_vnode
+
+type Pgrp C.struct_pgrp
+
+type UserStruct C.struct_user
+
+type Au_session C.struct_au_session
+
+type Posix_cred C.struct_posix_cred
+
+type Label C.struct_label
+
+type AuditinfoAddr C.struct_auditinfo_addr
+type AuMask C.struct_au_mask
+type AuTidAddr C.struct_au_tid_addr
+
+// TAILQ(ucred)
+type UcredQueue C.struct_ucred_queue
diff --git a/vendor/github.com/shirou/gopsutil/process/types_freebsd.go b/vendor/github.com/shirou/gopsutil/process/types_freebsd.go
new file mode 100644
index 000000000..aa7b3462d
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/process/types_freebsd.go
@@ -0,0 +1,95 @@
+// +build ignore
+
+// We still need editing by hands.
+// go tool cgo -godefs types_freebsd.go | sed 's/\*int64/int64/' | sed 's/\*byte/int64/'  > process_freebsd_amd64.go
+
+/*
+Input to cgo -godefs.
+*/
+
+// +godefs map struct_pargs int64 /* pargs */
+// +godefs map struct_proc int64 /* proc */
+// +godefs map struct_user int64 /* user */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_filedesc int64 /* filedesc */
+// +godefs map struct_vmspace int64 /* vmspace */
+// +godefs map struct_pcb int64 /* pcb */
+// +godefs map struct_thread int64 /* thread */
+// +godefs map struct___sigset [16]byte /* sigset */
+
+package process
+
+/*
+#include <sys/types.h>
+#include <sys/user.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	CTLKern          = 1  // "high kernel": proc, limits
+	KernProc         = 14 // struct: process entries
+	KernProcPID      = 1  // by process id
+	KernProcProc     = 8  // only return procs
+	KernProcPathname = 12 // path to executable
+	KernProcArgs     = 7  // get/set arguments/proctitle
+)
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+)
+
+const (
+	sizeOfKinfoVmentry = C.sizeof_struct_kinfo_vmentry
+	sizeOfKinfoProc    = C.sizeof_struct_kinfo_proc
+)
+
+// from sys/proc.h
+const (
+	SIDL   = 1 /* Process being created by fork. */
+	SRUN   = 2 /* Currently runnable. */
+	SSLEEP = 3 /* Sleeping on an address. */
+	SSTOP  = 4 /* Process debugging or suspension. */
+	SZOMB  = 5 /* Awaiting collection by parent. */
+	SWAIT  = 6 /* Waiting for interrupt. */
+	SLOCK  = 7 /* Blocked on a lock. */
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type KinfoProc C.struct_kinfo_proc
+
+type Priority C.struct_priority
+
+type KinfoVmentry C.struct_kinfo_vmentry
diff --git a/vendor/github.com/shirou/gopsutil/process/types_openbsd.go b/vendor/github.com/shirou/gopsutil/process/types_openbsd.go
new file mode 100644
index 000000000..09ac59028
--- /dev/null
+++ b/vendor/github.com/shirou/gopsutil/process/types_openbsd.go
@@ -0,0 +1,103 @@
+// +build ignore
+
+// We still need editing by hands.
+// go tool cgo -godefs types_openbsd.go | sed 's/\*int64/int64/' | sed 's/\*byte/int64/'  > process_openbsd_amd64.go
+
+/*
+Input to cgo -godefs.
+*/
+
+// +godefs map struct_pargs int64 /* pargs */
+// +godefs map struct_proc int64 /* proc */
+// +godefs map struct_user int64 /* user */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_filedesc int64 /* filedesc */
+// +godefs map struct_vmspace int64 /* vmspace */
+// +godefs map struct_pcb int64 /* pcb */
+// +godefs map struct_thread int64 /* thread */
+// +godefs map struct___sigset [16]byte /* sigset */
+
+package process
+
+/*
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	CTLKern          = 1  // "high kernel": proc, limits
+	KernProc         = 66 // struct: process entries
+	KernProcAll      = 0
+	KernProcPID      = 1  // by process id
+	KernProcProc     = 8  // only return procs
+	KernProcPathname = 12 // path to executable
+	KernProcArgs     = 55 // get/set arguments/proctitle
+	KernProcArgv     = 1
+	KernProcEnv      = 3
+)
+
+const (
+	ArgMax = 256 * 1024 // sys/syslimits.h:#define  ARG_MAX
+)
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+)
+
+const (
+	sizeOfKinfoVmentry = C.sizeof_struct_kinfo_vmentry
+	sizeOfKinfoProc    = C.sizeof_struct_kinfo_proc
+)
+
+// from sys/proc.h
+const (
+	SIDL    = 1 /* Process being created by fork. */
+	SRUN    = 2 /* Currently runnable. */
+	SSLEEP  = 3 /* Sleeping on an address. */
+	SSTOP   = 4 /* Process debugging or suspension. */
+	SZOMB   = 5 /* Awaiting collection by parent. */
+	SDEAD   = 6 /* Thread is almost gone */
+	SONPROC = 7 /* Thread is currently on a CPU. */
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type KinfoProc C.struct_kinfo_proc
+
+type Priority C.struct_priority
+
+type KinfoVmentry C.struct_kinfo_vmentry
diff --git a/vendor/github.com/ulikunitz/xz/example.go b/vendor/github.com/ulikunitz/xz/example.go
new file mode 100644
index 000000000..855e60aee
--- /dev/null
+++ b/vendor/github.com/ulikunitz/xz/example.go
@@ -0,0 +1,40 @@
+// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+	"bytes"
+	"io"
+	"log"
+	"os"
+
+	"github.com/ulikunitz/xz"
+)
+
+func main() {
+	const text = "The quick brown fox jumps over the lazy dog.\n"
+	var buf bytes.Buffer
+	// compress text
+	w, err := xz.NewWriter(&buf)
+	if err != nil {
+		log.Fatalf("xz.NewWriter error %s", err)
+	}
+	if _, err := io.WriteString(w, text); err != nil {
+		log.Fatalf("WriteString error %s", err)
+	}
+	if err := w.Close(); err != nil {
+		log.Fatalf("w.Close error %s", err)
+	}
+	// decompress buffer and write output to stdout
+	r, err := xz.NewReader(&buf)
+	if err != nil {
+		log.Fatalf("NewReader error %s", err)
+	}
+	if _, err = io.Copy(os.Stdout, r); err != nil {
+		log.Fatalf("io.Copy error %s", err)
+	}
+}
diff --git a/vendor/golang.org/x/net/html/atom/gen.go b/vendor/golang.org/x/net/html/atom/gen.go
new file mode 100644
index 000000000..5d052781b
--- /dev/null
+++ b/vendor/golang.org/x/net/html/atom/gen.go
@@ -0,0 +1,712 @@
+// Copyright 2012 The Go 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 ignore
+
+//go:generate go run gen.go
+//go:generate go run gen.go -test
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"sort"
+	"strings"
+)
+
+// identifier converts s to a Go exported identifier.
+// It converts "div" to "Div" and "accept-charset" to "AcceptCharset".
+func identifier(s string) string {
+	b := make([]byte, 0, len(s))
+	cap := true
+	for _, c := range s {
+		if c == '-' {
+			cap = true
+			continue
+		}
+		if cap && 'a' <= c && c <= 'z' {
+			c -= 'a' - 'A'
+		}
+		cap = false
+		b = append(b, byte(c))
+	}
+	return string(b)
+}
+
+var test = flag.Bool("test", false, "generate table_test.go")
+
+func genFile(name string, buf *bytes.Buffer) {
+	b, err := format.Source(buf.Bytes())
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	if err := ioutil.WriteFile(name, b, 0644); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func main() {
+	flag.Parse()
+
+	var all []string
+	all = append(all, elements...)
+	all = append(all, attributes...)
+	all = append(all, eventHandlers...)
+	all = append(all, extra...)
+	sort.Strings(all)
+
+	// uniq - lists have dups
+	w := 0
+	for _, s := range all {
+		if w == 0 || all[w-1] != s {
+			all[w] = s
+			w++
+		}
+	}
+	all = all[:w]
+
+	if *test {
+		var buf bytes.Buffer
+		fmt.Fprintln(&buf, "// Code generated by go generate gen.go; DO NOT EDIT.\n")
+		fmt.Fprintln(&buf, "//go:generate go run gen.go -test\n")
+		fmt.Fprintln(&buf, "package atom\n")
+		fmt.Fprintln(&buf, "var testAtomList = []string{")
+		for _, s := range all {
+			fmt.Fprintf(&buf, "\t%q,\n", s)
+		}
+		fmt.Fprintln(&buf, "}")
+
+		genFile("table_test.go", &buf)
+		return
+	}
+
+	// Find hash that minimizes table size.
+	var best *table
+	for i := 0; i < 1000000; i++ {
+		if best != nil && 1<<(best.k-1) < len(all) {
+			break
+		}
+		h := rand.Uint32()
+		for k := uint(0); k <= 16; k++ {
+			if best != nil && k >= best.k {
+				break
+			}
+			var t table
+			if t.init(h, k, all) {
+				best = &t
+				break
+			}
+		}
+	}
+	if best == nil {
+		fmt.Fprintf(os.Stderr, "failed to construct string table\n")
+		os.Exit(1)
+	}
+
+	// Lay out strings, using overlaps when possible.
+	layout := append([]string{}, all...)
+
+	// Remove strings that are substrings of other strings
+	for changed := true; changed; {
+		changed = false
+		for i, s := range layout {
+			if s == "" {
+				continue
+			}
+			for j, t := range layout {
+				if i != j && t != "" && strings.Contains(s, t) {
+					changed = true
+					layout[j] = ""
+				}
+			}
+		}
+	}
+
+	// Join strings where one suffix matches another prefix.
+	for {
+		// Find best i, j, k such that layout[i][len-k:] == layout[j][:k],
+		// maximizing overlap length k.
+		besti := -1
+		bestj := -1
+		bestk := 0
+		for i, s := range layout {
+			if s == "" {
+				continue
+			}
+			for j, t := range layout {
+				if i == j {
+					continue
+				}
+				for k := bestk + 1; k <= len(s) && k <= len(t); k++ {
+					if s[len(s)-k:] == t[:k] {
+						besti = i
+						bestj = j
+						bestk = k
+					}
+				}
+			}
+		}
+		if bestk > 0 {
+			layout[besti] += layout[bestj][bestk:]
+			layout[bestj] = ""
+			continue
+		}
+		break
+	}
+
+	text := strings.Join(layout, "")
+
+	atom := map[string]uint32{}
+	for _, s := range all {
+		off := strings.Index(text, s)
+		if off < 0 {
+			panic("lost string " + s)
+		}
+		atom[s] = uint32(off<<8 | len(s))
+	}
+
+	var buf bytes.Buffer
+	// Generate the Go code.
+	fmt.Fprintln(&buf, "// Code generated by go generate gen.go; DO NOT EDIT.\n")
+	fmt.Fprintln(&buf, "//go:generate go run gen.go\n")
+	fmt.Fprintln(&buf, "package atom\n\nconst (")
+
+	// compute max len
+	maxLen := 0
+	for _, s := range all {
+		if maxLen < len(s) {
+			maxLen = len(s)
+		}
+		fmt.Fprintf(&buf, "\t%s Atom = %#x\n", identifier(s), atom[s])
+	}
+	fmt.Fprintln(&buf, ")\n")
+
+	fmt.Fprintf(&buf, "const hash0 = %#x\n\n", best.h0)
+	fmt.Fprintf(&buf, "const maxAtomLen = %d\n\n", maxLen)
+
+	fmt.Fprintf(&buf, "var table = [1<<%d]Atom{\n", best.k)
+	for i, s := range best.tab {
+		if s == "" {
+			continue
+		}
+		fmt.Fprintf(&buf, "\t%#x: %#x, // %s\n", i, atom[s], s)
+	}
+	fmt.Fprintf(&buf, "}\n")
+	datasize := (1 << best.k) * 4
+
+	fmt.Fprintln(&buf, "const atomText =")
+	textsize := len(text)
+	for len(text) > 60 {
+		fmt.Fprintf(&buf, "\t%q +\n", text[:60])
+		text = text[60:]
+	}
+	fmt.Fprintf(&buf, "\t%q\n\n", text)
+
+	genFile("table.go", &buf)
+
+	fmt.Fprintf(os.Stdout, "%d atoms; %d string bytes + %d tables = %d total data\n", len(all), textsize, datasize, textsize+datasize)
+}
+
+type byLen []string
+
+func (x byLen) Less(i, j int) bool { return len(x[i]) > len(x[j]) }
+func (x byLen) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x byLen) Len() int           { return len(x) }
+
+// fnv computes the FNV hash with an arbitrary starting value h.
+func fnv(h uint32, s string) uint32 {
+	for i := 0; i < len(s); i++ {
+		h ^= uint32(s[i])
+		h *= 16777619
+	}
+	return h
+}
+
+// A table represents an attempt at constructing the lookup table.
+// The lookup table uses cuckoo hashing, meaning that each string
+// can be found in one of two positions.
+type table struct {
+	h0   uint32
+	k    uint
+	mask uint32
+	tab  []string
+}
+
+// hash returns the two hashes for s.
+func (t *table) hash(s string) (h1, h2 uint32) {
+	h := fnv(t.h0, s)
+	h1 = h & t.mask
+	h2 = (h >> 16) & t.mask
+	return
+}
+
+// init initializes the table with the given parameters.
+// h0 is the initial hash value,
+// k is the number of bits of hash value to use, and
+// x is the list of strings to store in the table.
+// init returns false if the table cannot be constructed.
+func (t *table) init(h0 uint32, k uint, x []string) bool {
+	t.h0 = h0
+	t.k = k
+	t.tab = make([]string, 1<<k)
+	t.mask = 1<<k - 1
+	for _, s := range x {
+		if !t.insert(s) {
+			return false
+		}
+	}
+	return true
+}
+
+// insert inserts s in the table.
+func (t *table) insert(s string) bool {
+	h1, h2 := t.hash(s)
+	if t.tab[h1] == "" {
+		t.tab[h1] = s
+		return true
+	}
+	if t.tab[h2] == "" {
+		t.tab[h2] = s
+		return true
+	}
+	if t.push(h1, 0) {
+		t.tab[h1] = s
+		return true
+	}
+	if t.push(h2, 0) {
+		t.tab[h2] = s
+		return true
+	}
+	return false
+}
+
+// push attempts to push aside the entry in slot i.
+func (t *table) push(i uint32, depth int) bool {
+	if depth > len(t.tab) {
+		return false
+	}
+	s := t.tab[i]
+	h1, h2 := t.hash(s)
+	j := h1 + h2 - i
+	if t.tab[j] != "" && !t.push(j, depth+1) {
+		return false
+	}
+	t.tab[j] = s
+	return true
+}
+
+// The lists of element names and attribute keys were taken from
+// https://html.spec.whatwg.org/multipage/indices.html#index
+// as of the "HTML Living Standard - Last Updated 16 April 2018" version.
+
+// "command", "keygen" and "menuitem" have been removed from the spec,
+// but are kept here for backwards compatibility.
+var elements = []string{
+	"a",
+	"abbr",
+	"address",
+	"area",
+	"article",
+	"aside",
+	"audio",
+	"b",
+	"base",
+	"bdi",
+	"bdo",
+	"blockquote",
+	"body",
+	"br",
+	"button",
+	"canvas",
+	"caption",
+	"cite",
+	"code",
+	"col",
+	"colgroup",
+	"command",
+	"data",
+	"datalist",
+	"dd",
+	"del",
+	"details",
+	"dfn",
+	"dialog",
+	"div",
+	"dl",
+	"dt",
+	"em",
+	"embed",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"head",
+	"header",
+	"hgroup",
+	"hr",
+	"html",
+	"i",
+	"iframe",
+	"img",
+	"input",
+	"ins",
+	"kbd",
+	"keygen",
+	"label",
+	"legend",
+	"li",
+	"link",
+	"main",
+	"map",
+	"mark",
+	"menu",
+	"menuitem",
+	"meta",
+	"meter",
+	"nav",
+	"noscript",
+	"object",
+	"ol",
+	"optgroup",
+	"option",
+	"output",
+	"p",
+	"param",
+	"picture",
+	"pre",
+	"progress",
+	"q",
+	"rp",
+	"rt",
+	"ruby",
+	"s",
+	"samp",
+	"script",
+	"section",
+	"select",
+	"slot",
+	"small",
+	"source",
+	"span",
+	"strong",
+	"style",
+	"sub",
+	"summary",
+	"sup",
+	"table",
+	"tbody",
+	"td",
+	"template",
+	"textarea",
+	"tfoot",
+	"th",
+	"thead",
+	"time",
+	"title",
+	"tr",
+	"track",
+	"u",
+	"ul",
+	"var",
+	"video",
+	"wbr",
+}
+
+// https://html.spec.whatwg.org/multipage/indices.html#attributes-3
+//
+// "challenge", "command", "contextmenu", "dropzone", "icon", "keytype", "mediagroup",
+// "radiogroup", "spellcheck", "scoped", "seamless", "sortable" and "sorted" have been removed from the spec,
+// but are kept here for backwards compatibility.
+var attributes = []string{
+	"abbr",
+	"accept",
+	"accept-charset",
+	"accesskey",
+	"action",
+	"allowfullscreen",
+	"allowpaymentrequest",
+	"allowusermedia",
+	"alt",
+	"as",
+	"async",
+	"autocomplete",
+	"autofocus",
+	"autoplay",
+	"challenge",
+	"charset",
+	"checked",
+	"cite",
+	"class",
+	"color",
+	"cols",
+	"colspan",
+	"command",
+	"content",
+	"contenteditable",
+	"contextmenu",
+	"controls",
+	"coords",
+	"crossorigin",
+	"data",
+	"datetime",
+	"default",
+	"defer",
+	"dir",
+	"dirname",
+	"disabled",
+	"download",
+	"draggable",
+	"dropzone",
+	"enctype",
+	"for",
+	"form",
+	"formaction",
+	"formenctype",
+	"formmethod",
+	"formnovalidate",
+	"formtarget",
+	"headers",
+	"height",
+	"hidden",
+	"high",
+	"href",
+	"hreflang",
+	"http-equiv",
+	"icon",
+	"id",
+	"inputmode",
+	"integrity",
+	"is",
+	"ismap",
+	"itemid",
+	"itemprop",
+	"itemref",
+	"itemscope",
+	"itemtype",
+	"keytype",
+	"kind",
+	"label",
+	"lang",
+	"list",
+	"loop",
+	"low",
+	"manifest",
+	"max",
+	"maxlength",
+	"media",
+	"mediagroup",
+	"method",
+	"min",
+	"minlength",
+	"multiple",
+	"muted",
+	"name",
+	"nomodule",
+	"nonce",
+	"novalidate",
+	"open",
+	"optimum",
+	"pattern",
+	"ping",
+	"placeholder",
+	"playsinline",
+	"poster",
+	"preload",
+	"radiogroup",
+	"readonly",
+	"referrerpolicy",
+	"rel",
+	"required",
+	"reversed",
+	"rows",
+	"rowspan",
+	"sandbox",
+	"spellcheck",
+	"scope",
+	"scoped",
+	"seamless",
+	"selected",
+	"shape",
+	"size",
+	"sizes",
+	"sortable",
+	"sorted",
+	"slot",
+	"span",
+	"spellcheck",
+	"src",
+	"srcdoc",
+	"srclang",
+	"srcset",
+	"start",
+	"step",
+	"style",
+	"tabindex",
+	"target",
+	"title",
+	"translate",
+	"type",
+	"typemustmatch",
+	"updateviacache",
+	"usemap",
+	"value",
+	"width",
+	"workertype",
+	"wrap",
+}
+
+// "onautocomplete", "onautocompleteerror", "onmousewheel",
+// "onshow" and "onsort" have been removed from the spec,
+// but are kept here for backwards compatibility.
+var eventHandlers = []string{
+	"onabort",
+	"onautocomplete",
+	"onautocompleteerror",
+	"onauxclick",
+	"onafterprint",
+	"onbeforeprint",
+	"onbeforeunload",
+	"onblur",
+	"oncancel",
+	"oncanplay",
+	"oncanplaythrough",
+	"onchange",
+	"onclick",
+	"onclose",
+	"oncontextmenu",
+	"oncopy",
+	"oncuechange",
+	"oncut",
+	"ondblclick",
+	"ondrag",
+	"ondragend",
+	"ondragenter",
+	"ondragexit",
+	"ondragleave",
+	"ondragover",
+	"ondragstart",
+	"ondrop",
+	"ondurationchange",
+	"onemptied",
+	"onended",
+	"onerror",
+	"onfocus",
+	"onhashchange",
+	"oninput",
+	"oninvalid",
+	"onkeydown",
+	"onkeypress",
+	"onkeyup",
+	"onlanguagechange",
+	"onload",
+	"onloadeddata",
+	"onloadedmetadata",
+	"onloadend",
+	"onloadstart",
+	"onmessage",
+	"onmessageerror",
+	"onmousedown",
+	"onmouseenter",
+	"onmouseleave",
+	"onmousemove",
+	"onmouseout",
+	"onmouseover",
+	"onmouseup",
+	"onmousewheel",
+	"onwheel",
+	"onoffline",
+	"ononline",
+	"onpagehide",
+	"onpageshow",
+	"onpaste",
+	"onpause",
+	"onplay",
+	"onplaying",
+	"onpopstate",
+	"onprogress",
+	"onratechange",
+	"onreset",
+	"onresize",
+	"onrejectionhandled",
+	"onscroll",
+	"onsecuritypolicyviolation",
+	"onseeked",
+	"onseeking",
+	"onselect",
+	"onshow",
+	"onsort",
+	"onstalled",
+	"onstorage",
+	"onsubmit",
+	"onsuspend",
+	"ontimeupdate",
+	"ontoggle",
+	"onunhandledrejection",
+	"onunload",
+	"onvolumechange",
+	"onwaiting",
+}
+
+// extra are ad-hoc values not covered by any of the lists above.
+var extra = []string{
+	"acronym",
+	"align",
+	"annotation",
+	"annotation-xml",
+	"applet",
+	"basefont",
+	"bgsound",
+	"big",
+	"blink",
+	"center",
+	"color",
+	"desc",
+	"face",
+	"font",
+	"foreignObject", // HTML is case-insensitive, but SVG-embedded-in-HTML is case-sensitive.
+	"foreignobject",
+	"frame",
+	"frameset",
+	"image",
+	"isindex",
+	"listing",
+	"malignmark",
+	"marquee",
+	"math",
+	"mglyph",
+	"mi",
+	"mn",
+	"mo",
+	"ms",
+	"mtext",
+	"nobr",
+	"noembed",
+	"noframes",
+	"plaintext",
+	"prompt",
+	"public",
+	"rb",
+	"rtc",
+	"spacer",
+	"strike",
+	"svg",
+	"system",
+	"tt",
+	"xmp",
+}
diff --git a/vendor/golang.org/x/net/publicsuffix/gen.go b/vendor/golang.org/x/net/publicsuffix/gen.go
new file mode 100644
index 000000000..372ffbb24
--- /dev/null
+++ b/vendor/golang.org/x/net/publicsuffix/gen.go
@@ -0,0 +1,717 @@
+// Copyright 2012 The Go 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 ignore
+
+package main
+
+// This program generates table.go and table_test.go based on the authoritative
+// public suffix list at https://publicsuffix.org/list/effective_tld_names.dat
+//
+// The version is derived from
+// https://api.github.com/repos/publicsuffix/list/commits?path=public_suffix_list.dat
+// and a human-readable form is at
+// https://github.com/publicsuffix/list/commits/master/public_suffix_list.dat
+//
+// To fetch a particular git revision, such as 5c70ccd250, pass
+// -url "https://raw.githubusercontent.com/publicsuffix/list/5c70ccd250/public_suffix_list.dat"
+// and -version "an explicit version string".
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"regexp"
+	"sort"
+	"strings"
+
+	"golang.org/x/net/idna"
+)
+
+const (
+	// These sum of these four values must be no greater than 32.
+	nodesBitsChildren   = 10
+	nodesBitsICANN      = 1
+	nodesBitsTextOffset = 15
+	nodesBitsTextLength = 6
+
+	// These sum of these four values must be no greater than 32.
+	childrenBitsWildcard = 1
+	childrenBitsNodeType = 2
+	childrenBitsHi       = 14
+	childrenBitsLo       = 14
+)
+
+var (
+	maxChildren   int
+	maxTextOffset int
+	maxTextLength int
+	maxHi         uint32
+	maxLo         uint32
+)
+
+func max(a, b int) int {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+func u32max(a, b uint32) uint32 {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+const (
+	nodeTypeNormal     = 0
+	nodeTypeException  = 1
+	nodeTypeParentOnly = 2
+	numNodeType        = 3
+)
+
+func nodeTypeStr(n int) string {
+	switch n {
+	case nodeTypeNormal:
+		return "+"
+	case nodeTypeException:
+		return "!"
+	case nodeTypeParentOnly:
+		return "o"
+	}
+	panic("unreachable")
+}
+
+const (
+	defaultURL   = "https://publicsuffix.org/list/effective_tld_names.dat"
+	gitCommitURL = "https://api.github.com/repos/publicsuffix/list/commits?path=public_suffix_list.dat"
+)
+
+var (
+	labelEncoding = map[string]uint32{}
+	labelsList    = []string{}
+	labelsMap     = map[string]bool{}
+	rules         = []string{}
+	numICANNRules = 0
+
+	// validSuffixRE is used to check that the entries in the public suffix
+	// list are in canonical form (after Punycode encoding). Specifically,
+	// capital letters are not allowed.
+	validSuffixRE = regexp.MustCompile(`^[a-z0-9_\!\*\-\.]+$`)
+
+	shaRE  = regexp.MustCompile(`"sha":"([^"]+)"`)
+	dateRE = regexp.MustCompile(`"committer":{[^{]+"date":"([^"]+)"`)
+
+	comments = flag.Bool("comments", false, "generate table.go comments, for debugging")
+	subset   = flag.Bool("subset", false, "generate only a subset of the full table, for debugging")
+	url      = flag.String("url", defaultURL, "URL of the publicsuffix.org list. If empty, stdin is read instead")
+	v        = flag.Bool("v", false, "verbose output (to stderr)")
+	version  = flag.String("version", "", "the effective_tld_names.dat version")
+)
+
+func main() {
+	if err := main1(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func main1() error {
+	flag.Parse()
+	if nodesBitsTextLength+nodesBitsTextOffset+nodesBitsICANN+nodesBitsChildren > 32 {
+		return fmt.Errorf("not enough bits to encode the nodes table")
+	}
+	if childrenBitsLo+childrenBitsHi+childrenBitsNodeType+childrenBitsWildcard > 32 {
+		return fmt.Errorf("not enough bits to encode the children table")
+	}
+	if *version == "" {
+		if *url != defaultURL {
+			return fmt.Errorf("-version was not specified, and the -url is not the default one")
+		}
+		sha, date, err := gitCommit()
+		if err != nil {
+			return err
+		}
+		*version = fmt.Sprintf("publicsuffix.org's public_suffix_list.dat, git revision %s (%s)", sha, date)
+	}
+	var r io.Reader = os.Stdin
+	if *url != "" {
+		res, err := http.Get(*url)
+		if err != nil {
+			return err
+		}
+		if res.StatusCode != http.StatusOK {
+			return fmt.Errorf("bad GET status for %s: %d", *url, res.Status)
+		}
+		r = res.Body
+		defer res.Body.Close()
+	}
+
+	var root node
+	icann := false
+	br := bufio.NewReader(r)
+	for {
+		s, err := br.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		s = strings.TrimSpace(s)
+		if strings.Contains(s, "BEGIN ICANN DOMAINS") {
+			if len(rules) != 0 {
+				return fmt.Errorf(`expected no rules before "BEGIN ICANN DOMAINS"`)
+			}
+			icann = true
+			continue
+		}
+		if strings.Contains(s, "END ICANN DOMAINS") {
+			icann, numICANNRules = false, len(rules)
+			continue
+		}
+		if s == "" || strings.HasPrefix(s, "//") {
+			continue
+		}
+		s, err = idna.ToASCII(s)
+		if err != nil {
+			return err
+		}
+		if !validSuffixRE.MatchString(s) {
+			return fmt.Errorf("bad publicsuffix.org list data: %q", s)
+		}
+
+		if *subset {
+			switch {
+			case s == "ac.jp" || strings.HasSuffix(s, ".ac.jp"):
+			case s == "ak.us" || strings.HasSuffix(s, ".ak.us"):
+			case s == "ao" || strings.HasSuffix(s, ".ao"):
+			case s == "ar" || strings.HasSuffix(s, ".ar"):
+			case s == "arpa" || strings.HasSuffix(s, ".arpa"):
+			case s == "cy" || strings.HasSuffix(s, ".cy"):
+			case s == "dyndns.org" || strings.HasSuffix(s, ".dyndns.org"):
+			case s == "jp":
+			case s == "kobe.jp" || strings.HasSuffix(s, ".kobe.jp"):
+			case s == "kyoto.jp" || strings.HasSuffix(s, ".kyoto.jp"):
+			case s == "om" || strings.HasSuffix(s, ".om"):
+			case s == "uk" || strings.HasSuffix(s, ".uk"):
+			case s == "uk.com" || strings.HasSuffix(s, ".uk.com"):
+			case s == "tw" || strings.HasSuffix(s, ".tw"):
+			case s == "zw" || strings.HasSuffix(s, ".zw"):
+			case s == "xn--p1ai" || strings.HasSuffix(s, ".xn--p1ai"):
+				// xn--p1ai is Russian-Cyrillic "рф".
+			default:
+				continue
+			}
+		}
+
+		rules = append(rules, s)
+
+		nt, wildcard := nodeTypeNormal, false
+		switch {
+		case strings.HasPrefix(s, "*."):
+			s, nt = s[2:], nodeTypeParentOnly
+			wildcard = true
+		case strings.HasPrefix(s, "!"):
+			s, nt = s[1:], nodeTypeException
+		}
+		labels := strings.Split(s, ".")
+		for n, i := &root, len(labels)-1; i >= 0; i-- {
+			label := labels[i]
+			n = n.child(label)
+			if i == 0 {
+				if nt != nodeTypeParentOnly && n.nodeType == nodeTypeParentOnly {
+					n.nodeType = nt
+				}
+				n.icann = n.icann && icann
+				n.wildcard = n.wildcard || wildcard
+			}
+			labelsMap[label] = true
+		}
+	}
+	labelsList = make([]string, 0, len(labelsMap))
+	for label := range labelsMap {
+		labelsList = append(labelsList, label)
+	}
+	sort.Strings(labelsList)
+
+	if err := generate(printReal, &root, "table.go"); err != nil {
+		return err
+	}
+	if err := generate(printTest, &root, "table_test.go"); err != nil {
+		return err
+	}
+	return nil
+}
+
+func generate(p func(io.Writer, *node) error, root *node, filename string) error {
+	buf := new(bytes.Buffer)
+	if err := p(buf, root); err != nil {
+		return err
+	}
+	b, err := format.Source(buf.Bytes())
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(filename, b, 0644)
+}
+
+func gitCommit() (sha, date string, retErr error) {
+	res, err := http.Get(gitCommitURL)
+	if err != nil {
+		return "", "", err
+	}
+	if res.StatusCode != http.StatusOK {
+		return "", "", fmt.Errorf("bad GET status for %s: %d", gitCommitURL, res.Status)
+	}
+	defer res.Body.Close()
+	b, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", "", err
+	}
+	if m := shaRE.FindSubmatch(b); m != nil {
+		sha = string(m[1])
+	}
+	if m := dateRE.FindSubmatch(b); m != nil {
+		date = string(m[1])
+	}
+	if sha == "" || date == "" {
+		retErr = fmt.Errorf("could not find commit SHA and date in %s", gitCommitURL)
+	}
+	return sha, date, retErr
+}
+
+func printTest(w io.Writer, n *node) error {
+	fmt.Fprintf(w, "// generated by go run gen.go; DO NOT EDIT\n\n")
+	fmt.Fprintf(w, "package publicsuffix\n\nconst numICANNRules = %d\n\nvar rules = [...]string{\n", numICANNRules)
+	for _, rule := range rules {
+		fmt.Fprintf(w, "%q,\n", rule)
+	}
+	fmt.Fprintf(w, "}\n\nvar nodeLabels = [...]string{\n")
+	if err := n.walk(w, printNodeLabel); err != nil {
+		return err
+	}
+	fmt.Fprintf(w, "}\n")
+	return nil
+}
+
+func printReal(w io.Writer, n *node) error {
+	const header = `// generated by go run gen.go; DO NOT EDIT
+
+package publicsuffix
+
+const version = %q
+
+const (
+	nodesBitsChildren   = %d
+	nodesBitsICANN      = %d
+	nodesBitsTextOffset = %d
+	nodesBitsTextLength = %d
+
+	childrenBitsWildcard = %d
+	childrenBitsNodeType = %d
+	childrenBitsHi       = %d
+	childrenBitsLo       = %d
+)
+
+const (
+	nodeTypeNormal     = %d
+	nodeTypeException  = %d
+	nodeTypeParentOnly = %d
+)
+
+// numTLD is the number of top level domains.
+const numTLD = %d
+
+`
+	fmt.Fprintf(w, header, *version,
+		nodesBitsChildren, nodesBitsICANN, nodesBitsTextOffset, nodesBitsTextLength,
+		childrenBitsWildcard, childrenBitsNodeType, childrenBitsHi, childrenBitsLo,
+		nodeTypeNormal, nodeTypeException, nodeTypeParentOnly, len(n.children))
+
+	text := combineText(labelsList)
+	if text == "" {
+		return fmt.Errorf("internal error: makeText returned no text")
+	}
+	for _, label := range labelsList {
+		offset, length := strings.Index(text, label), len(label)
+		if offset < 0 {
+			return fmt.Errorf("internal error: could not find %q in text %q", label, text)
+		}
+		maxTextOffset, maxTextLength = max(maxTextOffset, offset), max(maxTextLength, length)
+		if offset >= 1<<nodesBitsTextOffset {
+			return fmt.Errorf("text offset %d is too large, or nodeBitsTextOffset is too small", offset)
+		}
+		if length >= 1<<nodesBitsTextLength {
+			return fmt.Errorf("text length %d is too large, or nodeBitsTextLength is too small", length)
+		}
+		labelEncoding[label] = uint32(offset)<<nodesBitsTextLength | uint32(length)
+	}
+	fmt.Fprintf(w, "// Text is the combined text of all labels.\nconst text = ")
+	for len(text) > 0 {
+		n, plus := len(text), ""
+		if n > 64 {
+			n, plus = 64, " +"
+		}
+		fmt.Fprintf(w, "%q%s\n", text[:n], plus)
+		text = text[n:]
+	}
+
+	if err := n.walk(w, assignIndexes); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(w, `
+
+// nodes is the list of nodes. Each node is represented as a uint32, which
+// encodes the node's children, wildcard bit and node type (as an index into
+// the children array), ICANN bit and text.
+//
+// If the table was generated with the -comments flag, there is a //-comment
+// after each node's data. In it is the nodes-array indexes of the children,
+// formatted as (n0x1234-n0x1256), with * denoting the wildcard bit. The
+// nodeType is printed as + for normal, ! for exception, and o for parent-only
+// nodes that have children but don't match a domain label in their own right.
+// An I denotes an ICANN domain.
+//
+// The layout within the uint32, from MSB to LSB, is:
+//	[%2d bits] unused
+//	[%2d bits] children index
+//	[%2d bits] ICANN bit
+//	[%2d bits] text index
+//	[%2d bits] text length
+var nodes = [...]uint32{
+`,
+		32-nodesBitsChildren-nodesBitsICANN-nodesBitsTextOffset-nodesBitsTextLength,
+		nodesBitsChildren, nodesBitsICANN, nodesBitsTextOffset, nodesBitsTextLength)
+	if err := n.walk(w, printNode); err != nil {
+		return err
+	}
+	fmt.Fprintf(w, `}
+
+// children is the list of nodes' children, the parent's wildcard bit and the
+// parent's node type. If a node has no children then their children index
+// will be in the range [0, 6), depending on the wildcard bit and node type.
+//
+// The layout within the uint32, from MSB to LSB, is:
+//	[%2d bits] unused
+//	[%2d bits] wildcard bit
+//	[%2d bits] node type
+//	[%2d bits] high nodes index (exclusive) of children
+//	[%2d bits] low nodes index (inclusive) of children
+var children=[...]uint32{
+`,
+		32-childrenBitsWildcard-childrenBitsNodeType-childrenBitsHi-childrenBitsLo,
+		childrenBitsWildcard, childrenBitsNodeType, childrenBitsHi, childrenBitsLo)
+	for i, c := range childrenEncoding {
+		s := "---------------"
+		lo := c & (1<<childrenBitsLo - 1)
+		hi := (c >> childrenBitsLo) & (1<<childrenBitsHi - 1)
+		if lo != hi {
+			s = fmt.Sprintf("n0x%04x-n0x%04x", lo, hi)
+		}
+		nodeType := int(c>>(childrenBitsLo+childrenBitsHi)) & (1<<childrenBitsNodeType - 1)
+		wildcard := c>>(childrenBitsLo+childrenBitsHi+childrenBitsNodeType) != 0
+		if *comments {
+			fmt.Fprintf(w, "0x%08x, // c0x%04x (%s)%s %s\n",
+				c, i, s, wildcardStr(wildcard), nodeTypeStr(nodeType))
+		} else {
+			fmt.Fprintf(w, "0x%x,\n", c)
+		}
+	}
+	fmt.Fprintf(w, "}\n\n")
+	fmt.Fprintf(w, "// max children %d (capacity %d)\n", maxChildren, 1<<nodesBitsChildren-1)
+	fmt.Fprintf(w, "// max text offset %d (capacity %d)\n", maxTextOffset, 1<<nodesBitsTextOffset-1)
+	fmt.Fprintf(w, "// max text length %d (capacity %d)\n", maxTextLength, 1<<nodesBitsTextLength-1)
+	fmt.Fprintf(w, "// max hi %d (capacity %d)\n", maxHi, 1<<childrenBitsHi-1)
+	fmt.Fprintf(w, "// max lo %d (capacity %d)\n", maxLo, 1<<childrenBitsLo-1)
+	return nil
+}
+
+type node struct {
+	label    string
+	nodeType int
+	icann    bool
+	wildcard bool
+	// nodesIndex and childrenIndex are the index of this node in the nodes
+	// and the index of its children offset/length in the children arrays.
+	nodesIndex, childrenIndex int
+	// firstChild is the index of this node's first child, or zero if this
+	// node has no children.
+	firstChild int
+	// children are the node's children, in strictly increasing node label order.
+	children []*node
+}
+
+func (n *node) walk(w io.Writer, f func(w1 io.Writer, n1 *node) error) error {
+	if err := f(w, n); err != nil {
+		return err
+	}
+	for _, c := range n.children {
+		if err := c.walk(w, f); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// child returns the child of n with the given label. The child is created if
+// it did not exist beforehand.
+func (n *node) child(label string) *node {
+	for _, c := range n.children {
+		if c.label == label {
+			return c
+		}
+	}
+	c := &node{
+		label:    label,
+		nodeType: nodeTypeParentOnly,
+		icann:    true,
+	}
+	n.children = append(n.children, c)
+	sort.Sort(byLabel(n.children))
+	return c
+}
+
+type byLabel []*node
+
+func (b byLabel) Len() int           { return len(b) }
+func (b byLabel) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+func (b byLabel) Less(i, j int) bool { return b[i].label < b[j].label }
+
+var nextNodesIndex int
+
+// childrenEncoding are the encoded entries in the generated children array.
+// All these pre-defined entries have no children.
+var childrenEncoding = []uint32{
+	0 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeNormal.
+	1 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeException.
+	2 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeParentOnly.
+	4 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeNormal.
+	5 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeException.
+	6 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeParentOnly.
+}
+
+var firstCallToAssignIndexes = true
+
+func assignIndexes(w io.Writer, n *node) error {
+	if len(n.children) != 0 {
+		// Assign nodesIndex.
+		n.firstChild = nextNodesIndex
+		for _, c := range n.children {
+			c.nodesIndex = nextNodesIndex
+			nextNodesIndex++
+		}
+
+		// The root node's children is implicit.
+		if firstCallToAssignIndexes {
+			firstCallToAssignIndexes = false
+			return nil
+		}
+
+		// Assign childrenIndex.
+		maxChildren = max(maxChildren, len(childrenEncoding))
+		if len(childrenEncoding) >= 1<<nodesBitsChildren {
+			return fmt.Errorf("children table size %d is too large, or nodeBitsChildren is too small", len(childrenEncoding))
+		}
+		n.childrenIndex = len(childrenEncoding)
+		lo := uint32(n.firstChild)
+		hi := lo + uint32(len(n.children))
+		maxLo, maxHi = u32max(maxLo, lo), u32max(maxHi, hi)
+		if lo >= 1<<childrenBitsLo {
+			return fmt.Errorf("children lo %d is too large, or childrenBitsLo is too small", lo)
+		}
+		if hi >= 1<<childrenBitsHi {
+			return fmt.Errorf("children hi %d is too large, or childrenBitsHi is too small", hi)
+		}
+		enc := hi<<childrenBitsLo | lo
+		enc |= uint32(n.nodeType) << (childrenBitsLo + childrenBitsHi)
+		if n.wildcard {
+			enc |= 1 << (childrenBitsLo + childrenBitsHi + childrenBitsNodeType)
+		}
+		childrenEncoding = append(childrenEncoding, enc)
+	} else {
+		n.childrenIndex = n.nodeType
+		if n.wildcard {
+			n.childrenIndex += numNodeType
+		}
+	}
+	return nil
+}
+
+func printNode(w io.Writer, n *node) error {
+	for _, c := range n.children {
+		s := "---------------"
+		if len(c.children) != 0 {
+			s = fmt.Sprintf("n0x%04x-n0x%04x", c.firstChild, c.firstChild+len(c.children))
+		}
+		encoding := labelEncoding[c.label]
+		if c.icann {
+			encoding |= 1 << (nodesBitsTextLength + nodesBitsTextOffset)
+		}
+		encoding |= uint32(c.childrenIndex) << (nodesBitsTextLength + nodesBitsTextOffset + nodesBitsICANN)
+		if *comments {
+			fmt.Fprintf(w, "0x%08x, // n0x%04x c0x%04x (%s)%s %s %s %s\n",
+				encoding, c.nodesIndex, c.childrenIndex, s, wildcardStr(c.wildcard),
+				nodeTypeStr(c.nodeType), icannStr(c.icann), c.label,
+			)
+		} else {
+			fmt.Fprintf(w, "0x%x,\n", encoding)
+		}
+	}
+	return nil
+}
+
+func printNodeLabel(w io.Writer, n *node) error {
+	for _, c := range n.children {
+		fmt.Fprintf(w, "%q,\n", c.label)
+	}
+	return nil
+}
+
+func icannStr(icann bool) string {
+	if icann {
+		return "I"
+	}
+	return " "
+}
+
+func wildcardStr(wildcard bool) string {
+	if wildcard {
+		return "*"
+	}
+	return " "
+}
+
+// combineText combines all the strings in labelsList to form one giant string.
+// Overlapping strings will be merged: "arpa" and "parliament" could yield
+// "arparliament".
+func combineText(labelsList []string) string {
+	beforeLength := 0
+	for _, s := range labelsList {
+		beforeLength += len(s)
+	}
+
+	text := crush(removeSubstrings(labelsList))
+	if *v {
+		fmt.Fprintf(os.Stderr, "crushed %d bytes to become %d bytes\n", beforeLength, len(text))
+	}
+	return text
+}
+
+type byLength []string
+
+func (s byLength) Len() int           { return len(s) }
+func (s byLength) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s byLength) Less(i, j int) bool { return len(s[i]) < len(s[j]) }
+
+// removeSubstrings returns a copy of its input with any strings removed
+// that are substrings of other provided strings.
+func removeSubstrings(input []string) []string {
+	// Make a copy of input.
+	ss := append(make([]string, 0, len(input)), input...)
+	sort.Sort(byLength(ss))
+
+	for i, shortString := range ss {
+		// For each string, only consider strings higher than it in sort order, i.e.
+		// of equal length or greater.
+		for _, longString := range ss[i+1:] {
+			if strings.Contains(longString, shortString) {
+				ss[i] = ""
+				break
+			}
+		}
+	}
+
+	// Remove the empty strings.
+	sort.Strings(ss)
+	for len(ss) > 0 && ss[0] == "" {
+		ss = ss[1:]
+	}
+	return ss
+}
+
+// crush combines a list of strings, taking advantage of overlaps. It returns a
+// single string that contains each input string as a substring.
+func crush(ss []string) string {
+	maxLabelLen := 0
+	for _, s := range ss {
+		if maxLabelLen < len(s) {
+			maxLabelLen = len(s)
+		}
+	}
+
+	for prefixLen := maxLabelLen; prefixLen > 0; prefixLen-- {
+		prefixes := makePrefixMap(ss, prefixLen)
+		for i, s := range ss {
+			if len(s) <= prefixLen {
+				continue
+			}
+			mergeLabel(ss, i, prefixLen, prefixes)
+		}
+	}
+
+	return strings.Join(ss, "")
+}
+
+// mergeLabel merges the label at ss[i] with the first available matching label
+// in prefixMap, where the last "prefixLen" characters in ss[i] match the first
+// "prefixLen" characters in the matching label.
+// It will merge ss[i] repeatedly until no more matches are available.
+// All matching labels merged into ss[i] are replaced by "".
+func mergeLabel(ss []string, i, prefixLen int, prefixes prefixMap) {
+	s := ss[i]
+	suffix := s[len(s)-prefixLen:]
+	for _, j := range prefixes[suffix] {
+		// Empty strings mean "already used." Also avoid merging with self.
+		if ss[j] == "" || i == j {
+			continue
+		}
+		if *v {
+			fmt.Fprintf(os.Stderr, "%d-length overlap at (%4d,%4d): %q and %q share %q\n",
+				prefixLen, i, j, ss[i], ss[j], suffix)
+		}
+		ss[i] += ss[j][prefixLen:]
+		ss[j] = ""
+		// ss[i] has a new suffix, so merge again if possible.
+		// Note: we only have to merge again at the same prefix length. Shorter
+		// prefix lengths will be handled in the next iteration of crush's for loop.
+		// Can there be matches for longer prefix lengths, introduced by the merge?
+		// I believe that any such matches would by necessity have been eliminated
+		// during substring removal or merged at a higher prefix length. For
+		// instance, in crush("abc", "cde", "bcdef"), combining "abc" and "cde"
+		// would yield "abcde", which could be merged with "bcdef." However, in
+		// practice "cde" would already have been elimintated by removeSubstrings.
+		mergeLabel(ss, i, prefixLen, prefixes)
+		return
+	}
+}
+
+// prefixMap maps from a prefix to a list of strings containing that prefix. The
+// list of strings is represented as indexes into a slice of strings stored
+// elsewhere.
+type prefixMap map[string][]int
+
+// makePrefixMap constructs a prefixMap from a slice of strings.
+func makePrefixMap(ss []string, prefixLen int) prefixMap {
+	prefixes := make(prefixMap)
+	for i, s := range ss {
+		// We use < rather than <= because if a label matches on a prefix equal to
+		// its full length, that's actually a substring match handled by
+		// removeSubstrings.
+		if prefixLen < len(s) {
+			prefix := s[:prefixLen]
+			prefixes[prefix] = append(prefixes[prefix], i)
+		}
+	}
+
+	return prefixes
+}
diff --git a/vendor/golang.org/x/sys/unix/mkasm_darwin.go b/vendor/golang.org/x/sys/unix/mkasm_darwin.go
new file mode 100644
index 000000000..4548b993d
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/mkasm_darwin.go
@@ -0,0 +1,61 @@
+// Copyright 2018 The Go 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 ignore
+
+// mkasm_darwin.go generates assembly trampolines to call libSystem routines from Go.
+//This program must be run after mksyscall.go.
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+)
+
+func main() {
+	in1, err := ioutil.ReadFile("syscall_darwin.go")
+	if err != nil {
+		log.Fatalf("can't open syscall_darwin.go: %s", err)
+	}
+	arch := os.Args[1]
+	in2, err := ioutil.ReadFile(fmt.Sprintf("syscall_darwin_%s.go", arch))
+	if err != nil {
+		log.Fatalf("can't open syscall_darwin_%s.go: %s", arch, err)
+	}
+	in3, err := ioutil.ReadFile(fmt.Sprintf("zsyscall_darwin_%s.go", arch))
+	if err != nil {
+		log.Fatalf("can't open zsyscall_darwin_%s.go: %s", arch, err)
+	}
+	in := string(in1) + string(in2) + string(in3)
+
+	trampolines := map[string]bool{}
+
+	var out bytes.Buffer
+
+	fmt.Fprintf(&out, "// go run mkasm_darwin.go %s\n", strings.Join(os.Args[1:], " "))
+	fmt.Fprintf(&out, "// Code generated by the command above; DO NOT EDIT.\n")
+	fmt.Fprintf(&out, "\n")
+	fmt.Fprintf(&out, "// +build go1.12\n")
+	fmt.Fprintf(&out, "\n")
+	fmt.Fprintf(&out, "#include \"textflag.h\"\n")
+	for _, line := range strings.Split(in, "\n") {
+		if !strings.HasPrefix(line, "func ") || !strings.HasSuffix(line, "_trampoline()") {
+			continue
+		}
+		fn := line[5 : len(line)-13]
+		if !trampolines[fn] {
+			trampolines[fn] = true
+			fmt.Fprintf(&out, "TEXT ·%s_trampoline(SB),NOSPLIT,$0-0\n", fn)
+			fmt.Fprintf(&out, "\tJMP\t%s(SB)\n", fn)
+		}
+	}
+	err = ioutil.WriteFile(fmt.Sprintf("zsyscall_darwin_%s.s", arch), out.Bytes(), 0644)
+	if err != nil {
+		log.Fatalf("can't write zsyscall_darwin_%s.s: %s", arch, err)
+	}
+}
diff --git a/vendor/golang.org/x/sys/unix/mkpost.go b/vendor/golang.org/x/sys/unix/mkpost.go
new file mode 100644
index 000000000..eb4332059
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/mkpost.go
@@ -0,0 +1,122 @@
+// Copyright 2016 The Go 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 ignore
+
+// mkpost processes the output of cgo -godefs to
+// modify the generated types. It is used to clean up
+// the sys API in an architecture specific manner.
+//
+// mkpost is run after cgo -godefs; see README.md.
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"io/ioutil"
+	"log"
+	"os"
+	"regexp"
+)
+
+func main() {
+	// Get the OS and architecture (using GOARCH_TARGET if it exists)
+	goos := os.Getenv("GOOS")
+	goarch := os.Getenv("GOARCH_TARGET")
+	if goarch == "" {
+		goarch = os.Getenv("GOARCH")
+	}
+	// Check that we are using the Docker-based build system if we should be.
+	if goos == "linux" {
+		if os.Getenv("GOLANG_SYS_BUILD") != "docker" {
+			os.Stderr.WriteString("In the Docker-based build system, mkpost should not be called directly.\n")
+			os.Stderr.WriteString("See README.md\n")
+			os.Exit(1)
+		}
+	}
+
+	b, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if goos == "aix" {
+		// Replace type of Atim, Mtim and Ctim by Timespec in Stat_t
+		// to avoid having both StTimespec and Timespec.
+		sttimespec := regexp.MustCompile(`_Ctype_struct_st_timespec`)
+		b = sttimespec.ReplaceAll(b, []byte("Timespec"))
+	}
+
+	// Intentionally export __val fields in Fsid and Sigset_t
+	valRegex := regexp.MustCompile(`type (Fsid|Sigset_t) struct {(\s+)X__(bits|val)(\s+\S+\s+)}`)
+	b = valRegex.ReplaceAll(b, []byte("type $1 struct {${2}Val$4}"))
+
+	// Intentionally export __fds_bits field in FdSet
+	fdSetRegex := regexp.MustCompile(`type (FdSet) struct {(\s+)X__fds_bits(\s+\S+\s+)}`)
+	b = fdSetRegex.ReplaceAll(b, []byte("type $1 struct {${2}Bits$3}"))
+
+	// If we have empty Ptrace structs, we should delete them. Only s390x emits
+	// nonempty Ptrace structs.
+	ptraceRexexp := regexp.MustCompile(`type Ptrace((Psw|Fpregs|Per) struct {\s*})`)
+	b = ptraceRexexp.ReplaceAll(b, nil)
+
+	// Replace the control_regs union with a blank identifier for now.
+	controlRegsRegex := regexp.MustCompile(`(Control_regs)\s+\[0\]uint64`)
+	b = controlRegsRegex.ReplaceAll(b, []byte("_ [0]uint64"))
+
+	// Remove fields that are added by glibc
+	// Note that this is unstable as the identifers are private.
+	removeFieldsRegex := regexp.MustCompile(`X__glibc\S*`)
+	b = removeFieldsRegex.ReplaceAll(b, []byte("_"))
+
+	// Convert [65]int8 to [65]byte in Utsname members to simplify
+	// conversion to string; see golang.org/issue/20753
+	convertUtsnameRegex := regexp.MustCompile(`((Sys|Node|Domain)name|Release|Version|Machine)(\s+)\[(\d+)\]u?int8`)
+	b = convertUtsnameRegex.ReplaceAll(b, []byte("$1$3[$4]byte"))
+
+	// Convert [1024]int8 to [1024]byte in Ptmget members
+	convertPtmget := regexp.MustCompile(`([SC]n)(\s+)\[(\d+)\]u?int8`)
+	b = convertPtmget.ReplaceAll(b, []byte("$1[$3]byte"))
+
+	// Remove spare fields (e.g. in Statx_t)
+	spareFieldsRegex := regexp.MustCompile(`X__spare\S*`)
+	b = spareFieldsRegex.ReplaceAll(b, []byte("_"))
+
+	// Remove cgo padding fields
+	removePaddingFieldsRegex := regexp.MustCompile(`Pad_cgo_\d+`)
+	b = removePaddingFieldsRegex.ReplaceAll(b, []byte("_"))
+
+	// Remove padding, hidden, or unused fields
+	removeFieldsRegex = regexp.MustCompile(`\b(X_\S+|Padding)`)
+	b = removeFieldsRegex.ReplaceAll(b, []byte("_"))
+
+	// Remove the first line of warning from cgo
+	b = b[bytes.IndexByte(b, '\n')+1:]
+	// Modify the command in the header to include:
+	//  mkpost, our own warning, and a build tag.
+	replacement := fmt.Sprintf(`$1 | go run mkpost.go
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build %s,%s`, goarch, goos)
+	cgoCommandRegex := regexp.MustCompile(`(cgo -godefs .*)`)
+	b = cgoCommandRegex.ReplaceAll(b, []byte(replacement))
+
+	// Rename Stat_t time fields
+	if goos == "freebsd" && goarch == "386" {
+		// Hide Stat_t.[AMCB]tim_ext fields
+		renameStatTimeExtFieldsRegex := regexp.MustCompile(`[AMCB]tim_ext`)
+		b = renameStatTimeExtFieldsRegex.ReplaceAll(b, []byte("_"))
+	}
+	renameStatTimeFieldsRegex := regexp.MustCompile(`([AMCB])(?:irth)?time?(?:spec)?\s+(Timespec|StTimespec)`)
+	b = renameStatTimeFieldsRegex.ReplaceAll(b, []byte("${1}tim ${2}"))
+
+	// gofmt
+	b, err = format.Source(b)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	os.Stdout.Write(b)
+}
diff --git a/vendor/golang.org/x/sys/unix/mksyscall.go b/vendor/golang.org/x/sys/unix/mksyscall.go
new file mode 100644
index 000000000..e4af9424e
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/mksyscall.go
@@ -0,0 +1,407 @@
+// Copyright 2018 The Go 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 ignore
+
+/*
+This program reads a file containing function prototypes
+(like syscall_darwin.go) and generates system call bodies.
+The prototypes are marked by lines beginning with "//sys"
+and read like func declarations if //sys is replaced by func, but:
+	* The parameter lists must give a name for each argument.
+	  This includes return parameters.
+	* The parameter lists must give a type for each argument:
+	  the (x, y, z int) shorthand is not allowed.
+	* If the return parameter is an error number, it must be named errno.
+
+A line beginning with //sysnb is like //sys, except that the
+goroutine will not be suspended during the execution of the system
+call.  This must only be used for system calls which can never
+block, as otherwise the system call could cause all goroutines to
+hang.
+*/
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+)
+
+var (
+	b32       = flag.Bool("b32", false, "32bit big-endian")
+	l32       = flag.Bool("l32", false, "32bit little-endian")
+	plan9     = flag.Bool("plan9", false, "plan9")
+	openbsd   = flag.Bool("openbsd", false, "openbsd")
+	netbsd    = flag.Bool("netbsd", false, "netbsd")
+	dragonfly = flag.Bool("dragonfly", false, "dragonfly")
+	arm       = flag.Bool("arm", false, "arm") // 64-bit value should use (even, odd)-pair
+	tags      = flag.String("tags", "", "build tags")
+	filename  = flag.String("output", "", "output file name (standard output if omitted)")
+)
+
+// cmdLine returns this programs's commandline arguments
+func cmdLine() string {
+	return "go run mksyscall.go " + strings.Join(os.Args[1:], " ")
+}
+
+// buildTags returns build tags
+func buildTags() string {
+	return *tags
+}
+
+// Param is function parameter
+type Param struct {
+	Name string
+	Type string
+}
+
+// usage prints the program usage
+func usage() {
+	fmt.Fprintf(os.Stderr, "usage: go run mksyscall.go [-b32 | -l32] [-tags x,y] [file ...]\n")
+	os.Exit(1)
+}
+
+// parseParamList parses parameter list and returns a slice of parameters
+func parseParamList(list string) []string {
+	list = strings.TrimSpace(list)
+	if list == "" {
+		return []string{}
+	}
+	return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
+}
+
+// parseParam splits a parameter into name and type
+func parseParam(p string) Param {
+	ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
+	if ps == nil {
+		fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
+		os.Exit(1)
+	}
+	return Param{ps[1], ps[2]}
+}
+
+func main() {
+	// Get the OS and architecture (using GOARCH_TARGET if it exists)
+	goos := os.Getenv("GOOS")
+	if goos == "" {
+		fmt.Fprintln(os.Stderr, "GOOS not defined in environment")
+		os.Exit(1)
+	}
+	goarch := os.Getenv("GOARCH_TARGET")
+	if goarch == "" {
+		goarch = os.Getenv("GOARCH")
+	}
+
+	// Check that we are using the Docker-based build system if we should
+	if goos == "linux" {
+		if os.Getenv("GOLANG_SYS_BUILD") != "docker" {
+			fmt.Fprintf(os.Stderr, "In the Docker-based build system, mksyscall should not be called directly.\n")
+			fmt.Fprintf(os.Stderr, "See README.md\n")
+			os.Exit(1)
+		}
+	}
+
+	flag.Usage = usage
+	flag.Parse()
+	if len(flag.Args()) <= 0 {
+		fmt.Fprintf(os.Stderr, "no files to parse provided\n")
+		usage()
+	}
+
+	endianness := ""
+	if *b32 {
+		endianness = "big-endian"
+	} else if *l32 {
+		endianness = "little-endian"
+	}
+
+	libc := false
+	if goos == "darwin" && strings.Contains(buildTags(), ",go1.12") {
+		libc = true
+	}
+	trampolines := map[string]bool{}
+
+	text := ""
+	for _, path := range flag.Args() {
+		file, err := os.Open(path)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, err.Error())
+			os.Exit(1)
+		}
+		s := bufio.NewScanner(file)
+		for s.Scan() {
+			t := s.Text()
+			t = strings.TrimSpace(t)
+			t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
+			nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
+			if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
+				continue
+			}
+
+			// Line must be of the form
+			//	func Open(path string, mode int, perm int) (fd int, errno error)
+			// Split into name, in params, out params.
+			f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*((?i)SYS_[A-Z0-9_]+))?$`).FindStringSubmatch(t)
+			if f == nil {
+				fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
+				os.Exit(1)
+			}
+			funct, inps, outps, sysname := f[2], f[3], f[4], f[5]
+
+			// ClockGettime doesn't have a syscall number on Darwin, only generate libc wrappers.
+			if goos == "darwin" && !libc && funct == "ClockGettime" {
+				continue
+			}
+
+			// Split argument lists on comma.
+			in := parseParamList(inps)
+			out := parseParamList(outps)
+
+			// Try in vain to keep people from editing this file.
+			// The theory is that they jump into the middle of the file
+			// without reading the header.
+			text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
+
+			// Go function header.
+			outDecl := ""
+			if len(out) > 0 {
+				outDecl = fmt.Sprintf(" (%s)", strings.Join(out, ", "))
+			}
+			text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outDecl)
+
+			// Check if err return available
+			errvar := ""
+			for _, param := range out {
+				p := parseParam(param)
+				if p.Type == "error" {
+					errvar = p.Name
+					break
+				}
+			}
+
+			// Prepare arguments to Syscall.
+			var args []string
+			n := 0
+			for _, param := range in {
+				p := parseParam(param)
+				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
+					args = append(args, "uintptr(unsafe.Pointer("+p.Name+"))")
+				} else if p.Type == "string" && errvar != "" {
+					text += fmt.Sprintf("\tvar _p%d *byte\n", n)
+					text += fmt.Sprintf("\t_p%d, %s = BytePtrFromString(%s)\n", n, errvar, p.Name)
+					text += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
+					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
+					n++
+				} else if p.Type == "string" {
+					fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
+					text += fmt.Sprintf("\tvar _p%d *byte\n", n)
+					text += fmt.Sprintf("\t_p%d, _ = BytePtrFromString(%s)\n", n, p.Name)
+					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
+					n++
+				} else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
+					// Convert slice into pointer, length.
+					// Have to be careful not to take address of &a[0] if len == 0:
+					// pass dummy pointer in that case.
+					// Used to pass nil, but some OSes or simulators reject write(fd, nil, 0).
+					text += fmt.Sprintf("\tvar _p%d unsafe.Pointer\n", n)
+					text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = unsafe.Pointer(&%s[0])\n\t}", p.Name, n, p.Name)
+					text += fmt.Sprintf(" else {\n\t\t_p%d = unsafe.Pointer(&_zero)\n\t}\n", n)
+					args = append(args, fmt.Sprintf("uintptr(_p%d)", n), fmt.Sprintf("uintptr(len(%s))", p.Name))
+					n++
+				} else if p.Type == "int64" && (*openbsd || *netbsd) {
+					args = append(args, "0")
+					if endianness == "big-endian" {
+						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
+					} else if endianness == "little-endian" {
+						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
+					} else {
+						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
+					}
+				} else if p.Type == "int64" && *dragonfly {
+					if regexp.MustCompile(`^(?i)extp(read|write)`).FindStringSubmatch(funct) == nil {
+						args = append(args, "0")
+					}
+					if endianness == "big-endian" {
+						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
+					} else if endianness == "little-endian" {
+						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
+					} else {
+						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
+					}
+				} else if (p.Type == "int64" || p.Type == "uint64") && endianness != "" {
+					if len(args)%2 == 1 && *arm {
+						// arm abi specifies 64-bit argument uses
+						// (even, odd) pair
+						args = append(args, "0")
+					}
+					if endianness == "big-endian" {
+						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
+					} else {
+						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
+					}
+				} else {
+					args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
+				}
+			}
+
+			// Determine which form to use; pad args with zeros.
+			asm := "Syscall"
+			if nonblock != nil {
+				if errvar == "" && goos == "linux" {
+					asm = "RawSyscallNoError"
+				} else {
+					asm = "RawSyscall"
+				}
+			} else {
+				if errvar == "" && goos == "linux" {
+					asm = "SyscallNoError"
+				}
+			}
+			if len(args) <= 3 {
+				for len(args) < 3 {
+					args = append(args, "0")
+				}
+			} else if len(args) <= 6 {
+				asm += "6"
+				for len(args) < 6 {
+					args = append(args, "0")
+				}
+			} else if len(args) <= 9 {
+				asm += "9"
+				for len(args) < 9 {
+					args = append(args, "0")
+				}
+			} else {
+				fmt.Fprintf(os.Stderr, "%s:%s too many arguments to system call\n", path, funct)
+			}
+
+			// System call number.
+			if sysname == "" {
+				sysname = "SYS_" + funct
+				sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
+				sysname = strings.ToUpper(sysname)
+			}
+
+			var libcFn string
+			if libc {
+				asm = "syscall_" + strings.ToLower(asm[:1]) + asm[1:] // internal syscall call
+				sysname = strings.TrimPrefix(sysname, "SYS_")         // remove SYS_
+				sysname = strings.ToLower(sysname)                    // lowercase
+				if sysname == "getdirentries64" {
+					// Special case - libSystem name and
+					// raw syscall name don't match.
+					sysname = "__getdirentries64"
+				}
+				libcFn = sysname
+				sysname = "funcPC(libc_" + sysname + "_trampoline)"
+			}
+
+			// Actual call.
+			arglist := strings.Join(args, ", ")
+			call := fmt.Sprintf("%s(%s, %s)", asm, sysname, arglist)
+
+			// Assign return values.
+			body := ""
+			ret := []string{"_", "_", "_"}
+			doErrno := false
+			for i := 0; i < len(out); i++ {
+				p := parseParam(out[i])
+				reg := ""
+				if p.Name == "err" && !*plan9 {
+					reg = "e1"
+					ret[2] = reg
+					doErrno = true
+				} else if p.Name == "err" && *plan9 {
+					ret[0] = "r0"
+					ret[2] = "e1"
+					break
+				} else {
+					reg = fmt.Sprintf("r%d", i)
+					ret[i] = reg
+				}
+				if p.Type == "bool" {
+					reg = fmt.Sprintf("%s != 0", reg)
+				}
+				if p.Type == "int64" && endianness != "" {
+					// 64-bit number in r1:r0 or r0:r1.
+					if i+2 > len(out) {
+						fmt.Fprintf(os.Stderr, "%s:%s not enough registers for int64 return\n", path, funct)
+					}
+					if endianness == "big-endian" {
+						reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i, i+1)
+					} else {
+						reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i+1, i)
+					}
+					ret[i] = fmt.Sprintf("r%d", i)
+					ret[i+1] = fmt.Sprintf("r%d", i+1)
+				}
+				if reg != "e1" || *plan9 {
+					body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
+				}
+			}
+			if ret[0] == "_" && ret[1] == "_" && ret[2] == "_" {
+				text += fmt.Sprintf("\t%s\n", call)
+			} else {
+				if errvar == "" && goos == "linux" {
+					// raw syscall without error on Linux, see golang.org/issue/22924
+					text += fmt.Sprintf("\t%s, %s := %s\n", ret[0], ret[1], call)
+				} else {
+					text += fmt.Sprintf("\t%s, %s, %s := %s\n", ret[0], ret[1], ret[2], call)
+				}
+			}
+			text += body
+
+			if *plan9 && ret[2] == "e1" {
+				text += "\tif int32(r0) == -1 {\n"
+				text += "\t\terr = e1\n"
+				text += "\t}\n"
+			} else if doErrno {
+				text += "\tif e1 != 0 {\n"
+				text += "\t\terr = errnoErr(e1)\n"
+				text += "\t}\n"
+			}
+			text += "\treturn\n"
+			text += "}\n\n"
+
+			if libc && !trampolines[libcFn] {
+				// some system calls share a trampoline, like read and readlen.
+				trampolines[libcFn] = true
+				// Declare assembly trampoline.
+				text += fmt.Sprintf("func libc_%s_trampoline()\n", libcFn)
+				// Assembly trampoline calls the libc_* function, which this magic
+				// redirects to use the function from libSystem.
+				text += fmt.Sprintf("//go:linkname libc_%s libc_%s\n", libcFn, libcFn)
+				text += fmt.Sprintf("//go:cgo_import_dynamic libc_%s %s \"/usr/lib/libSystem.B.dylib\"\n", libcFn, libcFn)
+				text += "\n"
+			}
+		}
+		if err := s.Err(); err != nil {
+			fmt.Fprintf(os.Stderr, err.Error())
+			os.Exit(1)
+		}
+		file.Close()
+	}
+	fmt.Printf(srcTemplate, cmdLine(), buildTags(), text)
+}
+
+const srcTemplate = `// %s
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build %s
+
+package unix
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var _ syscall.Errno
+
+%s
+`
diff --git a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go
new file mode 100644
index 000000000..3be3cdfc3
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go
@@ -0,0 +1,415 @@
+// Copyright 2019 The Go 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 ignore
+
+/*
+This program reads a file containing function prototypes
+(like syscall_aix.go) and generates system call bodies.
+The prototypes are marked by lines beginning with "//sys"
+and read like func declarations if //sys is replaced by func, but:
+	* The parameter lists must give a name for each argument.
+	  This includes return parameters.
+	* The parameter lists must give a type for each argument:
+	  the (x, y, z int) shorthand is not allowed.
+	* If the return parameter is an error number, it must be named err.
+	* If go func name needs to be different than its libc name,
+	* or the function is not in libc, name could be specified
+	* at the end, after "=" sign, like
+	  //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
+*/
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+)
+
+var (
+	b32  = flag.Bool("b32", false, "32bit big-endian")
+	l32  = flag.Bool("l32", false, "32bit little-endian")
+	aix  = flag.Bool("aix", false, "aix")
+	tags = flag.String("tags", "", "build tags")
+)
+
+// cmdLine returns this programs's commandline arguments
+func cmdLine() string {
+	return "go run mksyscall_aix_ppc.go " + strings.Join(os.Args[1:], " ")
+}
+
+// buildTags returns build tags
+func buildTags() string {
+	return *tags
+}
+
+// Param is function parameter
+type Param struct {
+	Name string
+	Type string
+}
+
+// usage prints the program usage
+func usage() {
+	fmt.Fprintf(os.Stderr, "usage: go run mksyscall_aix_ppc.go [-b32 | -l32] [-tags x,y] [file ...]\n")
+	os.Exit(1)
+}
+
+// parseParamList parses parameter list and returns a slice of parameters
+func parseParamList(list string) []string {
+	list = strings.TrimSpace(list)
+	if list == "" {
+		return []string{}
+	}
+	return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
+}
+
+// parseParam splits a parameter into name and type
+func parseParam(p string) Param {
+	ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
+	if ps == nil {
+		fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
+		os.Exit(1)
+	}
+	return Param{ps[1], ps[2]}
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+	if len(flag.Args()) <= 0 {
+		fmt.Fprintf(os.Stderr, "no files to parse provided\n")
+		usage()
+	}
+
+	endianness := ""
+	if *b32 {
+		endianness = "big-endian"
+	} else if *l32 {
+		endianness = "little-endian"
+	}
+
+	pack := ""
+	text := ""
+	cExtern := "/*\n#include <stdint.h>\n#include <stddef.h>\n"
+	for _, path := range flag.Args() {
+		file, err := os.Open(path)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, err.Error())
+			os.Exit(1)
+		}
+		s := bufio.NewScanner(file)
+		for s.Scan() {
+			t := s.Text()
+			t = strings.TrimSpace(t)
+			t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
+			if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
+				pack = p[1]
+			}
+			nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
+			if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
+				continue
+			}
+
+			// Line must be of the form
+			//	func Open(path string, mode int, perm int) (fd int, err error)
+			// Split into name, in params, out params.
+			f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
+			if f == nil {
+				fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
+				os.Exit(1)
+			}
+			funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
+
+			// Split argument lists on comma.
+			in := parseParamList(inps)
+			out := parseParamList(outps)
+
+			inps = strings.Join(in, ", ")
+			outps = strings.Join(out, ", ")
+
+			// Try in vain to keep people from editing this file.
+			// The theory is that they jump into the middle of the file
+			// without reading the header.
+			text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
+
+			// Check if value return, err return available
+			errvar := ""
+			retvar := ""
+			rettype := ""
+			for _, param := range out {
+				p := parseParam(param)
+				if p.Type == "error" {
+					errvar = p.Name
+				} else {
+					retvar = p.Name
+					rettype = p.Type
+				}
+			}
+
+			// System call name.
+			if sysname == "" {
+				sysname = funct
+			}
+			sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
+			sysname = strings.ToLower(sysname) // All libc functions are lowercase.
+
+			cRettype := ""
+			if rettype == "unsafe.Pointer" {
+				cRettype = "uintptr_t"
+			} else if rettype == "uintptr" {
+				cRettype = "uintptr_t"
+			} else if regexp.MustCompile(`^_`).FindStringSubmatch(rettype) != nil {
+				cRettype = "uintptr_t"
+			} else if rettype == "int" {
+				cRettype = "int"
+			} else if rettype == "int32" {
+				cRettype = "int"
+			} else if rettype == "int64" {
+				cRettype = "long long"
+			} else if rettype == "uint32" {
+				cRettype = "unsigned int"
+			} else if rettype == "uint64" {
+				cRettype = "unsigned long long"
+			} else {
+				cRettype = "int"
+			}
+			if sysname == "exit" {
+				cRettype = "void"
+			}
+
+			// Change p.Types to c
+			var cIn []string
+			for _, param := range in {
+				p := parseParam(param)
+				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
+					cIn = append(cIn, "uintptr_t")
+				} else if p.Type == "string" {
+					cIn = append(cIn, "uintptr_t")
+				} else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
+					cIn = append(cIn, "uintptr_t", "size_t")
+				} else if p.Type == "unsafe.Pointer" {
+					cIn = append(cIn, "uintptr_t")
+				} else if p.Type == "uintptr" {
+					cIn = append(cIn, "uintptr_t")
+				} else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
+					cIn = append(cIn, "uintptr_t")
+				} else if p.Type == "int" {
+					cIn = append(cIn, "int")
+				} else if p.Type == "int32" {
+					cIn = append(cIn, "int")
+				} else if p.Type == "int64" {
+					cIn = append(cIn, "long long")
+				} else if p.Type == "uint32" {
+					cIn = append(cIn, "unsigned int")
+				} else if p.Type == "uint64" {
+					cIn = append(cIn, "unsigned long long")
+				} else {
+					cIn = append(cIn, "int")
+				}
+			}
+
+			if funct != "fcntl" && funct != "FcntlInt" && funct != "readlen" && funct != "writelen" {
+				if sysname == "select" {
+					// select is a keyword of Go. Its name is
+					// changed to c_select.
+					cExtern += "#define c_select select\n"
+				}
+				// Imports of system calls from libc
+				cExtern += fmt.Sprintf("%s %s", cRettype, sysname)
+				cIn := strings.Join(cIn, ", ")
+				cExtern += fmt.Sprintf("(%s);\n", cIn)
+			}
+
+			// So file name.
+			if *aix {
+				if modname == "" {
+					modname = "libc.a/shr_64.o"
+				} else {
+					fmt.Fprintf(os.Stderr, "%s: only syscall using libc are available\n", funct)
+					os.Exit(1)
+				}
+			}
+
+			strconvfunc := "C.CString"
+
+			// Go function header.
+			if outps != "" {
+				outps = fmt.Sprintf(" (%s)", outps)
+			}
+			if text != "" {
+				text += "\n"
+			}
+
+			text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outps)
+
+			// Prepare arguments to Syscall.
+			var args []string
+			n := 0
+			argN := 0
+			for _, param := range in {
+				p := parseParam(param)
+				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
+					args = append(args, "C.uintptr_t(uintptr(unsafe.Pointer("+p.Name+")))")
+				} else if p.Type == "string" && errvar != "" {
+					text += fmt.Sprintf("\t_p%d := uintptr(unsafe.Pointer(%s(%s)))\n", n, strconvfunc, p.Name)
+					args = append(args, fmt.Sprintf("C.uintptr_t(_p%d)", n))
+					n++
+				} else if p.Type == "string" {
+					fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
+					text += fmt.Sprintf("\t_p%d := uintptr(unsafe.Pointer(%s(%s)))\n", n, strconvfunc, p.Name)
+					args = append(args, fmt.Sprintf("C.uintptr_t(_p%d)", n))
+					n++
+				} else if m := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); m != nil {
+					// Convert slice into pointer, length.
+					// Have to be careful not to take address of &a[0] if len == 0:
+					// pass nil in that case.
+					text += fmt.Sprintf("\tvar _p%d *%s\n", n, m[1])
+					text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
+					args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(unsafe.Pointer(_p%d)))", n))
+					n++
+					text += fmt.Sprintf("\tvar _p%d int\n", n)
+					text += fmt.Sprintf("\t_p%d = len(%s)\n", n, p.Name)
+					args = append(args, fmt.Sprintf("C.size_t(_p%d)", n))
+					n++
+				} else if p.Type == "int64" && endianness != "" {
+					if endianness == "big-endian" {
+						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
+					} else {
+						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
+					}
+					n++
+				} else if p.Type == "bool" {
+					text += fmt.Sprintf("\tvar _p%d uint32\n", n)
+					text += fmt.Sprintf("\tif %s {\n\t\t_p%d = 1\n\t} else {\n\t\t_p%d = 0\n\t}\n", p.Name, n, n)
+					args = append(args, fmt.Sprintf("_p%d", n))
+				} else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
+					args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(%s))", p.Name))
+				} else if p.Type == "unsafe.Pointer" {
+					args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(%s))", p.Name))
+				} else if p.Type == "int" {
+					if (argN == 2) && ((funct == "readlen") || (funct == "writelen")) {
+						args = append(args, fmt.Sprintf("C.size_t(%s)", p.Name))
+					} else if argN == 0 && funct == "fcntl" {
+						args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
+					} else if (argN == 2) && ((funct == "fcntl") || (funct == "FcntlInt")) {
+						args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
+					} else {
+						args = append(args, fmt.Sprintf("C.int(%s)", p.Name))
+					}
+				} else if p.Type == "int32" {
+					args = append(args, fmt.Sprintf("C.int(%s)", p.Name))
+				} else if p.Type == "int64" {
+					args = append(args, fmt.Sprintf("C.longlong(%s)", p.Name))
+				} else if p.Type == "uint32" {
+					args = append(args, fmt.Sprintf("C.uint(%s)", p.Name))
+				} else if p.Type == "uint64" {
+					args = append(args, fmt.Sprintf("C.ulonglong(%s)", p.Name))
+				} else if p.Type == "uintptr" {
+					args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
+				} else {
+					args = append(args, fmt.Sprintf("C.int(%s)", p.Name))
+				}
+				argN++
+			}
+
+			// Actual call.
+			arglist := strings.Join(args, ", ")
+			call := ""
+			if sysname == "exit" {
+				if errvar != "" {
+					call += "er :="
+				} else {
+					call += ""
+				}
+			} else if errvar != "" {
+				call += "r0,er :="
+			} else if retvar != "" {
+				call += "r0,_ :="
+			} else {
+				call += ""
+			}
+			if sysname == "select" {
+				// select is a keyword of Go. Its name is
+				// changed to c_select.
+				call += fmt.Sprintf("C.c_%s(%s)", sysname, arglist)
+			} else {
+				call += fmt.Sprintf("C.%s(%s)", sysname, arglist)
+			}
+
+			// Assign return values.
+			body := ""
+			for i := 0; i < len(out); i++ {
+				p := parseParam(out[i])
+				reg := ""
+				if p.Name == "err" {
+					reg = "e1"
+				} else {
+					reg = "r0"
+				}
+				if reg != "e1" {
+					body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
+				}
+			}
+
+			// verify return
+			if sysname != "exit" && errvar != "" {
+				if regexp.MustCompile(`^uintptr`).FindStringSubmatch(cRettype) != nil {
+					body += "\tif (uintptr(r0) ==^uintptr(0) && er != nil) {\n"
+					body += fmt.Sprintf("\t\t%s = er\n", errvar)
+					body += "\t}\n"
+				} else {
+					body += "\tif (r0 ==-1 && er != nil) {\n"
+					body += fmt.Sprintf("\t\t%s = er\n", errvar)
+					body += "\t}\n"
+				}
+			} else if errvar != "" {
+				body += "\tif (er != nil) {\n"
+				body += fmt.Sprintf("\t\t%s = er\n", errvar)
+				body += "\t}\n"
+			}
+
+			text += fmt.Sprintf("\t%s\n", call)
+			text += body
+
+			text += "\treturn\n"
+			text += "}\n"
+		}
+		if err := s.Err(); err != nil {
+			fmt.Fprintf(os.Stderr, err.Error())
+			os.Exit(1)
+		}
+		file.Close()
+	}
+	imp := ""
+	if pack != "unix" {
+		imp = "import \"golang.org/x/sys/unix\"\n"
+
+	}
+	fmt.Printf(srcTemplate, cmdLine(), buildTags(), pack, cExtern, imp, text)
+}
+
+const srcTemplate = `// %s
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build %s
+
+package %s
+
+
+%s
+*/
+import "C"
+import (
+	"unsafe"
+)
+
+
+%s
+
+%s
+`
diff --git a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go
new file mode 100644
index 000000000..c96009951
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go
@@ -0,0 +1,614 @@
+// Copyright 2019 The Go 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 ignore
+
+/*
+This program reads a file containing function prototypes
+(like syscall_aix.go) and generates system call bodies.
+The prototypes are marked by lines beginning with "//sys"
+and read like func declarations if //sys is replaced by func, but:
+	* The parameter lists must give a name for each argument.
+	  This includes return parameters.
+	* The parameter lists must give a type for each argument:
+	  the (x, y, z int) shorthand is not allowed.
+	* If the return parameter is an error number, it must be named err.
+	* If go func name needs to be different than its libc name,
+	* or the function is not in libc, name could be specified
+	* at the end, after "=" sign, like
+	  //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
+
+
+This program will generate three files and handle both gc and gccgo implementation:
+  - zsyscall_aix_ppc64.go: the common part of each implementation (error handler, pointer creation)
+  - zsyscall_aix_ppc64_gc.go: gc part with //go_cgo_import_dynamic and a call to syscall6
+  - zsyscall_aix_ppc64_gccgo.go: gccgo part with C function and conversion to C type.
+
+ The generated code looks like this
+
+zsyscall_aix_ppc64.go
+func asyscall(...) (n int, err error) {
+	 // Pointer Creation
+	 r1, e1 := callasyscall(...)
+	 // Type Conversion
+	 // Error Handler
+	 return
+}
+
+zsyscall_aix_ppc64_gc.go
+//go:cgo_import_dynamic libc_asyscall asyscall "libc.a/shr_64.o"
+//go:linkname libc_asyscall libc_asyscall
+var asyscall syscallFunc
+
+func callasyscall(...) (r1 uintptr, e1 Errno) {
+	 r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_asyscall)), "nb_args", ... )
+	 return
+}
+
+zsyscall_aix_ppc64_ggcgo.go
+
+// int asyscall(...)
+
+import "C"
+
+func callasyscall(...) (r1 uintptr, e1 Errno) {
+	 r1 = uintptr(C.asyscall(...))
+	 e1 = syscall.GetErrno()
+	 return
+}
+*/
+
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"regexp"
+	"strings"
+)
+
+var (
+	b32  = flag.Bool("b32", false, "32bit big-endian")
+	l32  = flag.Bool("l32", false, "32bit little-endian")
+	aix  = flag.Bool("aix", false, "aix")
+	tags = flag.String("tags", "", "build tags")
+)
+
+// cmdLine returns this programs's commandline arguments
+func cmdLine() string {
+	return "go run mksyscall_aix_ppc64.go " + strings.Join(os.Args[1:], " ")
+}
+
+// buildTags returns build tags
+func buildTags() string {
+	return *tags
+}
+
+// Param is function parameter
+type Param struct {
+	Name string
+	Type string
+}
+
+// usage prints the program usage
+func usage() {
+	fmt.Fprintf(os.Stderr, "usage: go run mksyscall_aix_ppc64.go [-b32 | -l32] [-tags x,y] [file ...]\n")
+	os.Exit(1)
+}
+
+// parseParamList parses parameter list and returns a slice of parameters
+func parseParamList(list string) []string {
+	list = strings.TrimSpace(list)
+	if list == "" {
+		return []string{}
+	}
+	return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
+}
+
+// parseParam splits a parameter into name and type
+func parseParam(p string) Param {
+	ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
+	if ps == nil {
+		fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
+		os.Exit(1)
+	}
+	return Param{ps[1], ps[2]}
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+	if len(flag.Args()) <= 0 {
+		fmt.Fprintf(os.Stderr, "no files to parse provided\n")
+		usage()
+	}
+
+	endianness := ""
+	if *b32 {
+		endianness = "big-endian"
+	} else if *l32 {
+		endianness = "little-endian"
+	}
+
+	pack := ""
+	// GCCGO
+	textgccgo := ""
+	cExtern := "/*\n#include <stdint.h>\n"
+	// GC
+	textgc := ""
+	dynimports := ""
+	linknames := ""
+	var vars []string
+	// COMMON
+	textcommon := ""
+	for _, path := range flag.Args() {
+		file, err := os.Open(path)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, err.Error())
+			os.Exit(1)
+		}
+		s := bufio.NewScanner(file)
+		for s.Scan() {
+			t := s.Text()
+			t = strings.TrimSpace(t)
+			t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
+			if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
+				pack = p[1]
+			}
+			nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
+			if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
+				continue
+			}
+
+			// Line must be of the form
+			//	func Open(path string, mode int, perm int) (fd int, err error)
+			// Split into name, in params, out params.
+			f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
+			if f == nil {
+				fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
+				os.Exit(1)
+			}
+			funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
+
+			// Split argument lists on comma.
+			in := parseParamList(inps)
+			out := parseParamList(outps)
+
+			inps = strings.Join(in, ", ")
+			outps = strings.Join(out, ", ")
+
+			if sysname == "" {
+				sysname = funct
+			}
+
+			onlyCommon := false
+			if funct == "readlen" || funct == "writelen" || funct == "FcntlInt" || funct == "FcntlFlock" {
+				// This function call another syscall which is already implemented.
+				// Therefore, the gc and gccgo part must not be generated.
+				onlyCommon = true
+			}
+
+			// Try in vain to keep people from editing this file.
+			// The theory is that they jump into the middle of the file
+			// without reading the header.
+
+			textcommon += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
+			if !onlyCommon {
+				textgccgo += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
+				textgc += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
+			}
+
+			// Check if value return, err return available
+			errvar := ""
+			rettype := ""
+			for _, param := range out {
+				p := parseParam(param)
+				if p.Type == "error" {
+					errvar = p.Name
+				} else {
+					rettype = p.Type
+				}
+			}
+
+			sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
+			sysname = strings.ToLower(sysname) // All libc functions are lowercase.
+
+			// GCCGO Prototype return type
+			cRettype := ""
+			if rettype == "unsafe.Pointer" {
+				cRettype = "uintptr_t"
+			} else if rettype == "uintptr" {
+				cRettype = "uintptr_t"
+			} else if regexp.MustCompile(`^_`).FindStringSubmatch(rettype) != nil {
+				cRettype = "uintptr_t"
+			} else if rettype == "int" {
+				cRettype = "int"
+			} else if rettype == "int32" {
+				cRettype = "int"
+			} else if rettype == "int64" {
+				cRettype = "long long"
+			} else if rettype == "uint32" {
+				cRettype = "unsigned int"
+			} else if rettype == "uint64" {
+				cRettype = "unsigned long long"
+			} else {
+				cRettype = "int"
+			}
+			if sysname == "exit" {
+				cRettype = "void"
+			}
+
+			// GCCGO Prototype arguments type
+			var cIn []string
+			for i, param := range in {
+				p := parseParam(param)
+				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
+					cIn = append(cIn, "uintptr_t")
+				} else if p.Type == "string" {
+					cIn = append(cIn, "uintptr_t")
+				} else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
+					cIn = append(cIn, "uintptr_t", "size_t")
+				} else if p.Type == "unsafe.Pointer" {
+					cIn = append(cIn, "uintptr_t")
+				} else if p.Type == "uintptr" {
+					cIn = append(cIn, "uintptr_t")
+				} else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
+					cIn = append(cIn, "uintptr_t")
+				} else if p.Type == "int" {
+					if (i == 0 || i == 2) && funct == "fcntl" {
+						// These fcntl arguments needs to be uintptr to be able to call FcntlInt and FcntlFlock
+						cIn = append(cIn, "uintptr_t")
+					} else {
+						cIn = append(cIn, "int")
+					}
+
+				} else if p.Type == "int32" {
+					cIn = append(cIn, "int")
+				} else if p.Type == "int64" {
+					cIn = append(cIn, "long long")
+				} else if p.Type == "uint32" {
+					cIn = append(cIn, "unsigned int")
+				} else if p.Type == "uint64" {
+					cIn = append(cIn, "unsigned long long")
+				} else {
+					cIn = append(cIn, "int")
+				}
+			}
+
+			if !onlyCommon {
+				// GCCGO Prototype Generation
+				// Imports of system calls from libc
+				if sysname == "select" {
+					// select is a keyword of Go. Its name is
+					// changed to c_select.
+					cExtern += "#define c_select select\n"
+				}
+				cExtern += fmt.Sprintf("%s %s", cRettype, sysname)
+				cIn := strings.Join(cIn, ", ")
+				cExtern += fmt.Sprintf("(%s);\n", cIn)
+			}
+			// GC Library name
+			if modname == "" {
+				modname = "libc.a/shr_64.o"
+			} else {
+				fmt.Fprintf(os.Stderr, "%s: only syscall using libc are available\n", funct)
+				os.Exit(1)
+			}
+			sysvarname := fmt.Sprintf("libc_%s", sysname)
+
+			if !onlyCommon {
+				// GC Runtime import of function to allow cross-platform builds.
+				dynimports += fmt.Sprintf("//go:cgo_import_dynamic %s %s \"%s\"\n", sysvarname, sysname, modname)
+				// GC Link symbol to proc address variable.
+				linknames += fmt.Sprintf("//go:linkname %s %s\n", sysvarname, sysvarname)
+				// GC Library proc address variable.
+				vars = append(vars, sysvarname)
+			}
+
+			strconvfunc := "BytePtrFromString"
+			strconvtype := "*byte"
+
+			// Go function header.
+			if outps != "" {
+				outps = fmt.Sprintf(" (%s)", outps)
+			}
+			if textcommon != "" {
+				textcommon += "\n"
+			}
+
+			textcommon += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outps)
+
+			// Prepare arguments tocall.
+			var argscommon []string // Arguments in the common part
+			var argscall []string   // Arguments for call prototype
+			var argsgc []string     // Arguments for gc call (with syscall6)
+			var argsgccgo []string  // Arguments for gccgo call (with C.name_of_syscall)
+			n := 0
+			argN := 0
+			for _, param := range in {
+				p := parseParam(param)
+				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
+					argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(%s))", p.Name))
+					argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
+					argsgc = append(argsgc, p.Name)
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
+				} else if p.Type == "string" && errvar != "" {
+					textcommon += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
+					textcommon += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
+					textcommon += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
+
+					argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
+					argscall = append(argscall, fmt.Sprintf("_p%d uintptr ", n))
+					argsgc = append(argsgc, fmt.Sprintf("_p%d", n))
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n))
+					n++
+				} else if p.Type == "string" {
+					fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
+					textcommon += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
+					textcommon += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
+					textcommon += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
+
+					argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
+					argscall = append(argscall, fmt.Sprintf("_p%d uintptr", n))
+					argsgc = append(argsgc, fmt.Sprintf("_p%d", n))
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n))
+					n++
+				} else if m := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); m != nil {
+					// Convert slice into pointer, length.
+					// Have to be careful not to take address of &a[0] if len == 0:
+					// pass nil in that case.
+					textcommon += fmt.Sprintf("\tvar _p%d *%s\n", n, m[1])
+					textcommon += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
+					argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n), fmt.Sprintf("len(%s)", p.Name))
+					argscall = append(argscall, fmt.Sprintf("_p%d uintptr", n), fmt.Sprintf("_lenp%d int", n))
+					argsgc = append(argsgc, fmt.Sprintf("_p%d", n), fmt.Sprintf("uintptr(_lenp%d)", n))
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n), fmt.Sprintf("C.size_t(_lenp%d)", n))
+					n++
+				} else if p.Type == "int64" && endianness != "" {
+					fmt.Fprintf(os.Stderr, path+":"+funct+" uses int64 with 32 bits mode. Case not yet implemented\n")
+				} else if p.Type == "bool" {
+					fmt.Fprintf(os.Stderr, path+":"+funct+" uses bool. Case not yet implemented\n")
+				} else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil || p.Type == "unsafe.Pointer" {
+					argscommon = append(argscommon, fmt.Sprintf("uintptr(%s)", p.Name))
+					argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
+					argsgc = append(argsgc, p.Name)
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
+				} else if p.Type == "int" {
+					if (argN == 0 || argN == 2) && ((funct == "fcntl") || (funct == "FcntlInt") || (funct == "FcntlFlock")) {
+						// These fcntl arguments need to be uintptr to be able to call FcntlInt and FcntlFlock
+						argscommon = append(argscommon, fmt.Sprintf("uintptr(%s)", p.Name))
+						argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
+						argsgc = append(argsgc, p.Name)
+						argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
+
+					} else {
+						argscommon = append(argscommon, p.Name)
+						argscall = append(argscall, fmt.Sprintf("%s int", p.Name))
+						argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
+						argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
+					}
+				} else if p.Type == "int32" {
+					argscommon = append(argscommon, p.Name)
+					argscall = append(argscall, fmt.Sprintf("%s int32", p.Name))
+					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
+				} else if p.Type == "int64" {
+					argscommon = append(argscommon, p.Name)
+					argscall = append(argscall, fmt.Sprintf("%s int64", p.Name))
+					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.longlong(%s)", p.Name))
+				} else if p.Type == "uint32" {
+					argscommon = append(argscommon, p.Name)
+					argscall = append(argscall, fmt.Sprintf("%s uint32", p.Name))
+					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uint(%s)", p.Name))
+				} else if p.Type == "uint64" {
+					argscommon = append(argscommon, p.Name)
+					argscall = append(argscall, fmt.Sprintf("%s uint64", p.Name))
+					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.ulonglong(%s)", p.Name))
+				} else if p.Type == "uintptr" {
+					argscommon = append(argscommon, p.Name)
+					argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
+					argsgc = append(argsgc, p.Name)
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
+				} else {
+					argscommon = append(argscommon, fmt.Sprintf("int(%s)", p.Name))
+					argscall = append(argscall, fmt.Sprintf("%s int", p.Name))
+					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
+					argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
+				}
+				argN++
+			}
+			nargs := len(argsgc)
+
+			// COMMON function generation
+			argscommonlist := strings.Join(argscommon, ", ")
+			callcommon := fmt.Sprintf("call%s(%s)", sysname, argscommonlist)
+			ret := []string{"_", "_"}
+			body := ""
+			doErrno := false
+			for i := 0; i < len(out); i++ {
+				p := parseParam(out[i])
+				reg := ""
+				if p.Name == "err" {
+					reg = "e1"
+					ret[1] = reg
+					doErrno = true
+				} else {
+					reg = "r0"
+					ret[0] = reg
+				}
+				if p.Type == "bool" {
+					reg = fmt.Sprintf("%s != 0", reg)
+				}
+				if reg != "e1" {
+					body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
+				}
+			}
+			if ret[0] == "_" && ret[1] == "_" {
+				textcommon += fmt.Sprintf("\t%s\n", callcommon)
+			} else {
+				textcommon += fmt.Sprintf("\t%s, %s := %s\n", ret[0], ret[1], callcommon)
+			}
+			textcommon += body
+
+			if doErrno {
+				textcommon += "\tif e1 != 0 {\n"
+				textcommon += "\t\terr = errnoErr(e1)\n"
+				textcommon += "\t}\n"
+			}
+			textcommon += "\treturn\n"
+			textcommon += "}\n"
+
+			if onlyCommon {
+				continue
+			}
+
+			// CALL Prototype
+			callProto := fmt.Sprintf("func call%s(%s) (r1 uintptr, e1 Errno) {\n", sysname, strings.Join(argscall, ", "))
+
+			// GC function generation
+			asm := "syscall6"
+			if nonblock != nil {
+				asm = "rawSyscall6"
+			}
+
+			if len(argsgc) <= 6 {
+				for len(argsgc) < 6 {
+					argsgc = append(argsgc, "0")
+				}
+			} else {
+				fmt.Fprintf(os.Stderr, "%s: too many arguments to system call", funct)
+				os.Exit(1)
+			}
+			argsgclist := strings.Join(argsgc, ", ")
+			callgc := fmt.Sprintf("%s(uintptr(unsafe.Pointer(&%s)), %d, %s)", asm, sysvarname, nargs, argsgclist)
+
+			textgc += callProto
+			textgc += fmt.Sprintf("\tr1, _, e1 = %s\n", callgc)
+			textgc += "\treturn\n}\n"
+
+			// GCCGO function generation
+			argsgccgolist := strings.Join(argsgccgo, ", ")
+			var callgccgo string
+			if sysname == "select" {
+				// select is a keyword of Go. Its name is
+				// changed to c_select.
+				callgccgo = fmt.Sprintf("C.c_%s(%s)", sysname, argsgccgolist)
+			} else {
+				callgccgo = fmt.Sprintf("C.%s(%s)", sysname, argsgccgolist)
+			}
+			textgccgo += callProto
+			textgccgo += fmt.Sprintf("\tr1 = uintptr(%s)\n", callgccgo)
+			textgccgo += "\te1 = syscall.GetErrno()\n"
+			textgccgo += "\treturn\n}\n"
+		}
+		if err := s.Err(); err != nil {
+			fmt.Fprintf(os.Stderr, err.Error())
+			os.Exit(1)
+		}
+		file.Close()
+	}
+	imp := ""
+	if pack != "unix" {
+		imp = "import \"golang.org/x/sys/unix\"\n"
+
+	}
+
+	// Print zsyscall_aix_ppc64.go
+	err := ioutil.WriteFile("zsyscall_aix_ppc64.go",
+		[]byte(fmt.Sprintf(srcTemplate1, cmdLine(), buildTags(), pack, imp, textcommon)),
+		0644)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, err.Error())
+		os.Exit(1)
+	}
+
+	// Print zsyscall_aix_ppc64_gc.go
+	vardecls := "\t" + strings.Join(vars, ",\n\t")
+	vardecls += " syscallFunc"
+	err = ioutil.WriteFile("zsyscall_aix_ppc64_gc.go",
+		[]byte(fmt.Sprintf(srcTemplate2, cmdLine(), buildTags(), pack, imp, dynimports, linknames, vardecls, textgc)),
+		0644)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, err.Error())
+		os.Exit(1)
+	}
+
+	// Print zsyscall_aix_ppc64_gccgo.go
+	err = ioutil.WriteFile("zsyscall_aix_ppc64_gccgo.go",
+		[]byte(fmt.Sprintf(srcTemplate3, cmdLine(), buildTags(), pack, cExtern, imp, textgccgo)),
+		0644)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, err.Error())
+		os.Exit(1)
+	}
+}
+
+const srcTemplate1 = `// %s
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build %s
+
+package %s
+
+import (
+	"unsafe"
+)
+
+
+%s
+
+%s
+`
+const srcTemplate2 = `// %s
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build %s
+// +build !gccgo
+
+package %s
+
+import (
+	"unsafe"
+)
+%s
+%s
+%s
+type syscallFunc uintptr
+
+var (
+%s
+)
+
+// Implemented in runtime/syscall_aix.go.
+func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+
+%s
+`
+const srcTemplate3 = `// %s
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build %s
+// +build gccgo
+
+package %s
+
+%s
+*/
+import "C"
+import (
+	"syscall"
+)
+
+
+%s
+
+%s
+`
diff --git a/vendor/golang.org/x/sys/unix/mksyscall_solaris.go b/vendor/golang.org/x/sys/unix/mksyscall_solaris.go
new file mode 100644
index 000000000..3d864738b
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/mksyscall_solaris.go
@@ -0,0 +1,335 @@
+// Copyright 2019 The Go 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 ignore
+
+/*
+ This program reads a file containing function prototypes
+ (like syscall_solaris.go) and generates system call bodies.
+ The prototypes are marked by lines beginning with "//sys"
+ and read like func declarations if //sys is replaced by func, but:
+	* The parameter lists must give a name for each argument.
+	  This includes return parameters.
+	* The parameter lists must give a type for each argument:
+	  the (x, y, z int) shorthand is not allowed.
+	* If the return parameter is an error number, it must be named err.
+	* If go func name needs to be different than its libc name,
+	* or the function is not in libc, name could be specified
+	* at the end, after "=" sign, like
+	  //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
+*/
+
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+)
+
+var (
+	b32  = flag.Bool("b32", false, "32bit big-endian")
+	l32  = flag.Bool("l32", false, "32bit little-endian")
+	tags = flag.String("tags", "", "build tags")
+)
+
+// cmdLine returns this programs's commandline arguments
+func cmdLine() string {
+	return "go run mksyscall_solaris.go " + strings.Join(os.Args[1:], " ")
+}
+
+// buildTags returns build tags
+func buildTags() string {
+	return *tags
+}
+
+// Param is function parameter
+type Param struct {
+	Name string
+	Type string
+}
+
+// usage prints the program usage
+func usage() {
+	fmt.Fprintf(os.Stderr, "usage: go run mksyscall_solaris.go [-b32 | -l32] [-tags x,y] [file ...]\n")
+	os.Exit(1)
+}
+
+// parseParamList parses parameter list and returns a slice of parameters
+func parseParamList(list string) []string {
+	list = strings.TrimSpace(list)
+	if list == "" {
+		return []string{}
+	}
+	return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
+}
+
+// parseParam splits a parameter into name and type
+func parseParam(p string) Param {
+	ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
+	if ps == nil {
+		fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
+		os.Exit(1)
+	}
+	return Param{ps[1], ps[2]}
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+	if len(flag.Args()) <= 0 {
+		fmt.Fprintf(os.Stderr, "no files to parse provided\n")
+		usage()
+	}
+
+	endianness := ""
+	if *b32 {
+		endianness = "big-endian"
+	} else if *l32 {
+		endianness = "little-endian"
+	}
+
+	pack := ""
+	text := ""
+	dynimports := ""
+	linknames := ""
+	var vars []string
+	for _, path := range flag.Args() {
+		file, err := os.Open(path)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, err.Error())
+			os.Exit(1)
+		}
+		s := bufio.NewScanner(file)
+		for s.Scan() {
+			t := s.Text()
+			t = strings.TrimSpace(t)
+			t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
+			if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
+				pack = p[1]
+			}
+			nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
+			if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
+				continue
+			}
+
+			// Line must be of the form
+			//	func Open(path string, mode int, perm int) (fd int, err error)
+			// Split into name, in params, out params.
+			f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
+			if f == nil {
+				fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
+				os.Exit(1)
+			}
+			funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
+
+			// Split argument lists on comma.
+			in := parseParamList(inps)
+			out := parseParamList(outps)
+
+			inps = strings.Join(in, ", ")
+			outps = strings.Join(out, ", ")
+
+			// Try in vain to keep people from editing this file.
+			// The theory is that they jump into the middle of the file
+			// without reading the header.
+			text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
+
+			// So file name.
+			if modname == "" {
+				modname = "libc"
+			}
+
+			// System call name.
+			if sysname == "" {
+				sysname = funct
+			}
+
+			// System call pointer variable name.
+			sysvarname := fmt.Sprintf("proc%s", sysname)
+
+			strconvfunc := "BytePtrFromString"
+			strconvtype := "*byte"
+
+			sysname = strings.ToLower(sysname) // All libc functions are lowercase.
+
+			// Runtime import of function to allow cross-platform builds.
+			dynimports += fmt.Sprintf("//go:cgo_import_dynamic libc_%s %s \"%s.so\"\n", sysname, sysname, modname)
+			// Link symbol to proc address variable.
+			linknames += fmt.Sprintf("//go:linkname %s libc_%s\n", sysvarname, sysname)
+			// Library proc address variable.
+			vars = append(vars, sysvarname)
+
+			// Go function header.
+			outlist := strings.Join(out, ", ")
+			if outlist != "" {
+				outlist = fmt.Sprintf(" (%s)", outlist)
+			}
+			if text != "" {
+				text += "\n"
+			}
+			text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outlist)
+
+			// Check if err return available
+			errvar := ""
+			for _, param := range out {
+				p := parseParam(param)
+				if p.Type == "error" {
+					errvar = p.Name
+					continue
+				}
+			}
+
+			// Prepare arguments to Syscall.
+			var args []string
+			n := 0
+			for _, param := range in {
+				p := parseParam(param)
+				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
+					args = append(args, "uintptr(unsafe.Pointer("+p.Name+"))")
+				} else if p.Type == "string" && errvar != "" {
+					text += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
+					text += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
+					text += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
+					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
+					n++
+				} else if p.Type == "string" {
+					fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
+					text += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
+					text += fmt.Sprintf("\t_p%d, _ = %s(%s)\n", n, strconvfunc, p.Name)
+					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
+					n++
+				} else if s := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); s != nil {
+					// Convert slice into pointer, length.
+					// Have to be careful not to take address of &a[0] if len == 0:
+					// pass nil in that case.
+					text += fmt.Sprintf("\tvar _p%d *%s\n", n, s[1])
+					text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
+					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n), fmt.Sprintf("uintptr(len(%s))", p.Name))
+					n++
+				} else if p.Type == "int64" && endianness != "" {
+					if endianness == "big-endian" {
+						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
+					} else {
+						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
+					}
+				} else if p.Type == "bool" {
+					text += fmt.Sprintf("\tvar _p%d uint32\n", n)
+					text += fmt.Sprintf("\tif %s {\n\t\t_p%d = 1\n\t} else {\n\t\t_p%d = 0\n\t}\n", p.Name, n, n)
+					args = append(args, fmt.Sprintf("uintptr(_p%d)", n))
+					n++
+				} else {
+					args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
+				}
+			}
+			nargs := len(args)
+
+			// Determine which form to use; pad args with zeros.
+			asm := "sysvicall6"
+			if nonblock != nil {
+				asm = "rawSysvicall6"
+			}
+			if len(args) <= 6 {
+				for len(args) < 6 {
+					args = append(args, "0")
+				}
+			} else {
+				fmt.Fprintf(os.Stderr, "%s: too many arguments to system call\n", path)
+				os.Exit(1)
+			}
+
+			// Actual call.
+			arglist := strings.Join(args, ", ")
+			call := fmt.Sprintf("%s(uintptr(unsafe.Pointer(&%s)), %d, %s)", asm, sysvarname, nargs, arglist)
+
+			// Assign return values.
+			body := ""
+			ret := []string{"_", "_", "_"}
+			doErrno := false
+			for i := 0; i < len(out); i++ {
+				p := parseParam(out[i])
+				reg := ""
+				if p.Name == "err" {
+					reg = "e1"
+					ret[2] = reg
+					doErrno = true
+				} else {
+					reg = fmt.Sprintf("r%d", i)
+					ret[i] = reg
+				}
+				if p.Type == "bool" {
+					reg = fmt.Sprintf("%d != 0", reg)
+				}
+				if p.Type == "int64" && endianness != "" {
+					// 64-bit number in r1:r0 or r0:r1.
+					if i+2 > len(out) {
+						fmt.Fprintf(os.Stderr, "%s: not enough registers for int64 return\n", path)
+						os.Exit(1)
+					}
+					if endianness == "big-endian" {
+						reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i, i+1)
+					} else {
+						reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i+1, i)
+					}
+					ret[i] = fmt.Sprintf("r%d", i)
+					ret[i+1] = fmt.Sprintf("r%d", i+1)
+				}
+				if reg != "e1" {
+					body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
+				}
+			}
+			if ret[0] == "_" && ret[1] == "_" && ret[2] == "_" {
+				text += fmt.Sprintf("\t%s\n", call)
+			} else {
+				text += fmt.Sprintf("\t%s, %s, %s := %s\n", ret[0], ret[1], ret[2], call)
+			}
+			text += body
+
+			if doErrno {
+				text += "\tif e1 != 0 {\n"
+				text += "\t\terr = e1\n"
+				text += "\t}\n"
+			}
+			text += "\treturn\n"
+			text += "}\n"
+		}
+		if err := s.Err(); err != nil {
+			fmt.Fprintf(os.Stderr, err.Error())
+			os.Exit(1)
+		}
+		file.Close()
+	}
+	imp := ""
+	if pack != "unix" {
+		imp = "import \"golang.org/x/sys/unix\"\n"
+
+	}
+	vardecls := "\t" + strings.Join(vars, ",\n\t")
+	vardecls += " syscallFunc"
+	fmt.Printf(srcTemplate, cmdLine(), buildTags(), pack, imp, dynimports, linknames, vardecls, text)
+}
+
+const srcTemplate = `// %s
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build %s
+
+package %s
+
+import (
+	"syscall"
+	"unsafe"
+)
+%s
+%s
+%s
+var (
+%s	
+)
+
+%s
+`
diff --git a/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go b/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go
new file mode 100644
index 000000000..b6b409909
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go
@@ -0,0 +1,355 @@
+// Copyright 2019 The Go 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 ignore
+
+// Parse the header files for OpenBSD and generate a Go usable sysctl MIB.
+//
+// Build a MIB with each entry being an array containing the level, type and
+// a hash that will contain additional entries if the current entry is a node.
+// We then walk this MIB and create a flattened sysctl name to OID hash.
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+var (
+	goos, goarch string
+)
+
+// cmdLine returns this programs's commandline arguments.
+func cmdLine() string {
+	return "go run mksysctl_openbsd.go " + strings.Join(os.Args[1:], " ")
+}
+
+// buildTags returns build tags.
+func buildTags() string {
+	return fmt.Sprintf("%s,%s", goarch, goos)
+}
+
+// reMatch performs regular expression match and stores the substring slice to value pointed by m.
+func reMatch(re *regexp.Regexp, str string, m *[]string) bool {
+	*m = re.FindStringSubmatch(str)
+	if *m != nil {
+		return true
+	}
+	return false
+}
+
+type nodeElement struct {
+	n  int
+	t  string
+	pE *map[string]nodeElement
+}
+
+var (
+	debugEnabled bool
+	mib          map[string]nodeElement
+	node         *map[string]nodeElement
+	nodeMap      map[string]string
+	sysCtl       []string
+)
+
+var (
+	ctlNames1RE = regexp.MustCompile(`^#define\s+(CTL_NAMES)\s+{`)
+	ctlNames2RE = regexp.MustCompile(`^#define\s+(CTL_(.*)_NAMES)\s+{`)
+	ctlNames3RE = regexp.MustCompile(`^#define\s+((.*)CTL_NAMES)\s+{`)
+	netInetRE   = regexp.MustCompile(`^netinet/`)
+	netInet6RE  = regexp.MustCompile(`^netinet6/`)
+	netRE       = regexp.MustCompile(`^net/`)
+	bracesRE    = regexp.MustCompile(`{.*}`)
+	ctlTypeRE   = regexp.MustCompile(`{\s+"(\w+)",\s+(CTLTYPE_[A-Z]+)\s+}`)
+	fsNetKernRE = regexp.MustCompile(`^(fs|net|kern)_`)
+)
+
+func debug(s string) {
+	if debugEnabled {
+		fmt.Fprintln(os.Stderr, s)
+	}
+}
+
+// Walk the MIB and build a sysctl name to OID mapping.
+func buildSysctl(pNode *map[string]nodeElement, name string, oid []int) {
+	lNode := pNode // local copy of pointer to node
+	var keys []string
+	for k := range *lNode {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	for _, key := range keys {
+		nodename := name
+		if name != "" {
+			nodename += "."
+		}
+		nodename += key
+
+		nodeoid := append(oid, (*pNode)[key].n)
+
+		if (*pNode)[key].t == `CTLTYPE_NODE` {
+			if _, ok := nodeMap[nodename]; ok {
+				lNode = &mib
+				ctlName := nodeMap[nodename]
+				for _, part := range strings.Split(ctlName, ".") {
+					lNode = ((*lNode)[part]).pE
+				}
+			} else {
+				lNode = (*pNode)[key].pE
+			}
+			buildSysctl(lNode, nodename, nodeoid)
+		} else if (*pNode)[key].t != "" {
+			oidStr := []string{}
+			for j := range nodeoid {
+				oidStr = append(oidStr, fmt.Sprintf("%d", nodeoid[j]))
+			}
+			text := "\t{ \"" + nodename + "\", []_C_int{ " + strings.Join(oidStr, ", ") + " } }, \n"
+			sysCtl = append(sysCtl, text)
+		}
+	}
+}
+
+func main() {
+	// Get the OS (using GOOS_TARGET if it exist)
+	goos = os.Getenv("GOOS_TARGET")
+	if goos == "" {
+		goos = os.Getenv("GOOS")
+	}
+	// Get the architecture (using GOARCH_TARGET if it exists)
+	goarch = os.Getenv("GOARCH_TARGET")
+	if goarch == "" {
+		goarch = os.Getenv("GOARCH")
+	}
+	// Check if GOOS and GOARCH environment variables are defined
+	if goarch == "" || goos == "" {
+		fmt.Fprintf(os.Stderr, "GOARCH or GOOS not defined in environment\n")
+		os.Exit(1)
+	}
+
+	mib = make(map[string]nodeElement)
+	headers := [...]string{
+		`sys/sysctl.h`,
+		`sys/socket.h`,
+		`sys/tty.h`,
+		`sys/malloc.h`,
+		`sys/mount.h`,
+		`sys/namei.h`,
+		`sys/sem.h`,
+		`sys/shm.h`,
+		`sys/vmmeter.h`,
+		`uvm/uvmexp.h`,
+		`uvm/uvm_param.h`,
+		`uvm/uvm_swap_encrypt.h`,
+		`ddb/db_var.h`,
+		`net/if.h`,
+		`net/if_pfsync.h`,
+		`net/pipex.h`,
+		`netinet/in.h`,
+		`netinet/icmp_var.h`,
+		`netinet/igmp_var.h`,
+		`netinet/ip_ah.h`,
+		`netinet/ip_carp.h`,
+		`netinet/ip_divert.h`,
+		`netinet/ip_esp.h`,
+		`netinet/ip_ether.h`,
+		`netinet/ip_gre.h`,
+		`netinet/ip_ipcomp.h`,
+		`netinet/ip_ipip.h`,
+		`netinet/pim_var.h`,
+		`netinet/tcp_var.h`,
+		`netinet/udp_var.h`,
+		`netinet6/in6.h`,
+		`netinet6/ip6_divert.h`,
+		`netinet6/pim6_var.h`,
+		`netinet/icmp6.h`,
+		`netmpls/mpls.h`,
+	}
+
+	ctls := [...]string{
+		`kern`,
+		`vm`,
+		`fs`,
+		`net`,
+		//debug			/* Special handling required */
+		`hw`,
+		//machdep		/* Arch specific */
+		`user`,
+		`ddb`,
+		//vfs			/* Special handling required */
+		`fs.posix`,
+		`kern.forkstat`,
+		`kern.intrcnt`,
+		`kern.malloc`,
+		`kern.nchstats`,
+		`kern.seminfo`,
+		`kern.shminfo`,
+		`kern.timecounter`,
+		`kern.tty`,
+		`kern.watchdog`,
+		`net.bpf`,
+		`net.ifq`,
+		`net.inet`,
+		`net.inet.ah`,
+		`net.inet.carp`,
+		`net.inet.divert`,
+		`net.inet.esp`,
+		`net.inet.etherip`,
+		`net.inet.gre`,
+		`net.inet.icmp`,
+		`net.inet.igmp`,
+		`net.inet.ip`,
+		`net.inet.ip.ifq`,
+		`net.inet.ipcomp`,
+		`net.inet.ipip`,
+		`net.inet.mobileip`,
+		`net.inet.pfsync`,
+		`net.inet.pim`,
+		`net.inet.tcp`,
+		`net.inet.udp`,
+		`net.inet6`,
+		`net.inet6.divert`,
+		`net.inet6.ip6`,
+		`net.inet6.icmp6`,
+		`net.inet6.pim6`,
+		`net.inet6.tcp6`,
+		`net.inet6.udp6`,
+		`net.mpls`,
+		`net.mpls.ifq`,
+		`net.key`,
+		`net.pflow`,
+		`net.pfsync`,
+		`net.pipex`,
+		`net.rt`,
+		`vm.swapencrypt`,
+		//vfsgenctl		/* Special handling required */
+	}
+
+	// Node name "fixups"
+	ctlMap := map[string]string{
+		"ipproto":             "net.inet",
+		"net.inet.ipproto":    "net.inet",
+		"net.inet6.ipv6proto": "net.inet6",
+		"net.inet6.ipv6":      "net.inet6.ip6",
+		"net.inet.icmpv6":     "net.inet6.icmp6",
+		"net.inet6.divert6":   "net.inet6.divert",
+		"net.inet6.tcp6":      "net.inet.tcp",
+		"net.inet6.udp6":      "net.inet.udp",
+		"mpls":                "net.mpls",
+		"swpenc":              "vm.swapencrypt",
+	}
+
+	// Node mappings
+	nodeMap = map[string]string{
+		"net.inet.ip.ifq": "net.ifq",
+		"net.inet.pfsync": "net.pfsync",
+		"net.mpls.ifq":    "net.ifq",
+	}
+
+	mCtls := make(map[string]bool)
+	for _, ctl := range ctls {
+		mCtls[ctl] = true
+	}
+
+	for _, header := range headers {
+		debug("Processing " + header)
+		file, err := os.Open(filepath.Join("/usr/include", header))
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%v\n", err)
+			os.Exit(1)
+		}
+		s := bufio.NewScanner(file)
+		for s.Scan() {
+			var sub []string
+			if reMatch(ctlNames1RE, s.Text(), &sub) ||
+				reMatch(ctlNames2RE, s.Text(), &sub) ||
+				reMatch(ctlNames3RE, s.Text(), &sub) {
+				if sub[1] == `CTL_NAMES` {
+					// Top level.
+					node = &mib
+				} else {
+					// Node.
+					nodename := strings.ToLower(sub[2])
+					ctlName := ""
+					if reMatch(netInetRE, header, &sub) {
+						ctlName = "net.inet." + nodename
+					} else if reMatch(netInet6RE, header, &sub) {
+						ctlName = "net.inet6." + nodename
+					} else if reMatch(netRE, header, &sub) {
+						ctlName = "net." + nodename
+					} else {
+						ctlName = nodename
+						ctlName = fsNetKernRE.ReplaceAllString(ctlName, `$1.`)
+					}
+
+					if val, ok := ctlMap[ctlName]; ok {
+						ctlName = val
+					}
+					if _, ok := mCtls[ctlName]; !ok {
+						debug("Ignoring " + ctlName + "...")
+						continue
+					}
+
+					// Walk down from the top of the MIB.
+					node = &mib
+					for _, part := range strings.Split(ctlName, ".") {
+						if _, ok := (*node)[part]; !ok {
+							debug("Missing node " + part)
+							(*node)[part] = nodeElement{n: 0, t: "", pE: &map[string]nodeElement{}}
+						}
+						node = (*node)[part].pE
+					}
+				}
+
+				// Populate current node with entries.
+				i := -1
+				for !strings.HasPrefix(s.Text(), "}") {
+					s.Scan()
+					if reMatch(bracesRE, s.Text(), &sub) {
+						i++
+					}
+					if !reMatch(ctlTypeRE, s.Text(), &sub) {
+						continue
+					}
+					(*node)[sub[1]] = nodeElement{n: i, t: sub[2], pE: &map[string]nodeElement{}}
+				}
+			}
+		}
+		err = s.Err()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "%v\n", err)
+			os.Exit(1)
+		}
+		file.Close()
+	}
+	buildSysctl(&mib, "", []int{})
+
+	sort.Strings(sysCtl)
+	text := strings.Join(sysCtl, "")
+
+	fmt.Printf(srcTemplate, cmdLine(), buildTags(), text)
+}
+
+const srcTemplate = `// %s
+// Code generated by the command above; DO NOT EDIT.
+
+// +build %s
+
+package unix
+
+type mibentry struct {
+	ctlname string
+	ctloid []_C_int
+}
+
+var sysctlMib = []mibentry {
+%s
+}
+`
diff --git a/vendor/golang.org/x/sys/unix/mksysnum.go b/vendor/golang.org/x/sys/unix/mksysnum.go
new file mode 100644
index 000000000..baa6ecd85
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/mksysnum.go
@@ -0,0 +1,190 @@
+// Copyright 2018 The Go 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 ignore
+
+// Generate system call table for DragonFly, NetBSD,
+// FreeBSD, OpenBSD or Darwin from master list
+// (for example, /usr/src/sys/kern/syscalls.master or
+// sys/syscall.h).
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+)
+
+var (
+	goos, goarch string
+)
+
+// cmdLine returns this programs's commandline arguments
+func cmdLine() string {
+	return "go run mksysnum.go " + strings.Join(os.Args[1:], " ")
+}
+
+// buildTags returns build tags
+func buildTags() string {
+	return fmt.Sprintf("%s,%s", goarch, goos)
+}
+
+func checkErr(err error) {
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+		os.Exit(1)
+	}
+}
+
+// source string and substring slice for regexp
+type re struct {
+	str string   // source string
+	sub []string // matched sub-string
+}
+
+// Match performs regular expression match
+func (r *re) Match(exp string) bool {
+	r.sub = regexp.MustCompile(exp).FindStringSubmatch(r.str)
+	if r.sub != nil {
+		return true
+	}
+	return false
+}
+
+// fetchFile fetches a text file from URL
+func fetchFile(URL string) io.Reader {
+	resp, err := http.Get(URL)
+	checkErr(err)
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	checkErr(err)
+	return strings.NewReader(string(body))
+}
+
+// readFile reads a text file from path
+func readFile(path string) io.Reader {
+	file, err := os.Open(os.Args[1])
+	checkErr(err)
+	return file
+}
+
+func format(name, num, proto string) string {
+	name = strings.ToUpper(name)
+	// There are multiple entries for enosys and nosys, so comment them out.
+	nm := re{str: name}
+	if nm.Match(`^SYS_E?NOSYS$`) {
+		name = fmt.Sprintf("// %s", name)
+	}
+	if name == `SYS_SYS_EXIT` {
+		name = `SYS_EXIT`
+	}
+	return fmt.Sprintf("	%s = %s;  // %s\n", name, num, proto)
+}
+
+func main() {
+	// Get the OS (using GOOS_TARGET if it exist)
+	goos = os.Getenv("GOOS_TARGET")
+	if goos == "" {
+		goos = os.Getenv("GOOS")
+	}
+	// Get the architecture (using GOARCH_TARGET if it exists)
+	goarch = os.Getenv("GOARCH_TARGET")
+	if goarch == "" {
+		goarch = os.Getenv("GOARCH")
+	}
+	// Check if GOOS and GOARCH environment variables are defined
+	if goarch == "" || goos == "" {
+		fmt.Fprintf(os.Stderr, "GOARCH or GOOS not defined in environment\n")
+		os.Exit(1)
+	}
+
+	file := strings.TrimSpace(os.Args[1])
+	var syscalls io.Reader
+	if strings.HasPrefix(file, "https://") || strings.HasPrefix(file, "http://") {
+		// Download syscalls.master file
+		syscalls = fetchFile(file)
+	} else {
+		syscalls = readFile(file)
+	}
+
+	var text, line string
+	s := bufio.NewScanner(syscalls)
+	for s.Scan() {
+		t := re{str: line}
+		if t.Match(`^(.*)\\$`) {
+			// Handle continuation
+			line = t.sub[1]
+			line += strings.TrimLeft(s.Text(), " \t")
+		} else {
+			// New line
+			line = s.Text()
+		}
+		t = re{str: line}
+		if t.Match(`\\$`) {
+			continue
+		}
+		t = re{str: line}
+
+		switch goos {
+		case "dragonfly":
+			if t.Match(`^([0-9]+)\s+STD\s+({ \S+\s+(\w+).*)$`) {
+				num, proto := t.sub[1], t.sub[2]
+				name := fmt.Sprintf("SYS_%s", t.sub[3])
+				text += format(name, num, proto)
+			}
+		case "freebsd":
+			if t.Match(`^([0-9]+)\s+\S+\s+(?:(?:NO)?STD|COMPAT10)\s+({ \S+\s+(\w+).*)$`) {
+				num, proto := t.sub[1], t.sub[2]
+				name := fmt.Sprintf("SYS_%s", t.sub[3])
+				text += format(name, num, proto)
+			}
+		case "openbsd":
+			if t.Match(`^([0-9]+)\s+STD\s+(NOLOCK\s+)?({ \S+\s+\*?(\w+).*)$`) {
+				num, proto, name := t.sub[1], t.sub[3], t.sub[4]
+				text += format(name, num, proto)
+			}
+		case "netbsd":
+			if t.Match(`^([0-9]+)\s+((STD)|(NOERR))\s+(RUMP\s+)?({\s+\S+\s*\*?\s*\|(\S+)\|(\S*)\|(\w+).*\s+})(\s+(\S+))?$`) {
+				num, proto, compat := t.sub[1], t.sub[6], t.sub[8]
+				name := t.sub[7] + "_" + t.sub[9]
+				if t.sub[11] != "" {
+					name = t.sub[7] + "_" + t.sub[11]
+				}
+				name = strings.ToUpper(name)
+				if compat == "" || compat == "13" || compat == "30" || compat == "50" {
+					text += fmt.Sprintf("	%s = %s;  // %s\n", name, num, proto)
+				}
+			}
+		case "darwin":
+			if t.Match(`^#define\s+SYS_(\w+)\s+([0-9]+)`) {
+				name, num := t.sub[1], t.sub[2]
+				name = strings.ToUpper(name)
+				text += fmt.Sprintf("	SYS_%s = %s;\n", name, num)
+			}
+		default:
+			fmt.Fprintf(os.Stderr, "unrecognized GOOS=%s\n", goos)
+			os.Exit(1)
+
+		}
+	}
+	err := s.Err()
+	checkErr(err)
+
+	fmt.Printf(template, cmdLine(), buildTags(), text)
+}
+
+const template = `// %s
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build %s
+
+package unix
+
+const(
+%s)`
diff --git a/vendor/golang.org/x/sys/unix/types_aix.go b/vendor/golang.org/x/sys/unix/types_aix.go
new file mode 100644
index 000000000..40d2beede
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/types_aix.go
@@ -0,0 +1,237 @@
+// Copyright 2018 The Go 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 ignore
+// +build aix
+
+/*
+Input to cgo -godefs.  See also mkerrors.sh and mkall.sh
+*/
+
+// +godefs map struct_in_addr [4]byte /* in_addr */
+// +godefs map struct_in6_addr [16]byte /* in6_addr */
+
+package unix
+
+/*
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/limits.h>
+#include <sys/un.h>
+#include <utime.h>
+#include <sys/utsname.h>
+#include <sys/poll.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
+#include <sys/termio.h>
+#include <sys/ioctl.h>
+
+#include <termios.h>
+
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <netinet/in.h>
+#include <netinet/icmp6.h>
+
+
+#include <dirent.h>
+#include <fcntl.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+union sockaddr_all {
+	struct sockaddr s1;     // this one gets used for fields
+	struct sockaddr_in s2;  // these pad it out
+	struct sockaddr_in6 s3;
+	struct sockaddr_un s4;
+	struct sockaddr_dl s5;
+};
+
+struct sockaddr_any {
+	struct sockaddr addr;
+	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
+};
+
+*/
+import "C"
+
+// Machine characteristics
+
+const (
+	SizeofPtr      = C.sizeofPtr
+	SizeofShort    = C.sizeof_short
+	SizeofInt      = C.sizeof_int
+	SizeofLong     = C.sizeof_long
+	SizeofLongLong = C.sizeof_longlong
+	PathMax        = C.PATH_MAX
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+type off64 C.off64_t
+type off C.off_t
+type Mode_t C.mode_t
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+type Timeval32 C.struct_timeval32
+
+type Timex C.struct_timex
+
+type Time_t C.time_t
+
+type Tms C.struct_tms
+
+type Utimbuf C.struct_utimbuf
+
+type Timezone C.struct_timezone
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit64
+
+type Pid_t C.pid_t
+
+type _Gid_t C.gid_t
+
+type dev_t C.dev_t
+
+// Files
+
+type Stat_t C.struct_stat
+
+type StatxTimestamp C.struct_statx_timestamp
+
+type Statx_t C.struct_statx
+
+type Dirent C.struct_dirent
+
+// Sockets
+
+type RawSockaddrInet4 C.struct_sockaddr_in
+
+type RawSockaddrInet6 C.struct_sockaddr_in6
+
+type RawSockaddrUnix C.struct_sockaddr_un
+
+type RawSockaddrDatalink C.struct_sockaddr_dl
+
+type RawSockaddr C.struct_sockaddr
+
+type RawSockaddrAny C.struct_sockaddr_any
+
+type _Socklen C.socklen_t
+
+type Cmsghdr C.struct_cmsghdr
+
+type ICMPv6Filter C.struct_icmp6_filter
+
+type Iovec C.struct_iovec
+
+type IPMreq C.struct_ip_mreq
+
+type IPv6Mreq C.struct_ipv6_mreq
+
+type IPv6MTUInfo C.struct_ip6_mtuinfo
+
+type Linger C.struct_linger
+
+type Msghdr C.struct_msghdr
+
+const (
+	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
+	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
+	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
+	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
+	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
+	SizeofLinger           = C.sizeof_struct_linger
+	SizeofIPMreq           = C.sizeof_struct_ip_mreq
+	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
+	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
+	SizeofMsghdr           = C.sizeof_struct_msghdr
+	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
+	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
+)
+
+// Routing and interface messages
+
+const (
+	SizeofIfMsghdr = C.sizeof_struct_if_msghdr
+)
+
+type IfMsgHdr C.struct_if_msghdr
+
+// Misc
+
+type FdSet C.fd_set
+
+type Utsname C.struct_utsname
+
+type Ustat_t C.struct_ustat
+
+type Sigset_t C.sigset_t
+
+const (
+	AT_FDCWD            = C.AT_FDCWD
+	AT_REMOVEDIR        = C.AT_REMOVEDIR
+	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
+)
+
+// Terminal handling
+
+type Termios C.struct_termios
+
+type Termio C.struct_termio
+
+type Winsize C.struct_winsize
+
+//poll
+
+type PollFd struct {
+	Fd      int32
+	Events  uint16
+	Revents uint16
+}
+
+const (
+	POLLERR    = C.POLLERR
+	POLLHUP    = C.POLLHUP
+	POLLIN     = C.POLLIN
+	POLLNVAL   = C.POLLNVAL
+	POLLOUT    = C.POLLOUT
+	POLLPRI    = C.POLLPRI
+	POLLRDBAND = C.POLLRDBAND
+	POLLRDNORM = C.POLLRDNORM
+	POLLWRBAND = C.POLLWRBAND
+	POLLWRNORM = C.POLLWRNORM
+)
+
+//flock_t
+
+type Flock_t C.struct_flock64
+
+// Statfs
+
+type Fsid_t C.struct_fsid_t
+type Fsid64_t C.struct_fsid64_t
+
+type Statfs_t C.struct_statfs
+
+const RNDGETENTCNT = 0x80045200
diff --git a/vendor/golang.org/x/sys/unix/types_darwin.go b/vendor/golang.org/x/sys/unix/types_darwin.go
new file mode 100644
index 000000000..155c2e692
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/types_darwin.go
@@ -0,0 +1,283 @@
+// Copyright 2009 The Go 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 ignore
+
+/*
+Input to cgo -godefs.  See README.md
+*/
+
+// +godefs map struct_in_addr [4]byte /* in_addr */
+// +godefs map struct_in6_addr [16]byte /* in6_addr */
+
+package unix
+
+/*
+#define __DARWIN_UNIX03 0
+#define KERNEL
+#define _DARWIN_USE_64_BIT_INODE
+#include <dirent.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <termios.h>
+#include <unistd.h>
+#include <mach/mach.h>
+#include <mach/message.h>
+#include <sys/event.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/select.h>
+#include <sys/signal.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <sys/utsname.h>
+#include <sys/wait.h>
+#include <net/bpf.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/if_var.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <netinet/icmp6.h>
+#include <netinet/tcp.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+union sockaddr_all {
+	struct sockaddr s1;	// this one gets used for fields
+	struct sockaddr_in s2;	// these pad it out
+	struct sockaddr_in6 s3;
+	struct sockaddr_un s4;
+	struct sockaddr_dl s5;
+};
+
+struct sockaddr_any {
+	struct sockaddr addr;
+	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
+};
+
+*/
+import "C"
+
+// Machine characteristics
+
+const (
+	SizeofPtr      = C.sizeofPtr
+	SizeofShort    = C.sizeof_short
+	SizeofInt      = C.sizeof_int
+	SizeofLong     = C.sizeof_long
+	SizeofLongLong = C.sizeof_longlong
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+type Timeval32 C.struct_timeval32
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type _Gid_t C.gid_t
+
+// Files
+
+type Stat_t C.struct_stat64
+
+type Statfs_t C.struct_statfs64
+
+type Flock_t C.struct_flock
+
+type Fstore_t C.struct_fstore
+
+type Radvisory_t C.struct_radvisory
+
+type Fbootstraptransfer_t C.struct_fbootstraptransfer
+
+type Log2phys_t C.struct_log2phys
+
+type Fsid C.struct_fsid
+
+type Dirent C.struct_dirent
+
+// Sockets
+
+type RawSockaddrInet4 C.struct_sockaddr_in
+
+type RawSockaddrInet6 C.struct_sockaddr_in6
+
+type RawSockaddrUnix C.struct_sockaddr_un
+
+type RawSockaddrDatalink C.struct_sockaddr_dl
+
+type RawSockaddr C.struct_sockaddr
+
+type RawSockaddrAny C.struct_sockaddr_any
+
+type _Socklen C.socklen_t
+
+type Linger C.struct_linger
+
+type Iovec C.struct_iovec
+
+type IPMreq C.struct_ip_mreq
+
+type IPv6Mreq C.struct_ipv6_mreq
+
+type Msghdr C.struct_msghdr
+
+type Cmsghdr C.struct_cmsghdr
+
+type Inet4Pktinfo C.struct_in_pktinfo
+
+type Inet6Pktinfo C.struct_in6_pktinfo
+
+type IPv6MTUInfo C.struct_ip6_mtuinfo
+
+type ICMPv6Filter C.struct_icmp6_filter
+
+const (
+	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
+	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
+	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
+	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
+	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
+	SizeofLinger           = C.sizeof_struct_linger
+	SizeofIPMreq           = C.sizeof_struct_ip_mreq
+	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
+	SizeofMsghdr           = C.sizeof_struct_msghdr
+	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
+	SizeofInet4Pktinfo     = C.sizeof_struct_in_pktinfo
+	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
+	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
+	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
+)
+
+// Ptrace requests
+
+const (
+	PTRACE_TRACEME = C.PT_TRACE_ME
+	PTRACE_CONT    = C.PT_CONTINUE
+	PTRACE_KILL    = C.PT_KILL
+)
+
+// Events (kqueue, kevent)
+
+type Kevent_t C.struct_kevent
+
+// Select
+
+type FdSet C.fd_set
+
+// Routing and interface messages
+
+const (
+	SizeofIfMsghdr    = C.sizeof_struct_if_msghdr
+	SizeofIfData      = C.sizeof_struct_if_data
+	SizeofIfaMsghdr   = C.sizeof_struct_ifa_msghdr
+	SizeofIfmaMsghdr  = C.sizeof_struct_ifma_msghdr
+	SizeofIfmaMsghdr2 = C.sizeof_struct_ifma_msghdr2
+	SizeofRtMsghdr    = C.sizeof_struct_rt_msghdr
+	SizeofRtMetrics   = C.sizeof_struct_rt_metrics
+)
+
+type IfMsghdr C.struct_if_msghdr
+
+type IfData C.struct_if_data
+
+type IfaMsghdr C.struct_ifa_msghdr
+
+type IfmaMsghdr C.struct_ifma_msghdr
+
+type IfmaMsghdr2 C.struct_ifma_msghdr2
+
+type RtMsghdr C.struct_rt_msghdr
+
+type RtMetrics C.struct_rt_metrics
+
+// Berkeley packet filter
+
+const (
+	SizeofBpfVersion = C.sizeof_struct_bpf_version
+	SizeofBpfStat    = C.sizeof_struct_bpf_stat
+	SizeofBpfProgram = C.sizeof_struct_bpf_program
+	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
+	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
+)
+
+type BpfVersion C.struct_bpf_version
+
+type BpfStat C.struct_bpf_stat
+
+type BpfProgram C.struct_bpf_program
+
+type BpfInsn C.struct_bpf_insn
+
+type BpfHdr C.struct_bpf_hdr
+
+// Terminal handling
+
+type Termios C.struct_termios
+
+type Winsize C.struct_winsize
+
+// fchmodat-like syscalls.
+
+const (
+	AT_FDCWD            = C.AT_FDCWD
+	AT_REMOVEDIR        = C.AT_REMOVEDIR
+	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
+	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
+)
+
+// poll
+
+type PollFd C.struct_pollfd
+
+const (
+	POLLERR    = C.POLLERR
+	POLLHUP    = C.POLLHUP
+	POLLIN     = C.POLLIN
+	POLLNVAL   = C.POLLNVAL
+	POLLOUT    = C.POLLOUT
+	POLLPRI    = C.POLLPRI
+	POLLRDBAND = C.POLLRDBAND
+	POLLRDNORM = C.POLLRDNORM
+	POLLWRBAND = C.POLLWRBAND
+	POLLWRNORM = C.POLLWRNORM
+)
+
+// uname
+
+type Utsname C.struct_utsname
+
+// Clockinfo
+
+const SizeofClockinfo = C.sizeof_struct_clockinfo
+
+type Clockinfo C.struct_clockinfo
diff --git a/vendor/golang.org/x/sys/unix/types_dragonfly.go b/vendor/golang.org/x/sys/unix/types_dragonfly.go
new file mode 100644
index 000000000..3365dd79d
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/types_dragonfly.go
@@ -0,0 +1,263 @@
+// Copyright 2009 The Go 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 ignore
+
+/*
+Input to cgo -godefs.  See README.md
+*/
+
+// +godefs map struct_in_addr [4]byte /* in_addr */
+// +godefs map struct_in6_addr [16]byte /* in6_addr */
+
+package unix
+
+/*
+#define KERNEL
+#include <dirent.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <termios.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/event.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/select.h>
+#include <sys/signal.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <sys/utsname.h>
+#include <sys/wait.h>
+#include <net/bpf.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <netinet/icmp6.h>
+#include <netinet/tcp.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+union sockaddr_all {
+	struct sockaddr s1;	// this one gets used for fields
+	struct sockaddr_in s2;	// these pad it out
+	struct sockaddr_in6 s3;
+	struct sockaddr_un s4;
+	struct sockaddr_dl s5;
+};
+
+struct sockaddr_any {
+	struct sockaddr addr;
+	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
+};
+
+*/
+import "C"
+
+// Machine characteristics
+
+const (
+	SizeofPtr      = C.sizeofPtr
+	SizeofShort    = C.sizeof_short
+	SizeofInt      = C.sizeof_int
+	SizeofLong     = C.sizeof_long
+	SizeofLongLong = C.sizeof_longlong
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type _Gid_t C.gid_t
+
+// Files
+
+type Stat_t C.struct_stat
+
+type Statfs_t C.struct_statfs
+
+type Flock_t C.struct_flock
+
+type Dirent C.struct_dirent
+
+type Fsid C.struct_fsid
+
+// File system limits
+
+const (
+	PathMax = C.PATH_MAX
+)
+
+// Sockets
+
+type RawSockaddrInet4 C.struct_sockaddr_in
+
+type RawSockaddrInet6 C.struct_sockaddr_in6
+
+type RawSockaddrUnix C.struct_sockaddr_un
+
+type RawSockaddrDatalink C.struct_sockaddr_dl
+
+type RawSockaddr C.struct_sockaddr
+
+type RawSockaddrAny C.struct_sockaddr_any
+
+type _Socklen C.socklen_t
+
+type Linger C.struct_linger
+
+type Iovec C.struct_iovec
+
+type IPMreq C.struct_ip_mreq
+
+type IPv6Mreq C.struct_ipv6_mreq
+
+type Msghdr C.struct_msghdr
+
+type Cmsghdr C.struct_cmsghdr
+
+type Inet6Pktinfo C.struct_in6_pktinfo
+
+type IPv6MTUInfo C.struct_ip6_mtuinfo
+
+type ICMPv6Filter C.struct_icmp6_filter
+
+const (
+	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
+	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
+	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
+	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
+	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
+	SizeofLinger           = C.sizeof_struct_linger
+	SizeofIPMreq           = C.sizeof_struct_ip_mreq
+	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
+	SizeofMsghdr           = C.sizeof_struct_msghdr
+	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
+	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
+	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
+	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
+)
+
+// Ptrace requests
+
+const (
+	PTRACE_TRACEME = C.PT_TRACE_ME
+	PTRACE_CONT    = C.PT_CONTINUE
+	PTRACE_KILL    = C.PT_KILL
+)
+
+// Events (kqueue, kevent)
+
+type Kevent_t C.struct_kevent
+
+// Select
+
+type FdSet C.fd_set
+
+// Routing and interface messages
+
+const (
+	SizeofIfMsghdr         = C.sizeof_struct_if_msghdr
+	SizeofIfData           = C.sizeof_struct_if_data
+	SizeofIfaMsghdr        = C.sizeof_struct_ifa_msghdr
+	SizeofIfmaMsghdr       = C.sizeof_struct_ifma_msghdr
+	SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
+	SizeofRtMsghdr         = C.sizeof_struct_rt_msghdr
+	SizeofRtMetrics        = C.sizeof_struct_rt_metrics
+)
+
+type IfMsghdr C.struct_if_msghdr
+
+type IfData C.struct_if_data
+
+type IfaMsghdr C.struct_ifa_msghdr
+
+type IfmaMsghdr C.struct_ifma_msghdr
+
+type IfAnnounceMsghdr C.struct_if_announcemsghdr
+
+type RtMsghdr C.struct_rt_msghdr
+
+type RtMetrics C.struct_rt_metrics
+
+// Berkeley packet filter
+
+const (
+	SizeofBpfVersion = C.sizeof_struct_bpf_version
+	SizeofBpfStat    = C.sizeof_struct_bpf_stat
+	SizeofBpfProgram = C.sizeof_struct_bpf_program
+	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
+	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
+)
+
+type BpfVersion C.struct_bpf_version
+
+type BpfStat C.struct_bpf_stat
+
+type BpfProgram C.struct_bpf_program
+
+type BpfInsn C.struct_bpf_insn
+
+type BpfHdr C.struct_bpf_hdr
+
+// Terminal handling
+
+type Termios C.struct_termios
+
+type Winsize C.struct_winsize
+
+// fchmodat-like syscalls.
+
+const (
+	AT_FDCWD            = C.AT_FDCWD
+	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
+)
+
+// poll
+
+type PollFd C.struct_pollfd
+
+const (
+	POLLERR    = C.POLLERR
+	POLLHUP    = C.POLLHUP
+	POLLIN     = C.POLLIN
+	POLLNVAL   = C.POLLNVAL
+	POLLOUT    = C.POLLOUT
+	POLLPRI    = C.POLLPRI
+	POLLRDBAND = C.POLLRDBAND
+	POLLRDNORM = C.POLLRDNORM
+	POLLWRBAND = C.POLLWRBAND
+	POLLWRNORM = C.POLLWRNORM
+)
+
+// Uname
+
+type Utsname C.struct_utsname
diff --git a/vendor/golang.org/x/sys/unix/types_freebsd.go b/vendor/golang.org/x/sys/unix/types_freebsd.go
new file mode 100644
index 000000000..a121dc336
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/types_freebsd.go
@@ -0,0 +1,400 @@
+// Copyright 2009 The Go 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 ignore
+
+/*
+Input to cgo -godefs.  See README.md
+*/
+
+// +godefs map struct_in_addr [4]byte /* in_addr */
+// +godefs map struct_in6_addr [16]byte /* in6_addr */
+
+package unix
+
+/*
+#define	_WANT_FREEBSD11_STAT	1
+#define	_WANT_FREEBSD11_STATFS	1
+#define	_WANT_FREEBSD11_DIRENT	1
+#define	_WANT_FREEBSD11_KEVENT  1
+
+#include <dirent.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <termios.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/capsicum.h>
+#include <sys/event.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/select.h>
+#include <sys/signal.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <sys/utsname.h>
+#include <sys/wait.h>
+#include <net/bpf.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <netinet/icmp6.h>
+#include <netinet/tcp.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+union sockaddr_all {
+	struct sockaddr s1;	// this one gets used for fields
+	struct sockaddr_in s2;	// these pad it out
+	struct sockaddr_in6 s3;
+	struct sockaddr_un s4;
+	struct sockaddr_dl s5;
+};
+
+struct sockaddr_any {
+	struct sockaddr addr;
+	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
+};
+
+// This structure is a duplicate of if_data on FreeBSD 8-STABLE.
+// See /usr/include/net/if.h.
+struct if_data8 {
+	u_char  ifi_type;
+	u_char  ifi_physical;
+	u_char  ifi_addrlen;
+	u_char  ifi_hdrlen;
+	u_char  ifi_link_state;
+	u_char  ifi_spare_char1;
+	u_char  ifi_spare_char2;
+	u_char  ifi_datalen;
+	u_long  ifi_mtu;
+	u_long  ifi_metric;
+	u_long  ifi_baudrate;
+	u_long  ifi_ipackets;
+	u_long  ifi_ierrors;
+	u_long  ifi_opackets;
+	u_long  ifi_oerrors;
+	u_long  ifi_collisions;
+	u_long  ifi_ibytes;
+	u_long  ifi_obytes;
+	u_long  ifi_imcasts;
+	u_long  ifi_omcasts;
+	u_long  ifi_iqdrops;
+	u_long  ifi_noproto;
+	u_long  ifi_hwassist;
+// FIXME: these are now unions, so maybe need to change definitions?
+#undef ifi_epoch
+	time_t  ifi_epoch;
+#undef ifi_lastchange
+	struct  timeval ifi_lastchange;
+};
+
+// This structure is a duplicate of if_msghdr on FreeBSD 8-STABLE.
+// See /usr/include/net/if.h.
+struct if_msghdr8 {
+	u_short ifm_msglen;
+	u_char  ifm_version;
+	u_char  ifm_type;
+	int     ifm_addrs;
+	int     ifm_flags;
+	u_short ifm_index;
+	struct  if_data8 ifm_data;
+};
+*/
+import "C"
+
+// Machine characteristics
+
+const (
+	SizeofPtr      = C.sizeofPtr
+	SizeofShort    = C.sizeof_short
+	SizeofInt      = C.sizeof_int
+	SizeofLong     = C.sizeof_long
+	SizeofLongLong = C.sizeof_longlong
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type _Gid_t C.gid_t
+
+// Files
+
+const (
+	_statfsVersion = C.STATFS_VERSION
+	_dirblksiz     = C.DIRBLKSIZ
+)
+
+type Stat_t C.struct_stat
+
+type stat_freebsd11_t C.struct_freebsd11_stat
+
+type Statfs_t C.struct_statfs
+
+type statfs_freebsd11_t C.struct_freebsd11_statfs
+
+type Flock_t C.struct_flock
+
+type Dirent C.struct_dirent
+
+type dirent_freebsd11 C.struct_freebsd11_dirent
+
+type Fsid C.struct_fsid
+
+// File system limits
+
+const (
+	PathMax = C.PATH_MAX
+)
+
+// Advice to Fadvise
+
+const (
+	FADV_NORMAL     = C.POSIX_FADV_NORMAL
+	FADV_RANDOM     = C.POSIX_FADV_RANDOM
+	FADV_SEQUENTIAL = C.POSIX_FADV_SEQUENTIAL
+	FADV_WILLNEED   = C.POSIX_FADV_WILLNEED
+	FADV_DONTNEED   = C.POSIX_FADV_DONTNEED
+	FADV_NOREUSE    = C.POSIX_FADV_NOREUSE
+)
+
+// Sockets
+
+type RawSockaddrInet4 C.struct_sockaddr_in
+
+type RawSockaddrInet6 C.struct_sockaddr_in6
+
+type RawSockaddrUnix C.struct_sockaddr_un
+
+type RawSockaddrDatalink C.struct_sockaddr_dl
+
+type RawSockaddr C.struct_sockaddr
+
+type RawSockaddrAny C.struct_sockaddr_any
+
+type _Socklen C.socklen_t
+
+type Linger C.struct_linger
+
+type Iovec C.struct_iovec
+
+type IPMreq C.struct_ip_mreq
+
+type IPMreqn C.struct_ip_mreqn
+
+type IPv6Mreq C.struct_ipv6_mreq
+
+type Msghdr C.struct_msghdr
+
+type Cmsghdr C.struct_cmsghdr
+
+type Inet6Pktinfo C.struct_in6_pktinfo
+
+type IPv6MTUInfo C.struct_ip6_mtuinfo
+
+type ICMPv6Filter C.struct_icmp6_filter
+
+const (
+	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
+	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
+	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
+	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
+	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
+	SizeofLinger           = C.sizeof_struct_linger
+	SizeofIPMreq           = C.sizeof_struct_ip_mreq
+	SizeofIPMreqn          = C.sizeof_struct_ip_mreqn
+	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
+	SizeofMsghdr           = C.sizeof_struct_msghdr
+	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
+	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
+	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
+	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
+)
+
+// Ptrace requests
+
+const (
+	PTRACE_ATTACH     = C.PT_ATTACH
+	PTRACE_CONT       = C.PT_CONTINUE
+	PTRACE_DETACH     = C.PT_DETACH
+	PTRACE_GETFPREGS  = C.PT_GETFPREGS
+	PTRACE_GETFSBASE  = C.PT_GETFSBASE
+	PTRACE_GETLWPLIST = C.PT_GETLWPLIST
+	PTRACE_GETNUMLWPS = C.PT_GETNUMLWPS
+	PTRACE_GETREGS    = C.PT_GETREGS
+	PTRACE_GETXSTATE  = C.PT_GETXSTATE
+	PTRACE_IO         = C.PT_IO
+	PTRACE_KILL       = C.PT_KILL
+	PTRACE_LWPEVENTS  = C.PT_LWP_EVENTS
+	PTRACE_LWPINFO    = C.PT_LWPINFO
+	PTRACE_SETFPREGS  = C.PT_SETFPREGS
+	PTRACE_SETREGS    = C.PT_SETREGS
+	PTRACE_SINGLESTEP = C.PT_STEP
+	PTRACE_TRACEME    = C.PT_TRACE_ME
+)
+
+const (
+	PIOD_READ_D  = C.PIOD_READ_D
+	PIOD_WRITE_D = C.PIOD_WRITE_D
+	PIOD_READ_I  = C.PIOD_READ_I
+	PIOD_WRITE_I = C.PIOD_WRITE_I
+)
+
+const (
+	PL_FLAG_BORN   = C.PL_FLAG_BORN
+	PL_FLAG_EXITED = C.PL_FLAG_EXITED
+	PL_FLAG_SI     = C.PL_FLAG_SI
+)
+
+const (
+	TRAP_BRKPT = C.TRAP_BRKPT
+	TRAP_TRACE = C.TRAP_TRACE
+)
+
+type PtraceLwpInfoStruct C.struct_ptrace_lwpinfo
+
+type __Siginfo C.struct___siginfo
+
+type Sigset_t C.sigset_t
+
+type Reg C.struct_reg
+
+type FpReg C.struct_fpreg
+
+type PtraceIoDesc C.struct_ptrace_io_desc
+
+// Events (kqueue, kevent)
+
+type Kevent_t C.struct_kevent_freebsd11
+
+// Select
+
+type FdSet C.fd_set
+
+// Routing and interface messages
+
+const (
+	sizeofIfMsghdr         = C.sizeof_struct_if_msghdr
+	SizeofIfMsghdr         = C.sizeof_struct_if_msghdr8
+	sizeofIfData           = C.sizeof_struct_if_data
+	SizeofIfData           = C.sizeof_struct_if_data8
+	SizeofIfaMsghdr        = C.sizeof_struct_ifa_msghdr
+	SizeofIfmaMsghdr       = C.sizeof_struct_ifma_msghdr
+	SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
+	SizeofRtMsghdr         = C.sizeof_struct_rt_msghdr
+	SizeofRtMetrics        = C.sizeof_struct_rt_metrics
+)
+
+type ifMsghdr C.struct_if_msghdr
+
+type IfMsghdr C.struct_if_msghdr8
+
+type ifData C.struct_if_data
+
+type IfData C.struct_if_data8
+
+type IfaMsghdr C.struct_ifa_msghdr
+
+type IfmaMsghdr C.struct_ifma_msghdr
+
+type IfAnnounceMsghdr C.struct_if_announcemsghdr
+
+type RtMsghdr C.struct_rt_msghdr
+
+type RtMetrics C.struct_rt_metrics
+
+// Berkeley packet filter
+
+const (
+	SizeofBpfVersion    = C.sizeof_struct_bpf_version
+	SizeofBpfStat       = C.sizeof_struct_bpf_stat
+	SizeofBpfZbuf       = C.sizeof_struct_bpf_zbuf
+	SizeofBpfProgram    = C.sizeof_struct_bpf_program
+	SizeofBpfInsn       = C.sizeof_struct_bpf_insn
+	SizeofBpfHdr        = C.sizeof_struct_bpf_hdr
+	SizeofBpfZbufHeader = C.sizeof_struct_bpf_zbuf_header
+)
+
+type BpfVersion C.struct_bpf_version
+
+type BpfStat C.struct_bpf_stat
+
+type BpfZbuf C.struct_bpf_zbuf
+
+type BpfProgram C.struct_bpf_program
+
+type BpfInsn C.struct_bpf_insn
+
+type BpfHdr C.struct_bpf_hdr
+
+type BpfZbufHeader C.struct_bpf_zbuf_header
+
+// Terminal handling
+
+type Termios C.struct_termios
+
+type Winsize C.struct_winsize
+
+// fchmodat-like syscalls.
+
+const (
+	AT_FDCWD            = C.AT_FDCWD
+	AT_REMOVEDIR        = C.AT_REMOVEDIR
+	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
+	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
+)
+
+// poll
+
+type PollFd C.struct_pollfd
+
+const (
+	POLLERR      = C.POLLERR
+	POLLHUP      = C.POLLHUP
+	POLLIN       = C.POLLIN
+	POLLINIGNEOF = C.POLLINIGNEOF
+	POLLNVAL     = C.POLLNVAL
+	POLLOUT      = C.POLLOUT
+	POLLPRI      = C.POLLPRI
+	POLLRDBAND   = C.POLLRDBAND
+	POLLRDNORM   = C.POLLRDNORM
+	POLLWRBAND   = C.POLLWRBAND
+	POLLWRNORM   = C.POLLWRNORM
+)
+
+// Capabilities
+
+type CapRights C.struct_cap_rights
+
+// Uname
+
+type Utsname C.struct_utsname
diff --git a/vendor/golang.org/x/sys/unix/types_netbsd.go b/vendor/golang.org/x/sys/unix/types_netbsd.go
new file mode 100644
index 000000000..4a96d72c3
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/types_netbsd.go
@@ -0,0 +1,290 @@
+// Copyright 2009 The Go 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 ignore
+
+/*
+Input to cgo -godefs.  See README.md
+*/
+
+// +godefs map struct_in_addr [4]byte /* in_addr */
+// +godefs map struct_in6_addr [16]byte /* in6_addr */
+
+package unix
+
+/*
+#define KERNEL
+#include <dirent.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <termios.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/event.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/select.h>
+#include <sys/signal.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <sys/utsname.h>
+#include <sys/wait.h>
+#include <net/bpf.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <netinet/icmp6.h>
+#include <netinet/tcp.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+union sockaddr_all {
+	struct sockaddr s1;	// this one gets used for fields
+	struct sockaddr_in s2;	// these pad it out
+	struct sockaddr_in6 s3;
+	struct sockaddr_un s4;
+	struct sockaddr_dl s5;
+};
+
+struct sockaddr_any {
+	struct sockaddr addr;
+	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
+};
+
+*/
+import "C"
+
+// Machine characteristics
+
+const (
+	SizeofPtr      = C.sizeofPtr
+	SizeofShort    = C.sizeof_short
+	SizeofInt      = C.sizeof_int
+	SizeofLong     = C.sizeof_long
+	SizeofLongLong = C.sizeof_longlong
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type _Gid_t C.gid_t
+
+// Files
+
+type Stat_t C.struct_stat
+
+type Statfs_t C.struct_statfs
+
+type Flock_t C.struct_flock
+
+type Dirent C.struct_dirent
+
+type Fsid C.fsid_t
+
+// File system limits
+
+const (
+	PathMax = C.PATH_MAX
+)
+
+// Advice to Fadvise
+
+const (
+	FADV_NORMAL     = C.POSIX_FADV_NORMAL
+	FADV_RANDOM     = C.POSIX_FADV_RANDOM
+	FADV_SEQUENTIAL = C.POSIX_FADV_SEQUENTIAL
+	FADV_WILLNEED   = C.POSIX_FADV_WILLNEED
+	FADV_DONTNEED   = C.POSIX_FADV_DONTNEED
+	FADV_NOREUSE    = C.POSIX_FADV_NOREUSE
+)
+
+// Sockets
+
+type RawSockaddrInet4 C.struct_sockaddr_in
+
+type RawSockaddrInet6 C.struct_sockaddr_in6
+
+type RawSockaddrUnix C.struct_sockaddr_un
+
+type RawSockaddrDatalink C.struct_sockaddr_dl
+
+type RawSockaddr C.struct_sockaddr
+
+type RawSockaddrAny C.struct_sockaddr_any
+
+type _Socklen C.socklen_t
+
+type Linger C.struct_linger
+
+type Iovec C.struct_iovec
+
+type IPMreq C.struct_ip_mreq
+
+type IPv6Mreq C.struct_ipv6_mreq
+
+type Msghdr C.struct_msghdr
+
+type Cmsghdr C.struct_cmsghdr
+
+type Inet6Pktinfo C.struct_in6_pktinfo
+
+type IPv6MTUInfo C.struct_ip6_mtuinfo
+
+type ICMPv6Filter C.struct_icmp6_filter
+
+const (
+	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
+	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
+	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
+	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
+	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
+	SizeofLinger           = C.sizeof_struct_linger
+	SizeofIPMreq           = C.sizeof_struct_ip_mreq
+	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
+	SizeofMsghdr           = C.sizeof_struct_msghdr
+	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
+	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
+	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
+	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
+)
+
+// Ptrace requests
+
+const (
+	PTRACE_TRACEME = C.PT_TRACE_ME
+	PTRACE_CONT    = C.PT_CONTINUE
+	PTRACE_KILL    = C.PT_KILL
+)
+
+// Events (kqueue, kevent)
+
+type Kevent_t C.struct_kevent
+
+// Select
+
+type FdSet C.fd_set
+
+// Routing and interface messages
+
+const (
+	SizeofIfMsghdr         = C.sizeof_struct_if_msghdr
+	SizeofIfData           = C.sizeof_struct_if_data
+	SizeofIfaMsghdr        = C.sizeof_struct_ifa_msghdr
+	SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
+	SizeofRtMsghdr         = C.sizeof_struct_rt_msghdr
+	SizeofRtMetrics        = C.sizeof_struct_rt_metrics
+)
+
+type IfMsghdr C.struct_if_msghdr
+
+type IfData C.struct_if_data
+
+type IfaMsghdr C.struct_ifa_msghdr
+
+type IfAnnounceMsghdr C.struct_if_announcemsghdr
+
+type RtMsghdr C.struct_rt_msghdr
+
+type RtMetrics C.struct_rt_metrics
+
+type Mclpool C.struct_mclpool
+
+// Berkeley packet filter
+
+const (
+	SizeofBpfVersion = C.sizeof_struct_bpf_version
+	SizeofBpfStat    = C.sizeof_struct_bpf_stat
+	SizeofBpfProgram = C.sizeof_struct_bpf_program
+	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
+	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
+)
+
+type BpfVersion C.struct_bpf_version
+
+type BpfStat C.struct_bpf_stat
+
+type BpfProgram C.struct_bpf_program
+
+type BpfInsn C.struct_bpf_insn
+
+type BpfHdr C.struct_bpf_hdr
+
+type BpfTimeval C.struct_bpf_timeval
+
+// Terminal handling
+
+type Termios C.struct_termios
+
+type Winsize C.struct_winsize
+
+type Ptmget C.struct_ptmget
+
+// fchmodat-like syscalls.
+
+const (
+	AT_FDCWD            = C.AT_FDCWD
+	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
+	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
+)
+
+// poll
+
+type PollFd C.struct_pollfd
+
+const (
+	POLLERR    = C.POLLERR
+	POLLHUP    = C.POLLHUP
+	POLLIN     = C.POLLIN
+	POLLNVAL   = C.POLLNVAL
+	POLLOUT    = C.POLLOUT
+	POLLPRI    = C.POLLPRI
+	POLLRDBAND = C.POLLRDBAND
+	POLLRDNORM = C.POLLRDNORM
+	POLLWRBAND = C.POLLWRBAND
+	POLLWRNORM = C.POLLWRNORM
+)
+
+// Sysctl
+
+type Sysctlnode C.struct_sysctlnode
+
+// Uname
+
+type Utsname C.struct_utsname
+
+// Clockinfo
+
+const SizeofClockinfo = C.sizeof_struct_clockinfo
+
+type Clockinfo C.struct_clockinfo
diff --git a/vendor/golang.org/x/sys/unix/types_openbsd.go b/vendor/golang.org/x/sys/unix/types_openbsd.go
new file mode 100644
index 000000000..775cb57dc
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/types_openbsd.go
@@ -0,0 +1,283 @@
+// Copyright 2009 The Go 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 ignore
+
+/*
+Input to cgo -godefs.  See README.md
+*/
+
+// +godefs map struct_in_addr [4]byte /* in_addr */
+// +godefs map struct_in6_addr [16]byte /* in6_addr */
+
+package unix
+
+/*
+#define KERNEL
+#include <dirent.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <termios.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/event.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/select.h>
+#include <sys/signal.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <sys/utsname.h>
+#include <sys/wait.h>
+#include <uvm/uvmexp.h>
+#include <net/bpf.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <netinet/icmp6.h>
+#include <netinet/tcp.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+union sockaddr_all {
+	struct sockaddr s1;	// this one gets used for fields
+	struct sockaddr_in s2;	// these pad it out
+	struct sockaddr_in6 s3;
+	struct sockaddr_un s4;
+	struct sockaddr_dl s5;
+};
+
+struct sockaddr_any {
+	struct sockaddr addr;
+	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
+};
+
+*/
+import "C"
+
+// Machine characteristics
+
+const (
+	SizeofPtr      = C.sizeofPtr
+	SizeofShort    = C.sizeof_short
+	SizeofInt      = C.sizeof_int
+	SizeofLong     = C.sizeof_long
+	SizeofLongLong = C.sizeof_longlong
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type _Gid_t C.gid_t
+
+// Files
+
+type Stat_t C.struct_stat
+
+type Statfs_t C.struct_statfs
+
+type Flock_t C.struct_flock
+
+type Dirent C.struct_dirent
+
+type Fsid C.fsid_t
+
+// File system limits
+
+const (
+	PathMax = C.PATH_MAX
+)
+
+// Sockets
+
+type RawSockaddrInet4 C.struct_sockaddr_in
+
+type RawSockaddrInet6 C.struct_sockaddr_in6
+
+type RawSockaddrUnix C.struct_sockaddr_un
+
+type RawSockaddrDatalink C.struct_sockaddr_dl
+
+type RawSockaddr C.struct_sockaddr
+
+type RawSockaddrAny C.struct_sockaddr_any
+
+type _Socklen C.socklen_t
+
+type Linger C.struct_linger
+
+type Iovec C.struct_iovec
+
+type IPMreq C.struct_ip_mreq
+
+type IPv6Mreq C.struct_ipv6_mreq
+
+type Msghdr C.struct_msghdr
+
+type Cmsghdr C.struct_cmsghdr
+
+type Inet6Pktinfo C.struct_in6_pktinfo
+
+type IPv6MTUInfo C.struct_ip6_mtuinfo
+
+type ICMPv6Filter C.struct_icmp6_filter
+
+const (
+	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
+	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
+	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
+	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
+	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
+	SizeofLinger           = C.sizeof_struct_linger
+	SizeofIPMreq           = C.sizeof_struct_ip_mreq
+	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
+	SizeofMsghdr           = C.sizeof_struct_msghdr
+	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
+	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
+	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
+	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
+)
+
+// Ptrace requests
+
+const (
+	PTRACE_TRACEME = C.PT_TRACE_ME
+	PTRACE_CONT    = C.PT_CONTINUE
+	PTRACE_KILL    = C.PT_KILL
+)
+
+// Events (kqueue, kevent)
+
+type Kevent_t C.struct_kevent
+
+// Select
+
+type FdSet C.fd_set
+
+// Routing and interface messages
+
+const (
+	SizeofIfMsghdr         = C.sizeof_struct_if_msghdr
+	SizeofIfData           = C.sizeof_struct_if_data
+	SizeofIfaMsghdr        = C.sizeof_struct_ifa_msghdr
+	SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
+	SizeofRtMsghdr         = C.sizeof_struct_rt_msghdr
+	SizeofRtMetrics        = C.sizeof_struct_rt_metrics
+)
+
+type IfMsghdr C.struct_if_msghdr
+
+type IfData C.struct_if_data
+
+type IfaMsghdr C.struct_ifa_msghdr
+
+type IfAnnounceMsghdr C.struct_if_announcemsghdr
+
+type RtMsghdr C.struct_rt_msghdr
+
+type RtMetrics C.struct_rt_metrics
+
+type Mclpool C.struct_mclpool
+
+// Berkeley packet filter
+
+const (
+	SizeofBpfVersion = C.sizeof_struct_bpf_version
+	SizeofBpfStat    = C.sizeof_struct_bpf_stat
+	SizeofBpfProgram = C.sizeof_struct_bpf_program
+	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
+	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
+)
+
+type BpfVersion C.struct_bpf_version
+
+type BpfStat C.struct_bpf_stat
+
+type BpfProgram C.struct_bpf_program
+
+type BpfInsn C.struct_bpf_insn
+
+type BpfHdr C.struct_bpf_hdr
+
+type BpfTimeval C.struct_bpf_timeval
+
+// Terminal handling
+
+type Termios C.struct_termios
+
+type Winsize C.struct_winsize
+
+// fchmodat-like syscalls.
+
+const (
+	AT_FDCWD            = C.AT_FDCWD
+	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
+	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
+)
+
+// poll
+
+type PollFd C.struct_pollfd
+
+const (
+	POLLERR    = C.POLLERR
+	POLLHUP    = C.POLLHUP
+	POLLIN     = C.POLLIN
+	POLLNVAL   = C.POLLNVAL
+	POLLOUT    = C.POLLOUT
+	POLLPRI    = C.POLLPRI
+	POLLRDBAND = C.POLLRDBAND
+	POLLRDNORM = C.POLLRDNORM
+	POLLWRBAND = C.POLLWRBAND
+	POLLWRNORM = C.POLLWRNORM
+)
+
+// Signal Sets
+
+type Sigset_t C.sigset_t
+
+// Uname
+
+type Utsname C.struct_utsname
+
+// Uvmexp
+
+const SizeofUvmexp = C.sizeof_struct_uvmexp
+
+type Uvmexp C.struct_uvmexp
+
+// Clockinfo
+
+const SizeofClockinfo = C.sizeof_struct_clockinfo
+
+type Clockinfo C.struct_clockinfo
diff --git a/vendor/golang.org/x/sys/unix/types_solaris.go b/vendor/golang.org/x/sys/unix/types_solaris.go
new file mode 100644
index 000000000..2b716f934
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/types_solaris.go
@@ -0,0 +1,266 @@
+// Copyright 2009 The Go 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 ignore
+
+/*
+Input to cgo -godefs.  See README.md
+*/
+
+// +godefs map struct_in_addr [4]byte /* in_addr */
+// +godefs map struct_in6_addr [16]byte /* in6_addr */
+
+package unix
+
+/*
+#define KERNEL
+// These defines ensure that builds done on newer versions of Solaris are
+// backwards-compatible with older versions of Solaris and
+// OpenSolaris-based derivatives.
+#define __USE_SUNOS_SOCKETS__          // msghdr
+#define __USE_LEGACY_PROTOTYPES__      // iovec
+#include <dirent.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <limits.h>
+#include <poll.h>
+#include <signal.h>
+#include <termios.h>
+#include <termio.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <sys/resource.h>
+#include <sys/select.h>
+#include <sys/signal.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <sys/time.h>
+#include <sys/times.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+#include <sys/un.h>
+#include <sys/wait.h>
+#include <net/bpf.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <netinet/icmp6.h>
+#include <netinet/tcp.h>
+#include <ustat.h>
+#include <utime.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+union sockaddr_all {
+	struct sockaddr s1;	// this one gets used for fields
+	struct sockaddr_in s2;	// these pad it out
+	struct sockaddr_in6 s3;
+	struct sockaddr_un s4;
+	struct sockaddr_dl s5;
+};
+
+struct sockaddr_any {
+	struct sockaddr addr;
+	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
+};
+
+*/
+import "C"
+
+// Machine characteristics
+
+const (
+	SizeofPtr      = C.sizeofPtr
+	SizeofShort    = C.sizeof_short
+	SizeofInt      = C.sizeof_int
+	SizeofLong     = C.sizeof_long
+	SizeofLongLong = C.sizeof_longlong
+	PathMax        = C.PATH_MAX
+	MaxHostNameLen = C.MAXHOSTNAMELEN
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+type Timeval32 C.struct_timeval32
+
+type Tms C.struct_tms
+
+type Utimbuf C.struct_utimbuf
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type _Gid_t C.gid_t
+
+// Files
+
+type Stat_t C.struct_stat
+
+type Flock_t C.struct_flock
+
+type Dirent C.struct_dirent
+
+// Filesystems
+
+type _Fsblkcnt_t C.fsblkcnt_t
+
+type Statvfs_t C.struct_statvfs
+
+// Sockets
+
+type RawSockaddrInet4 C.struct_sockaddr_in
+
+type RawSockaddrInet6 C.struct_sockaddr_in6
+
+type RawSockaddrUnix C.struct_sockaddr_un
+
+type RawSockaddrDatalink C.struct_sockaddr_dl
+
+type RawSockaddr C.struct_sockaddr
+
+type RawSockaddrAny C.struct_sockaddr_any
+
+type _Socklen C.socklen_t
+
+type Linger C.struct_linger
+
+type Iovec C.struct_iovec
+
+type IPMreq C.struct_ip_mreq
+
+type IPv6Mreq C.struct_ipv6_mreq
+
+type Msghdr C.struct_msghdr
+
+type Cmsghdr C.struct_cmsghdr
+
+type Inet6Pktinfo C.struct_in6_pktinfo
+
+type IPv6MTUInfo C.struct_ip6_mtuinfo
+
+type ICMPv6Filter C.struct_icmp6_filter
+
+const (
+	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
+	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
+	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
+	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
+	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
+	SizeofLinger           = C.sizeof_struct_linger
+	SizeofIPMreq           = C.sizeof_struct_ip_mreq
+	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
+	SizeofMsghdr           = C.sizeof_struct_msghdr
+	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
+	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
+	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
+	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
+)
+
+// Select
+
+type FdSet C.fd_set
+
+// Misc
+
+type Utsname C.struct_utsname
+
+type Ustat_t C.struct_ustat
+
+const (
+	AT_FDCWD            = C.AT_FDCWD
+	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
+	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
+	AT_REMOVEDIR        = C.AT_REMOVEDIR
+	AT_EACCESS          = C.AT_EACCESS
+)
+
+// Routing and interface messages
+
+const (
+	SizeofIfMsghdr  = C.sizeof_struct_if_msghdr
+	SizeofIfData    = C.sizeof_struct_if_data
+	SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr
+	SizeofRtMsghdr  = C.sizeof_struct_rt_msghdr
+	SizeofRtMetrics = C.sizeof_struct_rt_metrics
+)
+
+type IfMsghdr C.struct_if_msghdr
+
+type IfData C.struct_if_data
+
+type IfaMsghdr C.struct_ifa_msghdr
+
+type RtMsghdr C.struct_rt_msghdr
+
+type RtMetrics C.struct_rt_metrics
+
+// Berkeley packet filter
+
+const (
+	SizeofBpfVersion = C.sizeof_struct_bpf_version
+	SizeofBpfStat    = C.sizeof_struct_bpf_stat
+	SizeofBpfProgram = C.sizeof_struct_bpf_program
+	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
+	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
+)
+
+type BpfVersion C.struct_bpf_version
+
+type BpfStat C.struct_bpf_stat
+
+type BpfProgram C.struct_bpf_program
+
+type BpfInsn C.struct_bpf_insn
+
+type BpfTimeval C.struct_bpf_timeval
+
+type BpfHdr C.struct_bpf_hdr
+
+// Terminal handling
+
+type Termios C.struct_termios
+
+type Termio C.struct_termio
+
+type Winsize C.struct_winsize
+
+// poll
+
+type PollFd C.struct_pollfd
+
+const (
+	POLLERR    = C.POLLERR
+	POLLHUP    = C.POLLHUP
+	POLLIN     = C.POLLIN
+	POLLNVAL   = C.POLLNVAL
+	POLLOUT    = C.POLLOUT
+	POLLPRI    = C.POLLPRI
+	POLLRDBAND = C.POLLRDBAND
+	POLLRDNORM = C.POLLRDNORM
+	POLLWRBAND = C.POLLWRBAND
+	POLLWRNORM = C.POLLWRNORM
+)
diff --git a/vendor/golang.org/x/text/encoding/charmap/maketables.go b/vendor/golang.org/x/text/encoding/charmap/maketables.go
new file mode 100644
index 000000000..f7941701e
--- /dev/null
+++ b/vendor/golang.org/x/text/encoding/charmap/maketables.go
@@ -0,0 +1,556 @@
+// Copyright 2013 The Go 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 ignore
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"net/http"
+	"sort"
+	"strings"
+	"unicode/utf8"
+
+	"golang.org/x/text/encoding"
+	"golang.org/x/text/internal/gen"
+)
+
+const ascii = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
+	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
+	` !"#$%&'()*+,-./0123456789:;<=>?` +
+	`@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` +
+	"`abcdefghijklmnopqrstuvwxyz{|}~\u007f"
+
+var encodings = []struct {
+	name        string
+	mib         string
+	comment     string
+	varName     string
+	replacement byte
+	mapping     string
+}{
+	{
+		"IBM Code Page 037",
+		"IBM037",
+		"",
+		"CodePage037",
+		0x3f,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM037-2.1.2.ucm",
+	},
+	{
+		"IBM Code Page 437",
+		"PC8CodePage437",
+		"",
+		"CodePage437",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM437-2.1.2.ucm",
+	},
+	{
+		"IBM Code Page 850",
+		"PC850Multilingual",
+		"",
+		"CodePage850",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM850-2.1.2.ucm",
+	},
+	{
+		"IBM Code Page 852",
+		"PCp852",
+		"",
+		"CodePage852",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM852-2.1.2.ucm",
+	},
+	{
+		"IBM Code Page 855",
+		"IBM855",
+		"",
+		"CodePage855",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM855-2.1.2.ucm",
+	},
+	{
+		"Windows Code Page 858", // PC latin1 with Euro
+		"IBM00858",
+		"",
+		"CodePage858",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/windows-858-2000.ucm",
+	},
+	{
+		"IBM Code Page 860",
+		"IBM860",
+		"",
+		"CodePage860",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM860-2.1.2.ucm",
+	},
+	{
+		"IBM Code Page 862",
+		"PC862LatinHebrew",
+		"",
+		"CodePage862",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM862-2.1.2.ucm",
+	},
+	{
+		"IBM Code Page 863",
+		"IBM863",
+		"",
+		"CodePage863",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM863-2.1.2.ucm",
+	},
+	{
+		"IBM Code Page 865",
+		"IBM865",
+		"",
+		"CodePage865",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM865-2.1.2.ucm",
+	},
+	{
+		"IBM Code Page 866",
+		"IBM866",
+		"",
+		"CodePage866",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-ibm866.txt",
+	},
+	{
+		"IBM Code Page 1047",
+		"IBM1047",
+		"",
+		"CodePage1047",
+		0x3f,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM1047-2.1.2.ucm",
+	},
+	{
+		"IBM Code Page 1140",
+		"IBM01140",
+		"",
+		"CodePage1140",
+		0x3f,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/ibm-1140_P100-1997.ucm",
+	},
+	{
+		"ISO 8859-1",
+		"ISOLatin1",
+		"",
+		"ISO8859_1",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/iso-8859_1-1998.ucm",
+	},
+	{
+		"ISO 8859-2",
+		"ISOLatin2",
+		"",
+		"ISO8859_2",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-2.txt",
+	},
+	{
+		"ISO 8859-3",
+		"ISOLatin3",
+		"",
+		"ISO8859_3",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-3.txt",
+	},
+	{
+		"ISO 8859-4",
+		"ISOLatin4",
+		"",
+		"ISO8859_4",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-4.txt",
+	},
+	{
+		"ISO 8859-5",
+		"ISOLatinCyrillic",
+		"",
+		"ISO8859_5",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-5.txt",
+	},
+	{
+		"ISO 8859-6",
+		"ISOLatinArabic",
+		"",
+		"ISO8859_6,ISO8859_6E,ISO8859_6I",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-6.txt",
+	},
+	{
+		"ISO 8859-7",
+		"ISOLatinGreek",
+		"",
+		"ISO8859_7",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-7.txt",
+	},
+	{
+		"ISO 8859-8",
+		"ISOLatinHebrew",
+		"",
+		"ISO8859_8,ISO8859_8E,ISO8859_8I",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-8.txt",
+	},
+	{
+		"ISO 8859-9",
+		"ISOLatin5",
+		"",
+		"ISO8859_9",
+		encoding.ASCIISub,
+		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/iso-8859_9-1999.ucm",
+	},
+	{
+		"ISO 8859-10",
+		"ISOLatin6",
+		"",
+		"ISO8859_10",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-10.txt",
+	},
+	{
+		"ISO 8859-13",
+		"ISO885913",
+		"",
+		"ISO8859_13",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-13.txt",
+	},
+	{
+		"ISO 8859-14",
+		"ISO885914",
+		"",
+		"ISO8859_14",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-14.txt",
+	},
+	{
+		"ISO 8859-15",
+		"ISO885915",
+		"",
+		"ISO8859_15",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-15.txt",
+	},
+	{
+		"ISO 8859-16",
+		"ISO885916",
+		"",
+		"ISO8859_16",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-iso-8859-16.txt",
+	},
+	{
+		"KOI8-R",
+		"KOI8R",
+		"",
+		"KOI8R",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-koi8-r.txt",
+	},
+	{
+		"KOI8-U",
+		"KOI8U",
+		"",
+		"KOI8U",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-koi8-u.txt",
+	},
+	{
+		"Macintosh",
+		"Macintosh",
+		"",
+		"Macintosh",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-macintosh.txt",
+	},
+	{
+		"Macintosh Cyrillic",
+		"MacintoshCyrillic",
+		"",
+		"MacintoshCyrillic",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-x-mac-cyrillic.txt",
+	},
+	{
+		"Windows 874",
+		"Windows874",
+		"",
+		"Windows874",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-874.txt",
+	},
+	{
+		"Windows 1250",
+		"Windows1250",
+		"",
+		"Windows1250",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-1250.txt",
+	},
+	{
+		"Windows 1251",
+		"Windows1251",
+		"",
+		"Windows1251",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-1251.txt",
+	},
+	{
+		"Windows 1252",
+		"Windows1252",
+		"",
+		"Windows1252",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-1252.txt",
+	},
+	{
+		"Windows 1253",
+		"Windows1253",
+		"",
+		"Windows1253",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-1253.txt",
+	},
+	{
+		"Windows 1254",
+		"Windows1254",
+		"",
+		"Windows1254",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-1254.txt",
+	},
+	{
+		"Windows 1255",
+		"Windows1255",
+		"",
+		"Windows1255",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-1255.txt",
+	},
+	{
+		"Windows 1256",
+		"Windows1256",
+		"",
+		"Windows1256",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-1256.txt",
+	},
+	{
+		"Windows 1257",
+		"Windows1257",
+		"",
+		"Windows1257",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-1257.txt",
+	},
+	{
+		"Windows 1258",
+		"Windows1258",
+		"",
+		"Windows1258",
+		encoding.ASCIISub,
+		"http://encoding.spec.whatwg.org/index-windows-1258.txt",
+	},
+	{
+		"X-User-Defined",
+		"XUserDefined",
+		"It is defined at http://encoding.spec.whatwg.org/#x-user-defined",
+		"XUserDefined",
+		encoding.ASCIISub,
+		ascii +
+			"\uf780\uf781\uf782\uf783\uf784\uf785\uf786\uf787" +
+			"\uf788\uf789\uf78a\uf78b\uf78c\uf78d\uf78e\uf78f" +
+			"\uf790\uf791\uf792\uf793\uf794\uf795\uf796\uf797" +
+			"\uf798\uf799\uf79a\uf79b\uf79c\uf79d\uf79e\uf79f" +
+			"\uf7a0\uf7a1\uf7a2\uf7a3\uf7a4\uf7a5\uf7a6\uf7a7" +
+			"\uf7a8\uf7a9\uf7aa\uf7ab\uf7ac\uf7ad\uf7ae\uf7af" +
+			"\uf7b0\uf7b1\uf7b2\uf7b3\uf7b4\uf7b5\uf7b6\uf7b7" +
+			"\uf7b8\uf7b9\uf7ba\uf7bb\uf7bc\uf7bd\uf7be\uf7bf" +
+			"\uf7c0\uf7c1\uf7c2\uf7c3\uf7c4\uf7c5\uf7c6\uf7c7" +
+			"\uf7c8\uf7c9\uf7ca\uf7cb\uf7cc\uf7cd\uf7ce\uf7cf" +
+			"\uf7d0\uf7d1\uf7d2\uf7d3\uf7d4\uf7d5\uf7d6\uf7d7" +
+			"\uf7d8\uf7d9\uf7da\uf7db\uf7dc\uf7dd\uf7de\uf7df" +
+			"\uf7e0\uf7e1\uf7e2\uf7e3\uf7e4\uf7e5\uf7e6\uf7e7" +
+			"\uf7e8\uf7e9\uf7ea\uf7eb\uf7ec\uf7ed\uf7ee\uf7ef" +
+			"\uf7f0\uf7f1\uf7f2\uf7f3\uf7f4\uf7f5\uf7f6\uf7f7" +
+			"\uf7f8\uf7f9\uf7fa\uf7fb\uf7fc\uf7fd\uf7fe\uf7ff",
+	},
+}
+
+func getWHATWG(url string) string {
+	res, err := http.Get(url)
+	if err != nil {
+		log.Fatalf("%q: Get: %v", url, err)
+	}
+	defer res.Body.Close()
+
+	mapping := make([]rune, 128)
+	for i := range mapping {
+		mapping[i] = '\ufffd'
+	}
+
+	scanner := bufio.NewScanner(res.Body)
+	for scanner.Scan() {
+		s := strings.TrimSpace(scanner.Text())
+		if s == "" || s[0] == '#' {
+			continue
+		}
+		x, y := 0, 0
+		if _, err := fmt.Sscanf(s, "%d\t0x%x", &x, &y); err != nil {
+			log.Fatalf("could not parse %q", s)
+		}
+		if x < 0 || 128 <= x {
+			log.Fatalf("code %d is out of range", x)
+		}
+		if 0x80 <= y && y < 0xa0 {
+			// We diverge from the WHATWG spec by mapping control characters
+			// in the range [0x80, 0xa0) to U+FFFD.
+			continue
+		}
+		mapping[x] = rune(y)
+	}
+	return ascii + string(mapping)
+}
+
+func getUCM(url string) string {
+	res, err := http.Get(url)
+	if err != nil {
+		log.Fatalf("%q: Get: %v", url, err)
+	}
+	defer res.Body.Close()
+
+	mapping := make([]rune, 256)
+	for i := range mapping {
+		mapping[i] = '\ufffd'
+	}
+
+	charsFound := 0
+	scanner := bufio.NewScanner(res.Body)
+	for scanner.Scan() {
+		s := strings.TrimSpace(scanner.Text())
+		if s == "" || s[0] == '#' {
+			continue
+		}
+		var c byte
+		var r rune
+		if _, err := fmt.Sscanf(s, `<U%x> \x%x |0`, &r, &c); err != nil {
+			continue
+		}
+		mapping[c] = r
+		charsFound++
+	}
+
+	if charsFound < 200 {
+		log.Fatalf("%q: only %d characters found (wrong page format?)", url, charsFound)
+	}
+
+	return string(mapping)
+}
+
+func main() {
+	mibs := map[string]bool{}
+	all := []string{}
+
+	w := gen.NewCodeWriter()
+	defer w.WriteGoFile("tables.go", "charmap")
+
+	printf := func(s string, a ...interface{}) { fmt.Fprintf(w, s, a...) }
+
+	printf("import (\n")
+	printf("\t\"golang.org/x/text/encoding\"\n")
+	printf("\t\"golang.org/x/text/encoding/internal/identifier\"\n")
+	printf(")\n\n")
+	for _, e := range encodings {
+		varNames := strings.Split(e.varName, ",")
+		all = append(all, varNames...)
+		varName := varNames[0]
+		switch {
+		case strings.HasPrefix(e.mapping, "http://encoding.spec.whatwg.org/"):
+			e.mapping = getWHATWG(e.mapping)
+		case strings.HasPrefix(e.mapping, "http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/"):
+			e.mapping = getUCM(e.mapping)
+		}
+
+		asciiSuperset, low := strings.HasPrefix(e.mapping, ascii), 0x00
+		if asciiSuperset {
+			low = 0x80
+		}
+		lvn := 1
+		if strings.HasPrefix(varName, "ISO") || strings.HasPrefix(varName, "KOI") {
+			lvn = 3
+		}
+		lowerVarName := strings.ToLower(varName[:lvn]) + varName[lvn:]
+		printf("// %s is the %s encoding.\n", varName, e.name)
+		if e.comment != "" {
+			printf("//\n// %s\n", e.comment)
+		}
+		printf("var %s *Charmap = &%s\n\nvar %s = Charmap{\nname: %q,\n",
+			varName, lowerVarName, lowerVarName, e.name)
+		if mibs[e.mib] {
+			log.Fatalf("MIB type %q declared multiple times.", e.mib)
+		}
+		printf("mib: identifier.%s,\n", e.mib)
+		printf("asciiSuperset: %t,\n", asciiSuperset)
+		printf("low: 0x%02x,\n", low)
+		printf("replacement: 0x%02x,\n", e.replacement)
+
+		printf("decode: [256]utf8Enc{\n")
+		i, backMapping := 0, map[rune]byte{}
+		for _, c := range e.mapping {
+			if _, ok := backMapping[c]; !ok && c != utf8.RuneError {
+				backMapping[c] = byte(i)
+			}
+			var buf [8]byte
+			n := utf8.EncodeRune(buf[:], c)
+			if n > 3 {
+				panic(fmt.Sprintf("rune %q (%U) is too long", c, c))
+			}
+			printf("{%d,[3]byte{0x%02x,0x%02x,0x%02x}},", n, buf[0], buf[1], buf[2])
+			if i%2 == 1 {
+				printf("\n")
+			}
+			i++
+		}
+		printf("},\n")
+
+		printf("encode: [256]uint32{\n")
+		encode := make([]uint32, 0, 256)
+		for c, i := range backMapping {
+			encode = append(encode, uint32(i)<<24|uint32(c))
+		}
+		sort.Sort(byRune(encode))
+		for len(encode) < cap(encode) {
+			encode = append(encode, encode[len(encode)-1])
+		}
+		for i, enc := range encode {
+			printf("0x%08x,", enc)
+			if i%8 == 7 {
+				printf("\n")
+			}
+		}
+		printf("},\n}\n")
+
+		// Add an estimate of the size of a single Charmap{} struct value, which
+		// includes two 256 elem arrays of 4 bytes and some extra fields, which
+		// align to 3 uint64s on 64-bit architectures.
+		w.Size += 2*4*256 + 3*8
+	}
+	// TODO: add proper line breaking.
+	printf("var listAll = []encoding.Encoding{\n%s,\n}\n\n", strings.Join(all, ",\n"))
+}
+
+type byRune []uint32
+
+func (b byRune) Len() int           { return len(b) }
+func (b byRune) Less(i, j int) bool { return b[i]&0xffffff < b[j]&0xffffff }
+func (b byRune) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/encoding/htmlindex/gen.go b/vendor/golang.org/x/text/encoding/htmlindex/gen.go
new file mode 100644
index 000000000..ac6b4a77f
--- /dev/null
+++ b/vendor/golang.org/x/text/encoding/htmlindex/gen.go
@@ -0,0 +1,173 @@
+// Copyright 2015 The Go 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 ignore
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"log"
+	"strings"
+
+	"golang.org/x/text/internal/gen"
+)
+
+type group struct {
+	Encodings []struct {
+		Labels []string
+		Name   string
+	}
+}
+
+func main() {
+	gen.Init()
+
+	r := gen.Open("https://encoding.spec.whatwg.org", "whatwg", "encodings.json")
+	var groups []group
+	if err := json.NewDecoder(r).Decode(&groups); err != nil {
+		log.Fatalf("Error reading encodings.json: %v", err)
+	}
+
+	w := &bytes.Buffer{}
+	fmt.Fprintln(w, "type htmlEncoding byte")
+	fmt.Fprintln(w, "const (")
+	for i, g := range groups {
+		for _, e := range g.Encodings {
+			key := strings.ToLower(e.Name)
+			name := consts[key]
+			if name == "" {
+				log.Fatalf("No const defined for %s.", key)
+			}
+			if i == 0 {
+				fmt.Fprintf(w, "%s htmlEncoding = iota\n", name)
+			} else {
+				fmt.Fprintf(w, "%s\n", name)
+			}
+		}
+	}
+	fmt.Fprintln(w, "numEncodings")
+	fmt.Fprint(w, ")\n\n")
+
+	fmt.Fprintln(w, "var canonical = [numEncodings]string{")
+	for _, g := range groups {
+		for _, e := range g.Encodings {
+			fmt.Fprintf(w, "%q,\n", strings.ToLower(e.Name))
+		}
+	}
+	fmt.Fprint(w, "}\n\n")
+
+	fmt.Fprintln(w, "var nameMap = map[string]htmlEncoding{")
+	for _, g := range groups {
+		for _, e := range g.Encodings {
+			for _, l := range e.Labels {
+				key := strings.ToLower(e.Name)
+				name := consts[key]
+				fmt.Fprintf(w, "%q: %s,\n", l, name)
+			}
+		}
+	}
+	fmt.Fprint(w, "}\n\n")
+
+	var tags []string
+	fmt.Fprintln(w, "var localeMap = []htmlEncoding{")
+	for _, loc := range locales {
+		tags = append(tags, loc.tag)
+		fmt.Fprintf(w, "%s, // %s \n", consts[loc.name], loc.tag)
+	}
+	fmt.Fprint(w, "}\n\n")
+
+	fmt.Fprintf(w, "const locales = %q\n", strings.Join(tags, " "))
+
+	gen.WriteGoFile("tables.go", "htmlindex", w.Bytes())
+}
+
+// consts maps canonical encoding name to internal constant.
+var consts = map[string]string{
+	"utf-8":          "utf8",
+	"ibm866":         "ibm866",
+	"iso-8859-2":     "iso8859_2",
+	"iso-8859-3":     "iso8859_3",
+	"iso-8859-4":     "iso8859_4",
+	"iso-8859-5":     "iso8859_5",
+	"iso-8859-6":     "iso8859_6",
+	"iso-8859-7":     "iso8859_7",
+	"iso-8859-8":     "iso8859_8",
+	"iso-8859-8-i":   "iso8859_8I",
+	"iso-8859-10":    "iso8859_10",
+	"iso-8859-13":    "iso8859_13",
+	"iso-8859-14":    "iso8859_14",
+	"iso-8859-15":    "iso8859_15",
+	"iso-8859-16":    "iso8859_16",
+	"koi8-r":         "koi8r",
+	"koi8-u":         "koi8u",
+	"macintosh":      "macintosh",
+	"windows-874":    "windows874",
+	"windows-1250":   "windows1250",
+	"windows-1251":   "windows1251",
+	"windows-1252":   "windows1252",
+	"windows-1253":   "windows1253",
+	"windows-1254":   "windows1254",
+	"windows-1255":   "windows1255",
+	"windows-1256":   "windows1256",
+	"windows-1257":   "windows1257",
+	"windows-1258":   "windows1258",
+	"x-mac-cyrillic": "macintoshCyrillic",
+	"gbk":            "gbk",
+	"gb18030":        "gb18030",
+	// "hz-gb-2312":     "hzgb2312", // Was removed from WhatWG
+	"big5":           "big5",
+	"euc-jp":         "eucjp",
+	"iso-2022-jp":    "iso2022jp",
+	"shift_jis":      "shiftJIS",
+	"euc-kr":         "euckr",
+	"replacement":    "replacement",
+	"utf-16be":       "utf16be",
+	"utf-16le":       "utf16le",
+	"x-user-defined": "xUserDefined",
+}
+
+// locales is taken from
+// https://html.spec.whatwg.org/multipage/syntax.html#encoding-sniffing-algorithm.
+var locales = []struct{ tag, name string }{
+	// The default value. Explicitly state latin to benefit from the exact
+	// script option, while still making 1252 the default encoding for languages
+	// written in Latin script.
+	{"und_Latn", "windows-1252"},
+	{"ar", "windows-1256"},
+	{"ba", "windows-1251"},
+	{"be", "windows-1251"},
+	{"bg", "windows-1251"},
+	{"cs", "windows-1250"},
+	{"el", "iso-8859-7"},
+	{"et", "windows-1257"},
+	{"fa", "windows-1256"},
+	{"he", "windows-1255"},
+	{"hr", "windows-1250"},
+	{"hu", "iso-8859-2"},
+	{"ja", "shift_jis"},
+	{"kk", "windows-1251"},
+	{"ko", "euc-kr"},
+	{"ku", "windows-1254"},
+	{"ky", "windows-1251"},
+	{"lt", "windows-1257"},
+	{"lv", "windows-1257"},
+	{"mk", "windows-1251"},
+	{"pl", "iso-8859-2"},
+	{"ru", "windows-1251"},
+	{"sah", "windows-1251"},
+	{"sk", "windows-1250"},
+	{"sl", "iso-8859-2"},
+	{"sr", "windows-1251"},
+	{"tg", "windows-1251"},
+	{"th", "windows-874"},
+	{"tr", "windows-1254"},
+	{"tt", "windows-1251"},
+	{"uk", "windows-1251"},
+	{"vi", "windows-1258"},
+	{"zh-hans", "gb18030"},
+	{"zh-hant", "big5"},
+}
diff --git a/vendor/golang.org/x/text/encoding/internal/identifier/gen.go b/vendor/golang.org/x/text/encoding/internal/identifier/gen.go
new file mode 100644
index 000000000..26cfef9c6
--- /dev/null
+++ b/vendor/golang.org/x/text/encoding/internal/identifier/gen.go
@@ -0,0 +1,142 @@
+// Copyright 2015 The Go 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 ignore
+
+package main
+
+import (
+	"bytes"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"log"
+	"strings"
+
+	"golang.org/x/text/internal/gen"
+)
+
+type registry struct {
+	XMLName  xml.Name `xml:"registry"`
+	Updated  string   `xml:"updated"`
+	Registry []struct {
+		ID     string `xml:"id,attr"`
+		Record []struct {
+			Name string `xml:"name"`
+			Xref []struct {
+				Type string `xml:"type,attr"`
+				Data string `xml:"data,attr"`
+			} `xml:"xref"`
+			Desc struct {
+				Data string `xml:",innerxml"`
+				// Any []struct {
+				// 	Data string `xml:",chardata"`
+				// } `xml:",any"`
+				// Data string `xml:",chardata"`
+			} `xml:"description,"`
+			MIB   string   `xml:"value"`
+			Alias []string `xml:"alias"`
+			MIME  string   `xml:"preferred_alias"`
+		} `xml:"record"`
+	} `xml:"registry"`
+}
+
+func main() {
+	r := gen.OpenIANAFile("assignments/character-sets/character-sets.xml")
+	reg := &registry{}
+	if err := xml.NewDecoder(r).Decode(&reg); err != nil && err != io.EOF {
+		log.Fatalf("Error decoding charset registry: %v", err)
+	}
+	if len(reg.Registry) == 0 || reg.Registry[0].ID != "character-sets-1" {
+		log.Fatalf("Unexpected ID %s", reg.Registry[0].ID)
+	}
+
+	w := &bytes.Buffer{}
+	fmt.Fprintf(w, "const (\n")
+	for _, rec := range reg.Registry[0].Record {
+		constName := ""
+		for _, a := range rec.Alias {
+			if strings.HasPrefix(a, "cs") && strings.IndexByte(a, '-') == -1 {
+				// Some of the constant definitions have comments in them. Strip those.
+				constName = strings.Title(strings.SplitN(a[2:], "\n", 2)[0])
+			}
+		}
+		if constName == "" {
+			switch rec.MIB {
+			case "2085":
+				constName = "HZGB2312" // Not listed as alias for some reason.
+			default:
+				log.Fatalf("No cs alias defined for %s.", rec.MIB)
+			}
+		}
+		if rec.MIME != "" {
+			rec.MIME = fmt.Sprintf(" (MIME: %s)", rec.MIME)
+		}
+		fmt.Fprintf(w, "// %s is the MIB identifier with IANA name %s%s.\n//\n", constName, rec.Name, rec.MIME)
+		if len(rec.Desc.Data) > 0 {
+			fmt.Fprint(w, "// ")
+			d := xml.NewDecoder(strings.NewReader(rec.Desc.Data))
+			inElem := true
+			attr := ""
+			for {
+				t, err := d.Token()
+				if err != nil {
+					if err != io.EOF {
+						log.Fatal(err)
+					}
+					break
+				}
+				switch x := t.(type) {
+				case xml.CharData:
+					attr = "" // Don't need attribute info.
+					a := bytes.Split([]byte(x), []byte("\n"))
+					for i, b := range a {
+						if b = bytes.TrimSpace(b); len(b) != 0 {
+							if !inElem && i > 0 {
+								fmt.Fprint(w, "\n// ")
+							}
+							inElem = false
+							fmt.Fprintf(w, "%s ", string(b))
+						}
+					}
+				case xml.StartElement:
+					if x.Name.Local == "xref" {
+						inElem = true
+						use := false
+						for _, a := range x.Attr {
+							if a.Name.Local == "type" {
+								use = use || a.Value != "person"
+							}
+							if a.Name.Local == "data" && use {
+								// Patch up URLs to use https. From some links, the
+								// https version is different from the http one.
+								s := a.Value
+								s = strings.Replace(s, "http://", "https://", -1)
+								s = strings.Replace(s, "/unicode/", "/", -1)
+								attr = s + " "
+							}
+						}
+					}
+				case xml.EndElement:
+					inElem = false
+					fmt.Fprint(w, attr)
+				}
+			}
+			fmt.Fprint(w, "\n")
+		}
+		for _, x := range rec.Xref {
+			switch x.Type {
+			case "rfc":
+				fmt.Fprintf(w, "// Reference: %s\n", strings.ToUpper(x.Data))
+			case "uri":
+				fmt.Fprintf(w, "// Reference: %s\n", x.Data)
+			}
+		}
+		fmt.Fprintf(w, "%s MIB = %s\n", constName, rec.MIB)
+		fmt.Fprintln(w)
+	}
+	fmt.Fprintln(w, ")")
+
+	gen.WriteGoFile("mib.go", "identifier", w.Bytes())
+}
diff --git a/vendor/golang.org/x/text/encoding/japanese/maketables.go b/vendor/golang.org/x/text/encoding/japanese/maketables.go
new file mode 100644
index 000000000..023957a67
--- /dev/null
+++ b/vendor/golang.org/x/text/encoding/japanese/maketables.go
@@ -0,0 +1,161 @@
+// Copyright 2013 The Go 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 ignore
+
+package main
+
+// This program generates tables.go:
+//	go run maketables.go | gofmt > tables.go
+
+// TODO: Emoji extensions?
+// https://www.unicode.org/faq/emoji_dingbats.html
+// https://www.unicode.org/Public/UNIDATA/EmojiSources.txt
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+type entry struct {
+	jisCode, table int
+}
+
+func main() {
+	fmt.Printf("// generated by go run maketables.go; DO NOT EDIT\n\n")
+	fmt.Printf("// Package japanese provides Japanese encodings such as EUC-JP and Shift JIS.\n")
+	fmt.Printf(`package japanese // import "golang.org/x/text/encoding/japanese"` + "\n\n")
+
+	reverse := [65536]entry{}
+	for i := range reverse {
+		reverse[i].table = -1
+	}
+
+	tables := []struct {
+		url  string
+		name string
+	}{
+		{"http://encoding.spec.whatwg.org/index-jis0208.txt", "0208"},
+		{"http://encoding.spec.whatwg.org/index-jis0212.txt", "0212"},
+	}
+	for i, table := range tables {
+		res, err := http.Get(table.url)
+		if err != nil {
+			log.Fatalf("%q: Get: %v", table.url, err)
+		}
+		defer res.Body.Close()
+
+		mapping := [65536]uint16{}
+
+		scanner := bufio.NewScanner(res.Body)
+		for scanner.Scan() {
+			s := strings.TrimSpace(scanner.Text())
+			if s == "" || s[0] == '#' {
+				continue
+			}
+			x, y := 0, uint16(0)
+			if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
+				log.Fatalf("%q: could not parse %q", table.url, s)
+			}
+			if x < 0 || 120*94 <= x {
+				log.Fatalf("%q: JIS code %d is out of range", table.url, x)
+			}
+			mapping[x] = y
+			if reverse[y].table == -1 {
+				reverse[y] = entry{jisCode: x, table: i}
+			}
+		}
+		if err := scanner.Err(); err != nil {
+			log.Fatalf("%q: scanner error: %v", table.url, err)
+		}
+
+		fmt.Printf("// jis%sDecode is the decoding table from JIS %s code to Unicode.\n// It is defined at %s\n",
+			table.name, table.name, table.url)
+		fmt.Printf("var jis%sDecode = [...]uint16{\n", table.name)
+		for i, m := range mapping {
+			if m != 0 {
+				fmt.Printf("\t%d: 0x%04X,\n", i, m)
+			}
+		}
+		fmt.Printf("}\n\n")
+	}
+
+	// Any run of at least separation continuous zero entries in the reverse map will
+	// be a separate encode table.
+	const separation = 1024
+
+	intervals := []interval(nil)
+	low, high := -1, -1
+	for i, v := range reverse {
+		if v.table == -1 {
+			continue
+		}
+		if low < 0 {
+			low = i
+		} else if i-high >= separation {
+			if high >= 0 {
+				intervals = append(intervals, interval{low, high})
+			}
+			low = i
+		}
+		high = i + 1
+	}
+	if high >= 0 {
+		intervals = append(intervals, interval{low, high})
+	}
+	sort.Sort(byDecreasingLength(intervals))
+
+	fmt.Printf("const (\n")
+	fmt.Printf("\tjis0208    = 1\n")
+	fmt.Printf("\tjis0212    = 2\n")
+	fmt.Printf("\tcodeMask   = 0x7f\n")
+	fmt.Printf("\tcodeShift  = 7\n")
+	fmt.Printf("\ttableShift = 14\n")
+	fmt.Printf(")\n\n")
+
+	fmt.Printf("const numEncodeTables = %d\n\n", len(intervals))
+	fmt.Printf("// encodeX are the encoding tables from Unicode to JIS code,\n")
+	fmt.Printf("// sorted by decreasing length.\n")
+	for i, v := range intervals {
+		fmt.Printf("// encode%d: %5d entries for runes in [%5d, %5d).\n", i, v.len(), v.low, v.high)
+	}
+	fmt.Printf("//\n")
+	fmt.Printf("// The high two bits of the value record whether the JIS code comes from the\n")
+	fmt.Printf("// JIS0208 table (high bits == 1) or the JIS0212 table (high bits == 2).\n")
+	fmt.Printf("// The low 14 bits are two 7-bit unsigned integers j1 and j2 that form the\n")
+	fmt.Printf("// JIS code (94*j1 + j2) within that table.\n")
+	fmt.Printf("\n")
+
+	for i, v := range intervals {
+		fmt.Printf("const encode%dLow, encode%dHigh = %d, %d\n\n", i, i, v.low, v.high)
+		fmt.Printf("var encode%d = [...]uint16{\n", i)
+		for j := v.low; j < v.high; j++ {
+			x := reverse[j]
+			if x.table == -1 {
+				continue
+			}
+			fmt.Printf("\t%d - %d: jis%s<<14 | 0x%02X<<7 | 0x%02X,\n",
+				j, v.low, tables[x.table].name, x.jisCode/94, x.jisCode%94)
+		}
+		fmt.Printf("}\n\n")
+	}
+}
+
+// interval is a half-open interval [low, high).
+type interval struct {
+	low, high int
+}
+
+func (i interval) len() int { return i.high - i.low }
+
+// byDecreasingLength sorts intervals by decreasing length.
+type byDecreasingLength []interval
+
+func (b byDecreasingLength) Len() int           { return len(b) }
+func (b byDecreasingLength) Less(i, j int) bool { return b[i].len() > b[j].len() }
+func (b byDecreasingLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/encoding/korean/maketables.go b/vendor/golang.org/x/text/encoding/korean/maketables.go
new file mode 100644
index 000000000..c84034fb6
--- /dev/null
+++ b/vendor/golang.org/x/text/encoding/korean/maketables.go
@@ -0,0 +1,143 @@
+// Copyright 2013 The Go 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 ignore
+
+package main
+
+// This program generates tables.go:
+//	go run maketables.go | gofmt > tables.go
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+func main() {
+	fmt.Printf("// generated by go run maketables.go; DO NOT EDIT\n\n")
+	fmt.Printf("// Package korean provides Korean encodings such as EUC-KR.\n")
+	fmt.Printf(`package korean // import "golang.org/x/text/encoding/korean"` + "\n\n")
+
+	res, err := http.Get("http://encoding.spec.whatwg.org/index-euc-kr.txt")
+	if err != nil {
+		log.Fatalf("Get: %v", err)
+	}
+	defer res.Body.Close()
+
+	mapping := [65536]uint16{}
+	reverse := [65536]uint16{}
+
+	scanner := bufio.NewScanner(res.Body)
+	for scanner.Scan() {
+		s := strings.TrimSpace(scanner.Text())
+		if s == "" || s[0] == '#' {
+			continue
+		}
+		x, y := uint16(0), uint16(0)
+		if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
+			log.Fatalf("could not parse %q", s)
+		}
+		if x < 0 || 178*(0xc7-0x81)+(0xfe-0xc7)*94+(0xff-0xa1) <= x {
+			log.Fatalf("EUC-KR code %d is out of range", x)
+		}
+		mapping[x] = y
+		if reverse[y] == 0 {
+			c0, c1 := uint16(0), uint16(0)
+			if x < 178*(0xc7-0x81) {
+				c0 = uint16(x/178) + 0x81
+				c1 = uint16(x % 178)
+				switch {
+				case c1 < 1*26:
+					c1 += 0x41
+				case c1 < 2*26:
+					c1 += 0x47
+				default:
+					c1 += 0x4d
+				}
+			} else {
+				x -= 178 * (0xc7 - 0x81)
+				c0 = uint16(x/94) + 0xc7
+				c1 = uint16(x%94) + 0xa1
+			}
+			reverse[y] = c0<<8 | c1
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		log.Fatalf("scanner error: %v", err)
+	}
+
+	fmt.Printf("// decode is the decoding table from EUC-KR code to Unicode.\n")
+	fmt.Printf("// It is defined at http://encoding.spec.whatwg.org/index-euc-kr.txt\n")
+	fmt.Printf("var decode = [...]uint16{\n")
+	for i, v := range mapping {
+		if v != 0 {
+			fmt.Printf("\t%d: 0x%04X,\n", i, v)
+		}
+	}
+	fmt.Printf("}\n\n")
+
+	// Any run of at least separation continuous zero entries in the reverse map will
+	// be a separate encode table.
+	const separation = 1024
+
+	intervals := []interval(nil)
+	low, high := -1, -1
+	for i, v := range reverse {
+		if v == 0 {
+			continue
+		}
+		if low < 0 {
+			low = i
+		} else if i-high >= separation {
+			if high >= 0 {
+				intervals = append(intervals, interval{low, high})
+			}
+			low = i
+		}
+		high = i + 1
+	}
+	if high >= 0 {
+		intervals = append(intervals, interval{low, high})
+	}
+	sort.Sort(byDecreasingLength(intervals))
+
+	fmt.Printf("const numEncodeTables = %d\n\n", len(intervals))
+	fmt.Printf("// encodeX are the encoding tables from Unicode to EUC-KR code,\n")
+	fmt.Printf("// sorted by decreasing length.\n")
+	for i, v := range intervals {
+		fmt.Printf("// encode%d: %5d entries for runes in [%5d, %5d).\n", i, v.len(), v.low, v.high)
+	}
+	fmt.Printf("\n")
+
+	for i, v := range intervals {
+		fmt.Printf("const encode%dLow, encode%dHigh = %d, %d\n\n", i, i, v.low, v.high)
+		fmt.Printf("var encode%d = [...]uint16{\n", i)
+		for j := v.low; j < v.high; j++ {
+			x := reverse[j]
+			if x == 0 {
+				continue
+			}
+			fmt.Printf("\t%d-%d: 0x%04X,\n", j, v.low, x)
+		}
+		fmt.Printf("}\n\n")
+	}
+}
+
+// interval is a half-open interval [low, high).
+type interval struct {
+	low, high int
+}
+
+func (i interval) len() int { return i.high - i.low }
+
+// byDecreasingLength sorts intervals by decreasing length.
+type byDecreasingLength []interval
+
+func (b byDecreasingLength) Len() int           { return len(b) }
+func (b byDecreasingLength) Less(i, j int) bool { return b[i].len() > b[j].len() }
+func (b byDecreasingLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/encoding/simplifiedchinese/maketables.go b/vendor/golang.org/x/text/encoding/simplifiedchinese/maketables.go
new file mode 100644
index 000000000..55016c786
--- /dev/null
+++ b/vendor/golang.org/x/text/encoding/simplifiedchinese/maketables.go
@@ -0,0 +1,161 @@
+// Copyright 2013 The Go 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 ignore
+
+package main
+
+// This program generates tables.go:
+//	go run maketables.go | gofmt > tables.go
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+func main() {
+	fmt.Printf("// generated by go run maketables.go; DO NOT EDIT\n\n")
+	fmt.Printf("// Package simplifiedchinese provides Simplified Chinese encodings such as GBK.\n")
+	fmt.Printf(`package simplifiedchinese // import "golang.org/x/text/encoding/simplifiedchinese"` + "\n\n")
+
+	printGB18030()
+	printGBK()
+}
+
+func printGB18030() {
+	res, err := http.Get("http://encoding.spec.whatwg.org/index-gb18030.txt")
+	if err != nil {
+		log.Fatalf("Get: %v", err)
+	}
+	defer res.Body.Close()
+
+	fmt.Printf("// gb18030 is the table from http://encoding.spec.whatwg.org/index-gb18030.txt\n")
+	fmt.Printf("var gb18030 = [...][2]uint16{\n")
+	scanner := bufio.NewScanner(res.Body)
+	for scanner.Scan() {
+		s := strings.TrimSpace(scanner.Text())
+		if s == "" || s[0] == '#' {
+			continue
+		}
+		x, y := uint32(0), uint32(0)
+		if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
+			log.Fatalf("could not parse %q", s)
+		}
+		if x < 0x10000 && y < 0x10000 {
+			fmt.Printf("\t{0x%04x, 0x%04x},\n", x, y)
+		}
+	}
+	fmt.Printf("}\n\n")
+}
+
+func printGBK() {
+	res, err := http.Get("http://encoding.spec.whatwg.org/index-gbk.txt")
+	if err != nil {
+		log.Fatalf("Get: %v", err)
+	}
+	defer res.Body.Close()
+
+	mapping := [65536]uint16{}
+	reverse := [65536]uint16{}
+
+	scanner := bufio.NewScanner(res.Body)
+	for scanner.Scan() {
+		s := strings.TrimSpace(scanner.Text())
+		if s == "" || s[0] == '#' {
+			continue
+		}
+		x, y := uint16(0), uint16(0)
+		if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
+			log.Fatalf("could not parse %q", s)
+		}
+		if x < 0 || 126*190 <= x {
+			log.Fatalf("GBK code %d is out of range", x)
+		}
+		mapping[x] = y
+		if reverse[y] == 0 {
+			c0, c1 := x/190, x%190
+			if c1 >= 0x3f {
+				c1++
+			}
+			reverse[y] = (0x81+c0)<<8 | (0x40 + c1)
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		log.Fatalf("scanner error: %v", err)
+	}
+
+	fmt.Printf("// decode is the decoding table from GBK code to Unicode.\n")
+	fmt.Printf("// It is defined at http://encoding.spec.whatwg.org/index-gbk.txt\n")
+	fmt.Printf("var decode = [...]uint16{\n")
+	for i, v := range mapping {
+		if v != 0 {
+			fmt.Printf("\t%d: 0x%04X,\n", i, v)
+		}
+	}
+	fmt.Printf("}\n\n")
+
+	// Any run of at least separation continuous zero entries in the reverse map will
+	// be a separate encode table.
+	const separation = 1024
+
+	intervals := []interval(nil)
+	low, high := -1, -1
+	for i, v := range reverse {
+		if v == 0 {
+			continue
+		}
+		if low < 0 {
+			low = i
+		} else if i-high >= separation {
+			if high >= 0 {
+				intervals = append(intervals, interval{low, high})
+			}
+			low = i
+		}
+		high = i + 1
+	}
+	if high >= 0 {
+		intervals = append(intervals, interval{low, high})
+	}
+	sort.Sort(byDecreasingLength(intervals))
+
+	fmt.Printf("const numEncodeTables = %d\n\n", len(intervals))
+	fmt.Printf("// encodeX are the encoding tables from Unicode to GBK code,\n")
+	fmt.Printf("// sorted by decreasing length.\n")
+	for i, v := range intervals {
+		fmt.Printf("// encode%d: %5d entries for runes in [%5d, %5d).\n", i, v.len(), v.low, v.high)
+	}
+	fmt.Printf("\n")
+
+	for i, v := range intervals {
+		fmt.Printf("const encode%dLow, encode%dHigh = %d, %d\n\n", i, i, v.low, v.high)
+		fmt.Printf("var encode%d = [...]uint16{\n", i)
+		for j := v.low; j < v.high; j++ {
+			x := reverse[j]
+			if x == 0 {
+				continue
+			}
+			fmt.Printf("\t%d-%d: 0x%04X,\n", j, v.low, x)
+		}
+		fmt.Printf("}\n\n")
+	}
+}
+
+// interval is a half-open interval [low, high).
+type interval struct {
+	low, high int
+}
+
+func (i interval) len() int { return i.high - i.low }
+
+// byDecreasingLength sorts intervals by decreasing length.
+type byDecreasingLength []interval
+
+func (b byDecreasingLength) Len() int           { return len(b) }
+func (b byDecreasingLength) Less(i, j int) bool { return b[i].len() > b[j].len() }
+func (b byDecreasingLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/encoding/traditionalchinese/maketables.go b/vendor/golang.org/x/text/encoding/traditionalchinese/maketables.go
new file mode 100644
index 000000000..cf7fdb31a
--- /dev/null
+++ b/vendor/golang.org/x/text/encoding/traditionalchinese/maketables.go
@@ -0,0 +1,140 @@
+// Copyright 2013 The Go 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 ignore
+
+package main
+
+// This program generates tables.go:
+//	go run maketables.go | gofmt > tables.go
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+func main() {
+	fmt.Printf("// generated by go run maketables.go; DO NOT EDIT\n\n")
+	fmt.Printf("// Package traditionalchinese provides Traditional Chinese encodings such as Big5.\n")
+	fmt.Printf(`package traditionalchinese // import "golang.org/x/text/encoding/traditionalchinese"` + "\n\n")
+
+	res, err := http.Get("http://encoding.spec.whatwg.org/index-big5.txt")
+	if err != nil {
+		log.Fatalf("Get: %v", err)
+	}
+	defer res.Body.Close()
+
+	mapping := [65536]uint32{}
+	reverse := [65536 * 4]uint16{}
+
+	scanner := bufio.NewScanner(res.Body)
+	for scanner.Scan() {
+		s := strings.TrimSpace(scanner.Text())
+		if s == "" || s[0] == '#' {
+			continue
+		}
+		x, y := uint16(0), uint32(0)
+		if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
+			log.Fatalf("could not parse %q", s)
+		}
+		if x < 0 || 126*157 <= x {
+			log.Fatalf("Big5 code %d is out of range", x)
+		}
+		mapping[x] = y
+
+		// The WHATWG spec http://encoding.spec.whatwg.org/#indexes says that
+		// "The index pointer for code point in index is the first pointer
+		// corresponding to code point in index", which would normally mean
+		// that the code below should be guarded by "if reverse[y] == 0", but
+		// last instead of first seems to match the behavior of
+		// "iconv -f UTF-8 -t BIG5". For example, U+8005 者 occurs twice in
+		// http://encoding.spec.whatwg.org/index-big5.txt, as index 2148
+		// (encoded as "\x8e\xcd") and index 6543 (encoded as "\xaa\xcc")
+		// and "echo 者 | iconv -f UTF-8 -t BIG5 | xxd" gives "\xaa\xcc".
+		c0, c1 := x/157, x%157
+		if c1 < 0x3f {
+			c1 += 0x40
+		} else {
+			c1 += 0x62
+		}
+		reverse[y] = (0x81+c0)<<8 | c1
+	}
+	if err := scanner.Err(); err != nil {
+		log.Fatalf("scanner error: %v", err)
+	}
+
+	fmt.Printf("// decode is the decoding table from Big5 code to Unicode.\n")
+	fmt.Printf("// It is defined at http://encoding.spec.whatwg.org/index-big5.txt\n")
+	fmt.Printf("var decode = [...]uint32{\n")
+	for i, v := range mapping {
+		if v != 0 {
+			fmt.Printf("\t%d: 0x%08X,\n", i, v)
+		}
+	}
+	fmt.Printf("}\n\n")
+
+	// Any run of at least separation continuous zero entries in the reverse map will
+	// be a separate encode table.
+	const separation = 1024
+
+	intervals := []interval(nil)
+	low, high := -1, -1
+	for i, v := range reverse {
+		if v == 0 {
+			continue
+		}
+		if low < 0 {
+			low = i
+		} else if i-high >= separation {
+			if high >= 0 {
+				intervals = append(intervals, interval{low, high})
+			}
+			low = i
+		}
+		high = i + 1
+	}
+	if high >= 0 {
+		intervals = append(intervals, interval{low, high})
+	}
+	sort.Sort(byDecreasingLength(intervals))
+
+	fmt.Printf("const numEncodeTables = %d\n\n", len(intervals))
+	fmt.Printf("// encodeX are the encoding tables from Unicode to Big5 code,\n")
+	fmt.Printf("// sorted by decreasing length.\n")
+	for i, v := range intervals {
+		fmt.Printf("// encode%d: %5d entries for runes in [%6d, %6d).\n", i, v.len(), v.low, v.high)
+	}
+	fmt.Printf("\n")
+
+	for i, v := range intervals {
+		fmt.Printf("const encode%dLow, encode%dHigh = %d, %d\n\n", i, i, v.low, v.high)
+		fmt.Printf("var encode%d = [...]uint16{\n", i)
+		for j := v.low; j < v.high; j++ {
+			x := reverse[j]
+			if x == 0 {
+				continue
+			}
+			fmt.Printf("\t%d-%d: 0x%04X,\n", j, v.low, x)
+		}
+		fmt.Printf("}\n\n")
+	}
+}
+
+// interval is a half-open interval [low, high).
+type interval struct {
+	low, high int
+}
+
+func (i interval) len() int { return i.high - i.low }
+
+// byDecreasingLength sorts intervals by decreasing length.
+type byDecreasingLength []interval
+
+func (b byDecreasingLength) Len() int           { return len(b) }
+func (b byDecreasingLength) Less(i, j int) bool { return b[i].len() > b[j].len() }
+func (b byDecreasingLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/internal/language/compact/gen.go b/vendor/golang.org/x/text/internal/language/compact/gen.go
new file mode 100644
index 000000000..0c36a052f
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compact/gen.go
@@ -0,0 +1,64 @@
+// Copyright 2013 The Go 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 ignore
+
+// Language tag table generator.
+// Data read from the web.
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/unicode/cldr"
+)
+
+var (
+	test = flag.Bool("test",
+		false,
+		"test existing tables; can be used to compare web data with package data.")
+	outputFile = flag.String("output",
+		"tables.go",
+		"output file for generated tables")
+)
+
+func main() {
+	gen.Init()
+
+	w := gen.NewCodeWriter()
+	defer w.WriteGoFile("tables.go", "compact")
+
+	fmt.Fprintln(w, `import "golang.org/x/text/internal/language"`)
+
+	b := newBuilder(w)
+	gen.WriteCLDRVersion(w)
+
+	b.writeCompactIndex()
+}
+
+type builder struct {
+	w    *gen.CodeWriter
+	data *cldr.CLDR
+	supp *cldr.SupplementalData
+}
+
+func newBuilder(w *gen.CodeWriter) *builder {
+	r := gen.OpenCLDRCoreZip()
+	defer r.Close()
+	d := &cldr.Decoder{}
+	data, err := d.DecodeZip(r)
+	if err != nil {
+		log.Fatal(err)
+	}
+	b := builder{
+		w:    w,
+		data: data,
+		supp: data.Supplemental(),
+	}
+	return &b
+}
diff --git a/vendor/golang.org/x/text/internal/language/compact/gen_index.go b/vendor/golang.org/x/text/internal/language/compact/gen_index.go
new file mode 100644
index 000000000..136cefaf0
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compact/gen_index.go
@@ -0,0 +1,113 @@
+// Copyright 2015 The Go 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 ignore
+
+package main
+
+// This file generates derivative tables based on the language package itself.
+
+import (
+	"fmt"
+	"log"
+	"sort"
+	"strings"
+
+	"golang.org/x/text/internal/language"
+)
+
+// Compact indices:
+// Note -va-X variants only apply to localization variants.
+// BCP variants only ever apply to language.
+// The only ambiguity between tags is with regions.
+
+func (b *builder) writeCompactIndex() {
+	// Collect all language tags for which we have any data in CLDR.
+	m := map[language.Tag]bool{}
+	for _, lang := range b.data.Locales() {
+		// We include all locales unconditionally to be consistent with en_US.
+		// We want en_US, even though it has no data associated with it.
+
+		// TODO: put any of the languages for which no data exists at the end
+		// of the index. This allows all components based on ICU to use that
+		// as the cutoff point.
+		// if x := data.RawLDML(lang); false ||
+		// 	x.LocaleDisplayNames != nil ||
+		// 	x.Characters != nil ||
+		// 	x.Delimiters != nil ||
+		// 	x.Measurement != nil ||
+		// 	x.Dates != nil ||
+		// 	x.Numbers != nil ||
+		// 	x.Units != nil ||
+		// 	x.ListPatterns != nil ||
+		// 	x.Collations != nil ||
+		// 	x.Segmentations != nil ||
+		// 	x.Rbnf != nil ||
+		// 	x.Annotations != nil ||
+		// 	x.Metadata != nil {
+
+		// TODO: support POSIX natively, albeit non-standard.
+		tag := language.Make(strings.Replace(lang, "_POSIX", "-u-va-posix", 1))
+		m[tag] = true
+		// }
+	}
+
+	// TODO: plural rules are also defined for the deprecated tags:
+	//    iw mo sh tl
+	// Consider removing these as compact tags.
+
+	// Include locales for plural rules, which uses a different structure.
+	for _, plurals := range b.supp.Plurals {
+		for _, rules := range plurals.PluralRules {
+			for _, lang := range strings.Split(rules.Locales, " ") {
+				m[language.Make(lang)] = true
+			}
+		}
+	}
+
+	var coreTags []language.CompactCoreInfo
+	var special []string
+
+	for t := range m {
+		if x := t.Extensions(); len(x) != 0 && fmt.Sprint(x) != "[u-va-posix]" {
+			log.Fatalf("Unexpected extension %v in %v", x, t)
+		}
+		if len(t.Variants()) == 0 && len(t.Extensions()) == 0 {
+			cci, ok := language.GetCompactCore(t)
+			if !ok {
+				log.Fatalf("Locale for non-basic language %q", t)
+			}
+			coreTags = append(coreTags, cci)
+		} else {
+			special = append(special, t.String())
+		}
+	}
+
+	w := b.w
+
+	sort.Slice(coreTags, func(i, j int) bool { return coreTags[i] < coreTags[j] })
+	sort.Strings(special)
+
+	w.WriteComment(`
+	NumCompactTags is the number of common tags. The maximum tag is
+	NumCompactTags-1.`)
+	w.WriteConst("NumCompactTags", len(m))
+
+	fmt.Fprintln(w, "const (")
+	for i, t := range coreTags {
+		fmt.Fprintf(w, "%s ID = %d\n", ident(t.Tag().String()), i)
+	}
+	for i, t := range special {
+		fmt.Fprintf(w, "%s ID = %d\n", ident(t), i+len(coreTags))
+	}
+	fmt.Fprintln(w, ")")
+
+	w.WriteVar("coreTags", coreTags)
+
+	w.WriteConst("specialTagsStr", strings.Join(special, " "))
+}
+
+func ident(s string) string {
+	return strings.Replace(s, "-", "", -1) + "Index"
+}
diff --git a/vendor/golang.org/x/text/internal/language/compact/gen_parents.go b/vendor/golang.org/x/text/internal/language/compact/gen_parents.go
new file mode 100644
index 000000000..9543d5832
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compact/gen_parents.go
@@ -0,0 +1,54 @@
+// Copyright 2018 The Go 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 ignore
+
+package main
+
+import (
+	"log"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/language"
+	"golang.org/x/text/internal/language/compact"
+	"golang.org/x/text/unicode/cldr"
+)
+
+func main() {
+	r := gen.OpenCLDRCoreZip()
+	defer r.Close()
+
+	d := &cldr.Decoder{}
+	data, err := d.DecodeZip(r)
+	if err != nil {
+		log.Fatalf("DecodeZip: %v", err)
+	}
+
+	w := gen.NewCodeWriter()
+	defer w.WriteGoFile("parents.go", "compact")
+
+	// Create parents table.
+	type ID uint16
+	parents := make([]ID, compact.NumCompactTags)
+	for _, loc := range data.Locales() {
+		tag := language.MustParse(loc)
+		index, ok := compact.FromTag(tag)
+		if !ok {
+			continue
+		}
+		parentIndex := compact.ID(0) // und
+		for p := tag.Parent(); p != language.Und; p = p.Parent() {
+			if x, ok := compact.FromTag(p); ok {
+				parentIndex = x
+				break
+			}
+		}
+		parents[index] = ID(parentIndex)
+	}
+
+	w.WriteComment(`
+	parents maps a compact index of a tag to the compact index of the parent of
+	this tag.`)
+	w.WriteVar("parents", parents)
+}
diff --git a/vendor/golang.org/x/text/internal/language/gen.go b/vendor/golang.org/x/text/internal/language/gen.go
new file mode 100644
index 000000000..cdcc7febc
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/gen.go
@@ -0,0 +1,1520 @@
+// Copyright 2013 The Go 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 ignore
+
+// Language tag table generator.
+// Data read from the web.
+
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"math"
+	"reflect"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/tag"
+	"golang.org/x/text/unicode/cldr"
+)
+
+var (
+	test = flag.Bool("test",
+		false,
+		"test existing tables; can be used to compare web data with package data.")
+	outputFile = flag.String("output",
+		"tables.go",
+		"output file for generated tables")
+)
+
+var comment = []string{
+	`
+lang holds an alphabetically sorted list of ISO-639 language identifiers.
+All entries are 4 bytes. The index of the identifier (divided by 4) is the language tag.
+For 2-byte language identifiers, the two successive bytes have the following meaning:
+    - if the first letter of the 2- and 3-letter ISO codes are the same:
+      the second and third letter of the 3-letter ISO code.
+    - otherwise: a 0 and a by 2 bits right-shifted index into altLangISO3.
+For 3-byte language identifiers the 4th byte is 0.`,
+	`
+langNoIndex is a bit vector of all 3-letter language codes that are not used as an index
+in lookup tables. The language ids for these language codes are derived directly
+from the letters and are not consecutive.`,
+	`
+altLangISO3 holds an alphabetically sorted list of 3-letter language code alternatives
+to 2-letter language codes that cannot be derived using the method described above.
+Each 3-letter code is followed by its 1-byte langID.`,
+	`
+altLangIndex is used to convert indexes in altLangISO3 to langIDs.`,
+	`
+AliasMap maps langIDs to their suggested replacements.`,
+	`
+script is an alphabetically sorted list of ISO 15924 codes. The index
+of the script in the string, divided by 4, is the internal scriptID.`,
+	`
+isoRegionOffset needs to be added to the index of regionISO to obtain the regionID
+for 2-letter ISO codes. (The first isoRegionOffset regionIDs are reserved for
+the UN.M49 codes used for groups.)`,
+	`
+regionISO holds a list of alphabetically sorted 2-letter ISO region codes.
+Each 2-letter codes is followed by two bytes with the following meaning:
+    - [A-Z}{2}: the first letter of the 2-letter code plus these two
+                letters form the 3-letter ISO code.
+    - 0, n:     index into altRegionISO3.`,
+	`
+regionTypes defines the status of a region for various standards.`,
+	`
+m49 maps regionIDs to UN.M49 codes. The first isoRegionOffset entries are
+codes indicating collections of regions.`,
+	`
+m49Index gives indexes into fromM49 based on the three most significant bits
+of a 10-bit UN.M49 code. To search an UN.M49 code in fromM49, search in
+   fromM49[m49Index[msb39(code)]:m49Index[msb3(code)+1]]
+for an entry where the first 7 bits match the 7 lsb of the UN.M49 code.
+The region code is stored in the 9 lsb of the indexed value.`,
+	`
+fromM49 contains entries to map UN.M49 codes to regions. See m49Index for details.`,
+	`
+altRegionISO3 holds a list of 3-letter region codes that cannot be
+mapped to 2-letter codes using the default algorithm. This is a short list.`,
+	`
+altRegionIDs holds a list of regionIDs the positions of which match those
+of the 3-letter ISO codes in altRegionISO3.`,
+	`
+variantNumSpecialized is the number of specialized variants in variants.`,
+	`
+suppressScript is an index from langID to the dominant script for that language,
+if it exists.  If a script is given, it should be suppressed from the language tag.`,
+	`
+likelyLang is a lookup table, indexed by langID, for the most likely
+scripts and regions given incomplete information. If more entries exist for a
+given language, region and script are the index and size respectively
+of the list in likelyLangList.`,
+	`
+likelyLangList holds lists info associated with likelyLang.`,
+	`
+likelyRegion is a lookup table, indexed by regionID, for the most likely
+languages and scripts given incomplete information. If more entries exist
+for a given regionID, lang and script are the index and size respectively
+of the list in likelyRegionList.
+TODO: exclude containers and user-definable regions from the list.`,
+	`
+likelyRegionList holds lists info associated with likelyRegion.`,
+	`
+likelyScript is a lookup table, indexed by scriptID, for the most likely
+languages and regions given a script.`,
+	`
+nRegionGroups is the number of region groups.`,
+	`
+regionInclusion maps region identifiers to sets of regions in regionInclusionBits,
+where each set holds all groupings that are directly connected in a region
+containment graph.`,
+	`
+regionInclusionBits is an array of bit vectors where every vector represents
+a set of region groupings.  These sets are used to compute the distance
+between two regions for the purpose of language matching.`,
+	`
+regionInclusionNext marks, for each entry in regionInclusionBits, the set of
+all groups that are reachable from the groups set in the respective entry.`,
+}
+
+// TODO: consider changing some of these structures to tries. This can reduce
+// memory, but may increase the need for memory allocations. This could be
+// mitigated if we can piggyback on language tags for common cases.
+
+func failOnError(e error) {
+	if e != nil {
+		log.Panic(e)
+	}
+}
+
+type setType int
+
+const (
+	Indexed setType = 1 + iota // all elements must be of same size
+	Linear
+)
+
+type stringSet struct {
+	s              []string
+	sorted, frozen bool
+
+	// We often need to update values after the creation of an index is completed.
+	// We include a convenience map for keeping track of this.
+	update map[string]string
+	typ    setType // used for checking.
+}
+
+func (ss *stringSet) clone() stringSet {
+	c := *ss
+	c.s = append([]string(nil), c.s...)
+	return c
+}
+
+func (ss *stringSet) setType(t setType) {
+	if ss.typ != t && ss.typ != 0 {
+		log.Panicf("type %d cannot be assigned as it was already %d", t, ss.typ)
+	}
+}
+
+// parse parses a whitespace-separated string and initializes ss with its
+// components.
+func (ss *stringSet) parse(s string) {
+	scan := bufio.NewScanner(strings.NewReader(s))
+	scan.Split(bufio.ScanWords)
+	for scan.Scan() {
+		ss.add(scan.Text())
+	}
+}
+
+func (ss *stringSet) assertChangeable() {
+	if ss.frozen {
+		log.Panic("attempt to modify a frozen stringSet")
+	}
+}
+
+func (ss *stringSet) add(s string) {
+	ss.assertChangeable()
+	ss.s = append(ss.s, s)
+	ss.sorted = ss.frozen
+}
+
+func (ss *stringSet) freeze() {
+	ss.compact()
+	ss.frozen = true
+}
+
+func (ss *stringSet) compact() {
+	if ss.sorted {
+		return
+	}
+	a := ss.s
+	sort.Strings(a)
+	k := 0
+	for i := 1; i < len(a); i++ {
+		if a[k] != a[i] {
+			a[k+1] = a[i]
+			k++
+		}
+	}
+	ss.s = a[:k+1]
+	ss.sorted = ss.frozen
+}
+
+type funcSorter struct {
+	fn func(a, b string) bool
+	sort.StringSlice
+}
+
+func (s funcSorter) Less(i, j int) bool {
+	return s.fn(s.StringSlice[i], s.StringSlice[j])
+}
+
+func (ss *stringSet) sortFunc(f func(a, b string) bool) {
+	ss.compact()
+	sort.Sort(funcSorter{f, sort.StringSlice(ss.s)})
+}
+
+func (ss *stringSet) remove(s string) {
+	ss.assertChangeable()
+	if i, ok := ss.find(s); ok {
+		copy(ss.s[i:], ss.s[i+1:])
+		ss.s = ss.s[:len(ss.s)-1]
+	}
+}
+
+func (ss *stringSet) replace(ol, nu string) {
+	ss.s[ss.index(ol)] = nu
+	ss.sorted = ss.frozen
+}
+
+func (ss *stringSet) index(s string) int {
+	ss.setType(Indexed)
+	i, ok := ss.find(s)
+	if !ok {
+		if i < len(ss.s) {
+			log.Panicf("find: item %q is not in list. Closest match is %q.", s, ss.s[i])
+		}
+		log.Panicf("find: item %q is not in list", s)
+
+	}
+	return i
+}
+
+func (ss *stringSet) find(s string) (int, bool) {
+	ss.compact()
+	i := sort.SearchStrings(ss.s, s)
+	return i, i != len(ss.s) && ss.s[i] == s
+}
+
+func (ss *stringSet) slice() []string {
+	ss.compact()
+	return ss.s
+}
+
+func (ss *stringSet) updateLater(v, key string) {
+	if ss.update == nil {
+		ss.update = map[string]string{}
+	}
+	ss.update[v] = key
+}
+
+// join joins the string and ensures that all entries are of the same length.
+func (ss *stringSet) join() string {
+	ss.setType(Indexed)
+	n := len(ss.s[0])
+	for _, s := range ss.s {
+		if len(s) != n {
+			log.Panicf("join: not all entries are of the same length: %q", s)
+		}
+	}
+	ss.s = append(ss.s, strings.Repeat("\xff", n))
+	return strings.Join(ss.s, "")
+}
+
+// ianaEntry holds information for an entry in the IANA Language Subtag Repository.
+// All types use the same entry.
+// See http://tools.ietf.org/html/bcp47#section-5.1 for a description of the various
+// fields.
+type ianaEntry struct {
+	typ            string
+	description    []string
+	scope          string
+	added          string
+	preferred      string
+	deprecated     string
+	suppressScript string
+	macro          string
+	prefix         []string
+}
+
+type builder struct {
+	w    *gen.CodeWriter
+	hw   io.Writer // MultiWriter for w and w.Hash
+	data *cldr.CLDR
+	supp *cldr.SupplementalData
+
+	// indices
+	locale      stringSet // common locales
+	lang        stringSet // canonical language ids (2 or 3 letter ISO codes) with data
+	langNoIndex stringSet // 3-letter ISO codes with no associated data
+	script      stringSet // 4-letter ISO codes
+	region      stringSet // 2-letter ISO or 3-digit UN M49 codes
+	variant     stringSet // 4-8-alphanumeric variant code.
+
+	// Region codes that are groups with their corresponding group IDs.
+	groups map[int]index
+
+	// langInfo
+	registry map[string]*ianaEntry
+}
+
+type index uint
+
+func newBuilder(w *gen.CodeWriter) *builder {
+	r := gen.OpenCLDRCoreZip()
+	defer r.Close()
+	d := &cldr.Decoder{}
+	data, err := d.DecodeZip(r)
+	failOnError(err)
+	b := builder{
+		w:    w,
+		hw:   io.MultiWriter(w, w.Hash),
+		data: data,
+		supp: data.Supplemental(),
+	}
+	b.parseRegistry()
+	return &b
+}
+
+func (b *builder) parseRegistry() {
+	r := gen.OpenIANAFile("assignments/language-subtag-registry")
+	defer r.Close()
+	b.registry = make(map[string]*ianaEntry)
+
+	scan := bufio.NewScanner(r)
+	scan.Split(bufio.ScanWords)
+	var record *ianaEntry
+	for more := scan.Scan(); more; {
+		key := scan.Text()
+		more = scan.Scan()
+		value := scan.Text()
+		switch key {
+		case "Type:":
+			record = &ianaEntry{typ: value}
+		case "Subtag:", "Tag:":
+			if s := strings.SplitN(value, "..", 2); len(s) > 1 {
+				for a := s[0]; a <= s[1]; a = inc(a) {
+					b.addToRegistry(a, record)
+				}
+			} else {
+				b.addToRegistry(value, record)
+			}
+		case "Suppress-Script:":
+			record.suppressScript = value
+		case "Added:":
+			record.added = value
+		case "Deprecated:":
+			record.deprecated = value
+		case "Macrolanguage:":
+			record.macro = value
+		case "Preferred-Value:":
+			record.preferred = value
+		case "Prefix:":
+			record.prefix = append(record.prefix, value)
+		case "Scope:":
+			record.scope = value
+		case "Description:":
+			buf := []byte(value)
+			for more = scan.Scan(); more; more = scan.Scan() {
+				b := scan.Bytes()
+				if b[0] == '%' || b[len(b)-1] == ':' {
+					break
+				}
+				buf = append(buf, ' ')
+				buf = append(buf, b...)
+			}
+			record.description = append(record.description, string(buf))
+			continue
+		default:
+			continue
+		}
+		more = scan.Scan()
+	}
+	if scan.Err() != nil {
+		log.Panic(scan.Err())
+	}
+}
+
+func (b *builder) addToRegistry(key string, entry *ianaEntry) {
+	if info, ok := b.registry[key]; ok {
+		if info.typ != "language" || entry.typ != "extlang" {
+			log.Fatalf("parseRegistry: tag %q already exists", key)
+		}
+	} else {
+		b.registry[key] = entry
+	}
+}
+
+var commentIndex = make(map[string]string)
+
+func init() {
+	for _, s := range comment {
+		key := strings.TrimSpace(strings.SplitN(s, " ", 2)[0])
+		commentIndex[key] = s
+	}
+}
+
+func (b *builder) comment(name string) {
+	if s := commentIndex[name]; len(s) > 0 {
+		b.w.WriteComment(s)
+	} else {
+		fmt.Fprintln(b.w)
+	}
+}
+
+func (b *builder) pf(f string, x ...interface{}) {
+	fmt.Fprintf(b.hw, f, x...)
+	fmt.Fprint(b.hw, "\n")
+}
+
+func (b *builder) p(x ...interface{}) {
+	fmt.Fprintln(b.hw, x...)
+}
+
+func (b *builder) addSize(s int) {
+	b.w.Size += s
+	b.pf("// Size: %d bytes", s)
+}
+
+func (b *builder) writeConst(name string, x interface{}) {
+	b.comment(name)
+	b.w.WriteConst(name, x)
+}
+
+// writeConsts computes f(v) for all v in values and writes the results
+// as constants named _v to a single constant block.
+func (b *builder) writeConsts(f func(string) int, values ...string) {
+	b.pf("const (")
+	for _, v := range values {
+		b.pf("\t_%s = %v", v, f(v))
+	}
+	b.pf(")")
+}
+
+// writeType writes the type of the given value, which must be a struct.
+func (b *builder) writeType(value interface{}) {
+	b.comment(reflect.TypeOf(value).Name())
+	b.w.WriteType(value)
+}
+
+func (b *builder) writeSlice(name string, ss interface{}) {
+	b.writeSliceAddSize(name, 0, ss)
+}
+
+func (b *builder) writeSliceAddSize(name string, extraSize int, ss interface{}) {
+	b.comment(name)
+	b.w.Size += extraSize
+	v := reflect.ValueOf(ss)
+	t := v.Type().Elem()
+	b.pf("// Size: %d bytes, %d elements", v.Len()*int(t.Size())+extraSize, v.Len())
+
+	fmt.Fprintf(b.w, "var %s = ", name)
+	b.w.WriteArray(ss)
+	b.p()
+}
+
+type FromTo struct {
+	From, To uint16
+}
+
+func (b *builder) writeSortedMap(name string, ss *stringSet, index func(s string) uint16) {
+	ss.sortFunc(func(a, b string) bool {
+		return index(a) < index(b)
+	})
+	m := []FromTo{}
+	for _, s := range ss.s {
+		m = append(m, FromTo{index(s), index(ss.update[s])})
+	}
+	b.writeSlice(name, m)
+}
+
+const base = 'z' - 'a' + 1
+
+func strToInt(s string) uint {
+	v := uint(0)
+	for i := 0; i < len(s); i++ {
+		v *= base
+		v += uint(s[i] - 'a')
+	}
+	return v
+}
+
+// converts the given integer to the original ASCII string passed to strToInt.
+// len(s) must match the number of characters obtained.
+func intToStr(v uint, s []byte) {
+	for i := len(s) - 1; i >= 0; i-- {
+		s[i] = byte(v%base) + 'a'
+		v /= base
+	}
+}
+
+func (b *builder) writeBitVector(name string, ss []string) {
+	vec := make([]uint8, int(math.Ceil(math.Pow(base, float64(len(ss[0])))/8)))
+	for _, s := range ss {
+		v := strToInt(s)
+		vec[v/8] |= 1 << (v % 8)
+	}
+	b.writeSlice(name, vec)
+}
+
+// TODO: convert this type into a list or two-stage trie.
+func (b *builder) writeMapFunc(name string, m map[string]string, f func(string) uint16) {
+	b.comment(name)
+	v := reflect.ValueOf(m)
+	sz := v.Len() * (2 + int(v.Type().Key().Size()))
+	for _, k := range m {
+		sz += len(k)
+	}
+	b.addSize(sz)
+	keys := []string{}
+	b.pf(`var %s = map[string]uint16{`, name)
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		b.pf("\t%q: %v,", k, f(m[k]))
+	}
+	b.p("}")
+}
+
+func (b *builder) writeMap(name string, m interface{}) {
+	b.comment(name)
+	v := reflect.ValueOf(m)
+	sz := v.Len() * (2 + int(v.Type().Key().Size()) + int(v.Type().Elem().Size()))
+	b.addSize(sz)
+	f := strings.FieldsFunc(fmt.Sprintf("%#v", m), func(r rune) bool {
+		return strings.IndexRune("{}, ", r) != -1
+	})
+	sort.Strings(f[1:])
+	b.pf(`var %s = %s{`, name, f[0])
+	for _, kv := range f[1:] {
+		b.pf("\t%s,", kv)
+	}
+	b.p("}")
+}
+
+func (b *builder) langIndex(s string) uint16 {
+	if s == "und" {
+		return 0
+	}
+	if i, ok := b.lang.find(s); ok {
+		return uint16(i)
+	}
+	return uint16(strToInt(s)) + uint16(len(b.lang.s))
+}
+
+// inc advances the string to its lexicographical successor.
+func inc(s string) string {
+	const maxTagLength = 4
+	var buf [maxTagLength]byte
+	intToStr(strToInt(strings.ToLower(s))+1, buf[:len(s)])
+	for i := 0; i < len(s); i++ {
+		if s[i] <= 'Z' {
+			buf[i] -= 'a' - 'A'
+		}
+	}
+	return string(buf[:len(s)])
+}
+
+func (b *builder) parseIndices() {
+	meta := b.supp.Metadata
+
+	for k, v := range b.registry {
+		var ss *stringSet
+		switch v.typ {
+		case "language":
+			if len(k) == 2 || v.suppressScript != "" || v.scope == "special" {
+				b.lang.add(k)
+				continue
+			} else {
+				ss = &b.langNoIndex
+			}
+		case "region":
+			ss = &b.region
+		case "script":
+			ss = &b.script
+		case "variant":
+			ss = &b.variant
+		default:
+			continue
+		}
+		ss.add(k)
+	}
+	// Include any language for which there is data.
+	for _, lang := range b.data.Locales() {
+		if x := b.data.RawLDML(lang); false ||
+			x.LocaleDisplayNames != nil ||
+			x.Characters != nil ||
+			x.Delimiters != nil ||
+			x.Measurement != nil ||
+			x.Dates != nil ||
+			x.Numbers != nil ||
+			x.Units != nil ||
+			x.ListPatterns != nil ||
+			x.Collations != nil ||
+			x.Segmentations != nil ||
+			x.Rbnf != nil ||
+			x.Annotations != nil ||
+			x.Metadata != nil {
+
+			from := strings.Split(lang, "_")
+			if lang := from[0]; lang != "root" {
+				b.lang.add(lang)
+			}
+		}
+	}
+	// Include locales for plural rules, which uses a different structure.
+	for _, plurals := range b.data.Supplemental().Plurals {
+		for _, rules := range plurals.PluralRules {
+			for _, lang := range strings.Split(rules.Locales, " ") {
+				if lang = strings.Split(lang, "_")[0]; lang != "root" {
+					b.lang.add(lang)
+				}
+			}
+		}
+	}
+	// Include languages in likely subtags.
+	for _, m := range b.supp.LikelySubtags.LikelySubtag {
+		from := strings.Split(m.From, "_")
+		b.lang.add(from[0])
+	}
+	// Include ISO-639 alpha-3 bibliographic entries.
+	for _, a := range meta.Alias.LanguageAlias {
+		if a.Reason == "bibliographic" {
+			b.langNoIndex.add(a.Type)
+		}
+	}
+	// Include regions in territoryAlias (not all are in the IANA registry!)
+	for _, reg := range b.supp.Metadata.Alias.TerritoryAlias {
+		if len(reg.Type) == 2 {
+			b.region.add(reg.Type)
+		}
+	}
+
+	for _, s := range b.lang.s {
+		if len(s) == 3 {
+			b.langNoIndex.remove(s)
+		}
+	}
+	b.writeConst("NumLanguages", len(b.lang.slice())+len(b.langNoIndex.slice()))
+	b.writeConst("NumScripts", len(b.script.slice()))
+	b.writeConst("NumRegions", len(b.region.slice()))
+
+	// Add dummy codes at the start of each list to represent "unspecified".
+	b.lang.add("---")
+	b.script.add("----")
+	b.region.add("---")
+
+	// common locales
+	b.locale.parse(meta.DefaultContent.Locales)
+}
+
+// TODO: region inclusion data will probably not be use used in future matchers.
+
+func (b *builder) computeRegionGroups() {
+	b.groups = make(map[int]index)
+
+	// Create group indices.
+	for i := 1; b.region.s[i][0] < 'A'; i++ { // Base M49 indices on regionID.
+		b.groups[i] = index(len(b.groups))
+	}
+	for _, g := range b.supp.TerritoryContainment.Group {
+		// Skip UN and EURO zone as they are flattening the containment
+		// relationship.
+		if g.Type == "EZ" || g.Type == "UN" {
+			continue
+		}
+		group := b.region.index(g.Type)
+		if _, ok := b.groups[group]; !ok {
+			b.groups[group] = index(len(b.groups))
+		}
+	}
+	if len(b.groups) > 64 {
+		log.Fatalf("only 64 groups supported, found %d", len(b.groups))
+	}
+	b.writeConst("nRegionGroups", len(b.groups))
+}
+
+var langConsts = []string{
+	"af", "am", "ar", "az", "bg", "bn", "ca", "cs", "da", "de", "el", "en", "es",
+	"et", "fa", "fi", "fil", "fr", "gu", "he", "hi", "hr", "hu", "hy", "id", "is",
+	"it", "ja", "ka", "kk", "km", "kn", "ko", "ky", "lo", "lt", "lv", "mk", "ml",
+	"mn", "mo", "mr", "ms", "mul", "my", "nb", "ne", "nl", "no", "pa", "pl", "pt",
+	"ro", "ru", "sh", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th",
+	"tl", "tn", "tr", "uk", "ur", "uz", "vi", "zh", "zu",
+
+	// constants for grandfathered tags (if not already defined)
+	"jbo", "ami", "bnn", "hak", "tlh", "lb", "nv", "pwn", "tao", "tay", "tsu",
+	"nn", "sfb", "vgt", "sgg", "cmn", "nan", "hsn",
+}
+
+// writeLanguage generates all tables needed for language canonicalization.
+func (b *builder) writeLanguage() {
+	meta := b.supp.Metadata
+
+	b.writeConst("nonCanonicalUnd", b.lang.index("und"))
+	b.writeConsts(func(s string) int { return int(b.langIndex(s)) }, langConsts...)
+	b.writeConst("langPrivateStart", b.langIndex("qaa"))
+	b.writeConst("langPrivateEnd", b.langIndex("qtz"))
+
+	// Get language codes that need to be mapped (overlong 3-letter codes,
+	// deprecated 2-letter codes, legacy and grandfathered tags.)
+	langAliasMap := stringSet{}
+	aliasTypeMap := map[string]AliasType{}
+
+	// altLangISO3 get the alternative ISO3 names that need to be mapped.
+	altLangISO3 := stringSet{}
+	// Add dummy start to avoid the use of index 0.
+	altLangISO3.add("---")
+	altLangISO3.updateLater("---", "aa")
+
+	lang := b.lang.clone()
+	for _, a := range meta.Alias.LanguageAlias {
+		if a.Replacement == "" {
+			a.Replacement = "und"
+		}
+		// TODO: support mapping to tags
+		repl := strings.SplitN(a.Replacement, "_", 2)[0]
+		if a.Reason == "overlong" {
+			if len(a.Replacement) == 2 && len(a.Type) == 3 {
+				lang.updateLater(a.Replacement, a.Type)
+			}
+		} else if len(a.Type) <= 3 {
+			switch a.Reason {
+			case "macrolanguage":
+				aliasTypeMap[a.Type] = Macro
+			case "deprecated":
+				// handled elsewhere
+				continue
+			case "bibliographic", "legacy":
+				if a.Type == "no" {
+					continue
+				}
+				aliasTypeMap[a.Type] = Legacy
+			default:
+				log.Fatalf("new %s alias: %s", a.Reason, a.Type)
+			}
+			langAliasMap.add(a.Type)
+			langAliasMap.updateLater(a.Type, repl)
+		}
+	}
+	// Manually add the mapping of "nb" (Norwegian) to its macro language.
+	// This can be removed if CLDR adopts this change.
+	langAliasMap.add("nb")
+	langAliasMap.updateLater("nb", "no")
+	aliasTypeMap["nb"] = Macro
+
+	for k, v := range b.registry {
+		// Also add deprecated values for 3-letter ISO codes, which CLDR omits.
+		if v.typ == "language" && v.deprecated != "" && v.preferred != "" {
+			langAliasMap.add(k)
+			langAliasMap.updateLater(k, v.preferred)
+			aliasTypeMap[k] = Deprecated
+		}
+	}
+	// Fix CLDR mappings.
+	lang.updateLater("tl", "tgl")
+	lang.updateLater("sh", "hbs")
+	lang.updateLater("mo", "mol")
+	lang.updateLater("no", "nor")
+	lang.updateLater("tw", "twi")
+	lang.updateLater("nb", "nob")
+	lang.updateLater("ak", "aka")
+	lang.updateLater("bh", "bih")
+
+	// Ensure that each 2-letter code is matched with a 3-letter code.
+	for _, v := range lang.s[1:] {
+		s, ok := lang.update[v]
+		if !ok {
+			if s, ok = lang.update[langAliasMap.update[v]]; !ok {
+				continue
+			}
+			lang.update[v] = s
+		}
+		if v[0] != s[0] {
+			altLangISO3.add(s)
+			altLangISO3.updateLater(s, v)
+		}
+	}
+
+	// Complete canonicalized language tags.
+	lang.freeze()
+	for i, v := range lang.s {
+		// We can avoid these manual entries by using the IANA registry directly.
+		// Seems easier to update the list manually, as changes are rare.
+		// The panic in this loop will trigger if we miss an entry.
+		add := ""
+		if s, ok := lang.update[v]; ok {
+			if s[0] == v[0] {
+				add = s[1:]
+			} else {
+				add = string([]byte{0, byte(altLangISO3.index(s))})
+			}
+		} else if len(v) == 3 {
+			add = "\x00"
+		} else {
+			log.Panicf("no data for long form of %q", v)
+		}
+		lang.s[i] += add
+	}
+	b.writeConst("lang", tag.Index(lang.join()))
+
+	b.writeConst("langNoIndexOffset", len(b.lang.s))
+
+	// space of all valid 3-letter language identifiers.
+	b.writeBitVector("langNoIndex", b.langNoIndex.slice())
+
+	altLangIndex := []uint16{}
+	for i, s := range altLangISO3.slice() {
+		altLangISO3.s[i] += string([]byte{byte(len(altLangIndex))})
+		if i > 0 {
+			idx := b.lang.index(altLangISO3.update[s])
+			altLangIndex = append(altLangIndex, uint16(idx))
+		}
+	}
+	b.writeConst("altLangISO3", tag.Index(altLangISO3.join()))
+	b.writeSlice("altLangIndex", altLangIndex)
+
+	b.writeSortedMap("AliasMap", &langAliasMap, b.langIndex)
+	types := make([]AliasType, len(langAliasMap.s))
+	for i, s := range langAliasMap.s {
+		types[i] = aliasTypeMap[s]
+	}
+	b.writeSlice("AliasTypes", types)
+}
+
+var scriptConsts = []string{
+	"Latn", "Hani", "Hans", "Hant", "Qaaa", "Qaai", "Qabx", "Zinh", "Zyyy",
+	"Zzzz",
+}
+
+func (b *builder) writeScript() {
+	b.writeConsts(b.script.index, scriptConsts...)
+	b.writeConst("script", tag.Index(b.script.join()))
+
+	supp := make([]uint8, len(b.lang.slice()))
+	for i, v := range b.lang.slice()[1:] {
+		if sc := b.registry[v].suppressScript; sc != "" {
+			supp[i+1] = uint8(b.script.index(sc))
+		}
+	}
+	b.writeSlice("suppressScript", supp)
+
+	// There is only one deprecated script in CLDR. This value is hard-coded.
+	// We check here if the code must be updated.
+	for _, a := range b.supp.Metadata.Alias.ScriptAlias {
+		if a.Type != "Qaai" {
+			log.Panicf("unexpected deprecated stript %q", a.Type)
+		}
+	}
+}
+
+func parseM49(s string) int16 {
+	if len(s) == 0 {
+		return 0
+	}
+	v, err := strconv.ParseUint(s, 10, 10)
+	failOnError(err)
+	return int16(v)
+}
+
+var regionConsts = []string{
+	"001", "419", "BR", "CA", "ES", "GB", "MD", "PT", "UK", "US",
+	"ZZ", "XA", "XC", "XK", // Unofficial tag for Kosovo.
+}
+
+func (b *builder) writeRegion() {
+	b.writeConsts(b.region.index, regionConsts...)
+
+	isoOffset := b.region.index("AA")
+	m49map := make([]int16, len(b.region.slice()))
+	fromM49map := make(map[int16]int)
+	altRegionISO3 := ""
+	altRegionIDs := []uint16{}
+
+	b.writeConst("isoRegionOffset", isoOffset)
+
+	// 2-letter region lookup and mapping to numeric codes.
+	regionISO := b.region.clone()
+	regionISO.s = regionISO.s[isoOffset:]
+	regionISO.sorted = false
+
+	regionTypes := make([]byte, len(b.region.s))
+
+	// Is the region valid BCP 47?
+	for s, e := range b.registry {
+		if len(s) == 2 && s == strings.ToUpper(s) {
+			i := b.region.index(s)
+			for _, d := range e.description {
+				if strings.Contains(d, "Private use") {
+					regionTypes[i] = iso3166UserAssigned
+				}
+			}
+			regionTypes[i] |= bcp47Region
+		}
+	}
+
+	// Is the region a valid ccTLD?
+	r := gen.OpenIANAFile("domains/root/db")
+	defer r.Close()
+
+	buf, err := ioutil.ReadAll(r)
+	failOnError(err)
+	re := regexp.MustCompile(`"/domains/root/db/([a-z]{2}).html"`)
+	for _, m := range re.FindAllSubmatch(buf, -1) {
+		i := b.region.index(strings.ToUpper(string(m[1])))
+		regionTypes[i] |= ccTLD
+	}
+
+	b.writeSlice("regionTypes", regionTypes)
+
+	iso3Set := make(map[string]int)
+	update := func(iso2, iso3 string) {
+		i := regionISO.index(iso2)
+		if j, ok := iso3Set[iso3]; !ok && iso3[0] == iso2[0] {
+			regionISO.s[i] += iso3[1:]
+			iso3Set[iso3] = -1
+		} else {
+			if ok && j >= 0 {
+				regionISO.s[i] += string([]byte{0, byte(j)})
+			} else {
+				iso3Set[iso3] = len(altRegionISO3)
+				regionISO.s[i] += string([]byte{0, byte(len(altRegionISO3))})
+				altRegionISO3 += iso3
+				altRegionIDs = append(altRegionIDs, uint16(isoOffset+i))
+			}
+		}
+	}
+	for _, tc := range b.supp.CodeMappings.TerritoryCodes {
+		i := regionISO.index(tc.Type) + isoOffset
+		if d := m49map[i]; d != 0 {
+			log.Panicf("%s found as a duplicate UN.M49 code of %03d", tc.Numeric, d)
+		}
+		m49 := parseM49(tc.Numeric)
+		m49map[i] = m49
+		if r := fromM49map[m49]; r == 0 {
+			fromM49map[m49] = i
+		} else if r != i {
+			dep := b.registry[regionISO.s[r-isoOffset]].deprecated
+			if t := b.registry[tc.Type]; t != nil && dep != "" && (t.deprecated == "" || t.deprecated > dep) {
+				fromM49map[m49] = i
+			}
+		}
+	}
+	for _, ta := range b.supp.Metadata.Alias.TerritoryAlias {
+		if len(ta.Type) == 3 && ta.Type[0] <= '9' && len(ta.Replacement) == 2 {
+			from := parseM49(ta.Type)
+			if r := fromM49map[from]; r == 0 {
+				fromM49map[from] = regionISO.index(ta.Replacement) + isoOffset
+			}
+		}
+	}
+	for _, tc := range b.supp.CodeMappings.TerritoryCodes {
+		if len(tc.Alpha3) == 3 {
+			update(tc.Type, tc.Alpha3)
+		}
+	}
+	// This entries are not included in territoryCodes. Mostly 3-letter variants
+	// of deleted codes and an entry for QU.
+	for _, m := range []struct{ iso2, iso3 string }{
+		{"CT", "CTE"},
+		{"DY", "DHY"},
+		{"HV", "HVO"},
+		{"JT", "JTN"},
+		{"MI", "MID"},
+		{"NH", "NHB"},
+		{"NQ", "ATN"},
+		{"PC", "PCI"},
+		{"PU", "PUS"},
+		{"PZ", "PCZ"},
+		{"RH", "RHO"},
+		{"VD", "VDR"},
+		{"WK", "WAK"},
+		// These three-letter codes are used for others as well.
+		{"FQ", "ATF"},
+	} {
+		update(m.iso2, m.iso3)
+	}
+	for i, s := range regionISO.s {
+		if len(s) != 4 {
+			regionISO.s[i] = s + "  "
+		}
+	}
+	b.writeConst("regionISO", tag.Index(regionISO.join()))
+	b.writeConst("altRegionISO3", altRegionISO3)
+	b.writeSlice("altRegionIDs", altRegionIDs)
+
+	// Create list of deprecated regions.
+	// TODO: consider inserting SF -> FI. Not included by CLDR, but is the only
+	// Transitionally-reserved mapping not included.
+	regionOldMap := stringSet{}
+	// Include regions in territoryAlias (not all are in the IANA registry!)
+	for _, reg := range b.supp.Metadata.Alias.TerritoryAlias {
+		if len(reg.Type) == 2 && reg.Reason == "deprecated" && len(reg.Replacement) == 2 {
+			regionOldMap.add(reg.Type)
+			regionOldMap.updateLater(reg.Type, reg.Replacement)
+			i, _ := regionISO.find(reg.Type)
+			j, _ := regionISO.find(reg.Replacement)
+			if k := m49map[i+isoOffset]; k == 0 {
+				m49map[i+isoOffset] = m49map[j+isoOffset]
+			}
+		}
+	}
+	b.writeSortedMap("regionOldMap", &regionOldMap, func(s string) uint16 {
+		return uint16(b.region.index(s))
+	})
+	// 3-digit region lookup, groupings.
+	for i := 1; i < isoOffset; i++ {
+		m := parseM49(b.region.s[i])
+		m49map[i] = m
+		fromM49map[m] = i
+	}
+	b.writeSlice("m49", m49map)
+
+	const (
+		searchBits = 7
+		regionBits = 9
+	)
+	if len(m49map) >= 1<<regionBits {
+		log.Fatalf("Maximum number of regions exceeded: %d > %d", len(m49map), 1<<regionBits)
+	}
+	m49Index := [9]int16{}
+	fromM49 := []uint16{}
+	m49 := []int{}
+	for k, _ := range fromM49map {
+		m49 = append(m49, int(k))
+	}
+	sort.Ints(m49)
+	for _, k := range m49[1:] {
+		val := (k & (1<<searchBits - 1)) << regionBits
+		fromM49 = append(fromM49, uint16(val|fromM49map[int16(k)]))
+		m49Index[1:][k>>searchBits] = int16(len(fromM49))
+	}
+	b.writeSlice("m49Index", m49Index)
+	b.writeSlice("fromM49", fromM49)
+}
+
+const (
+	// TODO: put these lists in regionTypes as user data? Could be used for
+	// various optimizations and refinements and could be exposed in the API.
+	iso3166Except = "AC CP DG EA EU FX IC SU TA UK"
+	iso3166Trans  = "AN BU CS NT TP YU ZR" // SF is not in our set of Regions.
+	// DY and RH are actually not deleted, but indeterminately reserved.
+	iso3166DelCLDR = "CT DD DY FQ HV JT MI NH NQ PC PU PZ RH VD WK YD"
+)
+
+const (
+	iso3166UserAssigned = 1 << iota
+	ccTLD
+	bcp47Region
+)
+
+func find(list []string, s string) int {
+	for i, t := range list {
+		if t == s {
+			return i
+		}
+	}
+	return -1
+}
+
+// writeVariants generates per-variant information and creates a map from variant
+// name to index value. We assign index values such that sorting multiple
+// variants by index value will result in the correct order.
+// There are two types of variants: specialized and general. Specialized variants
+// are only applicable to certain language or language-script pairs. Generalized
+// variants apply to any language. Generalized variants always sort after
+// specialized variants.  We will therefore always assign a higher index value
+// to a generalized variant than any other variant. Generalized variants are
+// sorted alphabetically among themselves.
+// Specialized variants may also sort after other specialized variants. Such
+// variants will be ordered after any of the variants they may follow.
+// We assume that if a variant x is followed by a variant y, then for any prefix
+// p of x, p-x is a prefix of y. This allows us to order tags based on the
+// maximum of the length of any of its prefixes.
+// TODO: it is possible to define a set of Prefix values on variants such that
+// a total order cannot be defined to the point that this algorithm breaks.
+// In other words, we cannot guarantee the same order of variants for the
+// future using the same algorithm or for non-compliant combinations of
+// variants. For this reason, consider using simple alphabetic sorting
+// of variants and ignore Prefix restrictions altogether.
+func (b *builder) writeVariant() {
+	generalized := stringSet{}
+	specialized := stringSet{}
+	specializedExtend := stringSet{}
+	// Collate the variants by type and check assumptions.
+	for _, v := range b.variant.slice() {
+		e := b.registry[v]
+		if len(e.prefix) == 0 {
+			generalized.add(v)
+			continue
+		}
+		c := strings.Split(e.prefix[0], "-")
+		hasScriptOrRegion := false
+		if len(c) > 1 {
+			_, hasScriptOrRegion = b.script.find(c[1])
+			if !hasScriptOrRegion {
+				_, hasScriptOrRegion = b.region.find(c[1])
+
+			}
+		}
+		if len(c) == 1 || len(c) == 2 && hasScriptOrRegion {
+			// Variant is preceded by a language.
+			specialized.add(v)
+			continue
+		}
+		// Variant is preceded by another variant.
+		specializedExtend.add(v)
+		prefix := c[0] + "-"
+		if hasScriptOrRegion {
+			prefix += c[1]
+		}
+		for _, p := range e.prefix {
+			// Verify that the prefix minus the last element is a prefix of the
+			// predecessor element.
+			i := strings.LastIndex(p, "-")
+			pred := b.registry[p[i+1:]]
+			if find(pred.prefix, p[:i]) < 0 {
+				log.Fatalf("prefix %q for variant %q not consistent with predecessor spec", p, v)
+			}
+			// The sorting used below does not work in the general case. It works
+			// if we assume that variants that may be followed by others only have
+			// prefixes of the same length. Verify this.
+			count := strings.Count(p[:i], "-")
+			for _, q := range pred.prefix {
+				if c := strings.Count(q, "-"); c != count {
+					log.Fatalf("variant %q preceding %q has a prefix %q of size %d; want %d", p[i+1:], v, q, c, count)
+				}
+			}
+			if !strings.HasPrefix(p, prefix) {
+				log.Fatalf("prefix %q of variant %q should start with %q", p, v, prefix)
+			}
+		}
+	}
+
+	// Sort extended variants.
+	a := specializedExtend.s
+	less := func(v, w string) bool {
+		// Sort by the maximum number of elements.
+		maxCount := func(s string) (max int) {
+			for _, p := range b.registry[s].prefix {
+				if c := strings.Count(p, "-"); c > max {
+					max = c
+				}
+			}
+			return
+		}
+		if cv, cw := maxCount(v), maxCount(w); cv != cw {
+			return cv < cw
+		}
+		// Sort by name as tie breaker.
+		return v < w
+	}
+	sort.Sort(funcSorter{less, sort.StringSlice(a)})
+	specializedExtend.frozen = true
+
+	// Create index from variant name to index.
+	variantIndex := make(map[string]uint8)
+	add := func(s []string) {
+		for _, v := range s {
+			variantIndex[v] = uint8(len(variantIndex))
+		}
+	}
+	add(specialized.slice())
+	add(specializedExtend.s)
+	numSpecialized := len(variantIndex)
+	add(generalized.slice())
+	if n := len(variantIndex); n > 255 {
+		log.Fatalf("maximum number of variants exceeded: was %d; want <= 255", n)
+	}
+	b.writeMap("variantIndex", variantIndex)
+	b.writeConst("variantNumSpecialized", numSpecialized)
+}
+
+func (b *builder) writeLanguageInfo() {
+}
+
+// writeLikelyData writes tables that are used both for finding parent relations and for
+// language matching.  Each entry contains additional bits to indicate the status of the
+// data to know when it cannot be used for parent relations.
+func (b *builder) writeLikelyData() {
+	const (
+		isList = 1 << iota
+		scriptInFrom
+		regionInFrom
+	)
+	type ( // generated types
+		likelyScriptRegion struct {
+			region uint16
+			script uint8
+			flags  uint8
+		}
+		likelyLangScript struct {
+			lang   uint16
+			script uint8
+			flags  uint8
+		}
+		likelyLangRegion struct {
+			lang   uint16
+			region uint16
+		}
+		// likelyTag is used for getting likely tags for group regions, where
+		// the likely region might be a region contained in the group.
+		likelyTag struct {
+			lang   uint16
+			region uint16
+			script uint8
+		}
+	)
+	var ( // generated variables
+		likelyRegionGroup = make([]likelyTag, len(b.groups))
+		likelyLang        = make([]likelyScriptRegion, len(b.lang.s))
+		likelyRegion      = make([]likelyLangScript, len(b.region.s))
+		likelyScript      = make([]likelyLangRegion, len(b.script.s))
+		likelyLangList    = []likelyScriptRegion{}
+		likelyRegionList  = []likelyLangScript{}
+	)
+	type fromTo struct {
+		from, to []string
+	}
+	langToOther := map[int][]fromTo{}
+	regionToOther := map[int][]fromTo{}
+	for _, m := range b.supp.LikelySubtags.LikelySubtag {
+		from := strings.Split(m.From, "_")
+		to := strings.Split(m.To, "_")
+		if len(to) != 3 {
+			log.Fatalf("invalid number of subtags in %q: found %d, want 3", m.To, len(to))
+		}
+		if len(from) > 3 {
+			log.Fatalf("invalid number of subtags: found %d, want 1-3", len(from))
+		}
+		if from[0] != to[0] && from[0] != "und" {
+			log.Fatalf("unexpected language change in expansion: %s -> %s", from, to)
+		}
+		if len(from) == 3 {
+			if from[2] != to[2] {
+				log.Fatalf("unexpected region change in expansion: %s -> %s", from, to)
+			}
+			if from[0] != "und" {
+				log.Fatalf("unexpected fully specified from tag: %s -> %s", from, to)
+			}
+		}
+		if len(from) == 1 || from[0] != "und" {
+			id := 0
+			if from[0] != "und" {
+				id = b.lang.index(from[0])
+			}
+			langToOther[id] = append(langToOther[id], fromTo{from, to})
+		} else if len(from) == 2 && len(from[1]) == 4 {
+			sid := b.script.index(from[1])
+			likelyScript[sid].lang = uint16(b.langIndex(to[0]))
+			likelyScript[sid].region = uint16(b.region.index(to[2]))
+		} else {
+			r := b.region.index(from[len(from)-1])
+			if id, ok := b.groups[r]; ok {
+				if from[0] != "und" {
+					log.Fatalf("region changed unexpectedly: %s -> %s", from, to)
+				}
+				likelyRegionGroup[id].lang = uint16(b.langIndex(to[0]))
+				likelyRegionGroup[id].script = uint8(b.script.index(to[1]))
+				likelyRegionGroup[id].region = uint16(b.region.index(to[2]))
+			} else {
+				regionToOther[r] = append(regionToOther[r], fromTo{from, to})
+			}
+		}
+	}
+	b.writeType(likelyLangRegion{})
+	b.writeSlice("likelyScript", likelyScript)
+
+	for id := range b.lang.s {
+		list := langToOther[id]
+		if len(list) == 1 {
+			likelyLang[id].region = uint16(b.region.index(list[0].to[2]))
+			likelyLang[id].script = uint8(b.script.index(list[0].to[1]))
+		} else if len(list) > 1 {
+			likelyLang[id].flags = isList
+			likelyLang[id].region = uint16(len(likelyLangList))
+			likelyLang[id].script = uint8(len(list))
+			for _, x := range list {
+				flags := uint8(0)
+				if len(x.from) > 1 {
+					if x.from[1] == x.to[2] {
+						flags = regionInFrom
+					} else {
+						flags = scriptInFrom
+					}
+				}
+				likelyLangList = append(likelyLangList, likelyScriptRegion{
+					region: uint16(b.region.index(x.to[2])),
+					script: uint8(b.script.index(x.to[1])),
+					flags:  flags,
+				})
+			}
+		}
+	}
+	// TODO: merge suppressScript data with this table.
+	b.writeType(likelyScriptRegion{})
+	b.writeSlice("likelyLang", likelyLang)
+	b.writeSlice("likelyLangList", likelyLangList)
+
+	for id := range b.region.s {
+		list := regionToOther[id]
+		if len(list) == 1 {
+			likelyRegion[id].lang = uint16(b.langIndex(list[0].to[0]))
+			likelyRegion[id].script = uint8(b.script.index(list[0].to[1]))
+			if len(list[0].from) > 2 {
+				likelyRegion[id].flags = scriptInFrom
+			}
+		} else if len(list) > 1 {
+			likelyRegion[id].flags = isList
+			likelyRegion[id].lang = uint16(len(likelyRegionList))
+			likelyRegion[id].script = uint8(len(list))
+			for i, x := range list {
+				if len(x.from) == 2 && i != 0 || i > 0 && len(x.from) != 3 {
+					log.Fatalf("unspecified script must be first in list: %v at %d", x.from, i)
+				}
+				x := likelyLangScript{
+					lang:   uint16(b.langIndex(x.to[0])),
+					script: uint8(b.script.index(x.to[1])),
+				}
+				if len(list[0].from) > 2 {
+					x.flags = scriptInFrom
+				}
+				likelyRegionList = append(likelyRegionList, x)
+			}
+		}
+	}
+	b.writeType(likelyLangScript{})
+	b.writeSlice("likelyRegion", likelyRegion)
+	b.writeSlice("likelyRegionList", likelyRegionList)
+
+	b.writeType(likelyTag{})
+	b.writeSlice("likelyRegionGroup", likelyRegionGroup)
+}
+
+func (b *builder) writeRegionInclusionData() {
+	var (
+		// mm holds for each group the set of groups with a distance of 1.
+		mm = make(map[int][]index)
+
+		// containment holds for each group the transitive closure of
+		// containment of other groups.
+		containment = make(map[index][]index)
+	)
+	for _, g := range b.supp.TerritoryContainment.Group {
+		// Skip UN and EURO zone as they are flattening the containment
+		// relationship.
+		if g.Type == "EZ" || g.Type == "UN" {
+			continue
+		}
+		group := b.region.index(g.Type)
+		groupIdx := b.groups[group]
+		for _, mem := range strings.Split(g.Contains, " ") {
+			r := b.region.index(mem)
+			mm[r] = append(mm[r], groupIdx)
+			if g, ok := b.groups[r]; ok {
+				mm[group] = append(mm[group], g)
+				containment[groupIdx] = append(containment[groupIdx], g)
+			}
+		}
+	}
+
+	regionContainment := make([]uint64, len(b.groups))
+	for _, g := range b.groups {
+		l := containment[g]
+
+		// Compute the transitive closure of containment.
+		for i := 0; i < len(l); i++ {
+			l = append(l, containment[l[i]]...)
+		}
+
+		// Compute the bitmask.
+		regionContainment[g] = 1 << g
+		for _, v := range l {
+			regionContainment[g] |= 1 << v
+		}
+	}
+	b.writeSlice("regionContainment", regionContainment)
+
+	regionInclusion := make([]uint8, len(b.region.s))
+	bvs := make(map[uint64]index)
+	// Make the first bitvector positions correspond with the groups.
+	for r, i := range b.groups {
+		bv := uint64(1 << i)
+		for _, g := range mm[r] {
+			bv |= 1 << g
+		}
+		bvs[bv] = i
+		regionInclusion[r] = uint8(bvs[bv])
+	}
+	for r := 1; r < len(b.region.s); r++ {
+		if _, ok := b.groups[r]; !ok {
+			bv := uint64(0)
+			for _, g := range mm[r] {
+				bv |= 1 << g
+			}
+			if bv == 0 {
+				// Pick the world for unspecified regions.
+				bv = 1 << b.groups[b.region.index("001")]
+			}
+			if _, ok := bvs[bv]; !ok {
+				bvs[bv] = index(len(bvs))
+			}
+			regionInclusion[r] = uint8(bvs[bv])
+		}
+	}
+	b.writeSlice("regionInclusion", regionInclusion)
+	regionInclusionBits := make([]uint64, len(bvs))
+	for k, v := range bvs {
+		regionInclusionBits[v] = uint64(k)
+	}
+	// Add bit vectors for increasingly large distances until a fixed point is reached.
+	regionInclusionNext := []uint8{}
+	for i := 0; i < len(regionInclusionBits); i++ {
+		bits := regionInclusionBits[i]
+		next := bits
+		for i := uint(0); i < uint(len(b.groups)); i++ {
+			if bits&(1<<i) != 0 {
+				next |= regionInclusionBits[i]
+			}
+		}
+		if _, ok := bvs[next]; !ok {
+			bvs[next] = index(len(bvs))
+			regionInclusionBits = append(regionInclusionBits, next)
+		}
+		regionInclusionNext = append(regionInclusionNext, uint8(bvs[next]))
+	}
+	b.writeSlice("regionInclusionBits", regionInclusionBits)
+	b.writeSlice("regionInclusionNext", regionInclusionNext)
+}
+
+type parentRel struct {
+	lang       uint16
+	script     uint8
+	maxScript  uint8
+	toRegion   uint16
+	fromRegion []uint16
+}
+
+func (b *builder) writeParents() {
+	b.writeType(parentRel{})
+
+	parents := []parentRel{}
+
+	// Construct parent overrides.
+	n := 0
+	for _, p := range b.data.Supplemental().ParentLocales.ParentLocale {
+		// Skipping non-standard scripts to root is implemented using addTags.
+		if p.Parent == "root" {
+			continue
+		}
+
+		sub := strings.Split(p.Parent, "_")
+		parent := parentRel{lang: b.langIndex(sub[0])}
+		if len(sub) == 2 {
+			// TODO: check that all undefined scripts are indeed Latn in these
+			// cases.
+			parent.maxScript = uint8(b.script.index("Latn"))
+			parent.toRegion = uint16(b.region.index(sub[1]))
+		} else {
+			parent.script = uint8(b.script.index(sub[1]))
+			parent.maxScript = parent.script
+			parent.toRegion = uint16(b.region.index(sub[2]))
+		}
+		for _, c := range strings.Split(p.Locales, " ") {
+			region := b.region.index(c[strings.LastIndex(c, "_")+1:])
+			parent.fromRegion = append(parent.fromRegion, uint16(region))
+		}
+		parents = append(parents, parent)
+		n += len(parent.fromRegion)
+	}
+	b.writeSliceAddSize("parents", n*2, parents)
+}
+
+func main() {
+	gen.Init()
+
+	gen.Repackage("gen_common.go", "common.go", "language")
+
+	w := gen.NewCodeWriter()
+	defer w.WriteGoFile("tables.go", "language")
+
+	fmt.Fprintln(w, `import "golang.org/x/text/internal/tag"`)
+
+	b := newBuilder(w)
+	gen.WriteCLDRVersion(w)
+
+	b.parseIndices()
+	b.writeType(FromTo{})
+	b.writeLanguage()
+	b.writeScript()
+	b.writeRegion()
+	b.writeVariant()
+	// TODO: b.writeLocale()
+	b.computeRegionGroups()
+	b.writeLikelyData()
+	b.writeRegionInclusionData()
+	b.writeParents()
+}
diff --git a/vendor/golang.org/x/text/internal/language/gen_common.go b/vendor/golang.org/x/text/internal/language/gen_common.go
new file mode 100644
index 000000000..c419ceeb1
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/gen_common.go
@@ -0,0 +1,20 @@
+// Copyright 2014 The Go 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 ignore
+
+package main
+
+// This file contains code common to the maketables.go and the package code.
+
+// AliasType is the type of an alias in AliasMap.
+type AliasType int8
+
+const (
+	Deprecated AliasType = iota
+	Macro
+	Legacy
+
+	AliasTypeUnknown AliasType = -1
+)
diff --git a/vendor/golang.org/x/text/language/gen.go b/vendor/golang.org/x/text/language/gen.go
new file mode 100644
index 000000000..3004eb42c
--- /dev/null
+++ b/vendor/golang.org/x/text/language/gen.go
@@ -0,0 +1,305 @@
+// Copyright 2013 The Go 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 ignore
+
+// Language tag table generator.
+// Data read from the web.
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/language"
+	"golang.org/x/text/unicode/cldr"
+)
+
+var (
+	test = flag.Bool("test",
+		false,
+		"test existing tables; can be used to compare web data with package data.")
+	outputFile = flag.String("output",
+		"tables.go",
+		"output file for generated tables")
+)
+
+func main() {
+	gen.Init()
+
+	w := gen.NewCodeWriter()
+	defer w.WriteGoFile("tables.go", "language")
+
+	b := newBuilder(w)
+	gen.WriteCLDRVersion(w)
+
+	b.writeConstants()
+	b.writeMatchData()
+}
+
+type builder struct {
+	w    *gen.CodeWriter
+	hw   io.Writer // MultiWriter for w and w.Hash
+	data *cldr.CLDR
+	supp *cldr.SupplementalData
+}
+
+func (b *builder) langIndex(s string) uint16 {
+	return uint16(language.MustParseBase(s))
+}
+
+func (b *builder) regionIndex(s string) int {
+	return int(language.MustParseRegion(s))
+}
+
+func (b *builder) scriptIndex(s string) int {
+	return int(language.MustParseScript(s))
+}
+
+func newBuilder(w *gen.CodeWriter) *builder {
+	r := gen.OpenCLDRCoreZip()
+	defer r.Close()
+	d := &cldr.Decoder{}
+	data, err := d.DecodeZip(r)
+	if err != nil {
+		log.Fatal(err)
+	}
+	b := builder{
+		w:    w,
+		hw:   io.MultiWriter(w, w.Hash),
+		data: data,
+		supp: data.Supplemental(),
+	}
+	return &b
+}
+
+// writeConsts computes f(v) for all v in values and writes the results
+// as constants named _v to a single constant block.
+func (b *builder) writeConsts(f func(string) int, values ...string) {
+	fmt.Fprintln(b.w, "const (")
+	for _, v := range values {
+		fmt.Fprintf(b.w, "\t_%s = %v\n", v, f(v))
+	}
+	fmt.Fprintln(b.w, ")")
+}
+
+// TODO: region inclusion data will probably not be use used in future matchers.
+
+var langConsts = []string{
+	"de", "en", "fr", "it", "mo", "no", "nb", "pt", "sh", "mul", "und",
+}
+
+var scriptConsts = []string{
+	"Latn", "Hani", "Hans", "Hant", "Qaaa", "Qaai", "Qabx", "Zinh", "Zyyy",
+	"Zzzz",
+}
+
+var regionConsts = []string{
+	"001", "419", "BR", "CA", "ES", "GB", "MD", "PT", "UK", "US",
+	"ZZ", "XA", "XC", "XK", // Unofficial tag for Kosovo.
+}
+
+func (b *builder) writeConstants() {
+	b.writeConsts(func(s string) int { return int(b.langIndex(s)) }, langConsts...)
+	b.writeConsts(b.regionIndex, regionConsts...)
+	b.writeConsts(b.scriptIndex, scriptConsts...)
+}
+
+type mutualIntelligibility struct {
+	want, have uint16
+	distance   uint8
+	oneway     bool
+}
+
+type scriptIntelligibility struct {
+	wantLang, haveLang     uint16
+	wantScript, haveScript uint8
+	distance               uint8
+	// Always oneway
+}
+
+type regionIntelligibility struct {
+	lang     uint16 // compact language id
+	script   uint8  // 0 means any
+	group    uint8  // 0 means any; if bit 7 is set it means inverse
+	distance uint8
+	// Always twoway.
+}
+
+// writeMatchData writes tables with languages and scripts for which there is
+// mutual intelligibility. The data is based on CLDR's languageMatching data.
+// Note that we use a different algorithm than the one defined by CLDR and that
+// we slightly modify the data. For example, we convert scores to confidence levels.
+// We also drop all region-related data as we use a different algorithm to
+// determine region equivalence.
+func (b *builder) writeMatchData() {
+	lm := b.supp.LanguageMatching.LanguageMatches
+	cldr.MakeSlice(&lm).SelectAnyOf("type", "written_new")
+
+	regionHierarchy := map[string][]string{}
+	for _, g := range b.supp.TerritoryContainment.Group {
+		regions := strings.Split(g.Contains, " ")
+		regionHierarchy[g.Type] = append(regionHierarchy[g.Type], regions...)
+	}
+	regionToGroups := make([]uint8, language.NumRegions)
+
+	idToIndex := map[string]uint8{}
+	for i, mv := range lm[0].MatchVariable {
+		if i > 6 {
+			log.Fatalf("Too many groups: %d", i)
+		}
+		idToIndex[mv.Id] = uint8(i + 1)
+		// TODO: also handle '-'
+		for _, r := range strings.Split(mv.Value, "+") {
+			todo := []string{r}
+			for k := 0; k < len(todo); k++ {
+				r := todo[k]
+				regionToGroups[b.regionIndex(r)] |= 1 << uint8(i)
+				todo = append(todo, regionHierarchy[r]...)
+			}
+		}
+	}
+	b.w.WriteVar("regionToGroups", regionToGroups)
+
+	// maps language id to in- and out-of-group region.
+	paradigmLocales := [][3]uint16{}
+	locales := strings.Split(lm[0].ParadigmLocales[0].Locales, " ")
+	for i := 0; i < len(locales); i += 2 {
+		x := [3]uint16{}
+		for j := 0; j < 2; j++ {
+			pc := strings.SplitN(locales[i+j], "-", 2)
+			x[0] = b.langIndex(pc[0])
+			if len(pc) == 2 {
+				x[1+j] = uint16(b.regionIndex(pc[1]))
+			}
+		}
+		paradigmLocales = append(paradigmLocales, x)
+	}
+	b.w.WriteVar("paradigmLocales", paradigmLocales)
+
+	b.w.WriteType(mutualIntelligibility{})
+	b.w.WriteType(scriptIntelligibility{})
+	b.w.WriteType(regionIntelligibility{})
+
+	matchLang := []mutualIntelligibility{}
+	matchScript := []scriptIntelligibility{}
+	matchRegion := []regionIntelligibility{}
+	// Convert the languageMatch entries in lists keyed by desired language.
+	for _, m := range lm[0].LanguageMatch {
+		// Different versions of CLDR use different separators.
+		desired := strings.Replace(m.Desired, "-", "_", -1)
+		supported := strings.Replace(m.Supported, "-", "_", -1)
+		d := strings.Split(desired, "_")
+		s := strings.Split(supported, "_")
+		if len(d) != len(s) {
+			log.Fatalf("not supported: desired=%q; supported=%q", desired, supported)
+			continue
+		}
+		distance, _ := strconv.ParseInt(m.Distance, 10, 8)
+		switch len(d) {
+		case 2:
+			if desired == supported && desired == "*_*" {
+				continue
+			}
+			// language-script pair.
+			matchScript = append(matchScript, scriptIntelligibility{
+				wantLang:   uint16(b.langIndex(d[0])),
+				haveLang:   uint16(b.langIndex(s[0])),
+				wantScript: uint8(b.scriptIndex(d[1])),
+				haveScript: uint8(b.scriptIndex(s[1])),
+				distance:   uint8(distance),
+			})
+			if m.Oneway != "true" {
+				matchScript = append(matchScript, scriptIntelligibility{
+					wantLang:   uint16(b.langIndex(s[0])),
+					haveLang:   uint16(b.langIndex(d[0])),
+					wantScript: uint8(b.scriptIndex(s[1])),
+					haveScript: uint8(b.scriptIndex(d[1])),
+					distance:   uint8(distance),
+				})
+			}
+		case 1:
+			if desired == supported && desired == "*" {
+				continue
+			}
+			if distance == 1 {
+				// nb == no is already handled by macro mapping. Check there
+				// really is only this case.
+				if d[0] != "no" || s[0] != "nb" {
+					log.Fatalf("unhandled equivalence %s == %s", s[0], d[0])
+				}
+				continue
+			}
+			// TODO: consider dropping oneway field and just doubling the entry.
+			matchLang = append(matchLang, mutualIntelligibility{
+				want:     uint16(b.langIndex(d[0])),
+				have:     uint16(b.langIndex(s[0])),
+				distance: uint8(distance),
+				oneway:   m.Oneway == "true",
+			})
+		case 3:
+			if desired == supported && desired == "*_*_*" {
+				continue
+			}
+			if desired != supported {
+				// This is now supported by CLDR, but only one case, which
+				// should already be covered by paradigm locales. For instance,
+				// test case "und, en, en-GU, en-IN, en-GB ; en-ZA ; en-GB" in
+				// testdata/CLDRLocaleMatcherTest.txt tests this.
+				if supported != "en_*_GB" {
+					log.Fatalf("not supported: desired=%q; supported=%q", desired, supported)
+				}
+				continue
+			}
+			ri := regionIntelligibility{
+				lang:     b.langIndex(d[0]),
+				distance: uint8(distance),
+			}
+			if d[1] != "*" {
+				ri.script = uint8(b.scriptIndex(d[1]))
+			}
+			switch {
+			case d[2] == "*":
+				ri.group = 0x80 // not contained in anything
+			case strings.HasPrefix(d[2], "$!"):
+				ri.group = 0x80
+				d[2] = "$" + d[2][len("$!"):]
+				fallthrough
+			case strings.HasPrefix(d[2], "$"):
+				ri.group |= idToIndex[d[2]]
+			}
+			matchRegion = append(matchRegion, ri)
+		default:
+			log.Fatalf("not supported: desired=%q; supported=%q", desired, supported)
+		}
+	}
+	sort.SliceStable(matchLang, func(i, j int) bool {
+		return matchLang[i].distance < matchLang[j].distance
+	})
+	b.w.WriteComment(`
+		matchLang holds pairs of langIDs of base languages that are typically
+		mutually intelligible. Each pair is associated with a confidence and
+		whether the intelligibility goes one or both ways.`)
+	b.w.WriteVar("matchLang", matchLang)
+
+	b.w.WriteComment(`
+		matchScript holds pairs of scriptIDs where readers of one script
+		can typically also read the other. Each is associated with a confidence.`)
+	sort.SliceStable(matchScript, func(i, j int) bool {
+		return matchScript[i].distance < matchScript[j].distance
+	})
+	b.w.WriteVar("matchScript", matchScript)
+
+	sort.SliceStable(matchRegion, func(i, j int) bool {
+		return matchRegion[i].distance < matchRegion[j].distance
+	})
+	b.w.WriteVar("matchRegion", matchRegion)
+}
diff --git a/vendor/golang.org/x/text/unicode/bidi/gen.go b/vendor/golang.org/x/text/unicode/bidi/gen.go
new file mode 100644
index 000000000..987fc169c
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/bidi/gen.go
@@ -0,0 +1,133 @@
+// Copyright 2015 The Go 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 ignore
+
+package main
+
+import (
+	"flag"
+	"log"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/triegen"
+	"golang.org/x/text/internal/ucd"
+)
+
+var outputFile = flag.String("out", "tables.go", "output file")
+
+func main() {
+	gen.Init()
+	gen.Repackage("gen_trieval.go", "trieval.go", "bidi")
+	gen.Repackage("gen_ranges.go", "ranges_test.go", "bidi")
+
+	genTables()
+}
+
+// bidiClass names and codes taken from class "bc" in
+// https://www.unicode.org/Public/8.0.0/ucd/PropertyValueAliases.txt
+var bidiClass = map[string]Class{
+	"AL":  AL,  // ArabicLetter
+	"AN":  AN,  // ArabicNumber
+	"B":   B,   // ParagraphSeparator
+	"BN":  BN,  // BoundaryNeutral
+	"CS":  CS,  // CommonSeparator
+	"EN":  EN,  // EuropeanNumber
+	"ES":  ES,  // EuropeanSeparator
+	"ET":  ET,  // EuropeanTerminator
+	"L":   L,   // LeftToRight
+	"NSM": NSM, // NonspacingMark
+	"ON":  ON,  // OtherNeutral
+	"R":   R,   // RightToLeft
+	"S":   S,   // SegmentSeparator
+	"WS":  WS,  // WhiteSpace
+
+	"FSI": Control,
+	"PDF": Control,
+	"PDI": Control,
+	"LRE": Control,
+	"LRI": Control,
+	"LRO": Control,
+	"RLE": Control,
+	"RLI": Control,
+	"RLO": Control,
+}
+
+func genTables() {
+	if numClass > 0x0F {
+		log.Fatalf("Too many Class constants (%#x > 0x0F).", numClass)
+	}
+	w := gen.NewCodeWriter()
+	defer w.WriteVersionedGoFile(*outputFile, "bidi")
+
+	gen.WriteUnicodeVersion(w)
+
+	t := triegen.NewTrie("bidi")
+
+	// Build data about bracket mapping. These bits need to be or-ed with
+	// any other bits.
+	orMask := map[rune]uint64{}
+
+	xorMap := map[rune]int{}
+	xorMasks := []rune{0} // First value is no-op.
+
+	ucd.Parse(gen.OpenUCDFile("BidiBrackets.txt"), func(p *ucd.Parser) {
+		r1 := p.Rune(0)
+		r2 := p.Rune(1)
+		xor := r1 ^ r2
+		if _, ok := xorMap[xor]; !ok {
+			xorMap[xor] = len(xorMasks)
+			xorMasks = append(xorMasks, xor)
+		}
+		entry := uint64(xorMap[xor]) << xorMaskShift
+		switch p.String(2) {
+		case "o":
+			entry |= openMask
+		case "c", "n":
+		default:
+			log.Fatalf("Unknown bracket class %q.", p.String(2))
+		}
+		orMask[r1] = entry
+	})
+
+	w.WriteComment(`
+	xorMasks contains masks to be xor-ed with brackets to get the reverse
+	version.`)
+	w.WriteVar("xorMasks", xorMasks)
+
+	done := map[rune]bool{}
+
+	insert := func(r rune, c Class) {
+		if !done[r] {
+			t.Insert(r, orMask[r]|uint64(c))
+			done[r] = true
+		}
+	}
+
+	// Insert the derived BiDi properties.
+	ucd.Parse(gen.OpenUCDFile("extracted/DerivedBidiClass.txt"), func(p *ucd.Parser) {
+		r := p.Rune(0)
+		class, ok := bidiClass[p.String(1)]
+		if !ok {
+			log.Fatalf("%U: Unknown BiDi class %q", r, p.String(1))
+		}
+		insert(r, class)
+	})
+	visitDefaults(insert)
+
+	// TODO: use sparse blocks. This would reduce table size considerably
+	// from the looks of it.
+
+	sz, err := t.Gen(w)
+	if err != nil {
+		log.Fatal(err)
+	}
+	w.Size += sz
+}
+
+// dummy values to make methods in gen_common compile. The real versions
+// will be generated by this file to tables.go.
+var (
+	xorMasks []rune
+)
diff --git a/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go b/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go
new file mode 100644
index 000000000..02c3b505d
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go
@@ -0,0 +1,57 @@
+// Copyright 2015 The Go 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 ignore
+
+package main
+
+import (
+	"unicode"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/ucd"
+	"golang.org/x/text/unicode/rangetable"
+)
+
+// These tables are hand-extracted from:
+// https://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedBidiClass.txt
+func visitDefaults(fn func(r rune, c Class)) {
+	// first write default values for ranges listed above.
+	visitRunes(fn, AL, []rune{
+		0x0600, 0x07BF, // Arabic
+		0x08A0, 0x08FF, // Arabic Extended-A
+		0xFB50, 0xFDCF, // Arabic Presentation Forms
+		0xFDF0, 0xFDFF,
+		0xFE70, 0xFEFF,
+		0x0001EE00, 0x0001EEFF, // Arabic Mathematical Alpha Symbols
+	})
+	visitRunes(fn, R, []rune{
+		0x0590, 0x05FF, // Hebrew
+		0x07C0, 0x089F, // Nko et al.
+		0xFB1D, 0xFB4F,
+		0x00010800, 0x00010FFF, // Cypriot Syllabary et. al.
+		0x0001E800, 0x0001EDFF,
+		0x0001EF00, 0x0001EFFF,
+	})
+	visitRunes(fn, ET, []rune{ // European Terminator
+		0x20A0, 0x20Cf, // Currency symbols
+	})
+	rangetable.Visit(unicode.Noncharacter_Code_Point, func(r rune) {
+		fn(r, BN) // Boundary Neutral
+	})
+	ucd.Parse(gen.OpenUCDFile("DerivedCoreProperties.txt"), func(p *ucd.Parser) {
+		if p.String(1) == "Default_Ignorable_Code_Point" {
+			fn(p.Rune(0), BN) // Boundary Neutral
+		}
+	})
+}
+
+func visitRunes(fn func(r rune, c Class), c Class, runes []rune) {
+	for i := 0; i < len(runes); i += 2 {
+		lo, hi := runes[i], runes[i+1]
+		for j := lo; j <= hi; j++ {
+			fn(j, c)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go b/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go
new file mode 100644
index 000000000..9cb994289
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go
@@ -0,0 +1,64 @@
+// Copyright 2015 The Go 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 ignore
+
+package main
+
+// Class is the Unicode BiDi class. Each rune has a single class.
+type Class uint
+
+const (
+	L       Class = iota // LeftToRight
+	R                    // RightToLeft
+	EN                   // EuropeanNumber
+	ES                   // EuropeanSeparator
+	ET                   // EuropeanTerminator
+	AN                   // ArabicNumber
+	CS                   // CommonSeparator
+	B                    // ParagraphSeparator
+	S                    // SegmentSeparator
+	WS                   // WhiteSpace
+	ON                   // OtherNeutral
+	BN                   // BoundaryNeutral
+	NSM                  // NonspacingMark
+	AL                   // ArabicLetter
+	Control              // Control LRO - PDI
+
+	numClass
+
+	LRO // LeftToRightOverride
+	RLO // RightToLeftOverride
+	LRE // LeftToRightEmbedding
+	RLE // RightToLeftEmbedding
+	PDF // PopDirectionalFormat
+	LRI // LeftToRightIsolate
+	RLI // RightToLeftIsolate
+	FSI // FirstStrongIsolate
+	PDI // PopDirectionalIsolate
+
+	unknownClass = ^Class(0)
+)
+
+var controlToClass = map[rune]Class{
+	0x202D: LRO, // LeftToRightOverride,
+	0x202E: RLO, // RightToLeftOverride,
+	0x202A: LRE, // LeftToRightEmbedding,
+	0x202B: RLE, // RightToLeftEmbedding,
+	0x202C: PDF, // PopDirectionalFormat,
+	0x2066: LRI, // LeftToRightIsolate,
+	0x2067: RLI, // RightToLeftIsolate,
+	0x2068: FSI, // FirstStrongIsolate,
+	0x2069: PDI, // PopDirectionalIsolate,
+}
+
+// A trie entry has the following bits:
+// 7..5  XOR mask for brackets
+// 4     1: Bracket open, 0: Bracket close
+// 3..0  Class type
+
+const (
+	openMask     = 0x10
+	xorMaskShift = 5
+)
diff --git a/vendor/golang.org/x/text/unicode/norm/maketables.go b/vendor/golang.org/x/text/unicode/norm/maketables.go
new file mode 100644
index 000000000..30a3aa933
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/maketables.go
@@ -0,0 +1,986 @@
+// Copyright 2011 The Go 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 ignore
+
+// Normalization table generator.
+// Data read from the web.
+// See forminfo.go for a description of the trie values associated with each rune.
+
+package main
+
+import (
+	"bytes"
+	"encoding/binary"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/triegen"
+	"golang.org/x/text/internal/ucd"
+)
+
+func main() {
+	gen.Init()
+	loadUnicodeData()
+	compactCCC()
+	loadCompositionExclusions()
+	completeCharFields(FCanonical)
+	completeCharFields(FCompatibility)
+	computeNonStarterCounts()
+	verifyComputed()
+	printChars()
+	testDerived()
+	printTestdata()
+	makeTables()
+}
+
+var (
+	tablelist = flag.String("tables",
+		"all",
+		"comma-separated list of which tables to generate; "+
+			"can be 'decomp', 'recomp', 'info' and 'all'")
+	test = flag.Bool("test",
+		false,
+		"test existing tables against DerivedNormalizationProps and generate test data for regression testing")
+	verbose = flag.Bool("verbose",
+		false,
+		"write data to stdout as it is parsed")
+)
+
+const MaxChar = 0x10FFFF // anything above this shouldn't exist
+
+// Quick Check properties of runes allow us to quickly
+// determine whether a rune may occur in a normal form.
+// For a given normal form, a rune may be guaranteed to occur
+// verbatim (QC=Yes), may or may not combine with another
+// rune (QC=Maybe), or may not occur (QC=No).
+type QCResult int
+
+const (
+	QCUnknown QCResult = iota
+	QCYes
+	QCNo
+	QCMaybe
+)
+
+func (r QCResult) String() string {
+	switch r {
+	case QCYes:
+		return "Yes"
+	case QCNo:
+		return "No"
+	case QCMaybe:
+		return "Maybe"
+	}
+	return "***UNKNOWN***"
+}
+
+const (
+	FCanonical     = iota // NFC or NFD
+	FCompatibility        // NFKC or NFKD
+	FNumberOfFormTypes
+)
+
+const (
+	MComposed   = iota // NFC or NFKC
+	MDecomposed        // NFD or NFKD
+	MNumberOfModes
+)
+
+// This contains only the properties we're interested in.
+type Char struct {
+	name          string
+	codePoint     rune  // if zero, this index is not a valid code point.
+	ccc           uint8 // canonical combining class
+	origCCC       uint8
+	excludeInComp bool // from CompositionExclusions.txt
+	compatDecomp  bool // it has a compatibility expansion
+
+	nTrailingNonStarters uint8
+	nLeadingNonStarters  uint8 // must be equal to trailing if non-zero
+
+	forms [FNumberOfFormTypes]FormInfo // For FCanonical and FCompatibility
+
+	state State
+}
+
+var chars = make([]Char, MaxChar+1)
+var cccMap = make(map[uint8]uint8)
+
+func (c Char) String() string {
+	buf := new(bytes.Buffer)
+
+	fmt.Fprintf(buf, "%U [%s]:\n", c.codePoint, c.name)
+	fmt.Fprintf(buf, "  ccc: %v\n", c.ccc)
+	fmt.Fprintf(buf, "  excludeInComp: %v\n", c.excludeInComp)
+	fmt.Fprintf(buf, "  compatDecomp: %v\n", c.compatDecomp)
+	fmt.Fprintf(buf, "  state: %v\n", c.state)
+	fmt.Fprintf(buf, "  NFC:\n")
+	fmt.Fprint(buf, c.forms[FCanonical])
+	fmt.Fprintf(buf, "  NFKC:\n")
+	fmt.Fprint(buf, c.forms[FCompatibility])
+
+	return buf.String()
+}
+
+// In UnicodeData.txt, some ranges are marked like this:
+//	3400;<CJK Ideograph Extension A, First>;Lo;0;L;;;;;N;;;;;
+//	4DB5;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;;
+// parseCharacter keeps a state variable indicating the weirdness.
+type State int
+
+const (
+	SNormal State = iota // known to be zero for the type
+	SFirst
+	SLast
+	SMissing
+)
+
+var lastChar = rune('\u0000')
+
+func (c Char) isValid() bool {
+	return c.codePoint != 0 && c.state != SMissing
+}
+
+type FormInfo struct {
+	quickCheck [MNumberOfModes]QCResult // index: MComposed or MDecomposed
+	verified   [MNumberOfModes]bool     // index: MComposed or MDecomposed
+
+	combinesForward  bool // May combine with rune on the right
+	combinesBackward bool // May combine with rune on the left
+	isOneWay         bool // Never appears in result
+	inDecomp         bool // Some decompositions result in this char.
+	decomp           Decomposition
+	expandedDecomp   Decomposition
+}
+
+func (f FormInfo) String() string {
+	buf := bytes.NewBuffer(make([]byte, 0))
+
+	fmt.Fprintf(buf, "    quickCheck[C]: %v\n", f.quickCheck[MComposed])
+	fmt.Fprintf(buf, "    quickCheck[D]: %v\n", f.quickCheck[MDecomposed])
+	fmt.Fprintf(buf, "    cmbForward: %v\n", f.combinesForward)
+	fmt.Fprintf(buf, "    cmbBackward: %v\n", f.combinesBackward)
+	fmt.Fprintf(buf, "    isOneWay: %v\n", f.isOneWay)
+	fmt.Fprintf(buf, "    inDecomp: %v\n", f.inDecomp)
+	fmt.Fprintf(buf, "    decomposition: %X\n", f.decomp)
+	fmt.Fprintf(buf, "    expandedDecomp: %X\n", f.expandedDecomp)
+
+	return buf.String()
+}
+
+type Decomposition []rune
+
+func parseDecomposition(s string, skipfirst bool) (a []rune, err error) {
+	decomp := strings.Split(s, " ")
+	if len(decomp) > 0 && skipfirst {
+		decomp = decomp[1:]
+	}
+	for _, d := range decomp {
+		point, err := strconv.ParseUint(d, 16, 64)
+		if err != nil {
+			return a, err
+		}
+		a = append(a, rune(point))
+	}
+	return a, nil
+}
+
+func loadUnicodeData() {
+	f := gen.OpenUCDFile("UnicodeData.txt")
+	defer f.Close()
+	p := ucd.New(f)
+	for p.Next() {
+		r := p.Rune(ucd.CodePoint)
+		char := &chars[r]
+
+		char.ccc = uint8(p.Uint(ucd.CanonicalCombiningClass))
+		decmap := p.String(ucd.DecompMapping)
+
+		exp, err := parseDecomposition(decmap, false)
+		isCompat := false
+		if err != nil {
+			if len(decmap) > 0 {
+				exp, err = parseDecomposition(decmap, true)
+				if err != nil {
+					log.Fatalf(`%U: bad decomp |%v|: "%s"`, r, decmap, err)
+				}
+				isCompat = true
+			}
+		}
+
+		char.name = p.String(ucd.Name)
+		char.codePoint = r
+		char.forms[FCompatibility].decomp = exp
+		if !isCompat {
+			char.forms[FCanonical].decomp = exp
+		} else {
+			char.compatDecomp = true
+		}
+		if len(decmap) > 0 {
+			char.forms[FCompatibility].decomp = exp
+		}
+	}
+	if err := p.Err(); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// compactCCC converts the sparse set of CCC values to a continguous one,
+// reducing the number of bits needed from 8 to 6.
+func compactCCC() {
+	m := make(map[uint8]uint8)
+	for i := range chars {
+		c := &chars[i]
+		m[c.ccc] = 0
+	}
+	cccs := []int{}
+	for v, _ := range m {
+		cccs = append(cccs, int(v))
+	}
+	sort.Ints(cccs)
+	for i, c := range cccs {
+		cccMap[uint8(i)] = uint8(c)
+		m[uint8(c)] = uint8(i)
+	}
+	for i := range chars {
+		c := &chars[i]
+		c.origCCC = c.ccc
+		c.ccc = m[c.ccc]
+	}
+	if len(m) >= 1<<6 {
+		log.Fatalf("too many difference CCC values: %d >= 64", len(m))
+	}
+}
+
+// CompositionExclusions.txt has form:
+// 0958    # ...
+// See https://unicode.org/reports/tr44/ for full explanation
+func loadCompositionExclusions() {
+	f := gen.OpenUCDFile("CompositionExclusions.txt")
+	defer f.Close()
+	p := ucd.New(f)
+	for p.Next() {
+		c := &chars[p.Rune(0)]
+		if c.excludeInComp {
+			log.Fatalf("%U: Duplicate entry in exclusions.", c.codePoint)
+		}
+		c.excludeInComp = true
+	}
+	if e := p.Err(); e != nil {
+		log.Fatal(e)
+	}
+}
+
+// hasCompatDecomp returns true if any of the recursive
+// decompositions contains a compatibility expansion.
+// In this case, the character may not occur in NFK*.
+func hasCompatDecomp(r rune) bool {
+	c := &chars[r]
+	if c.compatDecomp {
+		return true
+	}
+	for _, d := range c.forms[FCompatibility].decomp {
+		if hasCompatDecomp(d) {
+			return true
+		}
+	}
+	return false
+}
+
+// Hangul related constants.
+const (
+	HangulBase = 0xAC00
+	HangulEnd  = 0xD7A4 // hangulBase + Jamo combinations (19 * 21 * 28)
+
+	JamoLBase = 0x1100
+	JamoLEnd  = 0x1113
+	JamoVBase = 0x1161
+	JamoVEnd  = 0x1176
+	JamoTBase = 0x11A8
+	JamoTEnd  = 0x11C3
+
+	JamoLVTCount = 19 * 21 * 28
+	JamoTCount   = 28
+)
+
+func isHangul(r rune) bool {
+	return HangulBase <= r && r < HangulEnd
+}
+
+func isHangulWithoutJamoT(r rune) bool {
+	if !isHangul(r) {
+		return false
+	}
+	r -= HangulBase
+	return r < JamoLVTCount && r%JamoTCount == 0
+}
+
+func ccc(r rune) uint8 {
+	return chars[r].ccc
+}
+
+// Insert a rune in a buffer, ordered by Canonical Combining Class.
+func insertOrdered(b Decomposition, r rune) Decomposition {
+	n := len(b)
+	b = append(b, 0)
+	cc := ccc(r)
+	if cc > 0 {
+		// Use bubble sort.
+		for ; n > 0; n-- {
+			if ccc(b[n-1]) <= cc {
+				break
+			}
+			b[n] = b[n-1]
+		}
+	}
+	b[n] = r
+	return b
+}
+
+// Recursively decompose.
+func decomposeRecursive(form int, r rune, d Decomposition) Decomposition {
+	dcomp := chars[r].forms[form].decomp
+	if len(dcomp) == 0 {
+		return insertOrdered(d, r)
+	}
+	for _, c := range dcomp {
+		d = decomposeRecursive(form, c, d)
+	}
+	return d
+}
+
+func completeCharFields(form int) {
+	// Phase 0: pre-expand decomposition.
+	for i := range chars {
+		f := &chars[i].forms[form]
+		if len(f.decomp) == 0 {
+			continue
+		}
+		exp := make(Decomposition, 0)
+		for _, c := range f.decomp {
+			exp = decomposeRecursive(form, c, exp)
+		}
+		f.expandedDecomp = exp
+	}
+
+	// Phase 1: composition exclusion, mark decomposition.
+	for i := range chars {
+		c := &chars[i]
+		f := &c.forms[form]
+
+		// Marks script-specific exclusions and version restricted.
+		f.isOneWay = c.excludeInComp
+
+		// Singletons
+		f.isOneWay = f.isOneWay || len(f.decomp) == 1
+
+		// Non-starter decompositions
+		if len(f.decomp) > 1 {
+			chk := c.ccc != 0 || chars[f.decomp[0]].ccc != 0
+			f.isOneWay = f.isOneWay || chk
+		}
+
+		// Runes that decompose into more than two runes.
+		f.isOneWay = f.isOneWay || len(f.decomp) > 2
+
+		if form == FCompatibility {
+			f.isOneWay = f.isOneWay || hasCompatDecomp(c.codePoint)
+		}
+
+		for _, r := range f.decomp {
+			chars[r].forms[form].inDecomp = true
+		}
+	}
+
+	// Phase 2: forward and backward combining.
+	for i := range chars {
+		c := &chars[i]
+		f := &c.forms[form]
+
+		if !f.isOneWay && len(f.decomp) == 2 {
+			f0 := &chars[f.decomp[0]].forms[form]
+			f1 := &chars[f.decomp[1]].forms[form]
+			if !f0.isOneWay {
+				f0.combinesForward = true
+			}
+			if !f1.isOneWay {
+				f1.combinesBackward = true
+			}
+		}
+		if isHangulWithoutJamoT(rune(i)) {
+			f.combinesForward = true
+		}
+	}
+
+	// Phase 3: quick check values.
+	for i := range chars {
+		c := &chars[i]
+		f := &c.forms[form]
+
+		switch {
+		case len(f.decomp) > 0:
+			f.quickCheck[MDecomposed] = QCNo
+		case isHangul(rune(i)):
+			f.quickCheck[MDecomposed] = QCNo
+		default:
+			f.quickCheck[MDecomposed] = QCYes
+		}
+		switch {
+		case f.isOneWay:
+			f.quickCheck[MComposed] = QCNo
+		case (i & 0xffff00) == JamoLBase:
+			f.quickCheck[MComposed] = QCYes
+			if JamoLBase <= i && i < JamoLEnd {
+				f.combinesForward = true
+			}
+			if JamoVBase <= i && i < JamoVEnd {
+				f.quickCheck[MComposed] = QCMaybe
+				f.combinesBackward = true
+				f.combinesForward = true
+			}
+			if JamoTBase <= i && i < JamoTEnd {
+				f.quickCheck[MComposed] = QCMaybe
+				f.combinesBackward = true
+			}
+		case !f.combinesBackward:
+			f.quickCheck[MComposed] = QCYes
+		default:
+			f.quickCheck[MComposed] = QCMaybe
+		}
+	}
+}
+
+func computeNonStarterCounts() {
+	// Phase 4: leading and trailing non-starter count
+	for i := range chars {
+		c := &chars[i]
+
+		runes := []rune{rune(i)}
+		// We always use FCompatibility so that the CGJ insertion points do not
+		// change for repeated normalizations with different forms.
+		if exp := c.forms[FCompatibility].expandedDecomp; len(exp) > 0 {
+			runes = exp
+		}
+		// We consider runes that combine backwards to be non-starters for the
+		// purpose of Stream-Safe Text Processing.
+		for _, r := range runes {
+			if cr := &chars[r]; cr.ccc == 0 && !cr.forms[FCompatibility].combinesBackward {
+				break
+			}
+			c.nLeadingNonStarters++
+		}
+		for i := len(runes) - 1; i >= 0; i-- {
+			if cr := &chars[runes[i]]; cr.ccc == 0 && !cr.forms[FCompatibility].combinesBackward {
+				break
+			}
+			c.nTrailingNonStarters++
+		}
+		if c.nTrailingNonStarters > 3 {
+			log.Fatalf("%U: Decomposition with more than 3 (%d) trailing modifiers (%U)", i, c.nTrailingNonStarters, runes)
+		}
+
+		if isHangul(rune(i)) {
+			c.nTrailingNonStarters = 2
+			if isHangulWithoutJamoT(rune(i)) {
+				c.nTrailingNonStarters = 1
+			}
+		}
+
+		if l, t := c.nLeadingNonStarters, c.nTrailingNonStarters; l > 0 && l != t {
+			log.Fatalf("%U: number of leading and trailing non-starters should be equal (%d vs %d)", i, l, t)
+		}
+		if t := c.nTrailingNonStarters; t > 3 {
+			log.Fatalf("%U: number of trailing non-starters is %d > 3", t)
+		}
+	}
+}
+
+func printBytes(w io.Writer, b []byte, name string) {
+	fmt.Fprintf(w, "// %s: %d bytes\n", name, len(b))
+	fmt.Fprintf(w, "var %s = [...]byte {", name)
+	for i, c := range b {
+		switch {
+		case i%64 == 0:
+			fmt.Fprintf(w, "\n// Bytes %x - %x\n", i, i+63)
+		case i%8 == 0:
+			fmt.Fprintf(w, "\n")
+		}
+		fmt.Fprintf(w, "0x%.2X, ", c)
+	}
+	fmt.Fprint(w, "\n}\n\n")
+}
+
+// See forminfo.go for format.
+func makeEntry(f *FormInfo, c *Char) uint16 {
+	e := uint16(0)
+	if r := c.codePoint; HangulBase <= r && r < HangulEnd {
+		e |= 0x40
+	}
+	if f.combinesForward {
+		e |= 0x20
+	}
+	if f.quickCheck[MDecomposed] == QCNo {
+		e |= 0x4
+	}
+	switch f.quickCheck[MComposed] {
+	case QCYes:
+	case QCNo:
+		e |= 0x10
+	case QCMaybe:
+		e |= 0x18
+	default:
+		log.Fatalf("Illegal quickcheck value %v.", f.quickCheck[MComposed])
+	}
+	e |= uint16(c.nTrailingNonStarters)
+	return e
+}
+
+// decompSet keeps track of unique decompositions, grouped by whether
+// the decomposition is followed by a trailing and/or leading CCC.
+type decompSet [7]map[string]bool
+
+const (
+	normalDecomp = iota
+	firstMulti
+	firstCCC
+	endMulti
+	firstLeadingCCC
+	firstCCCZeroExcept
+	firstStarterWithNLead
+	lastDecomp
+)
+
+var cname = []string{"firstMulti", "firstCCC", "endMulti", "firstLeadingCCC", "firstCCCZeroExcept", "firstStarterWithNLead", "lastDecomp"}
+
+func makeDecompSet() decompSet {
+	m := decompSet{}
+	for i := range m {
+		m[i] = make(map[string]bool)
+	}
+	return m
+}
+func (m *decompSet) insert(key int, s string) {
+	m[key][s] = true
+}
+
+func printCharInfoTables(w io.Writer) int {
+	mkstr := func(r rune, f *FormInfo) (int, string) {
+		d := f.expandedDecomp
+		s := string([]rune(d))
+		if max := 1 << 6; len(s) >= max {
+			const msg = "%U: too many bytes in decomposition: %d >= %d"
+			log.Fatalf(msg, r, len(s), max)
+		}
+		head := uint8(len(s))
+		if f.quickCheck[MComposed] != QCYes {
+			head |= 0x40
+		}
+		if f.combinesForward {
+			head |= 0x80
+		}
+		s = string([]byte{head}) + s
+
+		lccc := ccc(d[0])
+		tccc := ccc(d[len(d)-1])
+		cc := ccc(r)
+		if cc != 0 && lccc == 0 && tccc == 0 {
+			log.Fatalf("%U: trailing and leading ccc are 0 for non-zero ccc %d", r, cc)
+		}
+		if tccc < lccc && lccc != 0 {
+			const msg = "%U: lccc (%d) must be <= tcc (%d)"
+			log.Fatalf(msg, r, lccc, tccc)
+		}
+		index := normalDecomp
+		nTrail := chars[r].nTrailingNonStarters
+		nLead := chars[r].nLeadingNonStarters
+		if tccc > 0 || lccc > 0 || nTrail > 0 {
+			tccc <<= 2
+			tccc |= nTrail
+			s += string([]byte{tccc})
+			index = endMulti
+			for _, r := range d[1:] {
+				if ccc(r) == 0 {
+					index = firstCCC
+				}
+			}
+			if lccc > 0 || nLead > 0 {
+				s += string([]byte{lccc})
+				if index == firstCCC {
+					log.Fatalf("%U: multi-segment decomposition not supported for decompositions with leading CCC != 0", r)
+				}
+				index = firstLeadingCCC
+			}
+			if cc != lccc {
+				if cc != 0 {
+					log.Fatalf("%U: for lccc != ccc, expected ccc to be 0; was %d", r, cc)
+				}
+				index = firstCCCZeroExcept
+			}
+		} else if len(d) > 1 {
+			index = firstMulti
+		}
+		return index, s
+	}
+
+	decompSet := makeDecompSet()
+	const nLeadStr = "\x00\x01" // 0-byte length and tccc with nTrail.
+	decompSet.insert(firstStarterWithNLead, nLeadStr)
+
+	// Store the uniqued decompositions in a byte buffer,
+	// preceded by their byte length.
+	for _, c := range chars {
+		for _, f := range c.forms {
+			if len(f.expandedDecomp) == 0 {
+				continue
+			}
+			if f.combinesBackward {
+				log.Fatalf("%U: combinesBackward and decompose", c.codePoint)
+			}
+			index, s := mkstr(c.codePoint, &f)
+			decompSet.insert(index, s)
+		}
+	}
+
+	decompositions := bytes.NewBuffer(make([]byte, 0, 10000))
+	size := 0
+	positionMap := make(map[string]uint16)
+	decompositions.WriteString("\000")
+	fmt.Fprintln(w, "const (")
+	for i, m := range decompSet {
+		sa := []string{}
+		for s := range m {
+			sa = append(sa, s)
+		}
+		sort.Strings(sa)
+		for _, s := range sa {
+			p := decompositions.Len()
+			decompositions.WriteString(s)
+			positionMap[s] = uint16(p)
+		}
+		if cname[i] != "" {
+			fmt.Fprintf(w, "%s = 0x%X\n", cname[i], decompositions.Len())
+		}
+	}
+	fmt.Fprintln(w, "maxDecomp = 0x8000")
+	fmt.Fprintln(w, ")")
+	b := decompositions.Bytes()
+	printBytes(w, b, "decomps")
+	size += len(b)
+
+	varnames := []string{"nfc", "nfkc"}
+	for i := 0; i < FNumberOfFormTypes; i++ {
+		trie := triegen.NewTrie(varnames[i])
+
+		for r, c := range chars {
+			f := c.forms[i]
+			d := f.expandedDecomp
+			if len(d) != 0 {
+				_, key := mkstr(c.codePoint, &f)
+				trie.Insert(rune(r), uint64(positionMap[key]))
+				if c.ccc != ccc(d[0]) {
+					// We assume the lead ccc of a decomposition !=0 in this case.
+					if ccc(d[0]) == 0 {
+						log.Fatalf("Expected leading CCC to be non-zero; ccc is %d", c.ccc)
+					}
+				}
+			} else if c.nLeadingNonStarters > 0 && len(f.expandedDecomp) == 0 && c.ccc == 0 && !f.combinesBackward {
+				// Handle cases where it can't be detected that the nLead should be equal
+				// to nTrail.
+				trie.Insert(c.codePoint, uint64(positionMap[nLeadStr]))
+			} else if v := makeEntry(&f, &c)<<8 | uint16(c.ccc); v != 0 {
+				trie.Insert(c.codePoint, uint64(0x8000|v))
+			}
+		}
+		sz, err := trie.Gen(w, triegen.Compact(&normCompacter{name: varnames[i]}))
+		if err != nil {
+			log.Fatal(err)
+		}
+		size += sz
+	}
+	return size
+}
+
+func contains(sa []string, s string) bool {
+	for _, a := range sa {
+		if a == s {
+			return true
+		}
+	}
+	return false
+}
+
+func makeTables() {
+	w := &bytes.Buffer{}
+
+	size := 0
+	if *tablelist == "" {
+		return
+	}
+	list := strings.Split(*tablelist, ",")
+	if *tablelist == "all" {
+		list = []string{"recomp", "info"}
+	}
+
+	// Compute maximum decomposition size.
+	max := 0
+	for _, c := range chars {
+		if n := len(string(c.forms[FCompatibility].expandedDecomp)); n > max {
+			max = n
+		}
+	}
+	fmt.Fprintln(w, `import "sync"`)
+	fmt.Fprintln(w)
+
+	fmt.Fprintln(w, "const (")
+	fmt.Fprintln(w, "\t// Version is the Unicode edition from which the tables are derived.")
+	fmt.Fprintf(w, "\tVersion = %q\n", gen.UnicodeVersion())
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "\t// MaxTransformChunkSize indicates the maximum number of bytes that Transform")
+	fmt.Fprintln(w, "\t// may need to write atomically for any Form. Making a destination buffer at")
+	fmt.Fprintln(w, "\t// least this size ensures that Transform can always make progress and that")
+	fmt.Fprintln(w, "\t// the user does not need to grow the buffer on an ErrShortDst.")
+	fmt.Fprintf(w, "\tMaxTransformChunkSize = %d+maxNonStarters*4\n", len(string(0x034F))+max)
+	fmt.Fprintln(w, ")\n")
+
+	// Print the CCC remap table.
+	size += len(cccMap)
+	fmt.Fprintf(w, "var ccc = [%d]uint8{", len(cccMap))
+	for i := 0; i < len(cccMap); i++ {
+		if i%8 == 0 {
+			fmt.Fprintln(w)
+		}
+		fmt.Fprintf(w, "%3d, ", cccMap[uint8(i)])
+	}
+	fmt.Fprintln(w, "\n}\n")
+
+	if contains(list, "info") {
+		size += printCharInfoTables(w)
+	}
+
+	if contains(list, "recomp") {
+		// Note that we use 32 bit keys, instead of 64 bit.
+		// This clips the bits of three entries, but we know
+		// this won't cause a collision. The compiler will catch
+		// any changes made to UnicodeData.txt that introduces
+		// a collision.
+		// Note that the recomposition map for NFC and NFKC
+		// are identical.
+
+		// Recomposition map
+		nrentries := 0
+		for _, c := range chars {
+			f := c.forms[FCanonical]
+			if !f.isOneWay && len(f.decomp) > 0 {
+				nrentries++
+			}
+		}
+		sz := nrentries * 8
+		size += sz
+		fmt.Fprintf(w, "// recompMap: %d bytes (entries only)\n", sz)
+		fmt.Fprintln(w, "var recompMap map[uint32]rune")
+		fmt.Fprintln(w, "var recompMapOnce sync.Once\n")
+		fmt.Fprintln(w, `const recompMapPacked = "" +`)
+		var buf [8]byte
+		for i, c := range chars {
+			f := c.forms[FCanonical]
+			d := f.decomp
+			if !f.isOneWay && len(d) > 0 {
+				key := uint32(uint16(d[0]))<<16 + uint32(uint16(d[1]))
+				binary.BigEndian.PutUint32(buf[:4], key)
+				binary.BigEndian.PutUint32(buf[4:], uint32(i))
+				fmt.Fprintf(w, "\t\t%q + // 0x%.8X: 0x%.8X\n", string(buf[:]), key, uint32(i))
+			}
+		}
+		// hack so we don't have to special case the trailing plus sign
+		fmt.Fprintf(w, `	""`)
+		fmt.Fprintln(w)
+	}
+
+	fmt.Fprintf(w, "// Total size of tables: %dKB (%d bytes)\n", (size+512)/1024, size)
+	gen.WriteVersionedGoFile("tables.go", "norm", w.Bytes())
+}
+
+func printChars() {
+	if *verbose {
+		for _, c := range chars {
+			if !c.isValid() || c.state == SMissing {
+				continue
+			}
+			fmt.Println(c)
+		}
+	}
+}
+
+// verifyComputed does various consistency tests.
+func verifyComputed() {
+	for i, c := range chars {
+		for _, f := range c.forms {
+			isNo := (f.quickCheck[MDecomposed] == QCNo)
+			if (len(f.decomp) > 0) != isNo && !isHangul(rune(i)) {
+				log.Fatalf("%U: NF*D QC must be No if rune decomposes", i)
+			}
+
+			isMaybe := f.quickCheck[MComposed] == QCMaybe
+			if f.combinesBackward != isMaybe {
+				log.Fatalf("%U: NF*C QC must be Maybe if combinesBackward", i)
+			}
+			if len(f.decomp) > 0 && f.combinesForward && isMaybe {
+				log.Fatalf("%U: NF*C QC must be Yes or No if combinesForward and decomposes", i)
+			}
+
+			if len(f.expandedDecomp) != 0 {
+				continue
+			}
+			if a, b := c.nLeadingNonStarters > 0, (c.ccc > 0 || f.combinesBackward); a != b {
+				// We accept these runes to be treated differently (it only affects
+				// segment breaking in iteration, most likely on improper use), but
+				// reconsider if more characters are added.
+				// U+FF9E HALFWIDTH KATAKANA VOICED SOUND MARK;Lm;0;L;<narrow> 3099;;;;N;;;;;
+				// U+FF9F HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK;Lm;0;L;<narrow> 309A;;;;N;;;;;
+				// U+3133 HANGUL LETTER KIYEOK-SIOS;Lo;0;L;<compat> 11AA;;;;N;HANGUL LETTER GIYEOG SIOS;;;;
+				// U+318E HANGUL LETTER ARAEAE;Lo;0;L;<compat> 11A1;;;;N;HANGUL LETTER ALAE AE;;;;
+				// U+FFA3 HALFWIDTH HANGUL LETTER KIYEOK-SIOS;Lo;0;L;<narrow> 3133;;;;N;HALFWIDTH HANGUL LETTER GIYEOG SIOS;;;;
+				// U+FFDC HALFWIDTH HANGUL LETTER I;Lo;0;L;<narrow> 3163;;;;N;;;;;
+				if i != 0xFF9E && i != 0xFF9F && !(0x3133 <= i && i <= 0x318E) && !(0xFFA3 <= i && i <= 0xFFDC) {
+					log.Fatalf("%U: nLead was %v; want %v", i, a, b)
+				}
+			}
+		}
+		nfc := c.forms[FCanonical]
+		nfkc := c.forms[FCompatibility]
+		if nfc.combinesBackward != nfkc.combinesBackward {
+			log.Fatalf("%U: Cannot combine combinesBackward\n", c.codePoint)
+		}
+	}
+}
+
+// Use values in DerivedNormalizationProps.txt to compare against the
+// values we computed.
+// DerivedNormalizationProps.txt has form:
+// 00C0..00C5    ; NFD_QC; N # ...
+// 0374          ; NFD_QC; N # ...
+// See https://unicode.org/reports/tr44/ for full explanation
+func testDerived() {
+	f := gen.OpenUCDFile("DerivedNormalizationProps.txt")
+	defer f.Close()
+	p := ucd.New(f)
+	for p.Next() {
+		r := p.Rune(0)
+		c := &chars[r]
+
+		var ftype, mode int
+		qt := p.String(1)
+		switch qt {
+		case "NFC_QC":
+			ftype, mode = FCanonical, MComposed
+		case "NFD_QC":
+			ftype, mode = FCanonical, MDecomposed
+		case "NFKC_QC":
+			ftype, mode = FCompatibility, MComposed
+		case "NFKD_QC":
+			ftype, mode = FCompatibility, MDecomposed
+		default:
+			continue
+		}
+		var qr QCResult
+		switch p.String(2) {
+		case "Y":
+			qr = QCYes
+		case "N":
+			qr = QCNo
+		case "M":
+			qr = QCMaybe
+		default:
+			log.Fatalf(`Unexpected quick check value "%s"`, p.String(2))
+		}
+		if got := c.forms[ftype].quickCheck[mode]; got != qr {
+			log.Printf("%U: FAILED %s (was %v need %v)\n", r, qt, got, qr)
+		}
+		c.forms[ftype].verified[mode] = true
+	}
+	if err := p.Err(); err != nil {
+		log.Fatal(err)
+	}
+	// Any unspecified value must be QCYes. Verify this.
+	for i, c := range chars {
+		for j, fd := range c.forms {
+			for k, qr := range fd.quickCheck {
+				if !fd.verified[k] && qr != QCYes {
+					m := "%U: FAIL F:%d M:%d (was %v need Yes) %s\n"
+					log.Printf(m, i, j, k, qr, c.name)
+				}
+			}
+		}
+	}
+}
+
+var testHeader = `const (
+	Yes = iota
+	No
+	Maybe
+)
+
+type formData struct {
+	qc              uint8
+	combinesForward bool
+	decomposition   string
+}
+
+type runeData struct {
+	r      rune
+	ccc    uint8
+	nLead  uint8
+	nTrail uint8
+	f      [2]formData // 0: canonical; 1: compatibility
+}
+
+func f(qc uint8, cf bool, dec string) [2]formData {
+	return [2]formData{{qc, cf, dec}, {qc, cf, dec}}
+}
+
+func g(qc, qck uint8, cf, cfk bool, d, dk string) [2]formData {
+	return [2]formData{{qc, cf, d}, {qck, cfk, dk}}
+}
+
+var testData = []runeData{
+`
+
+func printTestdata() {
+	type lastInfo struct {
+		ccc    uint8
+		nLead  uint8
+		nTrail uint8
+		f      string
+	}
+
+	last := lastInfo{}
+	w := &bytes.Buffer{}
+	fmt.Fprintf(w, testHeader)
+	for r, c := range chars {
+		f := c.forms[FCanonical]
+		qc, cf, d := f.quickCheck[MComposed], f.combinesForward, string(f.expandedDecomp)
+		f = c.forms[FCompatibility]
+		qck, cfk, dk := f.quickCheck[MComposed], f.combinesForward, string(f.expandedDecomp)
+		s := ""
+		if d == dk && qc == qck && cf == cfk {
+			s = fmt.Sprintf("f(%s, %v, %q)", qc, cf, d)
+		} else {
+			s = fmt.Sprintf("g(%s, %s, %v, %v, %q, %q)", qc, qck, cf, cfk, d, dk)
+		}
+		current := lastInfo{c.ccc, c.nLeadingNonStarters, c.nTrailingNonStarters, s}
+		if last != current {
+			fmt.Fprintf(w, "\t{0x%x, %d, %d, %d, %s},\n", r, c.origCCC, c.nLeadingNonStarters, c.nTrailingNonStarters, s)
+			last = current
+		}
+	}
+	fmt.Fprintln(w, "}")
+	gen.WriteVersionedGoFile("data_test.go", "norm", w.Bytes())
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/triegen.go b/vendor/golang.org/x/text/unicode/norm/triegen.go
new file mode 100644
index 000000000..45d711900
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/triegen.go
@@ -0,0 +1,117 @@
+// Copyright 2011 The Go 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 ignore
+
+// Trie table generator.
+// Used by make*tables tools to generate a go file with trie data structures
+// for mapping UTF-8 to a 16-bit value. All but the last byte in a UTF-8 byte
+// sequence are used to lookup offsets in the index table to be used for the
+// next byte. The last byte is used to index into a table with 16-bit values.
+
+package main
+
+import (
+	"fmt"
+	"io"
+)
+
+const maxSparseEntries = 16
+
+type normCompacter struct {
+	sparseBlocks [][]uint64
+	sparseOffset []uint16
+	sparseCount  int
+	name         string
+}
+
+func mostFrequentStride(a []uint64) int {
+	counts := make(map[int]int)
+	var v int
+	for _, x := range a {
+		if stride := int(x) - v; v != 0 && stride >= 0 {
+			counts[stride]++
+		}
+		v = int(x)
+	}
+	var maxs, maxc int
+	for stride, cnt := range counts {
+		if cnt > maxc || (cnt == maxc && stride < maxs) {
+			maxs, maxc = stride, cnt
+		}
+	}
+	return maxs
+}
+
+func countSparseEntries(a []uint64) int {
+	stride := mostFrequentStride(a)
+	var v, count int
+	for _, tv := range a {
+		if int(tv)-v != stride {
+			if tv != 0 {
+				count++
+			}
+		}
+		v = int(tv)
+	}
+	return count
+}
+
+func (c *normCompacter) Size(v []uint64) (sz int, ok bool) {
+	if n := countSparseEntries(v); n <= maxSparseEntries {
+		return (n+1)*4 + 2, true
+	}
+	return 0, false
+}
+
+func (c *normCompacter) Store(v []uint64) uint32 {
+	h := uint32(len(c.sparseOffset))
+	c.sparseBlocks = append(c.sparseBlocks, v)
+	c.sparseOffset = append(c.sparseOffset, uint16(c.sparseCount))
+	c.sparseCount += countSparseEntries(v) + 1
+	return h
+}
+
+func (c *normCompacter) Handler() string {
+	return c.name + "Sparse.lookup"
+}
+
+func (c *normCompacter) Print(w io.Writer) (retErr error) {
+	p := func(f string, x ...interface{}) {
+		if _, err := fmt.Fprintf(w, f, x...); retErr == nil && err != nil {
+			retErr = err
+		}
+	}
+
+	ls := len(c.sparseBlocks)
+	p("// %sSparseOffset: %d entries, %d bytes\n", c.name, ls, ls*2)
+	p("var %sSparseOffset = %#v\n\n", c.name, c.sparseOffset)
+
+	ns := c.sparseCount
+	p("// %sSparseValues: %d entries, %d bytes\n", c.name, ns, ns*4)
+	p("var %sSparseValues = [%d]valueRange {", c.name, ns)
+	for i, b := range c.sparseBlocks {
+		p("\n// Block %#x, offset %#x", i, c.sparseOffset[i])
+		var v int
+		stride := mostFrequentStride(b)
+		n := countSparseEntries(b)
+		p("\n{value:%#04x,lo:%#02x},", stride, uint8(n))
+		for i, nv := range b {
+			if int(nv)-v != stride {
+				if v != 0 {
+					p(",hi:%#02x},", 0x80+i-1)
+				}
+				if nv != 0 {
+					p("\n{value:%#04x,lo:%#02x", nv, 0x80+i)
+				}
+			}
+			v = int(nv)
+		}
+		if v != 0 {
+			p(",hi:%#02x},", 0x80+len(b)-1)
+		}
+	}
+	p("\n}\n\n")
+	return
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 70d7a6c98..31a34c6f4 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -1,11 +1,11 @@
 # cloud.google.com/go v0.45.1
 cloud.google.com/go/compute/metadata
+cloud.google.com/go/storage
 cloud.google.com/go/iam
 cloud.google.com/go/internal
 cloud.google.com/go/internal/optional
 cloud.google.com/go/internal/trace
 cloud.google.com/go/internal/version
-cloud.google.com/go/storage
 # contrib.go.opencensus.io/exporter/ocagent v0.5.0
 contrib.go.opencensus.io/exporter/ocagent
 # github.com/1and1/oneandone-cloudserver-sdk-go v1.0.1
@@ -14,42 +14,42 @@ github.com/1and1/oneandone-cloudserver-sdk-go
 github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-04-01/compute
 github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute
 github.com/Azure/azure-sdk-for-go/services/network/mgmt/2018-01-01/network
-github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-06-01/subscriptions
 github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2018-02-01/resources
 github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage
 github.com/Azure/azure-sdk-for-go/storage
+github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-06-01/subscriptions
 github.com/Azure/azure-sdk-for-go/version
 # github.com/Azure/go-autorest v12.0.0+incompatible
 github.com/Azure/go-autorest/autorest
 github.com/Azure/go-autorest/autorest/adal
 github.com/Azure/go-autorest/autorest/azure
-github.com/Azure/go-autorest/autorest/date
 github.com/Azure/go-autorest/autorest/to
+github.com/Azure/go-autorest/autorest/date
 github.com/Azure/go-autorest/autorest/validation
-github.com/Azure/go-autorest/logger
 github.com/Azure/go-autorest/tracing
+github.com/Azure/go-autorest/logger
 # github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4
 github.com/Azure/go-ntlmssp
 # github.com/ChrisTrenkamp/goxpath v0.0.0-20170625215350-4fe035839290
 github.com/ChrisTrenkamp/goxpath
+github.com/ChrisTrenkamp/goxpath/tree/xmltree
+github.com/ChrisTrenkamp/goxpath/tree
 github.com/ChrisTrenkamp/goxpath/internal/execxp
-github.com/ChrisTrenkamp/goxpath/internal/lexer
 github.com/ChrisTrenkamp/goxpath/internal/parser
+github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlbuilder
+github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlele
+github.com/ChrisTrenkamp/goxpath/internal/lexer
 github.com/ChrisTrenkamp/goxpath/internal/parser/findutil
 github.com/ChrisTrenkamp/goxpath/internal/parser/intfns
 github.com/ChrisTrenkamp/goxpath/internal/parser/pathexpr
 github.com/ChrisTrenkamp/goxpath/internal/xconst
 github.com/ChrisTrenkamp/goxpath/internal/xsort
-github.com/ChrisTrenkamp/goxpath/tree
-github.com/ChrisTrenkamp/goxpath/tree/xmltree
-github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlbuilder
-github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlele
 github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlnode
 # github.com/NaverCloudPlatform/ncloud-sdk-go v0.0.0-20180110055012-c2e73f942591
-github.com/NaverCloudPlatform/ncloud-sdk-go/common
-github.com/NaverCloudPlatform/ncloud-sdk-go/oauth
-github.com/NaverCloudPlatform/ncloud-sdk-go/request
 github.com/NaverCloudPlatform/ncloud-sdk-go/sdk
+github.com/NaverCloudPlatform/ncloud-sdk-go/common
+github.com/NaverCloudPlatform/ncloud-sdk-go/request
+github.com/NaverCloudPlatform/ncloud-sdk-go/oauth
 # github.com/PuerkitoBio/goquery v1.5.0
 github.com/PuerkitoBio/goquery
 # github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d
@@ -57,18 +57,18 @@ github.com/StackExchange/wmi
 # github.com/Telmate/proxmox-api-go v0.0.0-20190815172943-ef9222844e60
 github.com/Telmate/proxmox-api-go/proxmox
 # github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190418113227-25233c783f4e
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses
+github.com/aliyun/alibaba-cloud-sdk-go/services/ecs
+github.com/aliyun/alibaba-cloud-sdk-go/services/ram
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils
 github.com/aliyun/alibaba-cloud-sdk-go/sdk
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils
-github.com/aliyun/alibaba-cloud-sdk-go/services/ecs
-github.com/aliyun/alibaba-cloud-sdk-go/services/ram
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers
 # github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20170113022742-e6dbea820a9f
 github.com/aliyun/aliyun-oss-go-sdk/oss
 # github.com/andybalholm/cascadia v1.0.0
@@ -93,49 +93,49 @@ github.com/armon/go-metrics
 github.com/armon/go-radix
 # github.com/aws/aws-sdk-go v1.24.1
 github.com/aws/aws-sdk-go/aws
+github.com/aws/aws-sdk-go/aws/ec2metadata
+github.com/aws/aws-sdk-go/aws/session
+github.com/aws/aws-sdk-go/service/ec2
 github.com/aws/aws-sdk-go/aws/awserr
-github.com/aws/aws-sdk-go/aws/awsutil
+github.com/aws/aws-sdk-go/aws/credentials
+github.com/aws/aws-sdk-go/aws/request
+github.com/aws/aws-sdk-go/service/ec2/ec2iface
+github.com/aws/aws-sdk-go/service/sts
+github.com/aws/aws-sdk-go/service/ecr
+github.com/aws/aws-sdk-go/service/s3
+github.com/aws/aws-sdk-go/service/s3/s3manager
+github.com/aws/aws-sdk-go/aws/endpoints
+github.com/aws/aws-sdk-go/internal/sdkio
 github.com/aws/aws-sdk-go/aws/client
 github.com/aws/aws-sdk-go/aws/client/metadata
 github.com/aws/aws-sdk-go/aws/corehandlers
-github.com/aws/aws-sdk-go/aws/credentials
-github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds
-github.com/aws/aws-sdk-go/aws/credentials/endpointcreds
+github.com/aws/aws-sdk-go/internal/sdkuri
 github.com/aws/aws-sdk-go/aws/credentials/processcreds
 github.com/aws/aws-sdk-go/aws/credentials/stscreds
 github.com/aws/aws-sdk-go/aws/csm
 github.com/aws/aws-sdk-go/aws/defaults
-github.com/aws/aws-sdk-go/aws/ec2metadata
-github.com/aws/aws-sdk-go/aws/endpoints
-github.com/aws/aws-sdk-go/aws/request
-github.com/aws/aws-sdk-go/aws/session
-github.com/aws/aws-sdk-go/aws/signer/v4
 github.com/aws/aws-sdk-go/internal/ini
-github.com/aws/aws-sdk-go/internal/s3err
-github.com/aws/aws-sdk-go/internal/sdkio
-github.com/aws/aws-sdk-go/internal/sdkmath
-github.com/aws/aws-sdk-go/internal/sdkrand
-github.com/aws/aws-sdk-go/internal/sdkuri
 github.com/aws/aws-sdk-go/internal/shareddefaults
+github.com/aws/aws-sdk-go/aws/awsutil
+github.com/aws/aws-sdk-go/aws/signer/v4
 github.com/aws/aws-sdk-go/private/protocol
 github.com/aws/aws-sdk-go/private/protocol/ec2query
+github.com/aws/aws-sdk-go/private/protocol/query
+github.com/aws/aws-sdk-go/private/protocol/jsonrpc
+github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds
+github.com/aws/aws-sdk-go/internal/s3err
 github.com/aws/aws-sdk-go/private/protocol/eventstream
 github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi
-github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
-github.com/aws/aws-sdk-go/private/protocol/jsonrpc
-github.com/aws/aws-sdk-go/private/protocol/query
-github.com/aws/aws-sdk-go/private/protocol/query/queryutil
 github.com/aws/aws-sdk-go/private/protocol/rest
 github.com/aws/aws-sdk-go/private/protocol/restxml
 github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
-github.com/aws/aws-sdk-go/service/ec2
-github.com/aws/aws-sdk-go/service/ec2/ec2iface
-github.com/aws/aws-sdk-go/service/ecr
-github.com/aws/aws-sdk-go/service/s3
 github.com/aws/aws-sdk-go/service/s3/s3iface
-github.com/aws/aws-sdk-go/service/s3/s3manager
-github.com/aws/aws-sdk-go/service/sts
+github.com/aws/aws-sdk-go/internal/sdkrand
 github.com/aws/aws-sdk-go/service/sts/stsiface
+github.com/aws/aws-sdk-go/aws/credentials/endpointcreds
+github.com/aws/aws-sdk-go/internal/sdkmath
+github.com/aws/aws-sdk-go/private/protocol/query/queryutil
+github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
 # github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d
 github.com/bgentry/go-netrc/netrc
 # github.com/bgentry/speakeasy v0.1.0
@@ -195,11 +195,11 @@ github.com/go-ole/go-ole/oleutil
 # github.com/gobwas/glob v0.2.3
 github.com/gobwas/glob
 github.com/gobwas/glob/compiler
-github.com/gobwas/glob/match
 github.com/gobwas/glob/syntax
+github.com/gobwas/glob/match
 github.com/gobwas/glob/syntax/ast
-github.com/gobwas/glob/syntax/lexer
 github.com/gobwas/glob/util/runes
+github.com/gobwas/glob/syntax/lexer
 github.com/gobwas/glob/util/strings
 # github.com/gocolly/colly v1.2.0
 github.com/gocolly/colly
@@ -212,19 +212,19 @@ github.com/gofrs/uuid
 # github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
 github.com/golang-collections/collections/stack
 # github.com/golang/protobuf v1.3.2
-github.com/golang/protobuf/jsonpb
 github.com/golang/protobuf/proto
-github.com/golang/protobuf/protoc-gen-go/descriptor
-github.com/golang/protobuf/protoc-gen-go/generator
-github.com/golang/protobuf/protoc-gen-go/generator/internal/remap
-github.com/golang/protobuf/protoc-gen-go/plugin
+github.com/golang/protobuf/ptypes/timestamp
 github.com/golang/protobuf/ptypes
+github.com/golang/protobuf/jsonpb
+github.com/golang/protobuf/protoc-gen-go/descriptor
 github.com/golang/protobuf/ptypes/any
 github.com/golang/protobuf/ptypes/duration
 github.com/golang/protobuf/ptypes/empty
 github.com/golang/protobuf/ptypes/struct
-github.com/golang/protobuf/ptypes/timestamp
 github.com/golang/protobuf/ptypes/wrappers
+github.com/golang/protobuf/protoc-gen-go/generator
+github.com/golang/protobuf/protoc-gen-go/generator/internal/remap
+github.com/golang/protobuf/protoc-gen-go/plugin
 # github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db
 github.com/golang/snappy
 # github.com/google/go-cmp v0.3.0
@@ -243,7 +243,6 @@ github.com/google/uuid
 github.com/googleapis/gax-go/v2
 # github.com/gophercloud/gophercloud v0.2.0
 github.com/gophercloud/gophercloud
-github.com/gophercloud/gophercloud/internal
 github.com/gophercloud/gophercloud/openstack
 github.com/gophercloud/gophercloud/openstack/blockstorage/extensions/volumeactions
 github.com/gophercloud/gophercloud/openstack/blockstorage/v3/volumes
@@ -252,18 +251,19 @@ github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/bootfromvolum
 github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/keypairs
 github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/startstop
 github.com/gophercloud/gophercloud/openstack/compute/v2/flavors
-github.com/gophercloud/gophercloud/openstack/compute/v2/images
 github.com/gophercloud/gophercloud/openstack/compute/v2/servers
-github.com/gophercloud/gophercloud/openstack/identity/v2/tenants
-github.com/gophercloud/gophercloud/openstack/identity/v2/tokens
-github.com/gophercloud/gophercloud/openstack/identity/v3/tokens
 github.com/gophercloud/gophercloud/openstack/imageservice/v2/images
 github.com/gophercloud/gophercloud/openstack/imageservice/v2/members
 github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/external
 github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/layer3/floatingips
 github.com/gophercloud/gophercloud/openstack/networking/v2/networks
-github.com/gophercloud/gophercloud/openstack/utils
 github.com/gophercloud/gophercloud/pagination
+github.com/gophercloud/gophercloud/openstack/identity/v2/tokens
+github.com/gophercloud/gophercloud/openstack/identity/v3/tokens
+github.com/gophercloud/gophercloud/openstack/utils
+github.com/gophercloud/gophercloud/openstack/compute/v2/images
+github.com/gophercloud/gophercloud/internal
+github.com/gophercloud/gophercloud/openstack/identity/v2/tenants
 # github.com/gophercloud/utils v0.0.0-20190124192022-a5c25e7a53a6
 github.com/gophercloud/utils/openstack/clientconfig
 # github.com/gorilla/websocket v0.0.0-20170319172727-a91eba7f9777
@@ -271,9 +271,9 @@ github.com/gorilla/websocket
 # github.com/grpc-ecosystem/go-grpc-middleware v1.1.0
 github.com/grpc-ecosystem/go-grpc-middleware
 # github.com/grpc-ecosystem/grpc-gateway v1.8.5
-github.com/grpc-ecosystem/grpc-gateway/internal
 github.com/grpc-ecosystem/grpc-gateway/runtime
 github.com/grpc-ecosystem/grpc-gateway/utilities
+github.com/grpc-ecosystem/grpc-gateway/internal
 # github.com/hashicorp/consul v1.4.0
 github.com/hashicorp/consul/api
 # github.com/hashicorp/errwrap v1.0.0
@@ -290,9 +290,9 @@ github.com/hashicorp/go-immutable-radix
 # github.com/hashicorp/go-multierror v1.0.0
 github.com/hashicorp/go-multierror
 # github.com/hashicorp/go-oracle-terraform v0.0.0-20181016190316-007121241b79
-github.com/hashicorp/go-oracle-terraform/client
 github.com/hashicorp/go-oracle-terraform/compute
 github.com/hashicorp/go-oracle-terraform/opc
+github.com/hashicorp/go-oracle-terraform/client
 # github.com/hashicorp/go-retryablehttp v0.5.2
 github.com/hashicorp/go-retryablehttp
 # github.com/hashicorp/go-rootcerts v0.0.0-20160503143440-6bb64b370b90
@@ -311,21 +311,21 @@ github.com/hashicorp/golang-lru/simplelru
 github.com/hashicorp/hcl
 github.com/hashicorp/hcl/hcl/ast
 github.com/hashicorp/hcl/hcl/parser
-github.com/hashicorp/hcl/hcl/scanner
-github.com/hashicorp/hcl/hcl/strconv
 github.com/hashicorp/hcl/hcl/token
 github.com/hashicorp/hcl/json/parser
+github.com/hashicorp/hcl/hcl/scanner
+github.com/hashicorp/hcl/hcl/strconv
 github.com/hashicorp/hcl/json/scanner
 github.com/hashicorp/hcl/json/token
 # github.com/hashicorp/serf v0.8.2
 github.com/hashicorp/serf/coordinate
 # github.com/hashicorp/vault v1.1.0
 github.com/hashicorp/vault/api
-github.com/hashicorp/vault/helper/compressutil
 github.com/hashicorp/vault/helper/consts
 github.com/hashicorp/vault/helper/hclutil
 github.com/hashicorp/vault/helper/jsonutil
 github.com/hashicorp/vault/helper/parseutil
+github.com/hashicorp/vault/helper/compressutil
 github.com/hashicorp/vault/helper/strutil
 # github.com/hashicorp/yamux v0.0.0-20181012175058-2f1d1f20f75d
 github.com/hashicorp/yamux
@@ -336,24 +336,26 @@ github.com/hetznercloud/hcloud-go/hcloud/schema
 github.com/hyperonecom/h1-client-go
 # github.com/jdcloud-api/jdcloud-sdk-go v1.9.1-0.20190605102154-3d81a50ca961
 github.com/jdcloud-api/jdcloud-sdk-go/core
-github.com/jdcloud-api/jdcloud-sdk-go/services/charge/models
-github.com/jdcloud-api/jdcloud-sdk-go/services/common/models
-github.com/jdcloud-api/jdcloud-sdk-go/services/disk/models
 github.com/jdcloud-api/jdcloud-sdk-go/services/vm/apis
 github.com/jdcloud-api/jdcloud-sdk-go/services/vm/client
 github.com/jdcloud-api/jdcloud-sdk-go/services/vm/models
 github.com/jdcloud-api/jdcloud-sdk-go/services/vpc/apis
 github.com/jdcloud-api/jdcloud-sdk-go/services/vpc/client
 github.com/jdcloud-api/jdcloud-sdk-go/services/vpc/models
+github.com/jdcloud-api/jdcloud-sdk-go/services/common/models
+github.com/jdcloud-api/jdcloud-sdk-go/services/charge/models
+github.com/jdcloud-api/jdcloud-sdk-go/services/disk/models
+# github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869
+github.com/jehiah/go-strftime
 # github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af
 github.com/jmespath/go-jmespath
 # github.com/joyent/triton-go v0.0.0-20180116165742-545edbe0d564
 github.com/joyent/triton-go
 github.com/joyent/triton-go/authentication
-github.com/joyent/triton-go/client
 github.com/joyent/triton-go/compute
 github.com/joyent/triton-go/errors
 github.com/joyent/triton-go/network
+github.com/joyent/triton-go/client
 # github.com/json-iterator/go v1.1.6
 github.com/json-iterator/go
 # github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1
@@ -442,8 +444,8 @@ github.com/pkg/sftp
 github.com/pmezard/go-difflib/difflib
 # github.com/posener/complete v1.1.1
 github.com/posener/complete
-github.com/posener/complete/cmd
 github.com/posener/complete/cmd/install
+github.com/posener/complete/cmd
 github.com/posener/complete/match
 # github.com/profitbricks/profitbricks-sdk-go v4.0.2+incompatible
 github.com/profitbricks/profitbricks-sdk-go
@@ -457,15 +459,15 @@ github.com/saintfish/chardet
 github.com/satori/go.uuid
 # github.com/scaleway/scaleway-cli v0.0.0-20180921094345-7b12c9699d70
 github.com/scaleway/scaleway-cli/pkg/api
-github.com/scaleway/scaleway-cli/pkg/sshcommand
 github.com/scaleway/scaleway-cli/pkg/utils
+github.com/scaleway/scaleway-cli/pkg/sshcommand
 # github.com/shirou/gopsutil v2.18.12+incompatible
+github.com/shirou/gopsutil/process
 github.com/shirou/gopsutil/cpu
 github.com/shirou/gopsutil/host
 github.com/shirou/gopsutil/internal/common
 github.com/shirou/gopsutil/mem
 github.com/shirou/gopsutil/net
-github.com/shirou/gopsutil/process
 # github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4
 github.com/shirou/w32
 # github.com/sirupsen/logrus v1.4.2
@@ -478,13 +480,11 @@ github.com/temoto/robotstxt
 # github.com/tencentcloud/tencentcloud-sdk-go v3.0.71+incompatible
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors
-github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312
+github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http
 # github.com/ucloud/ucloud-sdk-go v0.8.7
-github.com/ucloud/ucloud-sdk-go/private/protocol/http
-github.com/ucloud/ucloud-sdk-go/private/utils
 github.com/ucloud/ucloud-sdk-go/services/uaccount
 github.com/ucloud/ucloud-sdk-go/services/uhost
 github.com/ucloud/ucloud-sdk-go/services/unet
@@ -492,64 +492,70 @@ github.com/ucloud/ucloud-sdk-go/services/vpc
 github.com/ucloud/ucloud-sdk-go/ucloud
 github.com/ucloud/ucloud-sdk-go/ucloud/auth
 github.com/ucloud/ucloud-sdk-go/ucloud/error
-github.com/ucloud/ucloud-sdk-go/ucloud/log
 github.com/ucloud/ucloud-sdk-go/ucloud/request
 github.com/ucloud/ucloud-sdk-go/ucloud/response
+github.com/ucloud/ucloud-sdk-go/private/utils
+github.com/ucloud/ucloud-sdk-go/ucloud/log
+github.com/ucloud/ucloud-sdk-go/private/protocol/http
 github.com/ucloud/ucloud-sdk-go/ucloud/version
 # github.com/ugorji/go v0.0.0-20151218193438-646ae4a518c1
 github.com/ugorji/go/codec
 # github.com/ulikunitz/xz v0.5.5
 github.com/ulikunitz/xz
-github.com/ulikunitz/xz/internal/hash
 github.com/ulikunitz/xz/internal/xlog
 github.com/ulikunitz/xz/lzma
+github.com/ulikunitz/xz/internal/hash
 # github.com/vmware/govmomi v0.0.0-20170707011325-c2105a174311
 github.com/vmware/govmomi
 github.com/vmware/govmomi/find
-github.com/vmware/govmomi/list
 github.com/vmware/govmomi/object
+github.com/vmware/govmomi/vim25/types
 github.com/vmware/govmomi/property
 github.com/vmware/govmomi/session
-github.com/vmware/govmomi/task
 github.com/vmware/govmomi/vim25
-github.com/vmware/govmomi/vim25/debug
-github.com/vmware/govmomi/vim25/methods
-github.com/vmware/govmomi/vim25/mo
-github.com/vmware/govmomi/vim25/progress
 github.com/vmware/govmomi/vim25/soap
-github.com/vmware/govmomi/vim25/types
+github.com/vmware/govmomi/list
+github.com/vmware/govmomi/vim25/mo
+github.com/vmware/govmomi/task
+github.com/vmware/govmomi/vim25/methods
+github.com/vmware/govmomi/vim25/progress
+github.com/vmware/govmomi/vim25/debug
 github.com/vmware/govmomi/vim25/xml
 # github.com/xanzy/go-cloudstack v0.0.0-20190526095453-42f262b63ed0
 github.com/xanzy/go-cloudstack/cloudstack
 # github.com/yandex-cloud/go-genproto v0.0.0-20190916101622-7617782d381e
-github.com/yandex-cloud/go-genproto/yandex/cloud
-github.com/yandex-cloud/go-genproto/yandex/cloud/access
-github.com/yandex-cloud/go-genproto/yandex/cloud/api
 github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint
+github.com/yandex-cloud/go-genproto/yandex/cloud/vpc/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud
+github.com/yandex-cloud/go-genproto/yandex/cloud/api
+github.com/yandex-cloud/go-genproto/yandex/cloud/operation
+github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/instancegroup
 github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint
-github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility
-github.com/yandex-cloud/go-genproto/yandex/cloud/iot/devices/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/config
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/config
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mysql/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mysql/v1/config
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1/config
-github.com/yandex-cloud/go-genproto/yandex/cloud/operation
 github.com/yandex-cloud/go-genproto/yandex/cloud/resourcemanager/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/serverless/functions/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/serverless/triggers/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/vpc/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/access
+github.com/yandex-cloud/go-genproto/yandex/cloud/iot/devices/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/config
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/config
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mysql/v1/config
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1/config
+github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility
 # github.com/yandex-cloud/go-sdk v0.0.0-20190916101744-c781afa45829
 github.com/yandex-cloud/go-sdk
+github.com/yandex-cloud/go-sdk/iamkey
+github.com/yandex-cloud/go-sdk/pkg/requestid
+github.com/yandex-cloud/go-sdk/pkg/retry
+github.com/yandex-cloud/go-sdk/sdkresolvers
 github.com/yandex-cloud/go-sdk/dial
 github.com/yandex-cloud/go-sdk/gen/apiendpoint
 github.com/yandex-cloud/go-sdk/gen/compute
@@ -557,7 +563,6 @@ github.com/yandex-cloud/go-sdk/gen/compute/instancegroup
 github.com/yandex-cloud/go-sdk/gen/containerregistry
 github.com/yandex-cloud/go-sdk/gen/functions
 github.com/yandex-cloud/go-sdk/gen/iam
-github.com/yandex-cloud/go-sdk/gen/iam/awscompatibility
 github.com/yandex-cloud/go-sdk/gen/iot/devices
 github.com/yandex-cloud/go-sdk/gen/loadbalancer
 github.com/yandex-cloud/go-sdk/gen/mdb/clickhouse
@@ -569,78 +574,80 @@ github.com/yandex-cloud/go-sdk/gen/operation
 github.com/yandex-cloud/go-sdk/gen/resourcemanager
 github.com/yandex-cloud/go-sdk/gen/triggers
 github.com/yandex-cloud/go-sdk/gen/vpc
-github.com/yandex-cloud/go-sdk/iamkey
 github.com/yandex-cloud/go-sdk/operation
 github.com/yandex-cloud/go-sdk/pkg/grpcclient
-github.com/yandex-cloud/go-sdk/pkg/requestid
-github.com/yandex-cloud/go-sdk/pkg/retry
 github.com/yandex-cloud/go-sdk/pkg/sdkerrors
 github.com/yandex-cloud/go-sdk/pkg/singleflight
-github.com/yandex-cloud/go-sdk/sdkresolvers
+github.com/yandex-cloud/go-sdk/gen/iam/awscompatibility
 # go.opencensus.io v0.22.0
+go.opencensus.io/plugin/ochttp
+go.opencensus.io/plugin/ochttp/propagation/tracecontext
+go.opencensus.io/stats/view
+go.opencensus.io/trace
 go.opencensus.io
-go.opencensus.io/internal
+go.opencensus.io/plugin/ocgrpc
+go.opencensus.io/resource
+go.opencensus.io/stats
+go.opencensus.io/tag
+go.opencensus.io/trace/tracestate
+go.opencensus.io/plugin/ochttp/propagation/b3
+go.opencensus.io/trace/propagation
 go.opencensus.io/internal/tagencoding
 go.opencensus.io/metric/metricdata
 go.opencensus.io/metric/metricproducer
-go.opencensus.io/plugin/ocgrpc
-go.opencensus.io/plugin/ochttp
-go.opencensus.io/plugin/ochttp/propagation/b3
-go.opencensus.io/plugin/ochttp/propagation/tracecontext
-go.opencensus.io/resource
-go.opencensus.io/stats
 go.opencensus.io/stats/internal
-go.opencensus.io/stats/view
-go.opencensus.io/tag
-go.opencensus.io/trace
+go.opencensus.io/internal
 go.opencensus.io/trace/internal
-go.opencensus.io/trace/propagation
-go.opencensus.io/trace/tracestate
 # golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5
-golang.org/x/crypto/curve25519
-golang.org/x/crypto/ed25519
-golang.org/x/crypto/ed25519/internal/edwards25519
-golang.org/x/crypto/internal/chacha20
-golang.org/x/crypto/internal/subtle
-golang.org/x/crypto/md4
-golang.org/x/crypto/poly1305
 golang.org/x/crypto/ssh
 golang.org/x/crypto/ssh/agent
+golang.org/x/crypto/curve25519
+golang.org/x/crypto/ed25519
+golang.org/x/crypto/internal/chacha20
+golang.org/x/crypto/poly1305
+golang.org/x/crypto/md4
+golang.org/x/crypto/ed25519/internal/edwards25519
+golang.org/x/crypto/internal/subtle
 golang.org/x/crypto/ssh/terminal
 # golang.org/x/net v0.0.0-20190620200207-3b0461eec859
-golang.org/x/net/context
-golang.org/x/net/context/ctxhttp
-golang.org/x/net/html
-golang.org/x/net/html/atom
-golang.org/x/net/html/charset
-golang.org/x/net/http/httpguts
+golang.org/x/net/proxy
 golang.org/x/net/http2
+golang.org/x/net/html/charset
+golang.org/x/net/trace
+golang.org/x/net/html
+golang.org/x/net/internal/socks
+golang.org/x/net/http/httpguts
 golang.org/x/net/http2/hpack
 golang.org/x/net/idna
-golang.org/x/net/internal/socks
-golang.org/x/net/internal/timeseries
-golang.org/x/net/proxy
+golang.org/x/net/context/ctxhttp
+golang.org/x/net/context
 golang.org/x/net/publicsuffix
-golang.org/x/net/trace
+golang.org/x/net/internal/timeseries
+golang.org/x/net/html/atom
 # golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45
 golang.org/x/oauth2
 golang.org/x/oauth2/google
+golang.org/x/oauth2/jwt
 golang.org/x/oauth2/internal
 golang.org/x/oauth2/jws
-golang.org/x/oauth2/jwt
 # golang.org/x/sync v0.0.0-20190423024810-112230192c58
-golang.org/x/sync/errgroup
 golang.org/x/sync/semaphore
+golang.org/x/sync/errgroup
 # golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0
-golang.org/x/sys/cpu
 golang.org/x/sys/unix
 golang.org/x/sys/windows
+golang.org/x/sys/cpu
 # golang.org/x/text v0.3.2
 golang.org/x/text/encoding
 golang.org/x/text/encoding/charmap
 golang.org/x/text/encoding/htmlindex
-golang.org/x/text/encoding/internal
+golang.org/x/text/transform
+golang.org/x/text/secure/bidirule
+golang.org/x/text/unicode/bidi
+golang.org/x/text/unicode/norm
+golang.org/x/text/language
 golang.org/x/text/encoding/internal/identifier
+golang.org/x/text/encoding/internal
 golang.org/x/text/encoding/japanese
 golang.org/x/text/encoding/korean
 golang.org/x/text/encoding/simplifiedchinese
@@ -648,63 +655,57 @@ golang.org/x/text/encoding/traditionalchinese
 golang.org/x/text/encoding/unicode
 golang.org/x/text/internal/language
 golang.org/x/text/internal/language/compact
-golang.org/x/text/internal/tag
 golang.org/x/text/internal/utf8internal
-golang.org/x/text/language
 golang.org/x/text/runes
-golang.org/x/text/secure/bidirule
-golang.org/x/text/transform
-golang.org/x/text/unicode/bidi
-golang.org/x/text/unicode/norm
+golang.org/x/text/internal/tag
 # golang.org/x/time v0.0.0-20190308202827-9d24e82272b4
 golang.org/x/time/rate
 # google.golang.org/api v0.9.0
 google.golang.org/api/compute/v1
+google.golang.org/api/storage/v1
 google.golang.org/api/gensupport
 google.golang.org/api/googleapi
-google.golang.org/api/googleapi/internal/uritemplates
-google.golang.org/api/googleapi/transport
-google.golang.org/api/internal
-google.golang.org/api/iterator
 google.golang.org/api/option
-google.golang.org/api/storage/v1
-google.golang.org/api/support/bundler
 google.golang.org/api/transport/http
+google.golang.org/api/iterator
+google.golang.org/api/googleapi/internal/uritemplates
+google.golang.org/api/internal
+google.golang.org/api/googleapi/transport
 google.golang.org/api/transport/http/internal/propagation
+google.golang.org/api/support/bundler
 # google.golang.org/appengine v1.6.1
 google.golang.org/appengine
+google.golang.org/appengine/urlfetch
 google.golang.org/appengine/internal
 google.golang.org/appengine/internal/app_identity
+google.golang.org/appengine/internal/modules
+google.golang.org/appengine/internal/urlfetch
 google.golang.org/appengine/internal/base
 google.golang.org/appengine/internal/datastore
 google.golang.org/appengine/internal/log
-google.golang.org/appengine/internal/modules
 google.golang.org/appengine/internal/remote_api
-google.golang.org/appengine/internal/urlfetch
-google.golang.org/appengine/urlfetch
 # google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55
 google.golang.org/genproto/googleapis/api/annotations
-google.golang.org/genproto/googleapis/api/httpbody
-google.golang.org/genproto/googleapis/iam/v1
-google.golang.org/genproto/googleapis/rpc/code
+google.golang.org/genproto/protobuf/field_mask
 google.golang.org/genproto/googleapis/rpc/errdetails
 google.golang.org/genproto/googleapis/rpc/status
-google.golang.org/genproto/googleapis/type/expr
 google.golang.org/genproto/googleapis/type/timeofday
-google.golang.org/genproto/protobuf/field_mask
+google.golang.org/genproto/googleapis/iam/v1
+google.golang.org/genproto/googleapis/rpc/code
+google.golang.org/genproto/googleapis/type/expr
+google.golang.org/genproto/googleapis/api/httpbody
 # google.golang.org/grpc v1.21.1
 google.golang.org/grpc
-google.golang.org/grpc/balancer
-google.golang.org/grpc/balancer/base
-google.golang.org/grpc/balancer/roundrobin
-google.golang.org/grpc/binarylog/grpc_binarylog_v1
 google.golang.org/grpc/codes
-google.golang.org/grpc/connectivity
+google.golang.org/grpc/metadata
+google.golang.org/grpc/status
 google.golang.org/grpc/credentials
-google.golang.org/grpc/credentials/internal
+google.golang.org/grpc/grpclog
+google.golang.org/grpc/balancer
+google.golang.org/grpc/balancer/roundrobin
+google.golang.org/grpc/connectivity
 google.golang.org/grpc/encoding
 google.golang.org/grpc/encoding/proto
-google.golang.org/grpc/grpclog
 google.golang.org/grpc/internal
 google.golang.org/grpc/internal/backoff
 google.golang.org/grpc/internal/balancerload
@@ -713,18 +714,19 @@ google.golang.org/grpc/internal/channelz
 google.golang.org/grpc/internal/envconfig
 google.golang.org/grpc/internal/grpcrand
 google.golang.org/grpc/internal/grpcsync
-google.golang.org/grpc/internal/syscall
 google.golang.org/grpc/internal/transport
 google.golang.org/grpc/keepalive
-google.golang.org/grpc/metadata
 google.golang.org/grpc/naming
 google.golang.org/grpc/peer
 google.golang.org/grpc/resolver
 google.golang.org/grpc/resolver/dns
 google.golang.org/grpc/resolver/passthrough
 google.golang.org/grpc/stats
-google.golang.org/grpc/status
 google.golang.org/grpc/tap
+google.golang.org/grpc/credentials/internal
+google.golang.org/grpc/balancer/base
+google.golang.org/grpc/binarylog/grpc_binarylog_v1
+google.golang.org/grpc/internal/syscall
 # gopkg.in/ini.v1 v1.42.0
 gopkg.in/ini.v1
 # gopkg.in/resty.v1 v1.12.0
diff --git a/website/source/docs/templates/engine.html.md b/website/source/docs/templates/engine.html.md
index 06681e921..4c7883c88 100644
--- a/website/source/docs/templates/engine.html.md
+++ b/website/source/docs/templates/engine.html.md
@@ -66,6 +66,10 @@ Here is a full list of the available functions for reference.
     [formatted](https://golang.org/pkg/time/#example_Time_Format). See more
     examples below in [the `isotime` format
     reference](/docs/templates/engine.html#isotime-function-format-reference).
+    `strftime FORMAT` - UTC time, formated using the ISO C standard format
+    `FORMAT`. See
+    [jehiah/go-strftime](https://github.com/jehiah/go-strftime) for a list
+    of available format specifier.
 -   `lower` - Lowercases the string.
 -   `packer_version` - Returns Packer version.
 -   `pwd` - The working directory while executing Packer.

From 7f1f77b8c6ef064df5969452fc1f7cbe83f7d8ea Mon Sep 17 00:00:00 2001
From: psinghal20 <psinghal20@gmail.com>
Date: Thu, 10 Oct 2019 03:09:41 +0530
Subject: [PATCH 048/155] chore: tidy up go.mod

Signed-off-by: psinghal20 <psinghal20@gmail.com>
---
 go.mod | 1 -
 go.sum | 5 -----
 2 files changed, 6 deletions(-)

diff --git a/go.mod b/go.mod
index 2d09a5bf6..55c6db760 100644
--- a/go.mod
+++ b/go.mod
@@ -99,7 +99,6 @@ require (
 	github.com/mitchellh/go-fs v0.0.0-20180402234041-7b48fa161ea7
 	github.com/mitchellh/go-homedir v1.0.0
 	github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed
-	github.com/mitchellh/gox v1.0.1 // indirect
 	github.com/mitchellh/iochan v1.0.0
 	github.com/mitchellh/mapstructure v0.0.0-20180111000720-b4575eea38cc
 	github.com/mitchellh/panicwrap v0.0.0-20170106182340-fce601fe5557
diff --git a/go.sum b/go.sum
index b2b1398d5..6735fbbb6 100644
--- a/go.sum
+++ b/go.sum
@@ -57,8 +57,6 @@ github.com/armon/go-radix v1.0.0 h1:F4z6KzEeeQIMeLFa97iZU6vupzoecKdU5TX24SNppXI=
 github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
 github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3ATZkfNZeM=
 github.com/aws/aws-sdk-go v1.16.22/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
-github.com/aws/aws-sdk-go v1.22.2 h1:uYP58k2Cd9y1qBy8CxTe5ADmdi4kANm8Ul8ch3kkIcQ=
-github.com/aws/aws-sdk-go v1.22.2/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/aws/aws-sdk-go v1.24.1 h1:B2NRyTV1/+h+Dg8Bh7vnuvW6QZz/NBL+uzgC2uILDMI=
 github.com/aws/aws-sdk-go v1.24.1/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/azr/flock v0.0.0-20190823144736-958d66434653 h1:2H3Cu0cbG8iszfcgnANwC/cm0YkPJIQvaJ9/tSpwh9o=
@@ -208,7 +206,6 @@ github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdv
 github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/go-uuid v1.0.1 h1:fv1ep09latC32wFoVwnqcnKJGnMSdBanPczbHAYm1BE=
 github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-github.com/hashicorp/go-version v1.0.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/go-version v1.1.0 h1:bPIoEKD27tNdebFGGxxYwcL4nepeY4j1QP23PFRGzg0=
 github.com/hashicorp/go-version v1.1.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/go-version v1.2.0 h1:3vNe/fWF5CBgRIguda1meWhsZHy3m8gCJ5wx+dIzX/E=
@@ -306,8 +303,6 @@ github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eI
 github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed h1:FI2NIv6fpef6BQl2u3IZX/Cj20tfypRF4yd+uaHOMtI=
 github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed/go.mod h1:3rdaFaCv4AyBgu5ALFM0+tSuHrBh6v692nyQe3ikrq0=
 github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
-github.com/mitchellh/gox v1.0.1 h1:x0jD3dcHk9a9xPSDN6YEL4xL6Qz0dvNYm8yZqui5chI=
-github.com/mitchellh/gox v1.0.1/go.mod h1:ED6BioOGXMswlXa2zxfh/xdd5QhwYliBFn9V18Ap4z4=
 github.com/mitchellh/iochan v1.0.0 h1:C+X3KsSTLFVBr/tK1eYN/vs4rJcvsiLU338UhYPJWeY=
 github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
 github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=

From f9aebe1c9c2970ef1cf1e61193d06ceee93be735 Mon Sep 17 00:00:00 2001
From: Etienne Deneuve <etienne@deneuve.xyz>
Date: Fri, 11 Oct 2019 14:52:59 +0200
Subject: [PATCH 049/155] Change: Update doc, windows vm need ``/mode:vm`` to
 be syspreped correctly

---
 examples/azure/windows.json                    | 2 +-
 examples/azure/windows_custom_image.json       | 2 +-
 examples/azure/windows_quickstart.json         | 2 +-
 website/source/docs/builders/azure.html.md.erb | 2 +-
 website/source/docs/builders/ncloud.html.md    | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/examples/azure/windows.json b/examples/azure/windows.json
index 86445d73f..c1ee94d3d 100644
--- a/examples/azure/windows.json
+++ b/examples/azure/windows.json
@@ -37,7 +37,7 @@
         "  while ((Get-Service WindowsAzureGuestAgent).Status -ne 'Running') { Start-Sleep -s 5 }",
 
         "if( Test-Path $Env:SystemRoot\\windows\\system32\\Sysprep\\unattend.xml ){ rm $Env:SystemRoot\\windows\\system32\\Sysprep\\unattend.xml -Force}",
-        "& $env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /quiet /quit",
+        "& $env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /quiet /quit /mode:vm",
         "while($true) { $imageState = Get-ItemProperty HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State | Select ImageState; Write-Output $imageState.ImageState; if($imageState.ImageState -ne 'IMAGE_STATE_GENERALIZE_RESEAL_TO_OOBE') { Start-Sleep -s 10 } else { break } }"
     ]
   }]
diff --git a/examples/azure/windows_custom_image.json b/examples/azure/windows_custom_image.json
index 5a15a6946..a6e3d0057 100644
--- a/examples/azure/windows_custom_image.json
+++ b/examples/azure/windows_custom_image.json
@@ -42,7 +42,7 @@
         "  while ((Get-Service WindowsAzureGuestAgent).Status -ne 'Running') { Start-Sleep -s 5 }",
 
         "if( Test-Path $Env:SystemRoot\\windows\\system32\\Sysprep\\unattend.xml ){ rm $Env:SystemRoot\\windows\\system32\\Sysprep\\unattend.xml -Force}",
-        "& $env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /quiet /quit",
+        "& $env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /quiet /quit /mode:vm",
         "while($true) { $imageState = Get-ItemProperty HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State | Select ImageState; if($imageState.ImageState -ne 'IMAGE_STATE_GENERALIZE_RESEAL_TO_OOBE') { Write-Output $imageState.ImageState; Start-Sleep -s 10  } else { break } }"
     ]
   }]
diff --git a/examples/azure/windows_quickstart.json b/examples/azure/windows_quickstart.json
index 7cb6c9e8e..6d4fffb57 100644
--- a/examples/azure/windows_quickstart.json
+++ b/examples/azure/windows_quickstart.json
@@ -33,7 +33,7 @@
         "  while ((Get-Service WindowsAzureGuestAgent).Status -ne 'Running') { Start-Sleep -s 5 }",
 
         "if( Test-Path $Env:SystemRoot\\windows\\system32\\Sysprep\\unattend.xml ){ rm $Env:SystemRoot\\windows\\system32\\Sysprep\\unattend.xml -Force}",
-        "& $env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /quiet /quit",
+        "& $env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /quiet /quit /mode:vm",
         "while($true) { $imageState = Get-ItemProperty HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State | Select ImageState; if($imageState.ImageState -ne 'IMAGE_STATE_GENERALIZE_RESEAL_TO_OOBE') { Write-Output $imageState.ImageState; Start-Sleep -s 10  } else { break } }"
     ]
   }]
diff --git a/website/source/docs/builders/azure.html.md.erb b/website/source/docs/builders/azure.html.md.erb
index b09ff58fd..e2c83f80b 100644
--- a/website/source/docs/builders/azure.html.md.erb
+++ b/website/source/docs/builders/azure.html.md.erb
@@ -226,7 +226,7 @@ here](https://technet.microsoft.com/en-us/library/hh824815.aspx)
             "  while ((Get-Service WindowsAzureTelemetryService).Status -ne 'Running') { Start-Sleep -s 5 }",
             "  while ((Get-Service WindowsAzureGuestAgent).Status -ne 'Running') { Start-Sleep -s 5 }",
 
-            "& $env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /quiet /quit",
+            "& $env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /quiet /quit /mode:vm",
             "while($true) { $imageState = Get-ItemProperty HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Setup\\State | Select ImageState; if($imageState.ImageState -ne 'IMAGE_STATE_GENERALIZE_RESEAL_TO_OOBE') { Write-Output $imageState.ImageState; Start-Sleep -s 10  } else { break } }"
         ]
     }
diff --git a/website/source/docs/builders/ncloud.html.md b/website/source/docs/builders/ncloud.html.md
index 154fc1c8d..8c7d1c705 100644
--- a/website/source/docs/builders/ncloud.html.md
+++ b/website/source/docs/builders/ncloud.html.md
@@ -136,7 +136,7 @@ provision when creating a Windows server.
         {
           "type": "powershell",
           "inline": [
-            "$Env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /shutdown /quiet \"/unattend:C:\\Program Files (x86)\\NBP\\nserver64.xml\" "
+            "$Env:SystemRoot\\System32\\Sysprep\\Sysprep.exe /oobe /generalize /shutdown /quiet /mode:vm \"/unattend:C:\\Program Files (x86)\\NBP\\nserver64.xml\" "
           ]
         }
       ]

From 95e1a0ef729e8a28639928cc499d509d4ecee9c6 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Fri, 11 Oct 2019 12:05:46 -0700
Subject: [PATCH 050/155] ran make generate to unstick tests

---
 go.mod | 1 -
 1 file changed, 1 deletion(-)

diff --git a/go.mod b/go.mod
index 55c6db760..327a88162 100644
--- a/go.mod
+++ b/go.mod
@@ -49,7 +49,6 @@ require (
 	github.com/gofrs/flock v0.7.1
 	github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
 	github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
-	github.com/google/btree v1.0.0 // indirect
 	github.com/google/go-cmp v0.3.0
 	github.com/google/go-querystring v1.0.0 // indirect
 	github.com/google/shlex v0.0.0-20150127133951-6f45313302b9

From 2150ce7cba35ce1457b6430ccdaa57d527ec2546 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Fri, 11 Oct 2019 12:15:37 -0700
Subject: [PATCH 051/155] ran go mod vendor

---
 .../klauspost/compress/flate/gen.go           |  265 ---
 .../github.com/klauspost/cpuid/private-gen.go |  476 ------
 vendor/github.com/linode/linodego/template.go |  167 --
 .../azure-sdk-for-go/core/http/triv.go        |  141 --
 .../core/tls/generate_cert.go                 |  118 --
 .../shirou/gopsutil/host/types_darwin.go      |   17 -
 .../shirou/gopsutil/host/types_freebsd.go     |   44 -
 .../shirou/gopsutil/host/types_linux.go       |   42 -
 .../shirou/gopsutil/host/types_openbsd.go     |   43 -
 .../shirou/gopsutil/mem/types_openbsd.go      |   34 -
 .../shirou/gopsutil/process/types_darwin.go   |  160 --
 .../shirou/gopsutil/process/types_freebsd.go  |   95 --
 .../shirou/gopsutil/process/types_openbsd.go  |  103 --
 vendor/github.com/ulikunitz/xz/example.go     |   40 -
 vendor/golang.org/x/net/html/atom/gen.go      |  712 --------
 vendor/golang.org/x/net/publicsuffix/gen.go   |  717 --------
 vendor/golang.org/x/sys/unix/mkasm_darwin.go  |   61 -
 vendor/golang.org/x/sys/unix/mkpost.go        |  122 --
 vendor/golang.org/x/sys/unix/mksyscall.go     |  407 -----
 .../x/sys/unix/mksyscall_aix_ppc.go           |  415 -----
 .../x/sys/unix/mksyscall_aix_ppc64.go         |  614 -------
 .../x/sys/unix/mksyscall_solaris.go           |  335 ----
 .../golang.org/x/sys/unix/mksysctl_openbsd.go |  355 ----
 vendor/golang.org/x/sys/unix/mksysnum.go      |  190 ---
 vendor/golang.org/x/sys/unix/types_aix.go     |  237 ---
 vendor/golang.org/x/sys/unix/types_darwin.go  |  283 ---
 .../golang.org/x/sys/unix/types_dragonfly.go  |  263 ---
 vendor/golang.org/x/sys/unix/types_freebsd.go |  400 -----
 vendor/golang.org/x/sys/unix/types_netbsd.go  |  290 ----
 vendor/golang.org/x/sys/unix/types_openbsd.go |  283 ---
 vendor/golang.org/x/sys/unix/types_solaris.go |  266 ---
 .../x/text/encoding/charmap/maketables.go     |  556 ------
 .../x/text/encoding/htmlindex/gen.go          |  173 --
 .../text/encoding/internal/identifier/gen.go  |  142 --
 .../x/text/encoding/japanese/maketables.go    |  161 --
 .../x/text/encoding/korean/maketables.go      |  143 --
 .../encoding/simplifiedchinese/maketables.go  |  161 --
 .../encoding/traditionalchinese/maketables.go |  140 --
 .../x/text/internal/language/compact/gen.go   |   64 -
 .../internal/language/compact/gen_index.go    |  113 --
 .../internal/language/compact/gen_parents.go  |   54 -
 .../x/text/internal/language/gen.go           | 1520 -----------------
 .../x/text/internal/language/gen_common.go    |   20 -
 vendor/golang.org/x/text/language/gen.go      |  305 ----
 vendor/golang.org/x/text/unicode/bidi/gen.go  |  133 --
 .../x/text/unicode/bidi/gen_ranges.go         |   57 -
 .../x/text/unicode/bidi/gen_trieval.go        |   64 -
 .../x/text/unicode/norm/maketables.go         |  986 -----------
 .../golang.org/x/text/unicode/norm/triegen.go |  117 --
 vendor/modules.txt                            |  318 ++--
 50 files changed, 159 insertions(+), 12763 deletions(-)
 delete mode 100644 vendor/github.com/klauspost/compress/flate/gen.go
 delete mode 100644 vendor/github.com/klauspost/cpuid/private-gen.go
 delete mode 100644 vendor/github.com/linode/linodego/template.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/triv.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/generate_cert.go
 delete mode 100644 vendor/github.com/shirou/gopsutil/host/types_darwin.go
 delete mode 100644 vendor/github.com/shirou/gopsutil/host/types_freebsd.go
 delete mode 100644 vendor/github.com/shirou/gopsutil/host/types_linux.go
 delete mode 100644 vendor/github.com/shirou/gopsutil/host/types_openbsd.go
 delete mode 100644 vendor/github.com/shirou/gopsutil/mem/types_openbsd.go
 delete mode 100644 vendor/github.com/shirou/gopsutil/process/types_darwin.go
 delete mode 100644 vendor/github.com/shirou/gopsutil/process/types_freebsd.go
 delete mode 100644 vendor/github.com/shirou/gopsutil/process/types_openbsd.go
 delete mode 100644 vendor/github.com/ulikunitz/xz/example.go
 delete mode 100644 vendor/golang.org/x/net/html/atom/gen.go
 delete mode 100644 vendor/golang.org/x/net/publicsuffix/gen.go
 delete mode 100644 vendor/golang.org/x/sys/unix/mkasm_darwin.go
 delete mode 100644 vendor/golang.org/x/sys/unix/mkpost.go
 delete mode 100644 vendor/golang.org/x/sys/unix/mksyscall.go
 delete mode 100644 vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go
 delete mode 100644 vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go
 delete mode 100644 vendor/golang.org/x/sys/unix/mksyscall_solaris.go
 delete mode 100644 vendor/golang.org/x/sys/unix/mksysctl_openbsd.go
 delete mode 100644 vendor/golang.org/x/sys/unix/mksysnum.go
 delete mode 100644 vendor/golang.org/x/sys/unix/types_aix.go
 delete mode 100644 vendor/golang.org/x/sys/unix/types_darwin.go
 delete mode 100644 vendor/golang.org/x/sys/unix/types_dragonfly.go
 delete mode 100644 vendor/golang.org/x/sys/unix/types_freebsd.go
 delete mode 100644 vendor/golang.org/x/sys/unix/types_netbsd.go
 delete mode 100644 vendor/golang.org/x/sys/unix/types_openbsd.go
 delete mode 100644 vendor/golang.org/x/sys/unix/types_solaris.go
 delete mode 100644 vendor/golang.org/x/text/encoding/charmap/maketables.go
 delete mode 100644 vendor/golang.org/x/text/encoding/htmlindex/gen.go
 delete mode 100644 vendor/golang.org/x/text/encoding/internal/identifier/gen.go
 delete mode 100644 vendor/golang.org/x/text/encoding/japanese/maketables.go
 delete mode 100644 vendor/golang.org/x/text/encoding/korean/maketables.go
 delete mode 100644 vendor/golang.org/x/text/encoding/simplifiedchinese/maketables.go
 delete mode 100644 vendor/golang.org/x/text/encoding/traditionalchinese/maketables.go
 delete mode 100644 vendor/golang.org/x/text/internal/language/compact/gen.go
 delete mode 100644 vendor/golang.org/x/text/internal/language/compact/gen_index.go
 delete mode 100644 vendor/golang.org/x/text/internal/language/compact/gen_parents.go
 delete mode 100644 vendor/golang.org/x/text/internal/language/gen.go
 delete mode 100644 vendor/golang.org/x/text/internal/language/gen_common.go
 delete mode 100644 vendor/golang.org/x/text/language/gen.go
 delete mode 100644 vendor/golang.org/x/text/unicode/bidi/gen.go
 delete mode 100644 vendor/golang.org/x/text/unicode/bidi/gen_ranges.go
 delete mode 100644 vendor/golang.org/x/text/unicode/bidi/gen_trieval.go
 delete mode 100644 vendor/golang.org/x/text/unicode/norm/maketables.go
 delete mode 100644 vendor/golang.org/x/text/unicode/norm/triegen.go

diff --git a/vendor/github.com/klauspost/compress/flate/gen.go b/vendor/github.com/klauspost/compress/flate/gen.go
deleted file mode 100644
index 154c89a48..000000000
--- a/vendor/github.com/klauspost/compress/flate/gen.go
+++ /dev/null
@@ -1,265 +0,0 @@
-// Copyright 2012 The Go 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 ignore
-
-// This program generates fixedhuff.go
-// Invoke as
-//
-//	go run gen.go -output fixedhuff.go
-
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"go/format"
-	"io/ioutil"
-	"log"
-)
-
-var filename = flag.String("output", "fixedhuff.go", "output file name")
-
-const maxCodeLen = 16
-
-// Note: the definition of the huffmanDecoder struct is copied from
-// inflate.go, as it is private to the implementation.
-
-// chunk & 15 is number of bits
-// chunk >> 4 is value, including table link
-
-const (
-	huffmanChunkBits  = 9
-	huffmanNumChunks  = 1 << huffmanChunkBits
-	huffmanCountMask  = 15
-	huffmanValueShift = 4
-)
-
-type huffmanDecoder struct {
-	min      int                      // the minimum code length
-	chunks   [huffmanNumChunks]uint32 // chunks as described above
-	links    [][]uint32               // overflow links
-	linkMask uint32                   // mask the width of the link table
-}
-
-// Initialize Huffman decoding tables from array of code lengths.
-// Following this function, h is guaranteed to be initialized into a complete
-// tree (i.e., neither over-subscribed nor under-subscribed). The exception is a
-// degenerate case where the tree has only a single symbol with length 1. Empty
-// trees are permitted.
-func (h *huffmanDecoder) init(bits []int) bool {
-	// Sanity enables additional runtime tests during Huffman
-	// table construction.  It's intended to be used during
-	// development to supplement the currently ad-hoc unit tests.
-	const sanity = false
-
-	if h.min != 0 {
-		*h = huffmanDecoder{}
-	}
-
-	// Count number of codes of each length,
-	// compute min and max length.
-	var count [maxCodeLen]int
-	var min, max int
-	for _, n := range bits {
-		if n == 0 {
-			continue
-		}
-		if min == 0 || n < min {
-			min = n
-		}
-		if n > max {
-			max = n
-		}
-		count[n]++
-	}
-
-	// Empty tree. The decompressor.huffSym function will fail later if the tree
-	// is used. Technically, an empty tree is only valid for the HDIST tree and
-	// not the HCLEN and HLIT tree. However, a stream with an empty HCLEN tree
-	// is guaranteed to fail since it will attempt to use the tree to decode the
-	// codes for the HLIT and HDIST trees. Similarly, an empty HLIT tree is
-	// guaranteed to fail later since the compressed data section must be
-	// composed of at least one symbol (the end-of-block marker).
-	if max == 0 {
-		return true
-	}
-
-	code := 0
-	var nextcode [maxCodeLen]int
-	for i := min; i <= max; i++ {
-		code <<= 1
-		nextcode[i] = code
-		code += count[i]
-	}
-
-	// Check that the coding is complete (i.e., that we've
-	// assigned all 2-to-the-max possible bit sequences).
-	// Exception: To be compatible with zlib, we also need to
-	// accept degenerate single-code codings.  See also
-	// TestDegenerateHuffmanCoding.
-	if code != 1<<uint(max) && !(code == 1 && max == 1) {
-		return false
-	}
-
-	h.min = min
-	if max > huffmanChunkBits {
-		numLinks := 1 << (uint(max) - huffmanChunkBits)
-		h.linkMask = uint32(numLinks - 1)
-
-		// create link tables
-		link := nextcode[huffmanChunkBits+1] >> 1
-		h.links = make([][]uint32, huffmanNumChunks-link)
-		for j := uint(link); j < huffmanNumChunks; j++ {
-			reverse := int(reverseByte[j>>8]) | int(reverseByte[j&0xff])<<8
-			reverse >>= uint(16 - huffmanChunkBits)
-			off := j - uint(link)
-			if sanity && h.chunks[reverse] != 0 {
-				panic("impossible: overwriting existing chunk")
-			}
-			h.chunks[reverse] = uint32(off<<huffmanValueShift | (huffmanChunkBits + 1))
-			h.links[off] = make([]uint32, numLinks)
-		}
-	}
-
-	for i, n := range bits {
-		if n == 0 {
-			continue
-		}
-		code := nextcode[n]
-		nextcode[n]++
-		chunk := uint32(i<<huffmanValueShift | n)
-		reverse := int(reverseByte[code>>8]) | int(reverseByte[code&0xff])<<8
-		reverse >>= uint(16 - n)
-		if n <= huffmanChunkBits {
-			for off := reverse; off < len(h.chunks); off += 1 << uint(n) {
-				// We should never need to overwrite
-				// an existing chunk.  Also, 0 is
-				// never a valid chunk, because the
-				// lower 4 "count" bits should be
-				// between 1 and 15.
-				if sanity && h.chunks[off] != 0 {
-					panic("impossible: overwriting existing chunk")
-				}
-				h.chunks[off] = chunk
-			}
-		} else {
-			j := reverse & (huffmanNumChunks - 1)
-			if sanity && h.chunks[j]&huffmanCountMask != huffmanChunkBits+1 {
-				// Longer codes should have been
-				// associated with a link table above.
-				panic("impossible: not an indirect chunk")
-			}
-			value := h.chunks[j] >> huffmanValueShift
-			linktab := h.links[value]
-			reverse >>= huffmanChunkBits
-			for off := reverse; off < len(linktab); off += 1 << uint(n-huffmanChunkBits) {
-				if sanity && linktab[off] != 0 {
-					panic("impossible: overwriting existing chunk")
-				}
-				linktab[off] = chunk
-			}
-		}
-	}
-
-	if sanity {
-		// Above we've sanity checked that we never overwrote
-		// an existing entry.  Here we additionally check that
-		// we filled the tables completely.
-		for i, chunk := range h.chunks {
-			if chunk == 0 {
-				// As an exception, in the degenerate
-				// single-code case, we allow odd
-				// chunks to be missing.
-				if code == 1 && i%2 == 1 {
-					continue
-				}
-				panic("impossible: missing chunk")
-			}
-		}
-		for _, linktab := range h.links {
-			for _, chunk := range linktab {
-				if chunk == 0 {
-					panic("impossible: missing chunk")
-				}
-			}
-		}
-	}
-
-	return true
-}
-
-func main() {
-	flag.Parse()
-
-	var h huffmanDecoder
-	var bits [288]int
-	initReverseByte()
-	for i := 0; i < 144; i++ {
-		bits[i] = 8
-	}
-	for i := 144; i < 256; i++ {
-		bits[i] = 9
-	}
-	for i := 256; i < 280; i++ {
-		bits[i] = 7
-	}
-	for i := 280; i < 288; i++ {
-		bits[i] = 8
-	}
-	h.init(bits[:])
-	if h.links != nil {
-		log.Fatal("Unexpected links table in fixed Huffman decoder")
-	}
-
-	var buf bytes.Buffer
-
-	fmt.Fprintf(&buf, `// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.`+"\n\n")
-
-	fmt.Fprintln(&buf, "package flate")
-	fmt.Fprintln(&buf)
-	fmt.Fprintln(&buf, "// autogenerated by go run gen.go -output fixedhuff.go, DO NOT EDIT")
-	fmt.Fprintln(&buf)
-	fmt.Fprintln(&buf, "var fixedHuffmanDecoder = huffmanDecoder{")
-	fmt.Fprintf(&buf, "\t%d,\n", h.min)
-	fmt.Fprintln(&buf, "\t[huffmanNumChunks]uint32{")
-	for i := 0; i < huffmanNumChunks; i++ {
-		if i&7 == 0 {
-			fmt.Fprintf(&buf, "\t\t")
-		} else {
-			fmt.Fprintf(&buf, " ")
-		}
-		fmt.Fprintf(&buf, "0x%04x,", h.chunks[i])
-		if i&7 == 7 {
-			fmt.Fprintln(&buf)
-		}
-	}
-	fmt.Fprintln(&buf, "\t},")
-	fmt.Fprintln(&buf, "\tnil, 0,")
-	fmt.Fprintln(&buf, "}")
-
-	data, err := format.Source(buf.Bytes())
-	if err != nil {
-		log.Fatal(err)
-	}
-	err = ioutil.WriteFile(*filename, data, 0644)
-	if err != nil {
-		log.Fatal(err)
-	}
-}
-
-var reverseByte [256]byte
-
-func initReverseByte() {
-	for x := 0; x < 256; x++ {
-		var result byte
-		for i := uint(0); i < 8; i++ {
-			result |= byte(((x >> i) & 1) << (7 - i))
-		}
-		reverseByte[x] = result
-	}
-}
diff --git a/vendor/github.com/klauspost/cpuid/private-gen.go b/vendor/github.com/klauspost/cpuid/private-gen.go
deleted file mode 100644
index 437333d29..000000000
--- a/vendor/github.com/klauspost/cpuid/private-gen.go
+++ /dev/null
@@ -1,476 +0,0 @@
-// +build ignore
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"go/ast"
-	"go/parser"
-	"go/printer"
-	"go/token"
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-	"reflect"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-var inFiles = []string{"cpuid.go", "cpuid_test.go"}
-var copyFiles = []string{"cpuid_amd64.s", "cpuid_386.s", "detect_ref.go", "detect_intel.go"}
-var fileSet = token.NewFileSet()
-var reWrites = []rewrite{
-	initRewrite("CPUInfo -> cpuInfo"),
-	initRewrite("Vendor -> vendor"),
-	initRewrite("Flags -> flags"),
-	initRewrite("Detect -> detect"),
-	initRewrite("CPU -> cpu"),
-}
-var excludeNames = map[string]bool{"string": true, "join": true, "trim": true,
-	// cpuid_test.go
-	"t": true, "println": true, "logf": true, "log": true, "fatalf": true, "fatal": true,
-}
-
-var excludePrefixes = []string{"test", "benchmark"}
-
-func main() {
-	Package := "private"
-	parserMode := parser.ParseComments
-	exported := make(map[string]rewrite)
-	for _, file := range inFiles {
-		in, err := os.Open(file)
-		if err != nil {
-			log.Fatalf("opening input", err)
-		}
-
-		src, err := ioutil.ReadAll(in)
-		if err != nil {
-			log.Fatalf("reading input", err)
-		}
-
-		astfile, err := parser.ParseFile(fileSet, file, src, parserMode)
-		if err != nil {
-			log.Fatalf("parsing input", err)
-		}
-
-		for _, rw := range reWrites {
-			astfile = rw(astfile)
-		}
-
-		// Inspect the AST and print all identifiers and literals.
-		var startDecl token.Pos
-		var endDecl token.Pos
-		ast.Inspect(astfile, func(n ast.Node) bool {
-			var s string
-			switch x := n.(type) {
-			case *ast.Ident:
-				if x.IsExported() {
-					t := strings.ToLower(x.Name)
-					for _, pre := range excludePrefixes {
-						if strings.HasPrefix(t, pre) {
-							return true
-						}
-					}
-					if excludeNames[t] != true {
-						//if x.Pos() > startDecl && x.Pos() < endDecl {
-						exported[x.Name] = initRewrite(x.Name + " -> " + t)
-					}
-				}
-
-			case *ast.GenDecl:
-				if x.Tok == token.CONST && x.Lparen > 0 {
-					startDecl = x.Lparen
-					endDecl = x.Rparen
-					// fmt.Printf("Decl:%s -> %s\n", fileSet.Position(startDecl), fileSet.Position(endDecl))
-				}
-			}
-			if s != "" {
-				fmt.Printf("%s:\t%s\n", fileSet.Position(n.Pos()), s)
-			}
-			return true
-		})
-
-		for _, rw := range exported {
-			astfile = rw(astfile)
-		}
-
-		var buf bytes.Buffer
-
-		printer.Fprint(&buf, fileSet, astfile)
-
-		// Remove package documentation and insert information
-		s := buf.String()
-		ind := strings.Index(buf.String(), "\npackage cpuid")
-		s = s[ind:]
-		s = "// Generated, DO NOT EDIT,\n" +
-			"// but copy it to your own project and rename the package.\n" +
-			"// See more at http://github.com/klauspost/cpuid\n" +
-			s
-
-		outputName := Package + string(os.PathSeparator) + file
-
-		err = ioutil.WriteFile(outputName, []byte(s), 0644)
-		if err != nil {
-			log.Fatalf("writing output: %s", err)
-		}
-		log.Println("Generated", outputName)
-	}
-
-	for _, file := range copyFiles {
-		dst := ""
-		if strings.HasPrefix(file, "cpuid") {
-			dst = Package + string(os.PathSeparator) + file
-		} else {
-			dst = Package + string(os.PathSeparator) + "cpuid_" + file
-		}
-		err := copyFile(file, dst)
-		if err != nil {
-			log.Fatalf("copying file: %s", err)
-		}
-		log.Println("Copied", dst)
-	}
-}
-
-// CopyFile copies a file from src to dst. If src and dst files exist, and are
-// the same, then return success. Copy the file contents from src to dst.
-func copyFile(src, dst string) (err error) {
-	sfi, err := os.Stat(src)
-	if err != nil {
-		return
-	}
-	if !sfi.Mode().IsRegular() {
-		// cannot copy non-regular files (e.g., directories,
-		// symlinks, devices, etc.)
-		return fmt.Errorf("CopyFile: non-regular source file %s (%q)", sfi.Name(), sfi.Mode().String())
-	}
-	dfi, err := os.Stat(dst)
-	if err != nil {
-		if !os.IsNotExist(err) {
-			return
-		}
-	} else {
-		if !(dfi.Mode().IsRegular()) {
-			return fmt.Errorf("CopyFile: non-regular destination file %s (%q)", dfi.Name(), dfi.Mode().String())
-		}
-		if os.SameFile(sfi, dfi) {
-			return
-		}
-	}
-	err = copyFileContents(src, dst)
-	return
-}
-
-// copyFileContents copies the contents of the file named src to the file named
-// by dst. The file will be created if it does not already exist. If the
-// destination file exists, all it's contents will be replaced by the contents
-// of the source file.
-func copyFileContents(src, dst string) (err error) {
-	in, err := os.Open(src)
-	if err != nil {
-		return
-	}
-	defer in.Close()
-	out, err := os.Create(dst)
-	if err != nil {
-		return
-	}
-	defer func() {
-		cerr := out.Close()
-		if err == nil {
-			err = cerr
-		}
-	}()
-	if _, err = io.Copy(out, in); err != nil {
-		return
-	}
-	err = out.Sync()
-	return
-}
-
-type rewrite func(*ast.File) *ast.File
-
-// Mostly copied from gofmt
-func initRewrite(rewriteRule string) rewrite {
-	f := strings.Split(rewriteRule, "->")
-	if len(f) != 2 {
-		fmt.Fprintf(os.Stderr, "rewrite rule must be of the form 'pattern -> replacement'\n")
-		os.Exit(2)
-	}
-	pattern := parseExpr(f[0], "pattern")
-	replace := parseExpr(f[1], "replacement")
-	return func(p *ast.File) *ast.File { return rewriteFile(pattern, replace, p) }
-}
-
-// parseExpr parses s as an expression.
-// It might make sense to expand this to allow statement patterns,
-// but there are problems with preserving formatting and also
-// with what a wildcard for a statement looks like.
-func parseExpr(s, what string) ast.Expr {
-	x, err := parser.ParseExpr(s)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "parsing %s %s at %s\n", what, s, err)
-		os.Exit(2)
-	}
-	return x
-}
-
-// Keep this function for debugging.
-/*
-func dump(msg string, val reflect.Value) {
-	fmt.Printf("%s:\n", msg)
-	ast.Print(fileSet, val.Interface())
-	fmt.Println()
-}
-*/
-
-// rewriteFile applies the rewrite rule 'pattern -> replace' to an entire file.
-func rewriteFile(pattern, replace ast.Expr, p *ast.File) *ast.File {
-	cmap := ast.NewCommentMap(fileSet, p, p.Comments)
-	m := make(map[string]reflect.Value)
-	pat := reflect.ValueOf(pattern)
-	repl := reflect.ValueOf(replace)
-
-	var rewriteVal func(val reflect.Value) reflect.Value
-	rewriteVal = func(val reflect.Value) reflect.Value {
-		// don't bother if val is invalid to start with
-		if !val.IsValid() {
-			return reflect.Value{}
-		}
-		for k := range m {
-			delete(m, k)
-		}
-		val = apply(rewriteVal, val)
-		if match(m, pat, val) {
-			val = subst(m, repl, reflect.ValueOf(val.Interface().(ast.Node).Pos()))
-		}
-		return val
-	}
-
-	r := apply(rewriteVal, reflect.ValueOf(p)).Interface().(*ast.File)
-	r.Comments = cmap.Filter(r).Comments() // recreate comments list
-	return r
-}
-
-// set is a wrapper for x.Set(y); it protects the caller from panics if x cannot be changed to y.
-func set(x, y reflect.Value) {
-	// don't bother if x cannot be set or y is invalid
-	if !x.CanSet() || !y.IsValid() {
-		return
-	}
-	defer func() {
-		if x := recover(); x != nil {
-			if s, ok := x.(string); ok &&
-				(strings.Contains(s, "type mismatch") || strings.Contains(s, "not assignable")) {
-				// x cannot be set to y - ignore this rewrite
-				return
-			}
-			panic(x)
-		}
-	}()
-	x.Set(y)
-}
-
-// Values/types for special cases.
-var (
-	objectPtrNil = reflect.ValueOf((*ast.Object)(nil))
-	scopePtrNil  = reflect.ValueOf((*ast.Scope)(nil))
-
-	identType     = reflect.TypeOf((*ast.Ident)(nil))
-	objectPtrType = reflect.TypeOf((*ast.Object)(nil))
-	positionType  = reflect.TypeOf(token.NoPos)
-	callExprType  = reflect.TypeOf((*ast.CallExpr)(nil))
-	scopePtrType  = reflect.TypeOf((*ast.Scope)(nil))
-)
-
-// apply replaces each AST field x in val with f(x), returning val.
-// To avoid extra conversions, f operates on the reflect.Value form.
-func apply(f func(reflect.Value) reflect.Value, val reflect.Value) reflect.Value {
-	if !val.IsValid() {
-		return reflect.Value{}
-	}
-
-	// *ast.Objects introduce cycles and are likely incorrect after
-	// rewrite; don't follow them but replace with nil instead
-	if val.Type() == objectPtrType {
-		return objectPtrNil
-	}
-
-	// similarly for scopes: they are likely incorrect after a rewrite;
-	// replace them with nil
-	if val.Type() == scopePtrType {
-		return scopePtrNil
-	}
-
-	switch v := reflect.Indirect(val); v.Kind() {
-	case reflect.Slice:
-		for i := 0; i < v.Len(); i++ {
-			e := v.Index(i)
-			set(e, f(e))
-		}
-	case reflect.Struct:
-		for i := 0; i < v.NumField(); i++ {
-			e := v.Field(i)
-			set(e, f(e))
-		}
-	case reflect.Interface:
-		e := v.Elem()
-		set(v, f(e))
-	}
-	return val
-}
-
-func isWildcard(s string) bool {
-	rune, size := utf8.DecodeRuneInString(s)
-	return size == len(s) && unicode.IsLower(rune)
-}
-
-// match returns true if pattern matches val,
-// recording wildcard submatches in m.
-// If m == nil, match checks whether pattern == val.
-func match(m map[string]reflect.Value, pattern, val reflect.Value) bool {
-	// Wildcard matches any expression.  If it appears multiple
-	// times in the pattern, it must match the same expression
-	// each time.
-	if m != nil && pattern.IsValid() && pattern.Type() == identType {
-		name := pattern.Interface().(*ast.Ident).Name
-		if isWildcard(name) && val.IsValid() {
-			// wildcards only match valid (non-nil) expressions.
-			if _, ok := val.Interface().(ast.Expr); ok && !val.IsNil() {
-				if old, ok := m[name]; ok {
-					return match(nil, old, val)
-				}
-				m[name] = val
-				return true
-			}
-		}
-	}
-
-	// Otherwise, pattern and val must match recursively.
-	if !pattern.IsValid() || !val.IsValid() {
-		return !pattern.IsValid() && !val.IsValid()
-	}
-	if pattern.Type() != val.Type() {
-		return false
-	}
-
-	// Special cases.
-	switch pattern.Type() {
-	case identType:
-		// For identifiers, only the names need to match
-		// (and none of the other *ast.Object information).
-		// This is a common case, handle it all here instead
-		// of recursing down any further via reflection.
-		p := pattern.Interface().(*ast.Ident)
-		v := val.Interface().(*ast.Ident)
-		return p == nil && v == nil || p != nil && v != nil && p.Name == v.Name
-	case objectPtrType, positionType:
-		// object pointers and token positions always match
-		return true
-	case callExprType:
-		// For calls, the Ellipsis fields (token.Position) must
-		// match since that is how f(x) and f(x...) are different.
-		// Check them here but fall through for the remaining fields.
-		p := pattern.Interface().(*ast.CallExpr)
-		v := val.Interface().(*ast.CallExpr)
-		if p.Ellipsis.IsValid() != v.Ellipsis.IsValid() {
-			return false
-		}
-	}
-
-	p := reflect.Indirect(pattern)
-	v := reflect.Indirect(val)
-	if !p.IsValid() || !v.IsValid() {
-		return !p.IsValid() && !v.IsValid()
-	}
-
-	switch p.Kind() {
-	case reflect.Slice:
-		if p.Len() != v.Len() {
-			return false
-		}
-		for i := 0; i < p.Len(); i++ {
-			if !match(m, p.Index(i), v.Index(i)) {
-				return false
-			}
-		}
-		return true
-
-	case reflect.Struct:
-		for i := 0; i < p.NumField(); i++ {
-			if !match(m, p.Field(i), v.Field(i)) {
-				return false
-			}
-		}
-		return true
-
-	case reflect.Interface:
-		return match(m, p.Elem(), v.Elem())
-	}
-
-	// Handle token integers, etc.
-	return p.Interface() == v.Interface()
-}
-
-// subst returns a copy of pattern with values from m substituted in place
-// of wildcards and pos used as the position of tokens from the pattern.
-// if m == nil, subst returns a copy of pattern and doesn't change the line
-// number information.
-func subst(m map[string]reflect.Value, pattern reflect.Value, pos reflect.Value) reflect.Value {
-	if !pattern.IsValid() {
-		return reflect.Value{}
-	}
-
-	// Wildcard gets replaced with map value.
-	if m != nil && pattern.Type() == identType {
-		name := pattern.Interface().(*ast.Ident).Name
-		if isWildcard(name) {
-			if old, ok := m[name]; ok {
-				return subst(nil, old, reflect.Value{})
-			}
-		}
-	}
-
-	if pos.IsValid() && pattern.Type() == positionType {
-		// use new position only if old position was valid in the first place
-		if old := pattern.Interface().(token.Pos); !old.IsValid() {
-			return pattern
-		}
-		return pos
-	}
-
-	// Otherwise copy.
-	switch p := pattern; p.Kind() {
-	case reflect.Slice:
-		v := reflect.MakeSlice(p.Type(), p.Len(), p.Len())
-		for i := 0; i < p.Len(); i++ {
-			v.Index(i).Set(subst(m, p.Index(i), pos))
-		}
-		return v
-
-	case reflect.Struct:
-		v := reflect.New(p.Type()).Elem()
-		for i := 0; i < p.NumField(); i++ {
-			v.Field(i).Set(subst(m, p.Field(i), pos))
-		}
-		return v
-
-	case reflect.Ptr:
-		v := reflect.New(p.Type()).Elem()
-		if elem := p.Elem(); elem.IsValid() {
-			v.Set(subst(m, elem, pos).Addr())
-		}
-		return v
-
-	case reflect.Interface:
-		v := reflect.New(p.Type()).Elem()
-		if elem := p.Elem(); elem.IsValid() {
-			v.Set(subst(m, elem, pos))
-		}
-		return v
-	}
-
-	return pattern
-}
diff --git a/vendor/github.com/linode/linodego/template.go b/vendor/github.com/linode/linodego/template.go
deleted file mode 100644
index ed0616837..000000000
--- a/vendor/github.com/linode/linodego/template.go
+++ /dev/null
@@ -1,167 +0,0 @@
-// +build ignore
-
-package linodego
-
-/*
- - replace "Template" with "NameOfResource"
- - replace "template" with "nameOfResource"
- - copy template_test.go and do the same
- - When updating Template structs,
-   - use pointers where ever null'able would have a different meaning if the wrapper
-	 supplied "" or 0 instead
- - Add "NameOfResource" to client.go, resources.go, pagination.go
-*/
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-)
-
-// Template represents a Template object
-type Template struct {
-	ID int `json:"id"`
-	// UpdatedStr string `json:"updated"`
-	// Updated *time.Time `json:"-"`
-}
-
-// TemplateCreateOptions fields are those accepted by CreateTemplate
-type TemplateCreateOptions struct {
-}
-
-// TemplateUpdateOptions fields are those accepted by UpdateTemplate
-type TemplateUpdateOptions struct {
-}
-
-// GetCreateOptions converts a Template to TemplateCreateOptions for use in CreateTemplate
-func (i Template) GetCreateOptions() (o TemplateCreateOptions) {
-	// o.Label = i.Label
-	// o.Description = copyString(i.Description)
-	return
-}
-
-// GetUpdateOptions converts a Template to TemplateUpdateOptions for use in UpdateTemplate
-func (i Template) GetUpdateOptions() (o TemplateUpdateOptions) {
-	// o.Label = i.Label
-	// o.Description = copyString(i.Description)
-	return
-}
-
-// TemplatesPagedResponse represents a paginated Template API response
-type TemplatesPagedResponse struct {
-	*PageOptions
-	Data []Template `json:"data"`
-}
-
-// endpoint gets the endpoint URL for Template
-func (TemplatesPagedResponse) endpoint(c *Client) string {
-	endpoint, err := c.Templates.Endpoint()
-	if err != nil {
-		panic(err)
-	}
-	return endpoint
-}
-
-// appendData appends Templates when processing paginated Template responses
-func (resp *TemplatesPagedResponse) appendData(r *TemplatesPagedResponse) {
-	resp.Data = append(resp.Data, r.Data...)
-}
-
-// ListTemplates lists Templates
-func (c *Client) ListTemplates(ctx context.Context, opts *ListOptions) ([]Template, error) {
-	response := TemplatesPagedResponse{}
-	err := c.listHelper(ctx, &response, opts)
-	for i := range response.Data {
-		response.Data[i].fixDates()
-	}
-	if err != nil {
-		return nil, err
-	}
-	return response.Data, nil
-}
-
-// fixDates converts JSON timestamps to Go time.Time values
-func (i *Template) fixDates() *Template {
-	// i.Created, _ = parseDates(i.CreatedStr)
-	// i.Updated, _ = parseDates(i.UpdatedStr)
-	return i
-}
-
-// GetTemplate gets the template with the provided ID
-func (c *Client) GetTemplate(ctx context.Context, id int) (*Template, error) {
-	e, err := c.Templates.Endpoint()
-	if err != nil {
-		return nil, err
-	}
-	e = fmt.Sprintf("%s/%d", e, id)
-	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Template{}).Get(e))
-	if err != nil {
-		return nil, err
-	}
-	return r.Result().(*Template).fixDates(), nil
-}
-
-// CreateTemplate creates a Template
-func (c *Client) CreateTemplate(ctx context.Context, createOpts TemplateCreateOptions) (*Template, error) {
-	var body string
-	e, err := c.Templates.Endpoint()
-	if err != nil {
-		return nil, err
-	}
-
-	req := c.R(ctx).SetResult(&Template{})
-
-	if bodyData, err := json.Marshal(createOpts); err == nil {
-		body = string(bodyData)
-	} else {
-		return nil, NewError(err)
-	}
-
-	r, err := coupleAPIErrors(req.
-		SetBody(body).
-		Post(e))
-
-	if err != nil {
-		return nil, err
-	}
-	return r.Result().(*Template).fixDates(), nil
-}
-
-// UpdateTemplate updates the Template with the specified id
-func (c *Client) UpdateTemplate(ctx context.Context, id int, updateOpts TemplateUpdateOptions) (*Template, error) {
-	var body string
-	e, err := c.Templates.Endpoint()
-	if err != nil {
-		return nil, err
-	}
-	e = fmt.Sprintf("%s/%d", e, id)
-
-	req := c.R(ctx).SetResult(&Template{})
-
-	if bodyData, err := json.Marshal(updateOpts); err == nil {
-		body = string(bodyData)
-	} else {
-		return nil, NewError(err)
-	}
-
-	r, err := coupleAPIErrors(req.
-		SetBody(body).
-		Put(e))
-
-	if err != nil {
-		return nil, err
-	}
-	return r.Result().(*Template).fixDates(), nil
-}
-
-// DeleteTemplate deletes the Template with the specified id
-func (c *Client) DeleteTemplate(ctx context.Context, id int) error {
-	e, err := c.Templates.Endpoint()
-	if err != nil {
-		return err
-	}
-	e = fmt.Sprintf("%s/%d", e, id)
-
-	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
-	return err
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/triv.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/triv.go
deleted file mode 100644
index 232d65089..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/triv.go
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2009 The Go 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 ignore
-
-package main
-
-import (
-	"bytes"
-	"expvar"
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"os/exec"
-	"strconv"
-	"sync"
-)
-
-// hello world, the web server
-var helloRequests = expvar.NewInt("hello-requests")
-
-func HelloServer(w http.ResponseWriter, req *http.Request) {
-	helloRequests.Add(1)
-	io.WriteString(w, "hello, world!\n")
-}
-
-// Simple counter server. POSTing to it will set the value.
-type Counter struct {
-	mu sync.Mutex // protects n
-	n  int
-}
-
-// This makes Counter satisfy the expvar.Var interface, so we can export
-// it directly.
-func (ctr *Counter) String() string {
-	ctr.mu.Lock()
-	defer ctr.mu.Unlock()
-	return fmt.Sprintf("%d", ctr.n)
-}
-
-func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	ctr.mu.Lock()
-	defer ctr.mu.Unlock()
-	switch req.Method {
-	case "GET":
-		ctr.n++
-	case "POST":
-		buf := new(bytes.Buffer)
-		io.Copy(buf, req.Body)
-		body := buf.String()
-		if n, err := strconv.Atoi(body); err != nil {
-			fmt.Fprintf(w, "bad POST: %v\nbody: [%v]\n", err, body)
-		} else {
-			ctr.n = n
-			fmt.Fprint(w, "counter reset\n")
-		}
-	}
-	fmt.Fprintf(w, "counter = %d\n", ctr.n)
-}
-
-// simple flag server
-var booleanflag = flag.Bool("boolean", true, "another flag for testing")
-
-func FlagServer(w http.ResponseWriter, req *http.Request) {
-	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
-	fmt.Fprint(w, "Flags:\n")
-	flag.VisitAll(func(f *flag.Flag) {
-		if f.Value.String() != f.DefValue {
-			fmt.Fprintf(w, "%s = %s [default = %s]\n", f.Name, f.Value.String(), f.DefValue)
-		} else {
-			fmt.Fprintf(w, "%s = %s\n", f.Name, f.Value.String())
-		}
-	})
-}
-
-// simple argument server
-func ArgServer(w http.ResponseWriter, req *http.Request) {
-	for _, s := range os.Args {
-		fmt.Fprint(w, s, " ")
-	}
-}
-
-// a channel (just for the fun of it)
-type Chan chan int
-
-func ChanCreate() Chan {
-	c := make(Chan)
-	go func(c Chan) {
-		for x := 0; ; x++ {
-			c <- x
-		}
-	}(c)
-	return c
-}
-
-func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
-	io.WriteString(w, fmt.Sprintf("channel send #%d\n", <-ch))
-}
-
-// exec a program, redirecting output
-func DateServer(rw http.ResponseWriter, req *http.Request) {
-	rw.Header().Set("Content-Type", "text/plain; charset=utf-8")
-
-	date, err := exec.Command("/bin/date").Output()
-	if err != nil {
-		http.Error(rw, err.Error(), 500)
-		return
-	}
-	rw.Write(date)
-}
-
-func Logger(w http.ResponseWriter, req *http.Request) {
-	log.Print(req.URL)
-	http.Error(w, "oops", 404)
-}
-
-var webroot = flag.String("root", os.Getenv("HOME"), "web root directory")
-
-func main() {
-	flag.Parse()
-
-	// The counter is published as a variable directly.
-	ctr := new(Counter)
-	expvar.Publish("counter", ctr)
-	http.Handle("/counter", ctr)
-	http.Handle("/", http.HandlerFunc(Logger))
-	http.Handle("/go/", http.StripPrefix("/go/", http.FileServer(http.Dir(*webroot))))
-	http.Handle("/chan", ChanCreate())
-	http.HandleFunc("/flags", FlagServer)
-	http.HandleFunc("/args", ArgServer)
-	http.HandleFunc("/go/hello", HelloServer)
-	http.HandleFunc("/date", DateServer)
-	err := http.ListenAndServe(":12345", nil)
-	if err != nil {
-		log.Panicln("ListenAndServe:", err)
-	}
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/generate_cert.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/generate_cert.go
deleted file mode 100644
index b417ea464..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/generate_cert.go
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright 2009 The Go 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 ignore
-
-// Generate a self-signed X.509 certificate for a TLS server. Outputs to
-// 'cert.pem' and 'key.pem' and will overwrite existing files.
-
-package main
-
-import (
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"flag"
-	"fmt"
-	"log"
-	"math/big"
-	"net"
-	"os"
-	"strings"
-	"time"
-)
-
-var (
-	host      = flag.String("host", "", "Comma-separated hostnames and IPs to generate a certificate for")
-	validFrom = flag.String("start-date", "", "Creation date formatted as Jan 1 15:04:05 2011")
-	validFor  = flag.Duration("duration", 365*24*time.Hour, "Duration that certificate is valid for")
-	isCA      = flag.Bool("ca", false, "whether this cert should be its own Certificate Authority")
-	rsaBits   = flag.Int("rsa-bits", 2048, "Size of RSA key to generate")
-)
-
-func main() {
-	flag.Parse()
-
-	if len(*host) == 0 {
-		log.Fatalf("Missing required --host parameter")
-	}
-
-	priv, err := rsa.GenerateKey(rand.Reader, *rsaBits)
-	if err != nil {
-		log.Fatalf("failed to generate private key: %s", err)
-		return
-	}
-
-	var notBefore time.Time
-	if len(*validFrom) == 0 {
-		notBefore = time.Now()
-	} else {
-		notBefore, err = time.Parse("Jan 2 15:04:05 2006", *validFrom)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Failed to parse creation date: %s\n", err)
-			os.Exit(1)
-		}
-	}
-
-	notAfter := notBefore.Add(*validFor)
-
-	// end of ASN.1 time
-	endOfTime := time.Date(2049, 12, 31, 23, 59, 59, 0, time.UTC)
-	if notAfter.After(endOfTime) {
-		notAfter = endOfTime
-	}
-
-	template := x509.Certificate{
-		SerialNumber: new(big.Int).SetInt64(0),
-		Subject: pkix.Name{
-			Organization: []string{"Acme Co"},
-		},
-		NotBefore: notBefore,
-		NotAfter:  notAfter,
-
-		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		BasicConstraintsValid: true,
-	}
-
-	hosts := strings.Split(*host, ",")
-	for _, h := range hosts {
-		if ip := net.ParseIP(h); ip != nil {
-			template.IPAddresses = append(template.IPAddresses, ip)
-		} else {
-			template.DNSNames = append(template.DNSNames, h)
-		}
-	}
-
-	if *isCA {
-		template.IsCA = true
-		template.KeyUsage |= x509.KeyUsageCertSign
-	}
-
-	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
-	if err != nil {
-		log.Fatalf("Failed to create certificate: %s", err)
-		return
-	}
-
-	certOut, err := os.Create("cert.pem")
-	if err != nil {
-		log.Fatalf("failed to open cert.pem for writing: %s", err)
-		return
-	}
-	pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
-	certOut.Close()
-	log.Print("written cert.pem\n")
-
-	keyOut, err := os.OpenFile("key.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
-	if err != nil {
-		log.Print("failed to open key.pem for writing:", err)
-		return
-	}
-	pem.Encode(keyOut, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)})
-	keyOut.Close()
-	log.Print("written key.pem\n")
-}
diff --git a/vendor/github.com/shirou/gopsutil/host/types_darwin.go b/vendor/github.com/shirou/gopsutil/host/types_darwin.go
deleted file mode 100644
index b85822788..000000000
--- a/vendor/github.com/shirou/gopsutil/host/types_darwin.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// +build ignore
-// plus hand editing about timeval
-
-/*
-Input to cgo -godefs.
-*/
-
-package host
-
-/*
-#include <sys/time.h>
-#include <utmpx.h>
-*/
-import "C"
-
-type Utmpx C.struct_utmpx
-type Timeval C.struct_timeval
diff --git a/vendor/github.com/shirou/gopsutil/host/types_freebsd.go b/vendor/github.com/shirou/gopsutil/host/types_freebsd.go
deleted file mode 100644
index e70677f68..000000000
--- a/vendor/github.com/shirou/gopsutil/host/types_freebsd.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// +build ignore
-
-/*
-Input to cgo -godefs.
-*/
-
-package host
-
-/*
-#define KERNEL
-#include <sys/types.h>
-#include <sys/time.h>
-#include <utmpx.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-*/
-import "C"
-
-// Machine characteristics; for internal use.
-
-const (
-	sizeofPtr      = C.sizeofPtr
-	sizeofShort    = C.sizeof_short
-	sizeofInt      = C.sizeof_int
-	sizeofLong     = C.sizeof_long
-	sizeofLongLong = C.sizeof_longlong
-	sizeOfUtmpx    = C.sizeof_struct_utmpx
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-type Utmp C.struct_utmp
-type Utmpx C.struct_utmpx
-type Timeval C.struct_timeval
diff --git a/vendor/github.com/shirou/gopsutil/host/types_linux.go b/vendor/github.com/shirou/gopsutil/host/types_linux.go
deleted file mode 100644
index 8adecb6cf..000000000
--- a/vendor/github.com/shirou/gopsutil/host/types_linux.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// +build ignore
-
-/*
-Input to cgo -godefs.
-*/
-
-package host
-
-/*
-#include <sys/types.h>
-#include <utmp.h>
-
-enum {
-       sizeofPtr = sizeof(void*),
-};
-
-*/
-import "C"
-
-// Machine characteristics; for internal use.
-
-const (
-	sizeofPtr      = C.sizeofPtr
-	sizeofShort    = C.sizeof_short
-	sizeofInt      = C.sizeof_int
-	sizeofLong     = C.sizeof_long
-	sizeofLongLong = C.sizeof_longlong
-	sizeOfUtmp     = C.sizeof_struct_utmp
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-type utmp C.struct_utmp
-type exit_status C.struct_exit_status
-type timeval C.struct_timeval
diff --git a/vendor/github.com/shirou/gopsutil/host/types_openbsd.go b/vendor/github.com/shirou/gopsutil/host/types_openbsd.go
deleted file mode 100644
index 9ebb97ce5..000000000
--- a/vendor/github.com/shirou/gopsutil/host/types_openbsd.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// +build ignore
-
-/*
-Input to cgo -godefs.
-*/
-
-package host
-
-/*
-#define KERNEL
-#include <sys/types.h>
-#include <sys/time.h>
-#include <utmp.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-*/
-import "C"
-
-// Machine characteristics; for internal use.
-
-const (
-	sizeofPtr      = C.sizeofPtr
-	sizeofShort    = C.sizeof_short
-	sizeofInt      = C.sizeof_int
-	sizeofLong     = C.sizeof_long
-	sizeofLongLong = C.sizeof_longlong
-	sizeOfUtmp     = C.sizeof_struct_utmp
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-type Utmp C.struct_utmp
-type Timeval C.struct_timeval
diff --git a/vendor/github.com/shirou/gopsutil/mem/types_openbsd.go b/vendor/github.com/shirou/gopsutil/mem/types_openbsd.go
deleted file mode 100644
index 83cb91a19..000000000
--- a/vendor/github.com/shirou/gopsutil/mem/types_openbsd.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// +build ignore
-
-/*
-Input to cgo -godefs.
-*/
-
-package mem
-
-/*
-#include <sys/types.h>
-#include <sys/mount.h>
-#include <sys/sysctl.h>
-#include <uvm/uvmexp.h>
-
-*/
-import "C"
-
-// Machine characteristics; for internal use.
-
-const (
-	CTLVm         = 2
-	CTLVfs        = 10
-	VmUvmexp      = 4 // get uvmexp
-	VfsGeneric    = 0
-	VfsBcacheStat = 3
-)
-
-const (
-	sizeOfUvmexp      = C.sizeof_struct_uvmexp
-	sizeOfBcachestats = C.sizeof_struct_bcachestats
-)
-
-type Uvmexp C.struct_uvmexp
-type Bcachestats C.struct_bcachestats
diff --git a/vendor/github.com/shirou/gopsutil/process/types_darwin.go b/vendor/github.com/shirou/gopsutil/process/types_darwin.go
deleted file mode 100644
index 21216cd09..000000000
--- a/vendor/github.com/shirou/gopsutil/process/types_darwin.go
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Hand Writing
-// - all pointer in ExternProc to uint64
-
-// +build ignore
-
-/*
-Input to cgo -godefs.
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-// +godefs map struct_ [16]byte /* in6_addr */
-
-package process
-
-/*
-#define __DARWIN_UNIX03 0
-#define KERNEL
-#define _DARWIN_USE_64_BIT_INODE
-#include <dirent.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <termios.h>
-#include <unistd.h>
-#include <mach/mach.h>
-#include <mach/message.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/param.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <net/bpf.h>
-#include <net/if_dl.h>
-#include <net/if_var.h>
-#include <net/route.h>
-#include <netinet/in.h>
-
-#include <sys/sysctl.h>
-#include <sys/ucred.h>
-#include <sys/proc.h>
-#include <sys/time.h>
-#include <sys/_types/_timeval.h>
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-#include <sys/param.h>
-#include <bsm/audit.h>
-#include <sys/queue.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
-	struct sockaddr s1;	// this one gets used for fields
-	struct sockaddr_in s2;	// these pad it out
-	struct sockaddr_in6 s3;
-	struct sockaddr_un s4;
-	struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
-	struct sockaddr addr;
-	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-struct ucred_queue {
-        struct ucred *tqe_next;
-        struct ucred **tqe_prev;
-        TRACEBUF
-};
-
-*/
-import "C"
-
-// Machine characteristics; for internal use.
-
-const (
-	sizeofPtr      = C.sizeofPtr
-	sizeofShort    = C.sizeof_short
-	sizeofInt      = C.sizeof_int
-	sizeofLong     = C.sizeof_long
-	sizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type UGid_t C.gid_t
-
-type KinfoProc C.struct_kinfo_proc
-
-type Eproc C.struct_eproc
-
-type Proc C.struct_proc
-
-type Session C.struct_session
-
-type ucred C.struct_ucred
-
-type Uucred C.struct__ucred
-
-type Upcred C.struct__pcred
-
-type Vmspace C.struct_vmspace
-
-type Sigacts C.struct_sigacts
-
-type ExternProc C.struct_extern_proc
-
-type Itimerval C.struct_itimerval
-
-type Vnode C.struct_vnode
-
-type Pgrp C.struct_pgrp
-
-type UserStruct C.struct_user
-
-type Au_session C.struct_au_session
-
-type Posix_cred C.struct_posix_cred
-
-type Label C.struct_label
-
-type AuditinfoAddr C.struct_auditinfo_addr
-type AuMask C.struct_au_mask
-type AuTidAddr C.struct_au_tid_addr
-
-// TAILQ(ucred)
-type UcredQueue C.struct_ucred_queue
diff --git a/vendor/github.com/shirou/gopsutil/process/types_freebsd.go b/vendor/github.com/shirou/gopsutil/process/types_freebsd.go
deleted file mode 100644
index aa7b3462d..000000000
--- a/vendor/github.com/shirou/gopsutil/process/types_freebsd.go
+++ /dev/null
@@ -1,95 +0,0 @@
-// +build ignore
-
-// We still need editing by hands.
-// go tool cgo -godefs types_freebsd.go | sed 's/\*int64/int64/' | sed 's/\*byte/int64/'  > process_freebsd_amd64.go
-
-/*
-Input to cgo -godefs.
-*/
-
-// +godefs map struct_pargs int64 /* pargs */
-// +godefs map struct_proc int64 /* proc */
-// +godefs map struct_user int64 /* user */
-// +godefs map struct_vnode int64 /* vnode */
-// +godefs map struct_vnode int64 /* vnode */
-// +godefs map struct_filedesc int64 /* filedesc */
-// +godefs map struct_vmspace int64 /* vmspace */
-// +godefs map struct_pcb int64 /* pcb */
-// +godefs map struct_thread int64 /* thread */
-// +godefs map struct___sigset [16]byte /* sigset */
-
-package process
-
-/*
-#include <sys/types.h>
-#include <sys/user.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-
-*/
-import "C"
-
-// Machine characteristics; for internal use.
-
-const (
-	CTLKern          = 1  // "high kernel": proc, limits
-	KernProc         = 14 // struct: process entries
-	KernProcPID      = 1  // by process id
-	KernProcProc     = 8  // only return procs
-	KernProcPathname = 12 // path to executable
-	KernProcArgs     = 7  // get/set arguments/proctitle
-)
-
-const (
-	sizeofPtr      = C.sizeofPtr
-	sizeofShort    = C.sizeof_short
-	sizeofInt      = C.sizeof_int
-	sizeofLong     = C.sizeof_long
-	sizeofLongLong = C.sizeof_longlong
-)
-
-const (
-	sizeOfKinfoVmentry = C.sizeof_struct_kinfo_vmentry
-	sizeOfKinfoProc    = C.sizeof_struct_kinfo_proc
-)
-
-// from sys/proc.h
-const (
-	SIDL   = 1 /* Process being created by fork. */
-	SRUN   = 2 /* Currently runnable. */
-	SSLEEP = 3 /* Sleeping on an address. */
-	SSTOP  = 4 /* Process debugging or suspension. */
-	SZOMB  = 5 /* Awaiting collection by parent. */
-	SWAIT  = 6 /* Waiting for interrupt. */
-	SLOCK  = 7 /* Blocked on a lock. */
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type KinfoProc C.struct_kinfo_proc
-
-type Priority C.struct_priority
-
-type KinfoVmentry C.struct_kinfo_vmentry
diff --git a/vendor/github.com/shirou/gopsutil/process/types_openbsd.go b/vendor/github.com/shirou/gopsutil/process/types_openbsd.go
deleted file mode 100644
index 09ac59028..000000000
--- a/vendor/github.com/shirou/gopsutil/process/types_openbsd.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// +build ignore
-
-// We still need editing by hands.
-// go tool cgo -godefs types_openbsd.go | sed 's/\*int64/int64/' | sed 's/\*byte/int64/'  > process_openbsd_amd64.go
-
-/*
-Input to cgo -godefs.
-*/
-
-// +godefs map struct_pargs int64 /* pargs */
-// +godefs map struct_proc int64 /* proc */
-// +godefs map struct_user int64 /* user */
-// +godefs map struct_vnode int64 /* vnode */
-// +godefs map struct_vnode int64 /* vnode */
-// +godefs map struct_filedesc int64 /* filedesc */
-// +godefs map struct_vmspace int64 /* vmspace */
-// +godefs map struct_pcb int64 /* pcb */
-// +godefs map struct_thread int64 /* thread */
-// +godefs map struct___sigset [16]byte /* sigset */
-
-package process
-
-/*
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#include <sys/user.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-
-*/
-import "C"
-
-// Machine characteristics; for internal use.
-
-const (
-	CTLKern          = 1  // "high kernel": proc, limits
-	KernProc         = 66 // struct: process entries
-	KernProcAll      = 0
-	KernProcPID      = 1  // by process id
-	KernProcProc     = 8  // only return procs
-	KernProcPathname = 12 // path to executable
-	KernProcArgs     = 55 // get/set arguments/proctitle
-	KernProcArgv     = 1
-	KernProcEnv      = 3
-)
-
-const (
-	ArgMax = 256 * 1024 // sys/syslimits.h:#define  ARG_MAX
-)
-
-const (
-	sizeofPtr      = C.sizeofPtr
-	sizeofShort    = C.sizeof_short
-	sizeofInt      = C.sizeof_int
-	sizeofLong     = C.sizeof_long
-	sizeofLongLong = C.sizeof_longlong
-)
-
-const (
-	sizeOfKinfoVmentry = C.sizeof_struct_kinfo_vmentry
-	sizeOfKinfoProc    = C.sizeof_struct_kinfo_proc
-)
-
-// from sys/proc.h
-const (
-	SIDL    = 1 /* Process being created by fork. */
-	SRUN    = 2 /* Currently runnable. */
-	SSLEEP  = 3 /* Sleeping on an address. */
-	SSTOP   = 4 /* Process debugging or suspension. */
-	SZOMB   = 5 /* Awaiting collection by parent. */
-	SDEAD   = 6 /* Thread is almost gone */
-	SONPROC = 7 /* Thread is currently on a CPU. */
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type KinfoProc C.struct_kinfo_proc
-
-type Priority C.struct_priority
-
-type KinfoVmentry C.struct_kinfo_vmentry
diff --git a/vendor/github.com/ulikunitz/xz/example.go b/vendor/github.com/ulikunitz/xz/example.go
deleted file mode 100644
index 855e60aee..000000000
--- a/vendor/github.com/ulikunitz/xz/example.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2014-2017 Ulrich Kunitz. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"bytes"
-	"io"
-	"log"
-	"os"
-
-	"github.com/ulikunitz/xz"
-)
-
-func main() {
-	const text = "The quick brown fox jumps over the lazy dog.\n"
-	var buf bytes.Buffer
-	// compress text
-	w, err := xz.NewWriter(&buf)
-	if err != nil {
-		log.Fatalf("xz.NewWriter error %s", err)
-	}
-	if _, err := io.WriteString(w, text); err != nil {
-		log.Fatalf("WriteString error %s", err)
-	}
-	if err := w.Close(); err != nil {
-		log.Fatalf("w.Close error %s", err)
-	}
-	// decompress buffer and write output to stdout
-	r, err := xz.NewReader(&buf)
-	if err != nil {
-		log.Fatalf("NewReader error %s", err)
-	}
-	if _, err = io.Copy(os.Stdout, r); err != nil {
-		log.Fatalf("io.Copy error %s", err)
-	}
-}
diff --git a/vendor/golang.org/x/net/html/atom/gen.go b/vendor/golang.org/x/net/html/atom/gen.go
deleted file mode 100644
index 5d052781b..000000000
--- a/vendor/golang.org/x/net/html/atom/gen.go
+++ /dev/null
@@ -1,712 +0,0 @@
-// Copyright 2012 The Go 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 ignore
-
-//go:generate go run gen.go
-//go:generate go run gen.go -test
-
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"go/format"
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"sort"
-	"strings"
-)
-
-// identifier converts s to a Go exported identifier.
-// It converts "div" to "Div" and "accept-charset" to "AcceptCharset".
-func identifier(s string) string {
-	b := make([]byte, 0, len(s))
-	cap := true
-	for _, c := range s {
-		if c == '-' {
-			cap = true
-			continue
-		}
-		if cap && 'a' <= c && c <= 'z' {
-			c -= 'a' - 'A'
-		}
-		cap = false
-		b = append(b, byte(c))
-	}
-	return string(b)
-}
-
-var test = flag.Bool("test", false, "generate table_test.go")
-
-func genFile(name string, buf *bytes.Buffer) {
-	b, err := format.Source(buf.Bytes())
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-	if err := ioutil.WriteFile(name, b, 0644); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-func main() {
-	flag.Parse()
-
-	var all []string
-	all = append(all, elements...)
-	all = append(all, attributes...)
-	all = append(all, eventHandlers...)
-	all = append(all, extra...)
-	sort.Strings(all)
-
-	// uniq - lists have dups
-	w := 0
-	for _, s := range all {
-		if w == 0 || all[w-1] != s {
-			all[w] = s
-			w++
-		}
-	}
-	all = all[:w]
-
-	if *test {
-		var buf bytes.Buffer
-		fmt.Fprintln(&buf, "// Code generated by go generate gen.go; DO NOT EDIT.\n")
-		fmt.Fprintln(&buf, "//go:generate go run gen.go -test\n")
-		fmt.Fprintln(&buf, "package atom\n")
-		fmt.Fprintln(&buf, "var testAtomList = []string{")
-		for _, s := range all {
-			fmt.Fprintf(&buf, "\t%q,\n", s)
-		}
-		fmt.Fprintln(&buf, "}")
-
-		genFile("table_test.go", &buf)
-		return
-	}
-
-	// Find hash that minimizes table size.
-	var best *table
-	for i := 0; i < 1000000; i++ {
-		if best != nil && 1<<(best.k-1) < len(all) {
-			break
-		}
-		h := rand.Uint32()
-		for k := uint(0); k <= 16; k++ {
-			if best != nil && k >= best.k {
-				break
-			}
-			var t table
-			if t.init(h, k, all) {
-				best = &t
-				break
-			}
-		}
-	}
-	if best == nil {
-		fmt.Fprintf(os.Stderr, "failed to construct string table\n")
-		os.Exit(1)
-	}
-
-	// Lay out strings, using overlaps when possible.
-	layout := append([]string{}, all...)
-
-	// Remove strings that are substrings of other strings
-	for changed := true; changed; {
-		changed = false
-		for i, s := range layout {
-			if s == "" {
-				continue
-			}
-			for j, t := range layout {
-				if i != j && t != "" && strings.Contains(s, t) {
-					changed = true
-					layout[j] = ""
-				}
-			}
-		}
-	}
-
-	// Join strings where one suffix matches another prefix.
-	for {
-		// Find best i, j, k such that layout[i][len-k:] == layout[j][:k],
-		// maximizing overlap length k.
-		besti := -1
-		bestj := -1
-		bestk := 0
-		for i, s := range layout {
-			if s == "" {
-				continue
-			}
-			for j, t := range layout {
-				if i == j {
-					continue
-				}
-				for k := bestk + 1; k <= len(s) && k <= len(t); k++ {
-					if s[len(s)-k:] == t[:k] {
-						besti = i
-						bestj = j
-						bestk = k
-					}
-				}
-			}
-		}
-		if bestk > 0 {
-			layout[besti] += layout[bestj][bestk:]
-			layout[bestj] = ""
-			continue
-		}
-		break
-	}
-
-	text := strings.Join(layout, "")
-
-	atom := map[string]uint32{}
-	for _, s := range all {
-		off := strings.Index(text, s)
-		if off < 0 {
-			panic("lost string " + s)
-		}
-		atom[s] = uint32(off<<8 | len(s))
-	}
-
-	var buf bytes.Buffer
-	// Generate the Go code.
-	fmt.Fprintln(&buf, "// Code generated by go generate gen.go; DO NOT EDIT.\n")
-	fmt.Fprintln(&buf, "//go:generate go run gen.go\n")
-	fmt.Fprintln(&buf, "package atom\n\nconst (")
-
-	// compute max len
-	maxLen := 0
-	for _, s := range all {
-		if maxLen < len(s) {
-			maxLen = len(s)
-		}
-		fmt.Fprintf(&buf, "\t%s Atom = %#x\n", identifier(s), atom[s])
-	}
-	fmt.Fprintln(&buf, ")\n")
-
-	fmt.Fprintf(&buf, "const hash0 = %#x\n\n", best.h0)
-	fmt.Fprintf(&buf, "const maxAtomLen = %d\n\n", maxLen)
-
-	fmt.Fprintf(&buf, "var table = [1<<%d]Atom{\n", best.k)
-	for i, s := range best.tab {
-		if s == "" {
-			continue
-		}
-		fmt.Fprintf(&buf, "\t%#x: %#x, // %s\n", i, atom[s], s)
-	}
-	fmt.Fprintf(&buf, "}\n")
-	datasize := (1 << best.k) * 4
-
-	fmt.Fprintln(&buf, "const atomText =")
-	textsize := len(text)
-	for len(text) > 60 {
-		fmt.Fprintf(&buf, "\t%q +\n", text[:60])
-		text = text[60:]
-	}
-	fmt.Fprintf(&buf, "\t%q\n\n", text)
-
-	genFile("table.go", &buf)
-
-	fmt.Fprintf(os.Stdout, "%d atoms; %d string bytes + %d tables = %d total data\n", len(all), textsize, datasize, textsize+datasize)
-}
-
-type byLen []string
-
-func (x byLen) Less(i, j int) bool { return len(x[i]) > len(x[j]) }
-func (x byLen) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-func (x byLen) Len() int           { return len(x) }
-
-// fnv computes the FNV hash with an arbitrary starting value h.
-func fnv(h uint32, s string) uint32 {
-	for i := 0; i < len(s); i++ {
-		h ^= uint32(s[i])
-		h *= 16777619
-	}
-	return h
-}
-
-// A table represents an attempt at constructing the lookup table.
-// The lookup table uses cuckoo hashing, meaning that each string
-// can be found in one of two positions.
-type table struct {
-	h0   uint32
-	k    uint
-	mask uint32
-	tab  []string
-}
-
-// hash returns the two hashes for s.
-func (t *table) hash(s string) (h1, h2 uint32) {
-	h := fnv(t.h0, s)
-	h1 = h & t.mask
-	h2 = (h >> 16) & t.mask
-	return
-}
-
-// init initializes the table with the given parameters.
-// h0 is the initial hash value,
-// k is the number of bits of hash value to use, and
-// x is the list of strings to store in the table.
-// init returns false if the table cannot be constructed.
-func (t *table) init(h0 uint32, k uint, x []string) bool {
-	t.h0 = h0
-	t.k = k
-	t.tab = make([]string, 1<<k)
-	t.mask = 1<<k - 1
-	for _, s := range x {
-		if !t.insert(s) {
-			return false
-		}
-	}
-	return true
-}
-
-// insert inserts s in the table.
-func (t *table) insert(s string) bool {
-	h1, h2 := t.hash(s)
-	if t.tab[h1] == "" {
-		t.tab[h1] = s
-		return true
-	}
-	if t.tab[h2] == "" {
-		t.tab[h2] = s
-		return true
-	}
-	if t.push(h1, 0) {
-		t.tab[h1] = s
-		return true
-	}
-	if t.push(h2, 0) {
-		t.tab[h2] = s
-		return true
-	}
-	return false
-}
-
-// push attempts to push aside the entry in slot i.
-func (t *table) push(i uint32, depth int) bool {
-	if depth > len(t.tab) {
-		return false
-	}
-	s := t.tab[i]
-	h1, h2 := t.hash(s)
-	j := h1 + h2 - i
-	if t.tab[j] != "" && !t.push(j, depth+1) {
-		return false
-	}
-	t.tab[j] = s
-	return true
-}
-
-// The lists of element names and attribute keys were taken from
-// https://html.spec.whatwg.org/multipage/indices.html#index
-// as of the "HTML Living Standard - Last Updated 16 April 2018" version.
-
-// "command", "keygen" and "menuitem" have been removed from the spec,
-// but are kept here for backwards compatibility.
-var elements = []string{
-	"a",
-	"abbr",
-	"address",
-	"area",
-	"article",
-	"aside",
-	"audio",
-	"b",
-	"base",
-	"bdi",
-	"bdo",
-	"blockquote",
-	"body",
-	"br",
-	"button",
-	"canvas",
-	"caption",
-	"cite",
-	"code",
-	"col",
-	"colgroup",
-	"command",
-	"data",
-	"datalist",
-	"dd",
-	"del",
-	"details",
-	"dfn",
-	"dialog",
-	"div",
-	"dl",
-	"dt",
-	"em",
-	"embed",
-	"fieldset",
-	"figcaption",
-	"figure",
-	"footer",
-	"form",
-	"h1",
-	"h2",
-	"h3",
-	"h4",
-	"h5",
-	"h6",
-	"head",
-	"header",
-	"hgroup",
-	"hr",
-	"html",
-	"i",
-	"iframe",
-	"img",
-	"input",
-	"ins",
-	"kbd",
-	"keygen",
-	"label",
-	"legend",
-	"li",
-	"link",
-	"main",
-	"map",
-	"mark",
-	"menu",
-	"menuitem",
-	"meta",
-	"meter",
-	"nav",
-	"noscript",
-	"object",
-	"ol",
-	"optgroup",
-	"option",
-	"output",
-	"p",
-	"param",
-	"picture",
-	"pre",
-	"progress",
-	"q",
-	"rp",
-	"rt",
-	"ruby",
-	"s",
-	"samp",
-	"script",
-	"section",
-	"select",
-	"slot",
-	"small",
-	"source",
-	"span",
-	"strong",
-	"style",
-	"sub",
-	"summary",
-	"sup",
-	"table",
-	"tbody",
-	"td",
-	"template",
-	"textarea",
-	"tfoot",
-	"th",
-	"thead",
-	"time",
-	"title",
-	"tr",
-	"track",
-	"u",
-	"ul",
-	"var",
-	"video",
-	"wbr",
-}
-
-// https://html.spec.whatwg.org/multipage/indices.html#attributes-3
-//
-// "challenge", "command", "contextmenu", "dropzone", "icon", "keytype", "mediagroup",
-// "radiogroup", "spellcheck", "scoped", "seamless", "sortable" and "sorted" have been removed from the spec,
-// but are kept here for backwards compatibility.
-var attributes = []string{
-	"abbr",
-	"accept",
-	"accept-charset",
-	"accesskey",
-	"action",
-	"allowfullscreen",
-	"allowpaymentrequest",
-	"allowusermedia",
-	"alt",
-	"as",
-	"async",
-	"autocomplete",
-	"autofocus",
-	"autoplay",
-	"challenge",
-	"charset",
-	"checked",
-	"cite",
-	"class",
-	"color",
-	"cols",
-	"colspan",
-	"command",
-	"content",
-	"contenteditable",
-	"contextmenu",
-	"controls",
-	"coords",
-	"crossorigin",
-	"data",
-	"datetime",
-	"default",
-	"defer",
-	"dir",
-	"dirname",
-	"disabled",
-	"download",
-	"draggable",
-	"dropzone",
-	"enctype",
-	"for",
-	"form",
-	"formaction",
-	"formenctype",
-	"formmethod",
-	"formnovalidate",
-	"formtarget",
-	"headers",
-	"height",
-	"hidden",
-	"high",
-	"href",
-	"hreflang",
-	"http-equiv",
-	"icon",
-	"id",
-	"inputmode",
-	"integrity",
-	"is",
-	"ismap",
-	"itemid",
-	"itemprop",
-	"itemref",
-	"itemscope",
-	"itemtype",
-	"keytype",
-	"kind",
-	"label",
-	"lang",
-	"list",
-	"loop",
-	"low",
-	"manifest",
-	"max",
-	"maxlength",
-	"media",
-	"mediagroup",
-	"method",
-	"min",
-	"minlength",
-	"multiple",
-	"muted",
-	"name",
-	"nomodule",
-	"nonce",
-	"novalidate",
-	"open",
-	"optimum",
-	"pattern",
-	"ping",
-	"placeholder",
-	"playsinline",
-	"poster",
-	"preload",
-	"radiogroup",
-	"readonly",
-	"referrerpolicy",
-	"rel",
-	"required",
-	"reversed",
-	"rows",
-	"rowspan",
-	"sandbox",
-	"spellcheck",
-	"scope",
-	"scoped",
-	"seamless",
-	"selected",
-	"shape",
-	"size",
-	"sizes",
-	"sortable",
-	"sorted",
-	"slot",
-	"span",
-	"spellcheck",
-	"src",
-	"srcdoc",
-	"srclang",
-	"srcset",
-	"start",
-	"step",
-	"style",
-	"tabindex",
-	"target",
-	"title",
-	"translate",
-	"type",
-	"typemustmatch",
-	"updateviacache",
-	"usemap",
-	"value",
-	"width",
-	"workertype",
-	"wrap",
-}
-
-// "onautocomplete", "onautocompleteerror", "onmousewheel",
-// "onshow" and "onsort" have been removed from the spec,
-// but are kept here for backwards compatibility.
-var eventHandlers = []string{
-	"onabort",
-	"onautocomplete",
-	"onautocompleteerror",
-	"onauxclick",
-	"onafterprint",
-	"onbeforeprint",
-	"onbeforeunload",
-	"onblur",
-	"oncancel",
-	"oncanplay",
-	"oncanplaythrough",
-	"onchange",
-	"onclick",
-	"onclose",
-	"oncontextmenu",
-	"oncopy",
-	"oncuechange",
-	"oncut",
-	"ondblclick",
-	"ondrag",
-	"ondragend",
-	"ondragenter",
-	"ondragexit",
-	"ondragleave",
-	"ondragover",
-	"ondragstart",
-	"ondrop",
-	"ondurationchange",
-	"onemptied",
-	"onended",
-	"onerror",
-	"onfocus",
-	"onhashchange",
-	"oninput",
-	"oninvalid",
-	"onkeydown",
-	"onkeypress",
-	"onkeyup",
-	"onlanguagechange",
-	"onload",
-	"onloadeddata",
-	"onloadedmetadata",
-	"onloadend",
-	"onloadstart",
-	"onmessage",
-	"onmessageerror",
-	"onmousedown",
-	"onmouseenter",
-	"onmouseleave",
-	"onmousemove",
-	"onmouseout",
-	"onmouseover",
-	"onmouseup",
-	"onmousewheel",
-	"onwheel",
-	"onoffline",
-	"ononline",
-	"onpagehide",
-	"onpageshow",
-	"onpaste",
-	"onpause",
-	"onplay",
-	"onplaying",
-	"onpopstate",
-	"onprogress",
-	"onratechange",
-	"onreset",
-	"onresize",
-	"onrejectionhandled",
-	"onscroll",
-	"onsecuritypolicyviolation",
-	"onseeked",
-	"onseeking",
-	"onselect",
-	"onshow",
-	"onsort",
-	"onstalled",
-	"onstorage",
-	"onsubmit",
-	"onsuspend",
-	"ontimeupdate",
-	"ontoggle",
-	"onunhandledrejection",
-	"onunload",
-	"onvolumechange",
-	"onwaiting",
-}
-
-// extra are ad-hoc values not covered by any of the lists above.
-var extra = []string{
-	"acronym",
-	"align",
-	"annotation",
-	"annotation-xml",
-	"applet",
-	"basefont",
-	"bgsound",
-	"big",
-	"blink",
-	"center",
-	"color",
-	"desc",
-	"face",
-	"font",
-	"foreignObject", // HTML is case-insensitive, but SVG-embedded-in-HTML is case-sensitive.
-	"foreignobject",
-	"frame",
-	"frameset",
-	"image",
-	"isindex",
-	"listing",
-	"malignmark",
-	"marquee",
-	"math",
-	"mglyph",
-	"mi",
-	"mn",
-	"mo",
-	"ms",
-	"mtext",
-	"nobr",
-	"noembed",
-	"noframes",
-	"plaintext",
-	"prompt",
-	"public",
-	"rb",
-	"rtc",
-	"spacer",
-	"strike",
-	"svg",
-	"system",
-	"tt",
-	"xmp",
-}
diff --git a/vendor/golang.org/x/net/publicsuffix/gen.go b/vendor/golang.org/x/net/publicsuffix/gen.go
deleted file mode 100644
index 372ffbb24..000000000
--- a/vendor/golang.org/x/net/publicsuffix/gen.go
+++ /dev/null
@@ -1,717 +0,0 @@
-// Copyright 2012 The Go 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 ignore
-
-package main
-
-// This program generates table.go and table_test.go based on the authoritative
-// public suffix list at https://publicsuffix.org/list/effective_tld_names.dat
-//
-// The version is derived from
-// https://api.github.com/repos/publicsuffix/list/commits?path=public_suffix_list.dat
-// and a human-readable form is at
-// https://github.com/publicsuffix/list/commits/master/public_suffix_list.dat
-//
-// To fetch a particular git revision, such as 5c70ccd250, pass
-// -url "https://raw.githubusercontent.com/publicsuffix/list/5c70ccd250/public_suffix_list.dat"
-// and -version "an explicit version string".
-
-import (
-	"bufio"
-	"bytes"
-	"flag"
-	"fmt"
-	"go/format"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"regexp"
-	"sort"
-	"strings"
-
-	"golang.org/x/net/idna"
-)
-
-const (
-	// These sum of these four values must be no greater than 32.
-	nodesBitsChildren   = 10
-	nodesBitsICANN      = 1
-	nodesBitsTextOffset = 15
-	nodesBitsTextLength = 6
-
-	// These sum of these four values must be no greater than 32.
-	childrenBitsWildcard = 1
-	childrenBitsNodeType = 2
-	childrenBitsHi       = 14
-	childrenBitsLo       = 14
-)
-
-var (
-	maxChildren   int
-	maxTextOffset int
-	maxTextLength int
-	maxHi         uint32
-	maxLo         uint32
-)
-
-func max(a, b int) int {
-	if a < b {
-		return b
-	}
-	return a
-}
-
-func u32max(a, b uint32) uint32 {
-	if a < b {
-		return b
-	}
-	return a
-}
-
-const (
-	nodeTypeNormal     = 0
-	nodeTypeException  = 1
-	nodeTypeParentOnly = 2
-	numNodeType        = 3
-)
-
-func nodeTypeStr(n int) string {
-	switch n {
-	case nodeTypeNormal:
-		return "+"
-	case nodeTypeException:
-		return "!"
-	case nodeTypeParentOnly:
-		return "o"
-	}
-	panic("unreachable")
-}
-
-const (
-	defaultURL   = "https://publicsuffix.org/list/effective_tld_names.dat"
-	gitCommitURL = "https://api.github.com/repos/publicsuffix/list/commits?path=public_suffix_list.dat"
-)
-
-var (
-	labelEncoding = map[string]uint32{}
-	labelsList    = []string{}
-	labelsMap     = map[string]bool{}
-	rules         = []string{}
-	numICANNRules = 0
-
-	// validSuffixRE is used to check that the entries in the public suffix
-	// list are in canonical form (after Punycode encoding). Specifically,
-	// capital letters are not allowed.
-	validSuffixRE = regexp.MustCompile(`^[a-z0-9_\!\*\-\.]+$`)
-
-	shaRE  = regexp.MustCompile(`"sha":"([^"]+)"`)
-	dateRE = regexp.MustCompile(`"committer":{[^{]+"date":"([^"]+)"`)
-
-	comments = flag.Bool("comments", false, "generate table.go comments, for debugging")
-	subset   = flag.Bool("subset", false, "generate only a subset of the full table, for debugging")
-	url      = flag.String("url", defaultURL, "URL of the publicsuffix.org list. If empty, stdin is read instead")
-	v        = flag.Bool("v", false, "verbose output (to stderr)")
-	version  = flag.String("version", "", "the effective_tld_names.dat version")
-)
-
-func main() {
-	if err := main1(); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-func main1() error {
-	flag.Parse()
-	if nodesBitsTextLength+nodesBitsTextOffset+nodesBitsICANN+nodesBitsChildren > 32 {
-		return fmt.Errorf("not enough bits to encode the nodes table")
-	}
-	if childrenBitsLo+childrenBitsHi+childrenBitsNodeType+childrenBitsWildcard > 32 {
-		return fmt.Errorf("not enough bits to encode the children table")
-	}
-	if *version == "" {
-		if *url != defaultURL {
-			return fmt.Errorf("-version was not specified, and the -url is not the default one")
-		}
-		sha, date, err := gitCommit()
-		if err != nil {
-			return err
-		}
-		*version = fmt.Sprintf("publicsuffix.org's public_suffix_list.dat, git revision %s (%s)", sha, date)
-	}
-	var r io.Reader = os.Stdin
-	if *url != "" {
-		res, err := http.Get(*url)
-		if err != nil {
-			return err
-		}
-		if res.StatusCode != http.StatusOK {
-			return fmt.Errorf("bad GET status for %s: %d", *url, res.Status)
-		}
-		r = res.Body
-		defer res.Body.Close()
-	}
-
-	var root node
-	icann := false
-	br := bufio.NewReader(r)
-	for {
-		s, err := br.ReadString('\n')
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return err
-		}
-		s = strings.TrimSpace(s)
-		if strings.Contains(s, "BEGIN ICANN DOMAINS") {
-			if len(rules) != 0 {
-				return fmt.Errorf(`expected no rules before "BEGIN ICANN DOMAINS"`)
-			}
-			icann = true
-			continue
-		}
-		if strings.Contains(s, "END ICANN DOMAINS") {
-			icann, numICANNRules = false, len(rules)
-			continue
-		}
-		if s == "" || strings.HasPrefix(s, "//") {
-			continue
-		}
-		s, err = idna.ToASCII(s)
-		if err != nil {
-			return err
-		}
-		if !validSuffixRE.MatchString(s) {
-			return fmt.Errorf("bad publicsuffix.org list data: %q", s)
-		}
-
-		if *subset {
-			switch {
-			case s == "ac.jp" || strings.HasSuffix(s, ".ac.jp"):
-			case s == "ak.us" || strings.HasSuffix(s, ".ak.us"):
-			case s == "ao" || strings.HasSuffix(s, ".ao"):
-			case s == "ar" || strings.HasSuffix(s, ".ar"):
-			case s == "arpa" || strings.HasSuffix(s, ".arpa"):
-			case s == "cy" || strings.HasSuffix(s, ".cy"):
-			case s == "dyndns.org" || strings.HasSuffix(s, ".dyndns.org"):
-			case s == "jp":
-			case s == "kobe.jp" || strings.HasSuffix(s, ".kobe.jp"):
-			case s == "kyoto.jp" || strings.HasSuffix(s, ".kyoto.jp"):
-			case s == "om" || strings.HasSuffix(s, ".om"):
-			case s == "uk" || strings.HasSuffix(s, ".uk"):
-			case s == "uk.com" || strings.HasSuffix(s, ".uk.com"):
-			case s == "tw" || strings.HasSuffix(s, ".tw"):
-			case s == "zw" || strings.HasSuffix(s, ".zw"):
-			case s == "xn--p1ai" || strings.HasSuffix(s, ".xn--p1ai"):
-				// xn--p1ai is Russian-Cyrillic "рф".
-			default:
-				continue
-			}
-		}
-
-		rules = append(rules, s)
-
-		nt, wildcard := nodeTypeNormal, false
-		switch {
-		case strings.HasPrefix(s, "*."):
-			s, nt = s[2:], nodeTypeParentOnly
-			wildcard = true
-		case strings.HasPrefix(s, "!"):
-			s, nt = s[1:], nodeTypeException
-		}
-		labels := strings.Split(s, ".")
-		for n, i := &root, len(labels)-1; i >= 0; i-- {
-			label := labels[i]
-			n = n.child(label)
-			if i == 0 {
-				if nt != nodeTypeParentOnly && n.nodeType == nodeTypeParentOnly {
-					n.nodeType = nt
-				}
-				n.icann = n.icann && icann
-				n.wildcard = n.wildcard || wildcard
-			}
-			labelsMap[label] = true
-		}
-	}
-	labelsList = make([]string, 0, len(labelsMap))
-	for label := range labelsMap {
-		labelsList = append(labelsList, label)
-	}
-	sort.Strings(labelsList)
-
-	if err := generate(printReal, &root, "table.go"); err != nil {
-		return err
-	}
-	if err := generate(printTest, &root, "table_test.go"); err != nil {
-		return err
-	}
-	return nil
-}
-
-func generate(p func(io.Writer, *node) error, root *node, filename string) error {
-	buf := new(bytes.Buffer)
-	if err := p(buf, root); err != nil {
-		return err
-	}
-	b, err := format.Source(buf.Bytes())
-	if err != nil {
-		return err
-	}
-	return ioutil.WriteFile(filename, b, 0644)
-}
-
-func gitCommit() (sha, date string, retErr error) {
-	res, err := http.Get(gitCommitURL)
-	if err != nil {
-		return "", "", err
-	}
-	if res.StatusCode != http.StatusOK {
-		return "", "", fmt.Errorf("bad GET status for %s: %d", gitCommitURL, res.Status)
-	}
-	defer res.Body.Close()
-	b, err := ioutil.ReadAll(res.Body)
-	if err != nil {
-		return "", "", err
-	}
-	if m := shaRE.FindSubmatch(b); m != nil {
-		sha = string(m[1])
-	}
-	if m := dateRE.FindSubmatch(b); m != nil {
-		date = string(m[1])
-	}
-	if sha == "" || date == "" {
-		retErr = fmt.Errorf("could not find commit SHA and date in %s", gitCommitURL)
-	}
-	return sha, date, retErr
-}
-
-func printTest(w io.Writer, n *node) error {
-	fmt.Fprintf(w, "// generated by go run gen.go; DO NOT EDIT\n\n")
-	fmt.Fprintf(w, "package publicsuffix\n\nconst numICANNRules = %d\n\nvar rules = [...]string{\n", numICANNRules)
-	for _, rule := range rules {
-		fmt.Fprintf(w, "%q,\n", rule)
-	}
-	fmt.Fprintf(w, "}\n\nvar nodeLabels = [...]string{\n")
-	if err := n.walk(w, printNodeLabel); err != nil {
-		return err
-	}
-	fmt.Fprintf(w, "}\n")
-	return nil
-}
-
-func printReal(w io.Writer, n *node) error {
-	const header = `// generated by go run gen.go; DO NOT EDIT
-
-package publicsuffix
-
-const version = %q
-
-const (
-	nodesBitsChildren   = %d
-	nodesBitsICANN      = %d
-	nodesBitsTextOffset = %d
-	nodesBitsTextLength = %d
-
-	childrenBitsWildcard = %d
-	childrenBitsNodeType = %d
-	childrenBitsHi       = %d
-	childrenBitsLo       = %d
-)
-
-const (
-	nodeTypeNormal     = %d
-	nodeTypeException  = %d
-	nodeTypeParentOnly = %d
-)
-
-// numTLD is the number of top level domains.
-const numTLD = %d
-
-`
-	fmt.Fprintf(w, header, *version,
-		nodesBitsChildren, nodesBitsICANN, nodesBitsTextOffset, nodesBitsTextLength,
-		childrenBitsWildcard, childrenBitsNodeType, childrenBitsHi, childrenBitsLo,
-		nodeTypeNormal, nodeTypeException, nodeTypeParentOnly, len(n.children))
-
-	text := combineText(labelsList)
-	if text == "" {
-		return fmt.Errorf("internal error: makeText returned no text")
-	}
-	for _, label := range labelsList {
-		offset, length := strings.Index(text, label), len(label)
-		if offset < 0 {
-			return fmt.Errorf("internal error: could not find %q in text %q", label, text)
-		}
-		maxTextOffset, maxTextLength = max(maxTextOffset, offset), max(maxTextLength, length)
-		if offset >= 1<<nodesBitsTextOffset {
-			return fmt.Errorf("text offset %d is too large, or nodeBitsTextOffset is too small", offset)
-		}
-		if length >= 1<<nodesBitsTextLength {
-			return fmt.Errorf("text length %d is too large, or nodeBitsTextLength is too small", length)
-		}
-		labelEncoding[label] = uint32(offset)<<nodesBitsTextLength | uint32(length)
-	}
-	fmt.Fprintf(w, "// Text is the combined text of all labels.\nconst text = ")
-	for len(text) > 0 {
-		n, plus := len(text), ""
-		if n > 64 {
-			n, plus = 64, " +"
-		}
-		fmt.Fprintf(w, "%q%s\n", text[:n], plus)
-		text = text[n:]
-	}
-
-	if err := n.walk(w, assignIndexes); err != nil {
-		return err
-	}
-
-	fmt.Fprintf(w, `
-
-// nodes is the list of nodes. Each node is represented as a uint32, which
-// encodes the node's children, wildcard bit and node type (as an index into
-// the children array), ICANN bit and text.
-//
-// If the table was generated with the -comments flag, there is a //-comment
-// after each node's data. In it is the nodes-array indexes of the children,
-// formatted as (n0x1234-n0x1256), with * denoting the wildcard bit. The
-// nodeType is printed as + for normal, ! for exception, and o for parent-only
-// nodes that have children but don't match a domain label in their own right.
-// An I denotes an ICANN domain.
-//
-// The layout within the uint32, from MSB to LSB, is:
-//	[%2d bits] unused
-//	[%2d bits] children index
-//	[%2d bits] ICANN bit
-//	[%2d bits] text index
-//	[%2d bits] text length
-var nodes = [...]uint32{
-`,
-		32-nodesBitsChildren-nodesBitsICANN-nodesBitsTextOffset-nodesBitsTextLength,
-		nodesBitsChildren, nodesBitsICANN, nodesBitsTextOffset, nodesBitsTextLength)
-	if err := n.walk(w, printNode); err != nil {
-		return err
-	}
-	fmt.Fprintf(w, `}
-
-// children is the list of nodes' children, the parent's wildcard bit and the
-// parent's node type. If a node has no children then their children index
-// will be in the range [0, 6), depending on the wildcard bit and node type.
-//
-// The layout within the uint32, from MSB to LSB, is:
-//	[%2d bits] unused
-//	[%2d bits] wildcard bit
-//	[%2d bits] node type
-//	[%2d bits] high nodes index (exclusive) of children
-//	[%2d bits] low nodes index (inclusive) of children
-var children=[...]uint32{
-`,
-		32-childrenBitsWildcard-childrenBitsNodeType-childrenBitsHi-childrenBitsLo,
-		childrenBitsWildcard, childrenBitsNodeType, childrenBitsHi, childrenBitsLo)
-	for i, c := range childrenEncoding {
-		s := "---------------"
-		lo := c & (1<<childrenBitsLo - 1)
-		hi := (c >> childrenBitsLo) & (1<<childrenBitsHi - 1)
-		if lo != hi {
-			s = fmt.Sprintf("n0x%04x-n0x%04x", lo, hi)
-		}
-		nodeType := int(c>>(childrenBitsLo+childrenBitsHi)) & (1<<childrenBitsNodeType - 1)
-		wildcard := c>>(childrenBitsLo+childrenBitsHi+childrenBitsNodeType) != 0
-		if *comments {
-			fmt.Fprintf(w, "0x%08x, // c0x%04x (%s)%s %s\n",
-				c, i, s, wildcardStr(wildcard), nodeTypeStr(nodeType))
-		} else {
-			fmt.Fprintf(w, "0x%x,\n", c)
-		}
-	}
-	fmt.Fprintf(w, "}\n\n")
-	fmt.Fprintf(w, "// max children %d (capacity %d)\n", maxChildren, 1<<nodesBitsChildren-1)
-	fmt.Fprintf(w, "// max text offset %d (capacity %d)\n", maxTextOffset, 1<<nodesBitsTextOffset-1)
-	fmt.Fprintf(w, "// max text length %d (capacity %d)\n", maxTextLength, 1<<nodesBitsTextLength-1)
-	fmt.Fprintf(w, "// max hi %d (capacity %d)\n", maxHi, 1<<childrenBitsHi-1)
-	fmt.Fprintf(w, "// max lo %d (capacity %d)\n", maxLo, 1<<childrenBitsLo-1)
-	return nil
-}
-
-type node struct {
-	label    string
-	nodeType int
-	icann    bool
-	wildcard bool
-	// nodesIndex and childrenIndex are the index of this node in the nodes
-	// and the index of its children offset/length in the children arrays.
-	nodesIndex, childrenIndex int
-	// firstChild is the index of this node's first child, or zero if this
-	// node has no children.
-	firstChild int
-	// children are the node's children, in strictly increasing node label order.
-	children []*node
-}
-
-func (n *node) walk(w io.Writer, f func(w1 io.Writer, n1 *node) error) error {
-	if err := f(w, n); err != nil {
-		return err
-	}
-	for _, c := range n.children {
-		if err := c.walk(w, f); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// child returns the child of n with the given label. The child is created if
-// it did not exist beforehand.
-func (n *node) child(label string) *node {
-	for _, c := range n.children {
-		if c.label == label {
-			return c
-		}
-	}
-	c := &node{
-		label:    label,
-		nodeType: nodeTypeParentOnly,
-		icann:    true,
-	}
-	n.children = append(n.children, c)
-	sort.Sort(byLabel(n.children))
-	return c
-}
-
-type byLabel []*node
-
-func (b byLabel) Len() int           { return len(b) }
-func (b byLabel) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
-func (b byLabel) Less(i, j int) bool { return b[i].label < b[j].label }
-
-var nextNodesIndex int
-
-// childrenEncoding are the encoded entries in the generated children array.
-// All these pre-defined entries have no children.
-var childrenEncoding = []uint32{
-	0 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeNormal.
-	1 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeException.
-	2 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeParentOnly.
-	4 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeNormal.
-	5 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeException.
-	6 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeParentOnly.
-}
-
-var firstCallToAssignIndexes = true
-
-func assignIndexes(w io.Writer, n *node) error {
-	if len(n.children) != 0 {
-		// Assign nodesIndex.
-		n.firstChild = nextNodesIndex
-		for _, c := range n.children {
-			c.nodesIndex = nextNodesIndex
-			nextNodesIndex++
-		}
-
-		// The root node's children is implicit.
-		if firstCallToAssignIndexes {
-			firstCallToAssignIndexes = false
-			return nil
-		}
-
-		// Assign childrenIndex.
-		maxChildren = max(maxChildren, len(childrenEncoding))
-		if len(childrenEncoding) >= 1<<nodesBitsChildren {
-			return fmt.Errorf("children table size %d is too large, or nodeBitsChildren is too small", len(childrenEncoding))
-		}
-		n.childrenIndex = len(childrenEncoding)
-		lo := uint32(n.firstChild)
-		hi := lo + uint32(len(n.children))
-		maxLo, maxHi = u32max(maxLo, lo), u32max(maxHi, hi)
-		if lo >= 1<<childrenBitsLo {
-			return fmt.Errorf("children lo %d is too large, or childrenBitsLo is too small", lo)
-		}
-		if hi >= 1<<childrenBitsHi {
-			return fmt.Errorf("children hi %d is too large, or childrenBitsHi is too small", hi)
-		}
-		enc := hi<<childrenBitsLo | lo
-		enc |= uint32(n.nodeType) << (childrenBitsLo + childrenBitsHi)
-		if n.wildcard {
-			enc |= 1 << (childrenBitsLo + childrenBitsHi + childrenBitsNodeType)
-		}
-		childrenEncoding = append(childrenEncoding, enc)
-	} else {
-		n.childrenIndex = n.nodeType
-		if n.wildcard {
-			n.childrenIndex += numNodeType
-		}
-	}
-	return nil
-}
-
-func printNode(w io.Writer, n *node) error {
-	for _, c := range n.children {
-		s := "---------------"
-		if len(c.children) != 0 {
-			s = fmt.Sprintf("n0x%04x-n0x%04x", c.firstChild, c.firstChild+len(c.children))
-		}
-		encoding := labelEncoding[c.label]
-		if c.icann {
-			encoding |= 1 << (nodesBitsTextLength + nodesBitsTextOffset)
-		}
-		encoding |= uint32(c.childrenIndex) << (nodesBitsTextLength + nodesBitsTextOffset + nodesBitsICANN)
-		if *comments {
-			fmt.Fprintf(w, "0x%08x, // n0x%04x c0x%04x (%s)%s %s %s %s\n",
-				encoding, c.nodesIndex, c.childrenIndex, s, wildcardStr(c.wildcard),
-				nodeTypeStr(c.nodeType), icannStr(c.icann), c.label,
-			)
-		} else {
-			fmt.Fprintf(w, "0x%x,\n", encoding)
-		}
-	}
-	return nil
-}
-
-func printNodeLabel(w io.Writer, n *node) error {
-	for _, c := range n.children {
-		fmt.Fprintf(w, "%q,\n", c.label)
-	}
-	return nil
-}
-
-func icannStr(icann bool) string {
-	if icann {
-		return "I"
-	}
-	return " "
-}
-
-func wildcardStr(wildcard bool) string {
-	if wildcard {
-		return "*"
-	}
-	return " "
-}
-
-// combineText combines all the strings in labelsList to form one giant string.
-// Overlapping strings will be merged: "arpa" and "parliament" could yield
-// "arparliament".
-func combineText(labelsList []string) string {
-	beforeLength := 0
-	for _, s := range labelsList {
-		beforeLength += len(s)
-	}
-
-	text := crush(removeSubstrings(labelsList))
-	if *v {
-		fmt.Fprintf(os.Stderr, "crushed %d bytes to become %d bytes\n", beforeLength, len(text))
-	}
-	return text
-}
-
-type byLength []string
-
-func (s byLength) Len() int           { return len(s) }
-func (s byLength) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-func (s byLength) Less(i, j int) bool { return len(s[i]) < len(s[j]) }
-
-// removeSubstrings returns a copy of its input with any strings removed
-// that are substrings of other provided strings.
-func removeSubstrings(input []string) []string {
-	// Make a copy of input.
-	ss := append(make([]string, 0, len(input)), input...)
-	sort.Sort(byLength(ss))
-
-	for i, shortString := range ss {
-		// For each string, only consider strings higher than it in sort order, i.e.
-		// of equal length or greater.
-		for _, longString := range ss[i+1:] {
-			if strings.Contains(longString, shortString) {
-				ss[i] = ""
-				break
-			}
-		}
-	}
-
-	// Remove the empty strings.
-	sort.Strings(ss)
-	for len(ss) > 0 && ss[0] == "" {
-		ss = ss[1:]
-	}
-	return ss
-}
-
-// crush combines a list of strings, taking advantage of overlaps. It returns a
-// single string that contains each input string as a substring.
-func crush(ss []string) string {
-	maxLabelLen := 0
-	for _, s := range ss {
-		if maxLabelLen < len(s) {
-			maxLabelLen = len(s)
-		}
-	}
-
-	for prefixLen := maxLabelLen; prefixLen > 0; prefixLen-- {
-		prefixes := makePrefixMap(ss, prefixLen)
-		for i, s := range ss {
-			if len(s) <= prefixLen {
-				continue
-			}
-			mergeLabel(ss, i, prefixLen, prefixes)
-		}
-	}
-
-	return strings.Join(ss, "")
-}
-
-// mergeLabel merges the label at ss[i] with the first available matching label
-// in prefixMap, where the last "prefixLen" characters in ss[i] match the first
-// "prefixLen" characters in the matching label.
-// It will merge ss[i] repeatedly until no more matches are available.
-// All matching labels merged into ss[i] are replaced by "".
-func mergeLabel(ss []string, i, prefixLen int, prefixes prefixMap) {
-	s := ss[i]
-	suffix := s[len(s)-prefixLen:]
-	for _, j := range prefixes[suffix] {
-		// Empty strings mean "already used." Also avoid merging with self.
-		if ss[j] == "" || i == j {
-			continue
-		}
-		if *v {
-			fmt.Fprintf(os.Stderr, "%d-length overlap at (%4d,%4d): %q and %q share %q\n",
-				prefixLen, i, j, ss[i], ss[j], suffix)
-		}
-		ss[i] += ss[j][prefixLen:]
-		ss[j] = ""
-		// ss[i] has a new suffix, so merge again if possible.
-		// Note: we only have to merge again at the same prefix length. Shorter
-		// prefix lengths will be handled in the next iteration of crush's for loop.
-		// Can there be matches for longer prefix lengths, introduced by the merge?
-		// I believe that any such matches would by necessity have been eliminated
-		// during substring removal or merged at a higher prefix length. For
-		// instance, in crush("abc", "cde", "bcdef"), combining "abc" and "cde"
-		// would yield "abcde", which could be merged with "bcdef." However, in
-		// practice "cde" would already have been elimintated by removeSubstrings.
-		mergeLabel(ss, i, prefixLen, prefixes)
-		return
-	}
-}
-
-// prefixMap maps from a prefix to a list of strings containing that prefix. The
-// list of strings is represented as indexes into a slice of strings stored
-// elsewhere.
-type prefixMap map[string][]int
-
-// makePrefixMap constructs a prefixMap from a slice of strings.
-func makePrefixMap(ss []string, prefixLen int) prefixMap {
-	prefixes := make(prefixMap)
-	for i, s := range ss {
-		// We use < rather than <= because if a label matches on a prefix equal to
-		// its full length, that's actually a substring match handled by
-		// removeSubstrings.
-		if prefixLen < len(s) {
-			prefix := s[:prefixLen]
-			prefixes[prefix] = append(prefixes[prefix], i)
-		}
-	}
-
-	return prefixes
-}
diff --git a/vendor/golang.org/x/sys/unix/mkasm_darwin.go b/vendor/golang.org/x/sys/unix/mkasm_darwin.go
deleted file mode 100644
index 4548b993d..000000000
--- a/vendor/golang.org/x/sys/unix/mkasm_darwin.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2018 The Go 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 ignore
-
-// mkasm_darwin.go generates assembly trampolines to call libSystem routines from Go.
-//This program must be run after mksyscall.go.
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"strings"
-)
-
-func main() {
-	in1, err := ioutil.ReadFile("syscall_darwin.go")
-	if err != nil {
-		log.Fatalf("can't open syscall_darwin.go: %s", err)
-	}
-	arch := os.Args[1]
-	in2, err := ioutil.ReadFile(fmt.Sprintf("syscall_darwin_%s.go", arch))
-	if err != nil {
-		log.Fatalf("can't open syscall_darwin_%s.go: %s", arch, err)
-	}
-	in3, err := ioutil.ReadFile(fmt.Sprintf("zsyscall_darwin_%s.go", arch))
-	if err != nil {
-		log.Fatalf("can't open zsyscall_darwin_%s.go: %s", arch, err)
-	}
-	in := string(in1) + string(in2) + string(in3)
-
-	trampolines := map[string]bool{}
-
-	var out bytes.Buffer
-
-	fmt.Fprintf(&out, "// go run mkasm_darwin.go %s\n", strings.Join(os.Args[1:], " "))
-	fmt.Fprintf(&out, "// Code generated by the command above; DO NOT EDIT.\n")
-	fmt.Fprintf(&out, "\n")
-	fmt.Fprintf(&out, "// +build go1.12\n")
-	fmt.Fprintf(&out, "\n")
-	fmt.Fprintf(&out, "#include \"textflag.h\"\n")
-	for _, line := range strings.Split(in, "\n") {
-		if !strings.HasPrefix(line, "func ") || !strings.HasSuffix(line, "_trampoline()") {
-			continue
-		}
-		fn := line[5 : len(line)-13]
-		if !trampolines[fn] {
-			trampolines[fn] = true
-			fmt.Fprintf(&out, "TEXT ·%s_trampoline(SB),NOSPLIT,$0-0\n", fn)
-			fmt.Fprintf(&out, "\tJMP\t%s(SB)\n", fn)
-		}
-	}
-	err = ioutil.WriteFile(fmt.Sprintf("zsyscall_darwin_%s.s", arch), out.Bytes(), 0644)
-	if err != nil {
-		log.Fatalf("can't write zsyscall_darwin_%s.s: %s", arch, err)
-	}
-}
diff --git a/vendor/golang.org/x/sys/unix/mkpost.go b/vendor/golang.org/x/sys/unix/mkpost.go
deleted file mode 100644
index eb4332059..000000000
--- a/vendor/golang.org/x/sys/unix/mkpost.go
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright 2016 The Go 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 ignore
-
-// mkpost processes the output of cgo -godefs to
-// modify the generated types. It is used to clean up
-// the sys API in an architecture specific manner.
-//
-// mkpost is run after cgo -godefs; see README.md.
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"go/format"
-	"io/ioutil"
-	"log"
-	"os"
-	"regexp"
-)
-
-func main() {
-	// Get the OS and architecture (using GOARCH_TARGET if it exists)
-	goos := os.Getenv("GOOS")
-	goarch := os.Getenv("GOARCH_TARGET")
-	if goarch == "" {
-		goarch = os.Getenv("GOARCH")
-	}
-	// Check that we are using the Docker-based build system if we should be.
-	if goos == "linux" {
-		if os.Getenv("GOLANG_SYS_BUILD") != "docker" {
-			os.Stderr.WriteString("In the Docker-based build system, mkpost should not be called directly.\n")
-			os.Stderr.WriteString("See README.md\n")
-			os.Exit(1)
-		}
-	}
-
-	b, err := ioutil.ReadAll(os.Stdin)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	if goos == "aix" {
-		// Replace type of Atim, Mtim and Ctim by Timespec in Stat_t
-		// to avoid having both StTimespec and Timespec.
-		sttimespec := regexp.MustCompile(`_Ctype_struct_st_timespec`)
-		b = sttimespec.ReplaceAll(b, []byte("Timespec"))
-	}
-
-	// Intentionally export __val fields in Fsid and Sigset_t
-	valRegex := regexp.MustCompile(`type (Fsid|Sigset_t) struct {(\s+)X__(bits|val)(\s+\S+\s+)}`)
-	b = valRegex.ReplaceAll(b, []byte("type $1 struct {${2}Val$4}"))
-
-	// Intentionally export __fds_bits field in FdSet
-	fdSetRegex := regexp.MustCompile(`type (FdSet) struct {(\s+)X__fds_bits(\s+\S+\s+)}`)
-	b = fdSetRegex.ReplaceAll(b, []byte("type $1 struct {${2}Bits$3}"))
-
-	// If we have empty Ptrace structs, we should delete them. Only s390x emits
-	// nonempty Ptrace structs.
-	ptraceRexexp := regexp.MustCompile(`type Ptrace((Psw|Fpregs|Per) struct {\s*})`)
-	b = ptraceRexexp.ReplaceAll(b, nil)
-
-	// Replace the control_regs union with a blank identifier for now.
-	controlRegsRegex := regexp.MustCompile(`(Control_regs)\s+\[0\]uint64`)
-	b = controlRegsRegex.ReplaceAll(b, []byte("_ [0]uint64"))
-
-	// Remove fields that are added by glibc
-	// Note that this is unstable as the identifers are private.
-	removeFieldsRegex := regexp.MustCompile(`X__glibc\S*`)
-	b = removeFieldsRegex.ReplaceAll(b, []byte("_"))
-
-	// Convert [65]int8 to [65]byte in Utsname members to simplify
-	// conversion to string; see golang.org/issue/20753
-	convertUtsnameRegex := regexp.MustCompile(`((Sys|Node|Domain)name|Release|Version|Machine)(\s+)\[(\d+)\]u?int8`)
-	b = convertUtsnameRegex.ReplaceAll(b, []byte("$1$3[$4]byte"))
-
-	// Convert [1024]int8 to [1024]byte in Ptmget members
-	convertPtmget := regexp.MustCompile(`([SC]n)(\s+)\[(\d+)\]u?int8`)
-	b = convertPtmget.ReplaceAll(b, []byte("$1[$3]byte"))
-
-	// Remove spare fields (e.g. in Statx_t)
-	spareFieldsRegex := regexp.MustCompile(`X__spare\S*`)
-	b = spareFieldsRegex.ReplaceAll(b, []byte("_"))
-
-	// Remove cgo padding fields
-	removePaddingFieldsRegex := regexp.MustCompile(`Pad_cgo_\d+`)
-	b = removePaddingFieldsRegex.ReplaceAll(b, []byte("_"))
-
-	// Remove padding, hidden, or unused fields
-	removeFieldsRegex = regexp.MustCompile(`\b(X_\S+|Padding)`)
-	b = removeFieldsRegex.ReplaceAll(b, []byte("_"))
-
-	// Remove the first line of warning from cgo
-	b = b[bytes.IndexByte(b, '\n')+1:]
-	// Modify the command in the header to include:
-	//  mkpost, our own warning, and a build tag.
-	replacement := fmt.Sprintf(`$1 | go run mkpost.go
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s,%s`, goarch, goos)
-	cgoCommandRegex := regexp.MustCompile(`(cgo -godefs .*)`)
-	b = cgoCommandRegex.ReplaceAll(b, []byte(replacement))
-
-	// Rename Stat_t time fields
-	if goos == "freebsd" && goarch == "386" {
-		// Hide Stat_t.[AMCB]tim_ext fields
-		renameStatTimeExtFieldsRegex := regexp.MustCompile(`[AMCB]tim_ext`)
-		b = renameStatTimeExtFieldsRegex.ReplaceAll(b, []byte("_"))
-	}
-	renameStatTimeFieldsRegex := regexp.MustCompile(`([AMCB])(?:irth)?time?(?:spec)?\s+(Timespec|StTimespec)`)
-	b = renameStatTimeFieldsRegex.ReplaceAll(b, []byte("${1}tim ${2}"))
-
-	// gofmt
-	b, err = format.Source(b)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	os.Stdout.Write(b)
-}
diff --git a/vendor/golang.org/x/sys/unix/mksyscall.go b/vendor/golang.org/x/sys/unix/mksyscall.go
deleted file mode 100644
index e4af9424e..000000000
--- a/vendor/golang.org/x/sys/unix/mksyscall.go
+++ /dev/null
@@ -1,407 +0,0 @@
-// Copyright 2018 The Go 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 ignore
-
-/*
-This program reads a file containing function prototypes
-(like syscall_darwin.go) and generates system call bodies.
-The prototypes are marked by lines beginning with "//sys"
-and read like func declarations if //sys is replaced by func, but:
-	* The parameter lists must give a name for each argument.
-	  This includes return parameters.
-	* The parameter lists must give a type for each argument:
-	  the (x, y, z int) shorthand is not allowed.
-	* If the return parameter is an error number, it must be named errno.
-
-A line beginning with //sysnb is like //sys, except that the
-goroutine will not be suspended during the execution of the system
-call.  This must only be used for system calls which can never
-block, as otherwise the system call could cause all goroutines to
-hang.
-*/
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"os"
-	"regexp"
-	"strings"
-)
-
-var (
-	b32       = flag.Bool("b32", false, "32bit big-endian")
-	l32       = flag.Bool("l32", false, "32bit little-endian")
-	plan9     = flag.Bool("plan9", false, "plan9")
-	openbsd   = flag.Bool("openbsd", false, "openbsd")
-	netbsd    = flag.Bool("netbsd", false, "netbsd")
-	dragonfly = flag.Bool("dragonfly", false, "dragonfly")
-	arm       = flag.Bool("arm", false, "arm") // 64-bit value should use (even, odd)-pair
-	tags      = flag.String("tags", "", "build tags")
-	filename  = flag.String("output", "", "output file name (standard output if omitted)")
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
-	return "go run mksyscall.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
-	return *tags
-}
-
-// Param is function parameter
-type Param struct {
-	Name string
-	Type string
-}
-
-// usage prints the program usage
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: go run mksyscall.go [-b32 | -l32] [-tags x,y] [file ...]\n")
-	os.Exit(1)
-}
-
-// parseParamList parses parameter list and returns a slice of parameters
-func parseParamList(list string) []string {
-	list = strings.TrimSpace(list)
-	if list == "" {
-		return []string{}
-	}
-	return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
-}
-
-// parseParam splits a parameter into name and type
-func parseParam(p string) Param {
-	ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
-	if ps == nil {
-		fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
-		os.Exit(1)
-	}
-	return Param{ps[1], ps[2]}
-}
-
-func main() {
-	// Get the OS and architecture (using GOARCH_TARGET if it exists)
-	goos := os.Getenv("GOOS")
-	if goos == "" {
-		fmt.Fprintln(os.Stderr, "GOOS not defined in environment")
-		os.Exit(1)
-	}
-	goarch := os.Getenv("GOARCH_TARGET")
-	if goarch == "" {
-		goarch = os.Getenv("GOARCH")
-	}
-
-	// Check that we are using the Docker-based build system if we should
-	if goos == "linux" {
-		if os.Getenv("GOLANG_SYS_BUILD") != "docker" {
-			fmt.Fprintf(os.Stderr, "In the Docker-based build system, mksyscall should not be called directly.\n")
-			fmt.Fprintf(os.Stderr, "See README.md\n")
-			os.Exit(1)
-		}
-	}
-
-	flag.Usage = usage
-	flag.Parse()
-	if len(flag.Args()) <= 0 {
-		fmt.Fprintf(os.Stderr, "no files to parse provided\n")
-		usage()
-	}
-
-	endianness := ""
-	if *b32 {
-		endianness = "big-endian"
-	} else if *l32 {
-		endianness = "little-endian"
-	}
-
-	libc := false
-	if goos == "darwin" && strings.Contains(buildTags(), ",go1.12") {
-		libc = true
-	}
-	trampolines := map[string]bool{}
-
-	text := ""
-	for _, path := range flag.Args() {
-		file, err := os.Open(path)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
-			os.Exit(1)
-		}
-		s := bufio.NewScanner(file)
-		for s.Scan() {
-			t := s.Text()
-			t = strings.TrimSpace(t)
-			t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
-			nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
-			if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
-				continue
-			}
-
-			// Line must be of the form
-			//	func Open(path string, mode int, perm int) (fd int, errno error)
-			// Split into name, in params, out params.
-			f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*((?i)SYS_[A-Z0-9_]+))?$`).FindStringSubmatch(t)
-			if f == nil {
-				fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
-				os.Exit(1)
-			}
-			funct, inps, outps, sysname := f[2], f[3], f[4], f[5]
-
-			// ClockGettime doesn't have a syscall number on Darwin, only generate libc wrappers.
-			if goos == "darwin" && !libc && funct == "ClockGettime" {
-				continue
-			}
-
-			// Split argument lists on comma.
-			in := parseParamList(inps)
-			out := parseParamList(outps)
-
-			// Try in vain to keep people from editing this file.
-			// The theory is that they jump into the middle of the file
-			// without reading the header.
-			text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
-
-			// Go function header.
-			outDecl := ""
-			if len(out) > 0 {
-				outDecl = fmt.Sprintf(" (%s)", strings.Join(out, ", "))
-			}
-			text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outDecl)
-
-			// Check if err return available
-			errvar := ""
-			for _, param := range out {
-				p := parseParam(param)
-				if p.Type == "error" {
-					errvar = p.Name
-					break
-				}
-			}
-
-			// Prepare arguments to Syscall.
-			var args []string
-			n := 0
-			for _, param := range in {
-				p := parseParam(param)
-				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
-					args = append(args, "uintptr(unsafe.Pointer("+p.Name+"))")
-				} else if p.Type == "string" && errvar != "" {
-					text += fmt.Sprintf("\tvar _p%d *byte\n", n)
-					text += fmt.Sprintf("\t_p%d, %s = BytePtrFromString(%s)\n", n, errvar, p.Name)
-					text += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
-					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
-					n++
-				} else if p.Type == "string" {
-					fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
-					text += fmt.Sprintf("\tvar _p%d *byte\n", n)
-					text += fmt.Sprintf("\t_p%d, _ = BytePtrFromString(%s)\n", n, p.Name)
-					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
-					n++
-				} else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
-					// Convert slice into pointer, length.
-					// Have to be careful not to take address of &a[0] if len == 0:
-					// pass dummy pointer in that case.
-					// Used to pass nil, but some OSes or simulators reject write(fd, nil, 0).
-					text += fmt.Sprintf("\tvar _p%d unsafe.Pointer\n", n)
-					text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = unsafe.Pointer(&%s[0])\n\t}", p.Name, n, p.Name)
-					text += fmt.Sprintf(" else {\n\t\t_p%d = unsafe.Pointer(&_zero)\n\t}\n", n)
-					args = append(args, fmt.Sprintf("uintptr(_p%d)", n), fmt.Sprintf("uintptr(len(%s))", p.Name))
-					n++
-				} else if p.Type == "int64" && (*openbsd || *netbsd) {
-					args = append(args, "0")
-					if endianness == "big-endian" {
-						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
-					} else if endianness == "little-endian" {
-						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
-					} else {
-						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
-					}
-				} else if p.Type == "int64" && *dragonfly {
-					if regexp.MustCompile(`^(?i)extp(read|write)`).FindStringSubmatch(funct) == nil {
-						args = append(args, "0")
-					}
-					if endianness == "big-endian" {
-						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
-					} else if endianness == "little-endian" {
-						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
-					} else {
-						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
-					}
-				} else if (p.Type == "int64" || p.Type == "uint64") && endianness != "" {
-					if len(args)%2 == 1 && *arm {
-						// arm abi specifies 64-bit argument uses
-						// (even, odd) pair
-						args = append(args, "0")
-					}
-					if endianness == "big-endian" {
-						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
-					} else {
-						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
-					}
-				} else {
-					args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
-				}
-			}
-
-			// Determine which form to use; pad args with zeros.
-			asm := "Syscall"
-			if nonblock != nil {
-				if errvar == "" && goos == "linux" {
-					asm = "RawSyscallNoError"
-				} else {
-					asm = "RawSyscall"
-				}
-			} else {
-				if errvar == "" && goos == "linux" {
-					asm = "SyscallNoError"
-				}
-			}
-			if len(args) <= 3 {
-				for len(args) < 3 {
-					args = append(args, "0")
-				}
-			} else if len(args) <= 6 {
-				asm += "6"
-				for len(args) < 6 {
-					args = append(args, "0")
-				}
-			} else if len(args) <= 9 {
-				asm += "9"
-				for len(args) < 9 {
-					args = append(args, "0")
-				}
-			} else {
-				fmt.Fprintf(os.Stderr, "%s:%s too many arguments to system call\n", path, funct)
-			}
-
-			// System call number.
-			if sysname == "" {
-				sysname = "SYS_" + funct
-				sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
-				sysname = strings.ToUpper(sysname)
-			}
-
-			var libcFn string
-			if libc {
-				asm = "syscall_" + strings.ToLower(asm[:1]) + asm[1:] // internal syscall call
-				sysname = strings.TrimPrefix(sysname, "SYS_")         // remove SYS_
-				sysname = strings.ToLower(sysname)                    // lowercase
-				if sysname == "getdirentries64" {
-					// Special case - libSystem name and
-					// raw syscall name don't match.
-					sysname = "__getdirentries64"
-				}
-				libcFn = sysname
-				sysname = "funcPC(libc_" + sysname + "_trampoline)"
-			}
-
-			// Actual call.
-			arglist := strings.Join(args, ", ")
-			call := fmt.Sprintf("%s(%s, %s)", asm, sysname, arglist)
-
-			// Assign return values.
-			body := ""
-			ret := []string{"_", "_", "_"}
-			doErrno := false
-			for i := 0; i < len(out); i++ {
-				p := parseParam(out[i])
-				reg := ""
-				if p.Name == "err" && !*plan9 {
-					reg = "e1"
-					ret[2] = reg
-					doErrno = true
-				} else if p.Name == "err" && *plan9 {
-					ret[0] = "r0"
-					ret[2] = "e1"
-					break
-				} else {
-					reg = fmt.Sprintf("r%d", i)
-					ret[i] = reg
-				}
-				if p.Type == "bool" {
-					reg = fmt.Sprintf("%s != 0", reg)
-				}
-				if p.Type == "int64" && endianness != "" {
-					// 64-bit number in r1:r0 or r0:r1.
-					if i+2 > len(out) {
-						fmt.Fprintf(os.Stderr, "%s:%s not enough registers for int64 return\n", path, funct)
-					}
-					if endianness == "big-endian" {
-						reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i, i+1)
-					} else {
-						reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i+1, i)
-					}
-					ret[i] = fmt.Sprintf("r%d", i)
-					ret[i+1] = fmt.Sprintf("r%d", i+1)
-				}
-				if reg != "e1" || *plan9 {
-					body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
-				}
-			}
-			if ret[0] == "_" && ret[1] == "_" && ret[2] == "_" {
-				text += fmt.Sprintf("\t%s\n", call)
-			} else {
-				if errvar == "" && goos == "linux" {
-					// raw syscall without error on Linux, see golang.org/issue/22924
-					text += fmt.Sprintf("\t%s, %s := %s\n", ret[0], ret[1], call)
-				} else {
-					text += fmt.Sprintf("\t%s, %s, %s := %s\n", ret[0], ret[1], ret[2], call)
-				}
-			}
-			text += body
-
-			if *plan9 && ret[2] == "e1" {
-				text += "\tif int32(r0) == -1 {\n"
-				text += "\t\terr = e1\n"
-				text += "\t}\n"
-			} else if doErrno {
-				text += "\tif e1 != 0 {\n"
-				text += "\t\terr = errnoErr(e1)\n"
-				text += "\t}\n"
-			}
-			text += "\treturn\n"
-			text += "}\n\n"
-
-			if libc && !trampolines[libcFn] {
-				// some system calls share a trampoline, like read and readlen.
-				trampolines[libcFn] = true
-				// Declare assembly trampoline.
-				text += fmt.Sprintf("func libc_%s_trampoline()\n", libcFn)
-				// Assembly trampoline calls the libc_* function, which this magic
-				// redirects to use the function from libSystem.
-				text += fmt.Sprintf("//go:linkname libc_%s libc_%s\n", libcFn, libcFn)
-				text += fmt.Sprintf("//go:cgo_import_dynamic libc_%s %s \"/usr/lib/libSystem.B.dylib\"\n", libcFn, libcFn)
-				text += "\n"
-			}
-		}
-		if err := s.Err(); err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
-			os.Exit(1)
-		}
-		file.Close()
-	}
-	fmt.Printf(srcTemplate, cmdLine(), buildTags(), text)
-}
-
-const srcTemplate = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package unix
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-var _ syscall.Errno
-
-%s
-`
diff --git a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go
deleted file mode 100644
index 3be3cdfc3..000000000
--- a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc.go
+++ /dev/null
@@ -1,415 +0,0 @@
-// Copyright 2019 The Go 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 ignore
-
-/*
-This program reads a file containing function prototypes
-(like syscall_aix.go) and generates system call bodies.
-The prototypes are marked by lines beginning with "//sys"
-and read like func declarations if //sys is replaced by func, but:
-	* The parameter lists must give a name for each argument.
-	  This includes return parameters.
-	* The parameter lists must give a type for each argument:
-	  the (x, y, z int) shorthand is not allowed.
-	* If the return parameter is an error number, it must be named err.
-	* If go func name needs to be different than its libc name,
-	* or the function is not in libc, name could be specified
-	* at the end, after "=" sign, like
-	  //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
-*/
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"os"
-	"regexp"
-	"strings"
-)
-
-var (
-	b32  = flag.Bool("b32", false, "32bit big-endian")
-	l32  = flag.Bool("l32", false, "32bit little-endian")
-	aix  = flag.Bool("aix", false, "aix")
-	tags = flag.String("tags", "", "build tags")
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
-	return "go run mksyscall_aix_ppc.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
-	return *tags
-}
-
-// Param is function parameter
-type Param struct {
-	Name string
-	Type string
-}
-
-// usage prints the program usage
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: go run mksyscall_aix_ppc.go [-b32 | -l32] [-tags x,y] [file ...]\n")
-	os.Exit(1)
-}
-
-// parseParamList parses parameter list and returns a slice of parameters
-func parseParamList(list string) []string {
-	list = strings.TrimSpace(list)
-	if list == "" {
-		return []string{}
-	}
-	return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
-}
-
-// parseParam splits a parameter into name and type
-func parseParam(p string) Param {
-	ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
-	if ps == nil {
-		fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
-		os.Exit(1)
-	}
-	return Param{ps[1], ps[2]}
-}
-
-func main() {
-	flag.Usage = usage
-	flag.Parse()
-	if len(flag.Args()) <= 0 {
-		fmt.Fprintf(os.Stderr, "no files to parse provided\n")
-		usage()
-	}
-
-	endianness := ""
-	if *b32 {
-		endianness = "big-endian"
-	} else if *l32 {
-		endianness = "little-endian"
-	}
-
-	pack := ""
-	text := ""
-	cExtern := "/*\n#include <stdint.h>\n#include <stddef.h>\n"
-	for _, path := range flag.Args() {
-		file, err := os.Open(path)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
-			os.Exit(1)
-		}
-		s := bufio.NewScanner(file)
-		for s.Scan() {
-			t := s.Text()
-			t = strings.TrimSpace(t)
-			t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
-			if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
-				pack = p[1]
-			}
-			nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
-			if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
-				continue
-			}
-
-			// Line must be of the form
-			//	func Open(path string, mode int, perm int) (fd int, err error)
-			// Split into name, in params, out params.
-			f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
-			if f == nil {
-				fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
-				os.Exit(1)
-			}
-			funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
-
-			// Split argument lists on comma.
-			in := parseParamList(inps)
-			out := parseParamList(outps)
-
-			inps = strings.Join(in, ", ")
-			outps = strings.Join(out, ", ")
-
-			// Try in vain to keep people from editing this file.
-			// The theory is that they jump into the middle of the file
-			// without reading the header.
-			text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
-
-			// Check if value return, err return available
-			errvar := ""
-			retvar := ""
-			rettype := ""
-			for _, param := range out {
-				p := parseParam(param)
-				if p.Type == "error" {
-					errvar = p.Name
-				} else {
-					retvar = p.Name
-					rettype = p.Type
-				}
-			}
-
-			// System call name.
-			if sysname == "" {
-				sysname = funct
-			}
-			sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
-			sysname = strings.ToLower(sysname) // All libc functions are lowercase.
-
-			cRettype := ""
-			if rettype == "unsafe.Pointer" {
-				cRettype = "uintptr_t"
-			} else if rettype == "uintptr" {
-				cRettype = "uintptr_t"
-			} else if regexp.MustCompile(`^_`).FindStringSubmatch(rettype) != nil {
-				cRettype = "uintptr_t"
-			} else if rettype == "int" {
-				cRettype = "int"
-			} else if rettype == "int32" {
-				cRettype = "int"
-			} else if rettype == "int64" {
-				cRettype = "long long"
-			} else if rettype == "uint32" {
-				cRettype = "unsigned int"
-			} else if rettype == "uint64" {
-				cRettype = "unsigned long long"
-			} else {
-				cRettype = "int"
-			}
-			if sysname == "exit" {
-				cRettype = "void"
-			}
-
-			// Change p.Types to c
-			var cIn []string
-			for _, param := range in {
-				p := parseParam(param)
-				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
-					cIn = append(cIn, "uintptr_t")
-				} else if p.Type == "string" {
-					cIn = append(cIn, "uintptr_t")
-				} else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
-					cIn = append(cIn, "uintptr_t", "size_t")
-				} else if p.Type == "unsafe.Pointer" {
-					cIn = append(cIn, "uintptr_t")
-				} else if p.Type == "uintptr" {
-					cIn = append(cIn, "uintptr_t")
-				} else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
-					cIn = append(cIn, "uintptr_t")
-				} else if p.Type == "int" {
-					cIn = append(cIn, "int")
-				} else if p.Type == "int32" {
-					cIn = append(cIn, "int")
-				} else if p.Type == "int64" {
-					cIn = append(cIn, "long long")
-				} else if p.Type == "uint32" {
-					cIn = append(cIn, "unsigned int")
-				} else if p.Type == "uint64" {
-					cIn = append(cIn, "unsigned long long")
-				} else {
-					cIn = append(cIn, "int")
-				}
-			}
-
-			if funct != "fcntl" && funct != "FcntlInt" && funct != "readlen" && funct != "writelen" {
-				if sysname == "select" {
-					// select is a keyword of Go. Its name is
-					// changed to c_select.
-					cExtern += "#define c_select select\n"
-				}
-				// Imports of system calls from libc
-				cExtern += fmt.Sprintf("%s %s", cRettype, sysname)
-				cIn := strings.Join(cIn, ", ")
-				cExtern += fmt.Sprintf("(%s);\n", cIn)
-			}
-
-			// So file name.
-			if *aix {
-				if modname == "" {
-					modname = "libc.a/shr_64.o"
-				} else {
-					fmt.Fprintf(os.Stderr, "%s: only syscall using libc are available\n", funct)
-					os.Exit(1)
-				}
-			}
-
-			strconvfunc := "C.CString"
-
-			// Go function header.
-			if outps != "" {
-				outps = fmt.Sprintf(" (%s)", outps)
-			}
-			if text != "" {
-				text += "\n"
-			}
-
-			text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outps)
-
-			// Prepare arguments to Syscall.
-			var args []string
-			n := 0
-			argN := 0
-			for _, param := range in {
-				p := parseParam(param)
-				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
-					args = append(args, "C.uintptr_t(uintptr(unsafe.Pointer("+p.Name+")))")
-				} else if p.Type == "string" && errvar != "" {
-					text += fmt.Sprintf("\t_p%d := uintptr(unsafe.Pointer(%s(%s)))\n", n, strconvfunc, p.Name)
-					args = append(args, fmt.Sprintf("C.uintptr_t(_p%d)", n))
-					n++
-				} else if p.Type == "string" {
-					fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
-					text += fmt.Sprintf("\t_p%d := uintptr(unsafe.Pointer(%s(%s)))\n", n, strconvfunc, p.Name)
-					args = append(args, fmt.Sprintf("C.uintptr_t(_p%d)", n))
-					n++
-				} else if m := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); m != nil {
-					// Convert slice into pointer, length.
-					// Have to be careful not to take address of &a[0] if len == 0:
-					// pass nil in that case.
-					text += fmt.Sprintf("\tvar _p%d *%s\n", n, m[1])
-					text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
-					args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(unsafe.Pointer(_p%d)))", n))
-					n++
-					text += fmt.Sprintf("\tvar _p%d int\n", n)
-					text += fmt.Sprintf("\t_p%d = len(%s)\n", n, p.Name)
-					args = append(args, fmt.Sprintf("C.size_t(_p%d)", n))
-					n++
-				} else if p.Type == "int64" && endianness != "" {
-					if endianness == "big-endian" {
-						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
-					} else {
-						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
-					}
-					n++
-				} else if p.Type == "bool" {
-					text += fmt.Sprintf("\tvar _p%d uint32\n", n)
-					text += fmt.Sprintf("\tif %s {\n\t\t_p%d = 1\n\t} else {\n\t\t_p%d = 0\n\t}\n", p.Name, n, n)
-					args = append(args, fmt.Sprintf("_p%d", n))
-				} else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
-					args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(%s))", p.Name))
-				} else if p.Type == "unsafe.Pointer" {
-					args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(%s))", p.Name))
-				} else if p.Type == "int" {
-					if (argN == 2) && ((funct == "readlen") || (funct == "writelen")) {
-						args = append(args, fmt.Sprintf("C.size_t(%s)", p.Name))
-					} else if argN == 0 && funct == "fcntl" {
-						args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
-					} else if (argN == 2) && ((funct == "fcntl") || (funct == "FcntlInt")) {
-						args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
-					} else {
-						args = append(args, fmt.Sprintf("C.int(%s)", p.Name))
-					}
-				} else if p.Type == "int32" {
-					args = append(args, fmt.Sprintf("C.int(%s)", p.Name))
-				} else if p.Type == "int64" {
-					args = append(args, fmt.Sprintf("C.longlong(%s)", p.Name))
-				} else if p.Type == "uint32" {
-					args = append(args, fmt.Sprintf("C.uint(%s)", p.Name))
-				} else if p.Type == "uint64" {
-					args = append(args, fmt.Sprintf("C.ulonglong(%s)", p.Name))
-				} else if p.Type == "uintptr" {
-					args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
-				} else {
-					args = append(args, fmt.Sprintf("C.int(%s)", p.Name))
-				}
-				argN++
-			}
-
-			// Actual call.
-			arglist := strings.Join(args, ", ")
-			call := ""
-			if sysname == "exit" {
-				if errvar != "" {
-					call += "er :="
-				} else {
-					call += ""
-				}
-			} else if errvar != "" {
-				call += "r0,er :="
-			} else if retvar != "" {
-				call += "r0,_ :="
-			} else {
-				call += ""
-			}
-			if sysname == "select" {
-				// select is a keyword of Go. Its name is
-				// changed to c_select.
-				call += fmt.Sprintf("C.c_%s(%s)", sysname, arglist)
-			} else {
-				call += fmt.Sprintf("C.%s(%s)", sysname, arglist)
-			}
-
-			// Assign return values.
-			body := ""
-			for i := 0; i < len(out); i++ {
-				p := parseParam(out[i])
-				reg := ""
-				if p.Name == "err" {
-					reg = "e1"
-				} else {
-					reg = "r0"
-				}
-				if reg != "e1" {
-					body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
-				}
-			}
-
-			// verify return
-			if sysname != "exit" && errvar != "" {
-				if regexp.MustCompile(`^uintptr`).FindStringSubmatch(cRettype) != nil {
-					body += "\tif (uintptr(r0) ==^uintptr(0) && er != nil) {\n"
-					body += fmt.Sprintf("\t\t%s = er\n", errvar)
-					body += "\t}\n"
-				} else {
-					body += "\tif (r0 ==-1 && er != nil) {\n"
-					body += fmt.Sprintf("\t\t%s = er\n", errvar)
-					body += "\t}\n"
-				}
-			} else if errvar != "" {
-				body += "\tif (er != nil) {\n"
-				body += fmt.Sprintf("\t\t%s = er\n", errvar)
-				body += "\t}\n"
-			}
-
-			text += fmt.Sprintf("\t%s\n", call)
-			text += body
-
-			text += "\treturn\n"
-			text += "}\n"
-		}
-		if err := s.Err(); err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
-			os.Exit(1)
-		}
-		file.Close()
-	}
-	imp := ""
-	if pack != "unix" {
-		imp = "import \"golang.org/x/sys/unix\"\n"
-
-	}
-	fmt.Printf(srcTemplate, cmdLine(), buildTags(), pack, cExtern, imp, text)
-}
-
-const srcTemplate = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package %s
-
-
-%s
-*/
-import "C"
-import (
-	"unsafe"
-)
-
-
-%s
-
-%s
-`
diff --git a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go
deleted file mode 100644
index c96009951..000000000
--- a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.go
+++ /dev/null
@@ -1,614 +0,0 @@
-// Copyright 2019 The Go 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 ignore
-
-/*
-This program reads a file containing function prototypes
-(like syscall_aix.go) and generates system call bodies.
-The prototypes are marked by lines beginning with "//sys"
-and read like func declarations if //sys is replaced by func, but:
-	* The parameter lists must give a name for each argument.
-	  This includes return parameters.
-	* The parameter lists must give a type for each argument:
-	  the (x, y, z int) shorthand is not allowed.
-	* If the return parameter is an error number, it must be named err.
-	* If go func name needs to be different than its libc name,
-	* or the function is not in libc, name could be specified
-	* at the end, after "=" sign, like
-	  //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
-
-
-This program will generate three files and handle both gc and gccgo implementation:
-  - zsyscall_aix_ppc64.go: the common part of each implementation (error handler, pointer creation)
-  - zsyscall_aix_ppc64_gc.go: gc part with //go_cgo_import_dynamic and a call to syscall6
-  - zsyscall_aix_ppc64_gccgo.go: gccgo part with C function and conversion to C type.
-
- The generated code looks like this
-
-zsyscall_aix_ppc64.go
-func asyscall(...) (n int, err error) {
-	 // Pointer Creation
-	 r1, e1 := callasyscall(...)
-	 // Type Conversion
-	 // Error Handler
-	 return
-}
-
-zsyscall_aix_ppc64_gc.go
-//go:cgo_import_dynamic libc_asyscall asyscall "libc.a/shr_64.o"
-//go:linkname libc_asyscall libc_asyscall
-var asyscall syscallFunc
-
-func callasyscall(...) (r1 uintptr, e1 Errno) {
-	 r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_asyscall)), "nb_args", ... )
-	 return
-}
-
-zsyscall_aix_ppc64_ggcgo.go
-
-// int asyscall(...)
-
-import "C"
-
-func callasyscall(...) (r1 uintptr, e1 Errno) {
-	 r1 = uintptr(C.asyscall(...))
-	 e1 = syscall.GetErrno()
-	 return
-}
-*/
-
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"regexp"
-	"strings"
-)
-
-var (
-	b32  = flag.Bool("b32", false, "32bit big-endian")
-	l32  = flag.Bool("l32", false, "32bit little-endian")
-	aix  = flag.Bool("aix", false, "aix")
-	tags = flag.String("tags", "", "build tags")
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
-	return "go run mksyscall_aix_ppc64.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
-	return *tags
-}
-
-// Param is function parameter
-type Param struct {
-	Name string
-	Type string
-}
-
-// usage prints the program usage
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: go run mksyscall_aix_ppc64.go [-b32 | -l32] [-tags x,y] [file ...]\n")
-	os.Exit(1)
-}
-
-// parseParamList parses parameter list and returns a slice of parameters
-func parseParamList(list string) []string {
-	list = strings.TrimSpace(list)
-	if list == "" {
-		return []string{}
-	}
-	return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
-}
-
-// parseParam splits a parameter into name and type
-func parseParam(p string) Param {
-	ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
-	if ps == nil {
-		fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
-		os.Exit(1)
-	}
-	return Param{ps[1], ps[2]}
-}
-
-func main() {
-	flag.Usage = usage
-	flag.Parse()
-	if len(flag.Args()) <= 0 {
-		fmt.Fprintf(os.Stderr, "no files to parse provided\n")
-		usage()
-	}
-
-	endianness := ""
-	if *b32 {
-		endianness = "big-endian"
-	} else if *l32 {
-		endianness = "little-endian"
-	}
-
-	pack := ""
-	// GCCGO
-	textgccgo := ""
-	cExtern := "/*\n#include <stdint.h>\n"
-	// GC
-	textgc := ""
-	dynimports := ""
-	linknames := ""
-	var vars []string
-	// COMMON
-	textcommon := ""
-	for _, path := range flag.Args() {
-		file, err := os.Open(path)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
-			os.Exit(1)
-		}
-		s := bufio.NewScanner(file)
-		for s.Scan() {
-			t := s.Text()
-			t = strings.TrimSpace(t)
-			t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
-			if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
-				pack = p[1]
-			}
-			nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
-			if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
-				continue
-			}
-
-			// Line must be of the form
-			//	func Open(path string, mode int, perm int) (fd int, err error)
-			// Split into name, in params, out params.
-			f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
-			if f == nil {
-				fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
-				os.Exit(1)
-			}
-			funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
-
-			// Split argument lists on comma.
-			in := parseParamList(inps)
-			out := parseParamList(outps)
-
-			inps = strings.Join(in, ", ")
-			outps = strings.Join(out, ", ")
-
-			if sysname == "" {
-				sysname = funct
-			}
-
-			onlyCommon := false
-			if funct == "readlen" || funct == "writelen" || funct == "FcntlInt" || funct == "FcntlFlock" {
-				// This function call another syscall which is already implemented.
-				// Therefore, the gc and gccgo part must not be generated.
-				onlyCommon = true
-			}
-
-			// Try in vain to keep people from editing this file.
-			// The theory is that they jump into the middle of the file
-			// without reading the header.
-
-			textcommon += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
-			if !onlyCommon {
-				textgccgo += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
-				textgc += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
-			}
-
-			// Check if value return, err return available
-			errvar := ""
-			rettype := ""
-			for _, param := range out {
-				p := parseParam(param)
-				if p.Type == "error" {
-					errvar = p.Name
-				} else {
-					rettype = p.Type
-				}
-			}
-
-			sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
-			sysname = strings.ToLower(sysname) // All libc functions are lowercase.
-
-			// GCCGO Prototype return type
-			cRettype := ""
-			if rettype == "unsafe.Pointer" {
-				cRettype = "uintptr_t"
-			} else if rettype == "uintptr" {
-				cRettype = "uintptr_t"
-			} else if regexp.MustCompile(`^_`).FindStringSubmatch(rettype) != nil {
-				cRettype = "uintptr_t"
-			} else if rettype == "int" {
-				cRettype = "int"
-			} else if rettype == "int32" {
-				cRettype = "int"
-			} else if rettype == "int64" {
-				cRettype = "long long"
-			} else if rettype == "uint32" {
-				cRettype = "unsigned int"
-			} else if rettype == "uint64" {
-				cRettype = "unsigned long long"
-			} else {
-				cRettype = "int"
-			}
-			if sysname == "exit" {
-				cRettype = "void"
-			}
-
-			// GCCGO Prototype arguments type
-			var cIn []string
-			for i, param := range in {
-				p := parseParam(param)
-				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
-					cIn = append(cIn, "uintptr_t")
-				} else if p.Type == "string" {
-					cIn = append(cIn, "uintptr_t")
-				} else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
-					cIn = append(cIn, "uintptr_t", "size_t")
-				} else if p.Type == "unsafe.Pointer" {
-					cIn = append(cIn, "uintptr_t")
-				} else if p.Type == "uintptr" {
-					cIn = append(cIn, "uintptr_t")
-				} else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
-					cIn = append(cIn, "uintptr_t")
-				} else if p.Type == "int" {
-					if (i == 0 || i == 2) && funct == "fcntl" {
-						// These fcntl arguments needs to be uintptr to be able to call FcntlInt and FcntlFlock
-						cIn = append(cIn, "uintptr_t")
-					} else {
-						cIn = append(cIn, "int")
-					}
-
-				} else if p.Type == "int32" {
-					cIn = append(cIn, "int")
-				} else if p.Type == "int64" {
-					cIn = append(cIn, "long long")
-				} else if p.Type == "uint32" {
-					cIn = append(cIn, "unsigned int")
-				} else if p.Type == "uint64" {
-					cIn = append(cIn, "unsigned long long")
-				} else {
-					cIn = append(cIn, "int")
-				}
-			}
-
-			if !onlyCommon {
-				// GCCGO Prototype Generation
-				// Imports of system calls from libc
-				if sysname == "select" {
-					// select is a keyword of Go. Its name is
-					// changed to c_select.
-					cExtern += "#define c_select select\n"
-				}
-				cExtern += fmt.Sprintf("%s %s", cRettype, sysname)
-				cIn := strings.Join(cIn, ", ")
-				cExtern += fmt.Sprintf("(%s);\n", cIn)
-			}
-			// GC Library name
-			if modname == "" {
-				modname = "libc.a/shr_64.o"
-			} else {
-				fmt.Fprintf(os.Stderr, "%s: only syscall using libc are available\n", funct)
-				os.Exit(1)
-			}
-			sysvarname := fmt.Sprintf("libc_%s", sysname)
-
-			if !onlyCommon {
-				// GC Runtime import of function to allow cross-platform builds.
-				dynimports += fmt.Sprintf("//go:cgo_import_dynamic %s %s \"%s\"\n", sysvarname, sysname, modname)
-				// GC Link symbol to proc address variable.
-				linknames += fmt.Sprintf("//go:linkname %s %s\n", sysvarname, sysvarname)
-				// GC Library proc address variable.
-				vars = append(vars, sysvarname)
-			}
-
-			strconvfunc := "BytePtrFromString"
-			strconvtype := "*byte"
-
-			// Go function header.
-			if outps != "" {
-				outps = fmt.Sprintf(" (%s)", outps)
-			}
-			if textcommon != "" {
-				textcommon += "\n"
-			}
-
-			textcommon += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outps)
-
-			// Prepare arguments tocall.
-			var argscommon []string // Arguments in the common part
-			var argscall []string   // Arguments for call prototype
-			var argsgc []string     // Arguments for gc call (with syscall6)
-			var argsgccgo []string  // Arguments for gccgo call (with C.name_of_syscall)
-			n := 0
-			argN := 0
-			for _, param := range in {
-				p := parseParam(param)
-				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
-					argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(%s))", p.Name))
-					argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
-					argsgc = append(argsgc, p.Name)
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
-				} else if p.Type == "string" && errvar != "" {
-					textcommon += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
-					textcommon += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
-					textcommon += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
-
-					argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
-					argscall = append(argscall, fmt.Sprintf("_p%d uintptr ", n))
-					argsgc = append(argsgc, fmt.Sprintf("_p%d", n))
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n))
-					n++
-				} else if p.Type == "string" {
-					fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
-					textcommon += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
-					textcommon += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
-					textcommon += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
-
-					argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
-					argscall = append(argscall, fmt.Sprintf("_p%d uintptr", n))
-					argsgc = append(argsgc, fmt.Sprintf("_p%d", n))
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n))
-					n++
-				} else if m := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); m != nil {
-					// Convert slice into pointer, length.
-					// Have to be careful not to take address of &a[0] if len == 0:
-					// pass nil in that case.
-					textcommon += fmt.Sprintf("\tvar _p%d *%s\n", n, m[1])
-					textcommon += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
-					argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n), fmt.Sprintf("len(%s)", p.Name))
-					argscall = append(argscall, fmt.Sprintf("_p%d uintptr", n), fmt.Sprintf("_lenp%d int", n))
-					argsgc = append(argsgc, fmt.Sprintf("_p%d", n), fmt.Sprintf("uintptr(_lenp%d)", n))
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n), fmt.Sprintf("C.size_t(_lenp%d)", n))
-					n++
-				} else if p.Type == "int64" && endianness != "" {
-					fmt.Fprintf(os.Stderr, path+":"+funct+" uses int64 with 32 bits mode. Case not yet implemented\n")
-				} else if p.Type == "bool" {
-					fmt.Fprintf(os.Stderr, path+":"+funct+" uses bool. Case not yet implemented\n")
-				} else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil || p.Type == "unsafe.Pointer" {
-					argscommon = append(argscommon, fmt.Sprintf("uintptr(%s)", p.Name))
-					argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
-					argsgc = append(argsgc, p.Name)
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
-				} else if p.Type == "int" {
-					if (argN == 0 || argN == 2) && ((funct == "fcntl") || (funct == "FcntlInt") || (funct == "FcntlFlock")) {
-						// These fcntl arguments need to be uintptr to be able to call FcntlInt and FcntlFlock
-						argscommon = append(argscommon, fmt.Sprintf("uintptr(%s)", p.Name))
-						argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
-						argsgc = append(argsgc, p.Name)
-						argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
-
-					} else {
-						argscommon = append(argscommon, p.Name)
-						argscall = append(argscall, fmt.Sprintf("%s int", p.Name))
-						argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
-						argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
-					}
-				} else if p.Type == "int32" {
-					argscommon = append(argscommon, p.Name)
-					argscall = append(argscall, fmt.Sprintf("%s int32", p.Name))
-					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
-				} else if p.Type == "int64" {
-					argscommon = append(argscommon, p.Name)
-					argscall = append(argscall, fmt.Sprintf("%s int64", p.Name))
-					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.longlong(%s)", p.Name))
-				} else if p.Type == "uint32" {
-					argscommon = append(argscommon, p.Name)
-					argscall = append(argscall, fmt.Sprintf("%s uint32", p.Name))
-					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uint(%s)", p.Name))
-				} else if p.Type == "uint64" {
-					argscommon = append(argscommon, p.Name)
-					argscall = append(argscall, fmt.Sprintf("%s uint64", p.Name))
-					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.ulonglong(%s)", p.Name))
-				} else if p.Type == "uintptr" {
-					argscommon = append(argscommon, p.Name)
-					argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
-					argsgc = append(argsgc, p.Name)
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
-				} else {
-					argscommon = append(argscommon, fmt.Sprintf("int(%s)", p.Name))
-					argscall = append(argscall, fmt.Sprintf("%s int", p.Name))
-					argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
-					argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
-				}
-				argN++
-			}
-			nargs := len(argsgc)
-
-			// COMMON function generation
-			argscommonlist := strings.Join(argscommon, ", ")
-			callcommon := fmt.Sprintf("call%s(%s)", sysname, argscommonlist)
-			ret := []string{"_", "_"}
-			body := ""
-			doErrno := false
-			for i := 0; i < len(out); i++ {
-				p := parseParam(out[i])
-				reg := ""
-				if p.Name == "err" {
-					reg = "e1"
-					ret[1] = reg
-					doErrno = true
-				} else {
-					reg = "r0"
-					ret[0] = reg
-				}
-				if p.Type == "bool" {
-					reg = fmt.Sprintf("%s != 0", reg)
-				}
-				if reg != "e1" {
-					body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
-				}
-			}
-			if ret[0] == "_" && ret[1] == "_" {
-				textcommon += fmt.Sprintf("\t%s\n", callcommon)
-			} else {
-				textcommon += fmt.Sprintf("\t%s, %s := %s\n", ret[0], ret[1], callcommon)
-			}
-			textcommon += body
-
-			if doErrno {
-				textcommon += "\tif e1 != 0 {\n"
-				textcommon += "\t\terr = errnoErr(e1)\n"
-				textcommon += "\t}\n"
-			}
-			textcommon += "\treturn\n"
-			textcommon += "}\n"
-
-			if onlyCommon {
-				continue
-			}
-
-			// CALL Prototype
-			callProto := fmt.Sprintf("func call%s(%s) (r1 uintptr, e1 Errno) {\n", sysname, strings.Join(argscall, ", "))
-
-			// GC function generation
-			asm := "syscall6"
-			if nonblock != nil {
-				asm = "rawSyscall6"
-			}
-
-			if len(argsgc) <= 6 {
-				for len(argsgc) < 6 {
-					argsgc = append(argsgc, "0")
-				}
-			} else {
-				fmt.Fprintf(os.Stderr, "%s: too many arguments to system call", funct)
-				os.Exit(1)
-			}
-			argsgclist := strings.Join(argsgc, ", ")
-			callgc := fmt.Sprintf("%s(uintptr(unsafe.Pointer(&%s)), %d, %s)", asm, sysvarname, nargs, argsgclist)
-
-			textgc += callProto
-			textgc += fmt.Sprintf("\tr1, _, e1 = %s\n", callgc)
-			textgc += "\treturn\n}\n"
-
-			// GCCGO function generation
-			argsgccgolist := strings.Join(argsgccgo, ", ")
-			var callgccgo string
-			if sysname == "select" {
-				// select is a keyword of Go. Its name is
-				// changed to c_select.
-				callgccgo = fmt.Sprintf("C.c_%s(%s)", sysname, argsgccgolist)
-			} else {
-				callgccgo = fmt.Sprintf("C.%s(%s)", sysname, argsgccgolist)
-			}
-			textgccgo += callProto
-			textgccgo += fmt.Sprintf("\tr1 = uintptr(%s)\n", callgccgo)
-			textgccgo += "\te1 = syscall.GetErrno()\n"
-			textgccgo += "\treturn\n}\n"
-		}
-		if err := s.Err(); err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
-			os.Exit(1)
-		}
-		file.Close()
-	}
-	imp := ""
-	if pack != "unix" {
-		imp = "import \"golang.org/x/sys/unix\"\n"
-
-	}
-
-	// Print zsyscall_aix_ppc64.go
-	err := ioutil.WriteFile("zsyscall_aix_ppc64.go",
-		[]byte(fmt.Sprintf(srcTemplate1, cmdLine(), buildTags(), pack, imp, textcommon)),
-		0644)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
-	// Print zsyscall_aix_ppc64_gc.go
-	vardecls := "\t" + strings.Join(vars, ",\n\t")
-	vardecls += " syscallFunc"
-	err = ioutil.WriteFile("zsyscall_aix_ppc64_gc.go",
-		[]byte(fmt.Sprintf(srcTemplate2, cmdLine(), buildTags(), pack, imp, dynimports, linknames, vardecls, textgc)),
-		0644)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-
-	// Print zsyscall_aix_ppc64_gccgo.go
-	err = ioutil.WriteFile("zsyscall_aix_ppc64_gccgo.go",
-		[]byte(fmt.Sprintf(srcTemplate3, cmdLine(), buildTags(), pack, cExtern, imp, textgccgo)),
-		0644)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
-		os.Exit(1)
-	}
-}
-
-const srcTemplate1 = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package %s
-
-import (
-	"unsafe"
-)
-
-
-%s
-
-%s
-`
-const srcTemplate2 = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-// +build !gccgo
-
-package %s
-
-import (
-	"unsafe"
-)
-%s
-%s
-%s
-type syscallFunc uintptr
-
-var (
-%s
-)
-
-// Implemented in runtime/syscall_aix.go.
-func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
-func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
-
-%s
-`
-const srcTemplate3 = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-// +build gccgo
-
-package %s
-
-%s
-*/
-import "C"
-import (
-	"syscall"
-)
-
-
-%s
-
-%s
-`
diff --git a/vendor/golang.org/x/sys/unix/mksyscall_solaris.go b/vendor/golang.org/x/sys/unix/mksyscall_solaris.go
deleted file mode 100644
index 3d864738b..000000000
--- a/vendor/golang.org/x/sys/unix/mksyscall_solaris.go
+++ /dev/null
@@ -1,335 +0,0 @@
-// Copyright 2019 The Go 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 ignore
-
-/*
- This program reads a file containing function prototypes
- (like syscall_solaris.go) and generates system call bodies.
- The prototypes are marked by lines beginning with "//sys"
- and read like func declarations if //sys is replaced by func, but:
-	* The parameter lists must give a name for each argument.
-	  This includes return parameters.
-	* The parameter lists must give a type for each argument:
-	  the (x, y, z int) shorthand is not allowed.
-	* If the return parameter is an error number, it must be named err.
-	* If go func name needs to be different than its libc name,
-	* or the function is not in libc, name could be specified
-	* at the end, after "=" sign, like
-	  //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
-*/
-
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"os"
-	"regexp"
-	"strings"
-)
-
-var (
-	b32  = flag.Bool("b32", false, "32bit big-endian")
-	l32  = flag.Bool("l32", false, "32bit little-endian")
-	tags = flag.String("tags", "", "build tags")
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
-	return "go run mksyscall_solaris.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
-	return *tags
-}
-
-// Param is function parameter
-type Param struct {
-	Name string
-	Type string
-}
-
-// usage prints the program usage
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: go run mksyscall_solaris.go [-b32 | -l32] [-tags x,y] [file ...]\n")
-	os.Exit(1)
-}
-
-// parseParamList parses parameter list and returns a slice of parameters
-func parseParamList(list string) []string {
-	list = strings.TrimSpace(list)
-	if list == "" {
-		return []string{}
-	}
-	return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
-}
-
-// parseParam splits a parameter into name and type
-func parseParam(p string) Param {
-	ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
-	if ps == nil {
-		fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
-		os.Exit(1)
-	}
-	return Param{ps[1], ps[2]}
-}
-
-func main() {
-	flag.Usage = usage
-	flag.Parse()
-	if len(flag.Args()) <= 0 {
-		fmt.Fprintf(os.Stderr, "no files to parse provided\n")
-		usage()
-	}
-
-	endianness := ""
-	if *b32 {
-		endianness = "big-endian"
-	} else if *l32 {
-		endianness = "little-endian"
-	}
-
-	pack := ""
-	text := ""
-	dynimports := ""
-	linknames := ""
-	var vars []string
-	for _, path := range flag.Args() {
-		file, err := os.Open(path)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
-			os.Exit(1)
-		}
-		s := bufio.NewScanner(file)
-		for s.Scan() {
-			t := s.Text()
-			t = strings.TrimSpace(t)
-			t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `)
-			if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
-				pack = p[1]
-			}
-			nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t)
-			if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil {
-				continue
-			}
-
-			// Line must be of the form
-			//	func Open(path string, mode int, perm int) (fd int, err error)
-			// Split into name, in params, out params.
-			f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
-			if f == nil {
-				fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
-				os.Exit(1)
-			}
-			funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
-
-			// Split argument lists on comma.
-			in := parseParamList(inps)
-			out := parseParamList(outps)
-
-			inps = strings.Join(in, ", ")
-			outps = strings.Join(out, ", ")
-
-			// Try in vain to keep people from editing this file.
-			// The theory is that they jump into the middle of the file
-			// without reading the header.
-			text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
-
-			// So file name.
-			if modname == "" {
-				modname = "libc"
-			}
-
-			// System call name.
-			if sysname == "" {
-				sysname = funct
-			}
-
-			// System call pointer variable name.
-			sysvarname := fmt.Sprintf("proc%s", sysname)
-
-			strconvfunc := "BytePtrFromString"
-			strconvtype := "*byte"
-
-			sysname = strings.ToLower(sysname) // All libc functions are lowercase.
-
-			// Runtime import of function to allow cross-platform builds.
-			dynimports += fmt.Sprintf("//go:cgo_import_dynamic libc_%s %s \"%s.so\"\n", sysname, sysname, modname)
-			// Link symbol to proc address variable.
-			linknames += fmt.Sprintf("//go:linkname %s libc_%s\n", sysvarname, sysname)
-			// Library proc address variable.
-			vars = append(vars, sysvarname)
-
-			// Go function header.
-			outlist := strings.Join(out, ", ")
-			if outlist != "" {
-				outlist = fmt.Sprintf(" (%s)", outlist)
-			}
-			if text != "" {
-				text += "\n"
-			}
-			text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outlist)
-
-			// Check if err return available
-			errvar := ""
-			for _, param := range out {
-				p := parseParam(param)
-				if p.Type == "error" {
-					errvar = p.Name
-					continue
-				}
-			}
-
-			// Prepare arguments to Syscall.
-			var args []string
-			n := 0
-			for _, param := range in {
-				p := parseParam(param)
-				if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
-					args = append(args, "uintptr(unsafe.Pointer("+p.Name+"))")
-				} else if p.Type == "string" && errvar != "" {
-					text += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
-					text += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
-					text += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
-					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
-					n++
-				} else if p.Type == "string" {
-					fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
-					text += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
-					text += fmt.Sprintf("\t_p%d, _ = %s(%s)\n", n, strconvfunc, p.Name)
-					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
-					n++
-				} else if s := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); s != nil {
-					// Convert slice into pointer, length.
-					// Have to be careful not to take address of &a[0] if len == 0:
-					// pass nil in that case.
-					text += fmt.Sprintf("\tvar _p%d *%s\n", n, s[1])
-					text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
-					args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n), fmt.Sprintf("uintptr(len(%s))", p.Name))
-					n++
-				} else if p.Type == "int64" && endianness != "" {
-					if endianness == "big-endian" {
-						args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name))
-					} else {
-						args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name))
-					}
-				} else if p.Type == "bool" {
-					text += fmt.Sprintf("\tvar _p%d uint32\n", n)
-					text += fmt.Sprintf("\tif %s {\n\t\t_p%d = 1\n\t} else {\n\t\t_p%d = 0\n\t}\n", p.Name, n, n)
-					args = append(args, fmt.Sprintf("uintptr(_p%d)", n))
-					n++
-				} else {
-					args = append(args, fmt.Sprintf("uintptr(%s)", p.Name))
-				}
-			}
-			nargs := len(args)
-
-			// Determine which form to use; pad args with zeros.
-			asm := "sysvicall6"
-			if nonblock != nil {
-				asm = "rawSysvicall6"
-			}
-			if len(args) <= 6 {
-				for len(args) < 6 {
-					args = append(args, "0")
-				}
-			} else {
-				fmt.Fprintf(os.Stderr, "%s: too many arguments to system call\n", path)
-				os.Exit(1)
-			}
-
-			// Actual call.
-			arglist := strings.Join(args, ", ")
-			call := fmt.Sprintf("%s(uintptr(unsafe.Pointer(&%s)), %d, %s)", asm, sysvarname, nargs, arglist)
-
-			// Assign return values.
-			body := ""
-			ret := []string{"_", "_", "_"}
-			doErrno := false
-			for i := 0; i < len(out); i++ {
-				p := parseParam(out[i])
-				reg := ""
-				if p.Name == "err" {
-					reg = "e1"
-					ret[2] = reg
-					doErrno = true
-				} else {
-					reg = fmt.Sprintf("r%d", i)
-					ret[i] = reg
-				}
-				if p.Type == "bool" {
-					reg = fmt.Sprintf("%d != 0", reg)
-				}
-				if p.Type == "int64" && endianness != "" {
-					// 64-bit number in r1:r0 or r0:r1.
-					if i+2 > len(out) {
-						fmt.Fprintf(os.Stderr, "%s: not enough registers for int64 return\n", path)
-						os.Exit(1)
-					}
-					if endianness == "big-endian" {
-						reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i, i+1)
-					} else {
-						reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i+1, i)
-					}
-					ret[i] = fmt.Sprintf("r%d", i)
-					ret[i+1] = fmt.Sprintf("r%d", i+1)
-				}
-				if reg != "e1" {
-					body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
-				}
-			}
-			if ret[0] == "_" && ret[1] == "_" && ret[2] == "_" {
-				text += fmt.Sprintf("\t%s\n", call)
-			} else {
-				text += fmt.Sprintf("\t%s, %s, %s := %s\n", ret[0], ret[1], ret[2], call)
-			}
-			text += body
-
-			if doErrno {
-				text += "\tif e1 != 0 {\n"
-				text += "\t\terr = e1\n"
-				text += "\t}\n"
-			}
-			text += "\treturn\n"
-			text += "}\n"
-		}
-		if err := s.Err(); err != nil {
-			fmt.Fprintf(os.Stderr, err.Error())
-			os.Exit(1)
-		}
-		file.Close()
-	}
-	imp := ""
-	if pack != "unix" {
-		imp = "import \"golang.org/x/sys/unix\"\n"
-
-	}
-	vardecls := "\t" + strings.Join(vars, ",\n\t")
-	vardecls += " syscallFunc"
-	fmt.Printf(srcTemplate, cmdLine(), buildTags(), pack, imp, dynimports, linknames, vardecls, text)
-}
-
-const srcTemplate = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package %s
-
-import (
-	"syscall"
-	"unsafe"
-)
-%s
-%s
-%s
-var (
-%s	
-)
-
-%s
-`
diff --git a/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go b/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go
deleted file mode 100644
index b6b409909..000000000
--- a/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go
+++ /dev/null
@@ -1,355 +0,0 @@
-// Copyright 2019 The Go 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 ignore
-
-// Parse the header files for OpenBSD and generate a Go usable sysctl MIB.
-//
-// Build a MIB with each entry being an array containing the level, type and
-// a hash that will contain additional entries if the current entry is a node.
-// We then walk this MIB and create a flattened sysctl name to OID hash.
-
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-var (
-	goos, goarch string
-)
-
-// cmdLine returns this programs's commandline arguments.
-func cmdLine() string {
-	return "go run mksysctl_openbsd.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags.
-func buildTags() string {
-	return fmt.Sprintf("%s,%s", goarch, goos)
-}
-
-// reMatch performs regular expression match and stores the substring slice to value pointed by m.
-func reMatch(re *regexp.Regexp, str string, m *[]string) bool {
-	*m = re.FindStringSubmatch(str)
-	if *m != nil {
-		return true
-	}
-	return false
-}
-
-type nodeElement struct {
-	n  int
-	t  string
-	pE *map[string]nodeElement
-}
-
-var (
-	debugEnabled bool
-	mib          map[string]nodeElement
-	node         *map[string]nodeElement
-	nodeMap      map[string]string
-	sysCtl       []string
-)
-
-var (
-	ctlNames1RE = regexp.MustCompile(`^#define\s+(CTL_NAMES)\s+{`)
-	ctlNames2RE = regexp.MustCompile(`^#define\s+(CTL_(.*)_NAMES)\s+{`)
-	ctlNames3RE = regexp.MustCompile(`^#define\s+((.*)CTL_NAMES)\s+{`)
-	netInetRE   = regexp.MustCompile(`^netinet/`)
-	netInet6RE  = regexp.MustCompile(`^netinet6/`)
-	netRE       = regexp.MustCompile(`^net/`)
-	bracesRE    = regexp.MustCompile(`{.*}`)
-	ctlTypeRE   = regexp.MustCompile(`{\s+"(\w+)",\s+(CTLTYPE_[A-Z]+)\s+}`)
-	fsNetKernRE = regexp.MustCompile(`^(fs|net|kern)_`)
-)
-
-func debug(s string) {
-	if debugEnabled {
-		fmt.Fprintln(os.Stderr, s)
-	}
-}
-
-// Walk the MIB and build a sysctl name to OID mapping.
-func buildSysctl(pNode *map[string]nodeElement, name string, oid []int) {
-	lNode := pNode // local copy of pointer to node
-	var keys []string
-	for k := range *lNode {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	for _, key := range keys {
-		nodename := name
-		if name != "" {
-			nodename += "."
-		}
-		nodename += key
-
-		nodeoid := append(oid, (*pNode)[key].n)
-
-		if (*pNode)[key].t == `CTLTYPE_NODE` {
-			if _, ok := nodeMap[nodename]; ok {
-				lNode = &mib
-				ctlName := nodeMap[nodename]
-				for _, part := range strings.Split(ctlName, ".") {
-					lNode = ((*lNode)[part]).pE
-				}
-			} else {
-				lNode = (*pNode)[key].pE
-			}
-			buildSysctl(lNode, nodename, nodeoid)
-		} else if (*pNode)[key].t != "" {
-			oidStr := []string{}
-			for j := range nodeoid {
-				oidStr = append(oidStr, fmt.Sprintf("%d", nodeoid[j]))
-			}
-			text := "\t{ \"" + nodename + "\", []_C_int{ " + strings.Join(oidStr, ", ") + " } }, \n"
-			sysCtl = append(sysCtl, text)
-		}
-	}
-}
-
-func main() {
-	// Get the OS (using GOOS_TARGET if it exist)
-	goos = os.Getenv("GOOS_TARGET")
-	if goos == "" {
-		goos = os.Getenv("GOOS")
-	}
-	// Get the architecture (using GOARCH_TARGET if it exists)
-	goarch = os.Getenv("GOARCH_TARGET")
-	if goarch == "" {
-		goarch = os.Getenv("GOARCH")
-	}
-	// Check if GOOS and GOARCH environment variables are defined
-	if goarch == "" || goos == "" {
-		fmt.Fprintf(os.Stderr, "GOARCH or GOOS not defined in environment\n")
-		os.Exit(1)
-	}
-
-	mib = make(map[string]nodeElement)
-	headers := [...]string{
-		`sys/sysctl.h`,
-		`sys/socket.h`,
-		`sys/tty.h`,
-		`sys/malloc.h`,
-		`sys/mount.h`,
-		`sys/namei.h`,
-		`sys/sem.h`,
-		`sys/shm.h`,
-		`sys/vmmeter.h`,
-		`uvm/uvmexp.h`,
-		`uvm/uvm_param.h`,
-		`uvm/uvm_swap_encrypt.h`,
-		`ddb/db_var.h`,
-		`net/if.h`,
-		`net/if_pfsync.h`,
-		`net/pipex.h`,
-		`netinet/in.h`,
-		`netinet/icmp_var.h`,
-		`netinet/igmp_var.h`,
-		`netinet/ip_ah.h`,
-		`netinet/ip_carp.h`,
-		`netinet/ip_divert.h`,
-		`netinet/ip_esp.h`,
-		`netinet/ip_ether.h`,
-		`netinet/ip_gre.h`,
-		`netinet/ip_ipcomp.h`,
-		`netinet/ip_ipip.h`,
-		`netinet/pim_var.h`,
-		`netinet/tcp_var.h`,
-		`netinet/udp_var.h`,
-		`netinet6/in6.h`,
-		`netinet6/ip6_divert.h`,
-		`netinet6/pim6_var.h`,
-		`netinet/icmp6.h`,
-		`netmpls/mpls.h`,
-	}
-
-	ctls := [...]string{
-		`kern`,
-		`vm`,
-		`fs`,
-		`net`,
-		//debug			/* Special handling required */
-		`hw`,
-		//machdep		/* Arch specific */
-		`user`,
-		`ddb`,
-		//vfs			/* Special handling required */
-		`fs.posix`,
-		`kern.forkstat`,
-		`kern.intrcnt`,
-		`kern.malloc`,
-		`kern.nchstats`,
-		`kern.seminfo`,
-		`kern.shminfo`,
-		`kern.timecounter`,
-		`kern.tty`,
-		`kern.watchdog`,
-		`net.bpf`,
-		`net.ifq`,
-		`net.inet`,
-		`net.inet.ah`,
-		`net.inet.carp`,
-		`net.inet.divert`,
-		`net.inet.esp`,
-		`net.inet.etherip`,
-		`net.inet.gre`,
-		`net.inet.icmp`,
-		`net.inet.igmp`,
-		`net.inet.ip`,
-		`net.inet.ip.ifq`,
-		`net.inet.ipcomp`,
-		`net.inet.ipip`,
-		`net.inet.mobileip`,
-		`net.inet.pfsync`,
-		`net.inet.pim`,
-		`net.inet.tcp`,
-		`net.inet.udp`,
-		`net.inet6`,
-		`net.inet6.divert`,
-		`net.inet6.ip6`,
-		`net.inet6.icmp6`,
-		`net.inet6.pim6`,
-		`net.inet6.tcp6`,
-		`net.inet6.udp6`,
-		`net.mpls`,
-		`net.mpls.ifq`,
-		`net.key`,
-		`net.pflow`,
-		`net.pfsync`,
-		`net.pipex`,
-		`net.rt`,
-		`vm.swapencrypt`,
-		//vfsgenctl		/* Special handling required */
-	}
-
-	// Node name "fixups"
-	ctlMap := map[string]string{
-		"ipproto":             "net.inet",
-		"net.inet.ipproto":    "net.inet",
-		"net.inet6.ipv6proto": "net.inet6",
-		"net.inet6.ipv6":      "net.inet6.ip6",
-		"net.inet.icmpv6":     "net.inet6.icmp6",
-		"net.inet6.divert6":   "net.inet6.divert",
-		"net.inet6.tcp6":      "net.inet.tcp",
-		"net.inet6.udp6":      "net.inet.udp",
-		"mpls":                "net.mpls",
-		"swpenc":              "vm.swapencrypt",
-	}
-
-	// Node mappings
-	nodeMap = map[string]string{
-		"net.inet.ip.ifq": "net.ifq",
-		"net.inet.pfsync": "net.pfsync",
-		"net.mpls.ifq":    "net.ifq",
-	}
-
-	mCtls := make(map[string]bool)
-	for _, ctl := range ctls {
-		mCtls[ctl] = true
-	}
-
-	for _, header := range headers {
-		debug("Processing " + header)
-		file, err := os.Open(filepath.Join("/usr/include", header))
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "%v\n", err)
-			os.Exit(1)
-		}
-		s := bufio.NewScanner(file)
-		for s.Scan() {
-			var sub []string
-			if reMatch(ctlNames1RE, s.Text(), &sub) ||
-				reMatch(ctlNames2RE, s.Text(), &sub) ||
-				reMatch(ctlNames3RE, s.Text(), &sub) {
-				if sub[1] == `CTL_NAMES` {
-					// Top level.
-					node = &mib
-				} else {
-					// Node.
-					nodename := strings.ToLower(sub[2])
-					ctlName := ""
-					if reMatch(netInetRE, header, &sub) {
-						ctlName = "net.inet." + nodename
-					} else if reMatch(netInet6RE, header, &sub) {
-						ctlName = "net.inet6." + nodename
-					} else if reMatch(netRE, header, &sub) {
-						ctlName = "net." + nodename
-					} else {
-						ctlName = nodename
-						ctlName = fsNetKernRE.ReplaceAllString(ctlName, `$1.`)
-					}
-
-					if val, ok := ctlMap[ctlName]; ok {
-						ctlName = val
-					}
-					if _, ok := mCtls[ctlName]; !ok {
-						debug("Ignoring " + ctlName + "...")
-						continue
-					}
-
-					// Walk down from the top of the MIB.
-					node = &mib
-					for _, part := range strings.Split(ctlName, ".") {
-						if _, ok := (*node)[part]; !ok {
-							debug("Missing node " + part)
-							(*node)[part] = nodeElement{n: 0, t: "", pE: &map[string]nodeElement{}}
-						}
-						node = (*node)[part].pE
-					}
-				}
-
-				// Populate current node with entries.
-				i := -1
-				for !strings.HasPrefix(s.Text(), "}") {
-					s.Scan()
-					if reMatch(bracesRE, s.Text(), &sub) {
-						i++
-					}
-					if !reMatch(ctlTypeRE, s.Text(), &sub) {
-						continue
-					}
-					(*node)[sub[1]] = nodeElement{n: i, t: sub[2], pE: &map[string]nodeElement{}}
-				}
-			}
-		}
-		err = s.Err()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "%v\n", err)
-			os.Exit(1)
-		}
-		file.Close()
-	}
-	buildSysctl(&mib, "", []int{})
-
-	sort.Strings(sysCtl)
-	text := strings.Join(sysCtl, "")
-
-	fmt.Printf(srcTemplate, cmdLine(), buildTags(), text)
-}
-
-const srcTemplate = `// %s
-// Code generated by the command above; DO NOT EDIT.
-
-// +build %s
-
-package unix
-
-type mibentry struct {
-	ctlname string
-	ctloid []_C_int
-}
-
-var sysctlMib = []mibentry {
-%s
-}
-`
diff --git a/vendor/golang.org/x/sys/unix/mksysnum.go b/vendor/golang.org/x/sys/unix/mksysnum.go
deleted file mode 100644
index baa6ecd85..000000000
--- a/vendor/golang.org/x/sys/unix/mksysnum.go
+++ /dev/null
@@ -1,190 +0,0 @@
-// Copyright 2018 The Go 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 ignore
-
-// Generate system call table for DragonFly, NetBSD,
-// FreeBSD, OpenBSD or Darwin from master list
-// (for example, /usr/src/sys/kern/syscalls.master or
-// sys/syscall.h).
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"regexp"
-	"strings"
-)
-
-var (
-	goos, goarch string
-)
-
-// cmdLine returns this programs's commandline arguments
-func cmdLine() string {
-	return "go run mksysnum.go " + strings.Join(os.Args[1:], " ")
-}
-
-// buildTags returns build tags
-func buildTags() string {
-	return fmt.Sprintf("%s,%s", goarch, goos)
-}
-
-func checkErr(err error) {
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
-		os.Exit(1)
-	}
-}
-
-// source string and substring slice for regexp
-type re struct {
-	str string   // source string
-	sub []string // matched sub-string
-}
-
-// Match performs regular expression match
-func (r *re) Match(exp string) bool {
-	r.sub = regexp.MustCompile(exp).FindStringSubmatch(r.str)
-	if r.sub != nil {
-		return true
-	}
-	return false
-}
-
-// fetchFile fetches a text file from URL
-func fetchFile(URL string) io.Reader {
-	resp, err := http.Get(URL)
-	checkErr(err)
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	checkErr(err)
-	return strings.NewReader(string(body))
-}
-
-// readFile reads a text file from path
-func readFile(path string) io.Reader {
-	file, err := os.Open(os.Args[1])
-	checkErr(err)
-	return file
-}
-
-func format(name, num, proto string) string {
-	name = strings.ToUpper(name)
-	// There are multiple entries for enosys and nosys, so comment them out.
-	nm := re{str: name}
-	if nm.Match(`^SYS_E?NOSYS$`) {
-		name = fmt.Sprintf("// %s", name)
-	}
-	if name == `SYS_SYS_EXIT` {
-		name = `SYS_EXIT`
-	}
-	return fmt.Sprintf("	%s = %s;  // %s\n", name, num, proto)
-}
-
-func main() {
-	// Get the OS (using GOOS_TARGET if it exist)
-	goos = os.Getenv("GOOS_TARGET")
-	if goos == "" {
-		goos = os.Getenv("GOOS")
-	}
-	// Get the architecture (using GOARCH_TARGET if it exists)
-	goarch = os.Getenv("GOARCH_TARGET")
-	if goarch == "" {
-		goarch = os.Getenv("GOARCH")
-	}
-	// Check if GOOS and GOARCH environment variables are defined
-	if goarch == "" || goos == "" {
-		fmt.Fprintf(os.Stderr, "GOARCH or GOOS not defined in environment\n")
-		os.Exit(1)
-	}
-
-	file := strings.TrimSpace(os.Args[1])
-	var syscalls io.Reader
-	if strings.HasPrefix(file, "https://") || strings.HasPrefix(file, "http://") {
-		// Download syscalls.master file
-		syscalls = fetchFile(file)
-	} else {
-		syscalls = readFile(file)
-	}
-
-	var text, line string
-	s := bufio.NewScanner(syscalls)
-	for s.Scan() {
-		t := re{str: line}
-		if t.Match(`^(.*)\\$`) {
-			// Handle continuation
-			line = t.sub[1]
-			line += strings.TrimLeft(s.Text(), " \t")
-		} else {
-			// New line
-			line = s.Text()
-		}
-		t = re{str: line}
-		if t.Match(`\\$`) {
-			continue
-		}
-		t = re{str: line}
-
-		switch goos {
-		case "dragonfly":
-			if t.Match(`^([0-9]+)\s+STD\s+({ \S+\s+(\w+).*)$`) {
-				num, proto := t.sub[1], t.sub[2]
-				name := fmt.Sprintf("SYS_%s", t.sub[3])
-				text += format(name, num, proto)
-			}
-		case "freebsd":
-			if t.Match(`^([0-9]+)\s+\S+\s+(?:(?:NO)?STD|COMPAT10)\s+({ \S+\s+(\w+).*)$`) {
-				num, proto := t.sub[1], t.sub[2]
-				name := fmt.Sprintf("SYS_%s", t.sub[3])
-				text += format(name, num, proto)
-			}
-		case "openbsd":
-			if t.Match(`^([0-9]+)\s+STD\s+(NOLOCK\s+)?({ \S+\s+\*?(\w+).*)$`) {
-				num, proto, name := t.sub[1], t.sub[3], t.sub[4]
-				text += format(name, num, proto)
-			}
-		case "netbsd":
-			if t.Match(`^([0-9]+)\s+((STD)|(NOERR))\s+(RUMP\s+)?({\s+\S+\s*\*?\s*\|(\S+)\|(\S*)\|(\w+).*\s+})(\s+(\S+))?$`) {
-				num, proto, compat := t.sub[1], t.sub[6], t.sub[8]
-				name := t.sub[7] + "_" + t.sub[9]
-				if t.sub[11] != "" {
-					name = t.sub[7] + "_" + t.sub[11]
-				}
-				name = strings.ToUpper(name)
-				if compat == "" || compat == "13" || compat == "30" || compat == "50" {
-					text += fmt.Sprintf("	%s = %s;  // %s\n", name, num, proto)
-				}
-			}
-		case "darwin":
-			if t.Match(`^#define\s+SYS_(\w+)\s+([0-9]+)`) {
-				name, num := t.sub[1], t.sub[2]
-				name = strings.ToUpper(name)
-				text += fmt.Sprintf("	SYS_%s = %s;\n", name, num)
-			}
-		default:
-			fmt.Fprintf(os.Stderr, "unrecognized GOOS=%s\n", goos)
-			os.Exit(1)
-
-		}
-	}
-	err := s.Err()
-	checkErr(err)
-
-	fmt.Printf(template, cmdLine(), buildTags(), text)
-}
-
-const template = `// %s
-// Code generated by the command above; see README.md. DO NOT EDIT.
-
-// +build %s
-
-package unix
-
-const(
-%s)`
diff --git a/vendor/golang.org/x/sys/unix/types_aix.go b/vendor/golang.org/x/sys/unix/types_aix.go
deleted file mode 100644
index 40d2beede..000000000
--- a/vendor/golang.org/x/sys/unix/types_aix.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2018 The Go 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 ignore
-// +build aix
-
-/*
-Input to cgo -godefs.  See also mkerrors.sh and mkall.sh
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/limits.h>
-#include <sys/un.h>
-#include <utime.h>
-#include <sys/utsname.h>
-#include <sys/poll.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <sys/statfs.h>
-#include <sys/termio.h>
-#include <sys/ioctl.h>
-
-#include <termios.h>
-
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-
-
-#include <dirent.h>
-#include <fcntl.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
-	struct sockaddr s1;     // this one gets used for fields
-	struct sockaddr_in s2;  // these pad it out
-	struct sockaddr_in6 s3;
-	struct sockaddr_un s4;
-	struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
-	struct sockaddr addr;
-	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
-	SizeofPtr      = C.sizeofPtr
-	SizeofShort    = C.sizeof_short
-	SizeofInt      = C.sizeof_int
-	SizeofLong     = C.sizeof_long
-	SizeofLongLong = C.sizeof_longlong
-	PathMax        = C.PATH_MAX
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-type off64 C.off64_t
-type off C.off_t
-type Mode_t C.mode_t
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-type Timeval32 C.struct_timeval32
-
-type Timex C.struct_timex
-
-type Time_t C.time_t
-
-type Tms C.struct_tms
-
-type Utimbuf C.struct_utimbuf
-
-type Timezone C.struct_timezone
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit64
-
-type Pid_t C.pid_t
-
-type _Gid_t C.gid_t
-
-type dev_t C.dev_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type StatxTimestamp C.struct_statx_timestamp
-
-type Statx_t C.struct_statx
-
-type Dirent C.struct_dirent
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Cmsghdr C.struct_cmsghdr
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type Linger C.struct_linger
-
-type Msghdr C.struct_msghdr
-
-const (
-	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
-	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
-	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
-	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
-	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
-	SizeofLinger           = C.sizeof_struct_linger
-	SizeofIPMreq           = C.sizeof_struct_ip_mreq
-	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
-	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
-	SizeofMsghdr           = C.sizeof_struct_msghdr
-	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
-	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
-)
-
-// Routing and interface messages
-
-const (
-	SizeofIfMsghdr = C.sizeof_struct_if_msghdr
-)
-
-type IfMsgHdr C.struct_if_msghdr
-
-// Misc
-
-type FdSet C.fd_set
-
-type Utsname C.struct_utsname
-
-type Ustat_t C.struct_ustat
-
-type Sigset_t C.sigset_t
-
-const (
-	AT_FDCWD            = C.AT_FDCWD
-	AT_REMOVEDIR        = C.AT_REMOVEDIR
-	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Termio C.struct_termio
-
-type Winsize C.struct_winsize
-
-//poll
-
-type PollFd struct {
-	Fd      int32
-	Events  uint16
-	Revents uint16
-}
-
-const (
-	POLLERR    = C.POLLERR
-	POLLHUP    = C.POLLHUP
-	POLLIN     = C.POLLIN
-	POLLNVAL   = C.POLLNVAL
-	POLLOUT    = C.POLLOUT
-	POLLPRI    = C.POLLPRI
-	POLLRDBAND = C.POLLRDBAND
-	POLLRDNORM = C.POLLRDNORM
-	POLLWRBAND = C.POLLWRBAND
-	POLLWRNORM = C.POLLWRNORM
-)
-
-//flock_t
-
-type Flock_t C.struct_flock64
-
-// Statfs
-
-type Fsid_t C.struct_fsid_t
-type Fsid64_t C.struct_fsid64_t
-
-type Statfs_t C.struct_statfs
-
-const RNDGETENTCNT = 0x80045200
diff --git a/vendor/golang.org/x/sys/unix/types_darwin.go b/vendor/golang.org/x/sys/unix/types_darwin.go
deleted file mode 100644
index 155c2e692..000000000
--- a/vendor/golang.org/x/sys/unix/types_darwin.go
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright 2009 The Go 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 ignore
-
-/*
-Input to cgo -godefs.  See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define __DARWIN_UNIX03 0
-#define KERNEL
-#define _DARWIN_USE_64_BIT_INODE
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <unistd.h>
-#include <mach/mach.h>
-#include <mach/message.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/param.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/if_var.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
-	struct sockaddr s1;	// this one gets used for fields
-	struct sockaddr_in s2;	// these pad it out
-	struct sockaddr_in6 s3;
-	struct sockaddr_un s4;
-	struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
-	struct sockaddr addr;
-	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
-	SizeofPtr      = C.sizeofPtr
-	SizeofShort    = C.sizeof_short
-	SizeofInt      = C.sizeof_int
-	SizeofLong     = C.sizeof_long
-	SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-type Timeval32 C.struct_timeval32
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat64
-
-type Statfs_t C.struct_statfs64
-
-type Flock_t C.struct_flock
-
-type Fstore_t C.struct_fstore
-
-type Radvisory_t C.struct_radvisory
-
-type Fbootstraptransfer_t C.struct_fbootstraptransfer
-
-type Log2phys_t C.struct_log2phys
-
-type Fsid C.struct_fsid
-
-type Dirent C.struct_dirent
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet4Pktinfo C.struct_in_pktinfo
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
-	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
-	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
-	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
-	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
-	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
-	SizeofLinger           = C.sizeof_struct_linger
-	SizeofIPMreq           = C.sizeof_struct_ip_mreq
-	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
-	SizeofMsghdr           = C.sizeof_struct_msghdr
-	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
-	SizeofInet4Pktinfo     = C.sizeof_struct_in_pktinfo
-	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
-	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
-	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
-	PTRACE_TRACEME = C.PT_TRACE_ME
-	PTRACE_CONT    = C.PT_CONTINUE
-	PTRACE_KILL    = C.PT_KILL
-)
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
-	SizeofIfMsghdr    = C.sizeof_struct_if_msghdr
-	SizeofIfData      = C.sizeof_struct_if_data
-	SizeofIfaMsghdr   = C.sizeof_struct_ifa_msghdr
-	SizeofIfmaMsghdr  = C.sizeof_struct_ifma_msghdr
-	SizeofIfmaMsghdr2 = C.sizeof_struct_ifma_msghdr2
-	SizeofRtMsghdr    = C.sizeof_struct_rt_msghdr
-	SizeofRtMetrics   = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfmaMsghdr C.struct_ifma_msghdr
-
-type IfmaMsghdr2 C.struct_ifma_msghdr2
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-// Berkeley packet filter
-
-const (
-	SizeofBpfVersion = C.sizeof_struct_bpf_version
-	SizeofBpfStat    = C.sizeof_struct_bpf_stat
-	SizeofBpfProgram = C.sizeof_struct_bpf_program
-	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
-	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-// fchmodat-like syscalls.
-
-const (
-	AT_FDCWD            = C.AT_FDCWD
-	AT_REMOVEDIR        = C.AT_REMOVEDIR
-	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
-	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
-	POLLERR    = C.POLLERR
-	POLLHUP    = C.POLLHUP
-	POLLIN     = C.POLLIN
-	POLLNVAL   = C.POLLNVAL
-	POLLOUT    = C.POLLOUT
-	POLLPRI    = C.POLLPRI
-	POLLRDBAND = C.POLLRDBAND
-	POLLRDNORM = C.POLLRDNORM
-	POLLWRBAND = C.POLLWRBAND
-	POLLWRNORM = C.POLLWRNORM
-)
-
-// uname
-
-type Utsname C.struct_utsname
-
-// Clockinfo
-
-const SizeofClockinfo = C.sizeof_struct_clockinfo
-
-type Clockinfo C.struct_clockinfo
diff --git a/vendor/golang.org/x/sys/unix/types_dragonfly.go b/vendor/golang.org/x/sys/unix/types_dragonfly.go
deleted file mode 100644
index 3365dd79d..000000000
--- a/vendor/golang.org/x/sys/unix/types_dragonfly.go
+++ /dev/null
@@ -1,263 +0,0 @@
-// Copyright 2009 The Go 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 ignore
-
-/*
-Input to cgo -godefs.  See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define KERNEL
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/param.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
-	struct sockaddr s1;	// this one gets used for fields
-	struct sockaddr_in s2;	// these pad it out
-	struct sockaddr_in6 s3;
-	struct sockaddr_un s4;
-	struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
-	struct sockaddr addr;
-	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
-	SizeofPtr      = C.sizeofPtr
-	SizeofShort    = C.sizeof_short
-	SizeofInt      = C.sizeof_int
-	SizeofLong     = C.sizeof_long
-	SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type Statfs_t C.struct_statfs
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-type Fsid C.struct_fsid
-
-// File system limits
-
-const (
-	PathMax = C.PATH_MAX
-)
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
-	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
-	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
-	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
-	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
-	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
-	SizeofLinger           = C.sizeof_struct_linger
-	SizeofIPMreq           = C.sizeof_struct_ip_mreq
-	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
-	SizeofMsghdr           = C.sizeof_struct_msghdr
-	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
-	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
-	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
-	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
-	PTRACE_TRACEME = C.PT_TRACE_ME
-	PTRACE_CONT    = C.PT_CONTINUE
-	PTRACE_KILL    = C.PT_KILL
-)
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
-	SizeofIfMsghdr         = C.sizeof_struct_if_msghdr
-	SizeofIfData           = C.sizeof_struct_if_data
-	SizeofIfaMsghdr        = C.sizeof_struct_ifa_msghdr
-	SizeofIfmaMsghdr       = C.sizeof_struct_ifma_msghdr
-	SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
-	SizeofRtMsghdr         = C.sizeof_struct_rt_msghdr
-	SizeofRtMetrics        = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfmaMsghdr C.struct_ifma_msghdr
-
-type IfAnnounceMsghdr C.struct_if_announcemsghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-// Berkeley packet filter
-
-const (
-	SizeofBpfVersion = C.sizeof_struct_bpf_version
-	SizeofBpfStat    = C.sizeof_struct_bpf_stat
-	SizeofBpfProgram = C.sizeof_struct_bpf_program
-	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
-	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-// fchmodat-like syscalls.
-
-const (
-	AT_FDCWD            = C.AT_FDCWD
-	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
-	POLLERR    = C.POLLERR
-	POLLHUP    = C.POLLHUP
-	POLLIN     = C.POLLIN
-	POLLNVAL   = C.POLLNVAL
-	POLLOUT    = C.POLLOUT
-	POLLPRI    = C.POLLPRI
-	POLLRDBAND = C.POLLRDBAND
-	POLLRDNORM = C.POLLRDNORM
-	POLLWRBAND = C.POLLWRBAND
-	POLLWRNORM = C.POLLWRNORM
-)
-
-// Uname
-
-type Utsname C.struct_utsname
diff --git a/vendor/golang.org/x/sys/unix/types_freebsd.go b/vendor/golang.org/x/sys/unix/types_freebsd.go
deleted file mode 100644
index a121dc336..000000000
--- a/vendor/golang.org/x/sys/unix/types_freebsd.go
+++ /dev/null
@@ -1,400 +0,0 @@
-// Copyright 2009 The Go 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 ignore
-
-/*
-Input to cgo -godefs.  See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define	_WANT_FREEBSD11_STAT	1
-#define	_WANT_FREEBSD11_STATFS	1
-#define	_WANT_FREEBSD11_DIRENT	1
-#define	_WANT_FREEBSD11_KEVENT  1
-
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/capsicum.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/param.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
-	struct sockaddr s1;	// this one gets used for fields
-	struct sockaddr_in s2;	// these pad it out
-	struct sockaddr_in6 s3;
-	struct sockaddr_un s4;
-	struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
-	struct sockaddr addr;
-	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-// This structure is a duplicate of if_data on FreeBSD 8-STABLE.
-// See /usr/include/net/if.h.
-struct if_data8 {
-	u_char  ifi_type;
-	u_char  ifi_physical;
-	u_char  ifi_addrlen;
-	u_char  ifi_hdrlen;
-	u_char  ifi_link_state;
-	u_char  ifi_spare_char1;
-	u_char  ifi_spare_char2;
-	u_char  ifi_datalen;
-	u_long  ifi_mtu;
-	u_long  ifi_metric;
-	u_long  ifi_baudrate;
-	u_long  ifi_ipackets;
-	u_long  ifi_ierrors;
-	u_long  ifi_opackets;
-	u_long  ifi_oerrors;
-	u_long  ifi_collisions;
-	u_long  ifi_ibytes;
-	u_long  ifi_obytes;
-	u_long  ifi_imcasts;
-	u_long  ifi_omcasts;
-	u_long  ifi_iqdrops;
-	u_long  ifi_noproto;
-	u_long  ifi_hwassist;
-// FIXME: these are now unions, so maybe need to change definitions?
-#undef ifi_epoch
-	time_t  ifi_epoch;
-#undef ifi_lastchange
-	struct  timeval ifi_lastchange;
-};
-
-// This structure is a duplicate of if_msghdr on FreeBSD 8-STABLE.
-// See /usr/include/net/if.h.
-struct if_msghdr8 {
-	u_short ifm_msglen;
-	u_char  ifm_version;
-	u_char  ifm_type;
-	int     ifm_addrs;
-	int     ifm_flags;
-	u_short ifm_index;
-	struct  if_data8 ifm_data;
-};
-*/
-import "C"
-
-// Machine characteristics
-
-const (
-	SizeofPtr      = C.sizeofPtr
-	SizeofShort    = C.sizeof_short
-	SizeofInt      = C.sizeof_int
-	SizeofLong     = C.sizeof_long
-	SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-const (
-	_statfsVersion = C.STATFS_VERSION
-	_dirblksiz     = C.DIRBLKSIZ
-)
-
-type Stat_t C.struct_stat
-
-type stat_freebsd11_t C.struct_freebsd11_stat
-
-type Statfs_t C.struct_statfs
-
-type statfs_freebsd11_t C.struct_freebsd11_statfs
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-type dirent_freebsd11 C.struct_freebsd11_dirent
-
-type Fsid C.struct_fsid
-
-// File system limits
-
-const (
-	PathMax = C.PATH_MAX
-)
-
-// Advice to Fadvise
-
-const (
-	FADV_NORMAL     = C.POSIX_FADV_NORMAL
-	FADV_RANDOM     = C.POSIX_FADV_RANDOM
-	FADV_SEQUENTIAL = C.POSIX_FADV_SEQUENTIAL
-	FADV_WILLNEED   = C.POSIX_FADV_WILLNEED
-	FADV_DONTNEED   = C.POSIX_FADV_DONTNEED
-	FADV_NOREUSE    = C.POSIX_FADV_NOREUSE
-)
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPMreqn C.struct_ip_mreqn
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
-	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
-	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
-	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
-	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
-	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
-	SizeofLinger           = C.sizeof_struct_linger
-	SizeofIPMreq           = C.sizeof_struct_ip_mreq
-	SizeofIPMreqn          = C.sizeof_struct_ip_mreqn
-	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
-	SizeofMsghdr           = C.sizeof_struct_msghdr
-	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
-	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
-	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
-	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
-	PTRACE_ATTACH     = C.PT_ATTACH
-	PTRACE_CONT       = C.PT_CONTINUE
-	PTRACE_DETACH     = C.PT_DETACH
-	PTRACE_GETFPREGS  = C.PT_GETFPREGS
-	PTRACE_GETFSBASE  = C.PT_GETFSBASE
-	PTRACE_GETLWPLIST = C.PT_GETLWPLIST
-	PTRACE_GETNUMLWPS = C.PT_GETNUMLWPS
-	PTRACE_GETREGS    = C.PT_GETREGS
-	PTRACE_GETXSTATE  = C.PT_GETXSTATE
-	PTRACE_IO         = C.PT_IO
-	PTRACE_KILL       = C.PT_KILL
-	PTRACE_LWPEVENTS  = C.PT_LWP_EVENTS
-	PTRACE_LWPINFO    = C.PT_LWPINFO
-	PTRACE_SETFPREGS  = C.PT_SETFPREGS
-	PTRACE_SETREGS    = C.PT_SETREGS
-	PTRACE_SINGLESTEP = C.PT_STEP
-	PTRACE_TRACEME    = C.PT_TRACE_ME
-)
-
-const (
-	PIOD_READ_D  = C.PIOD_READ_D
-	PIOD_WRITE_D = C.PIOD_WRITE_D
-	PIOD_READ_I  = C.PIOD_READ_I
-	PIOD_WRITE_I = C.PIOD_WRITE_I
-)
-
-const (
-	PL_FLAG_BORN   = C.PL_FLAG_BORN
-	PL_FLAG_EXITED = C.PL_FLAG_EXITED
-	PL_FLAG_SI     = C.PL_FLAG_SI
-)
-
-const (
-	TRAP_BRKPT = C.TRAP_BRKPT
-	TRAP_TRACE = C.TRAP_TRACE
-)
-
-type PtraceLwpInfoStruct C.struct_ptrace_lwpinfo
-
-type __Siginfo C.struct___siginfo
-
-type Sigset_t C.sigset_t
-
-type Reg C.struct_reg
-
-type FpReg C.struct_fpreg
-
-type PtraceIoDesc C.struct_ptrace_io_desc
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent_freebsd11
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
-	sizeofIfMsghdr         = C.sizeof_struct_if_msghdr
-	SizeofIfMsghdr         = C.sizeof_struct_if_msghdr8
-	sizeofIfData           = C.sizeof_struct_if_data
-	SizeofIfData           = C.sizeof_struct_if_data8
-	SizeofIfaMsghdr        = C.sizeof_struct_ifa_msghdr
-	SizeofIfmaMsghdr       = C.sizeof_struct_ifma_msghdr
-	SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
-	SizeofRtMsghdr         = C.sizeof_struct_rt_msghdr
-	SizeofRtMetrics        = C.sizeof_struct_rt_metrics
-)
-
-type ifMsghdr C.struct_if_msghdr
-
-type IfMsghdr C.struct_if_msghdr8
-
-type ifData C.struct_if_data
-
-type IfData C.struct_if_data8
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfmaMsghdr C.struct_ifma_msghdr
-
-type IfAnnounceMsghdr C.struct_if_announcemsghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-// Berkeley packet filter
-
-const (
-	SizeofBpfVersion    = C.sizeof_struct_bpf_version
-	SizeofBpfStat       = C.sizeof_struct_bpf_stat
-	SizeofBpfZbuf       = C.sizeof_struct_bpf_zbuf
-	SizeofBpfProgram    = C.sizeof_struct_bpf_program
-	SizeofBpfInsn       = C.sizeof_struct_bpf_insn
-	SizeofBpfHdr        = C.sizeof_struct_bpf_hdr
-	SizeofBpfZbufHeader = C.sizeof_struct_bpf_zbuf_header
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfZbuf C.struct_bpf_zbuf
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-type BpfZbufHeader C.struct_bpf_zbuf_header
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-// fchmodat-like syscalls.
-
-const (
-	AT_FDCWD            = C.AT_FDCWD
-	AT_REMOVEDIR        = C.AT_REMOVEDIR
-	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
-	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
-	POLLERR      = C.POLLERR
-	POLLHUP      = C.POLLHUP
-	POLLIN       = C.POLLIN
-	POLLINIGNEOF = C.POLLINIGNEOF
-	POLLNVAL     = C.POLLNVAL
-	POLLOUT      = C.POLLOUT
-	POLLPRI      = C.POLLPRI
-	POLLRDBAND   = C.POLLRDBAND
-	POLLRDNORM   = C.POLLRDNORM
-	POLLWRBAND   = C.POLLWRBAND
-	POLLWRNORM   = C.POLLWRNORM
-)
-
-// Capabilities
-
-type CapRights C.struct_cap_rights
-
-// Uname
-
-type Utsname C.struct_utsname
diff --git a/vendor/golang.org/x/sys/unix/types_netbsd.go b/vendor/golang.org/x/sys/unix/types_netbsd.go
deleted file mode 100644
index 4a96d72c3..000000000
--- a/vendor/golang.org/x/sys/unix/types_netbsd.go
+++ /dev/null
@@ -1,290 +0,0 @@
-// Copyright 2009 The Go 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 ignore
-
-/*
-Input to cgo -godefs.  See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define KERNEL
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/sysctl.h>
-#include <sys/time.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
-	struct sockaddr s1;	// this one gets used for fields
-	struct sockaddr_in s2;	// these pad it out
-	struct sockaddr_in6 s3;
-	struct sockaddr_un s4;
-	struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
-	struct sockaddr addr;
-	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
-	SizeofPtr      = C.sizeofPtr
-	SizeofShort    = C.sizeof_short
-	SizeofInt      = C.sizeof_int
-	SizeofLong     = C.sizeof_long
-	SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type Statfs_t C.struct_statfs
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-type Fsid C.fsid_t
-
-// File system limits
-
-const (
-	PathMax = C.PATH_MAX
-)
-
-// Advice to Fadvise
-
-const (
-	FADV_NORMAL     = C.POSIX_FADV_NORMAL
-	FADV_RANDOM     = C.POSIX_FADV_RANDOM
-	FADV_SEQUENTIAL = C.POSIX_FADV_SEQUENTIAL
-	FADV_WILLNEED   = C.POSIX_FADV_WILLNEED
-	FADV_DONTNEED   = C.POSIX_FADV_DONTNEED
-	FADV_NOREUSE    = C.POSIX_FADV_NOREUSE
-)
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
-	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
-	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
-	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
-	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
-	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
-	SizeofLinger           = C.sizeof_struct_linger
-	SizeofIPMreq           = C.sizeof_struct_ip_mreq
-	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
-	SizeofMsghdr           = C.sizeof_struct_msghdr
-	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
-	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
-	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
-	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
-	PTRACE_TRACEME = C.PT_TRACE_ME
-	PTRACE_CONT    = C.PT_CONTINUE
-	PTRACE_KILL    = C.PT_KILL
-)
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
-	SizeofIfMsghdr         = C.sizeof_struct_if_msghdr
-	SizeofIfData           = C.sizeof_struct_if_data
-	SizeofIfaMsghdr        = C.sizeof_struct_ifa_msghdr
-	SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
-	SizeofRtMsghdr         = C.sizeof_struct_rt_msghdr
-	SizeofRtMetrics        = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfAnnounceMsghdr C.struct_if_announcemsghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-type Mclpool C.struct_mclpool
-
-// Berkeley packet filter
-
-const (
-	SizeofBpfVersion = C.sizeof_struct_bpf_version
-	SizeofBpfStat    = C.sizeof_struct_bpf_stat
-	SizeofBpfProgram = C.sizeof_struct_bpf_program
-	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
-	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-type BpfTimeval C.struct_bpf_timeval
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-type Ptmget C.struct_ptmget
-
-// fchmodat-like syscalls.
-
-const (
-	AT_FDCWD            = C.AT_FDCWD
-	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
-	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
-	POLLERR    = C.POLLERR
-	POLLHUP    = C.POLLHUP
-	POLLIN     = C.POLLIN
-	POLLNVAL   = C.POLLNVAL
-	POLLOUT    = C.POLLOUT
-	POLLPRI    = C.POLLPRI
-	POLLRDBAND = C.POLLRDBAND
-	POLLRDNORM = C.POLLRDNORM
-	POLLWRBAND = C.POLLWRBAND
-	POLLWRNORM = C.POLLWRNORM
-)
-
-// Sysctl
-
-type Sysctlnode C.struct_sysctlnode
-
-// Uname
-
-type Utsname C.struct_utsname
-
-// Clockinfo
-
-const SizeofClockinfo = C.sizeof_struct_clockinfo
-
-type Clockinfo C.struct_clockinfo
diff --git a/vendor/golang.org/x/sys/unix/types_openbsd.go b/vendor/golang.org/x/sys/unix/types_openbsd.go
deleted file mode 100644
index 775cb57dc..000000000
--- a/vendor/golang.org/x/sys/unix/types_openbsd.go
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright 2009 The Go 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 ignore
-
-/*
-Input to cgo -godefs.  See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define KERNEL
-#include <dirent.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <sys/event.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/ptrace.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <uvm/uvmexp.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
-	struct sockaddr s1;	// this one gets used for fields
-	struct sockaddr_in s2;	// these pad it out
-	struct sockaddr_in6 s3;
-	struct sockaddr_un s4;
-	struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
-	struct sockaddr addr;
-	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
-	SizeofPtr      = C.sizeofPtr
-	SizeofShort    = C.sizeof_short
-	SizeofInt      = C.sizeof_int
-	SizeofLong     = C.sizeof_long
-	SizeofLongLong = C.sizeof_longlong
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type Statfs_t C.struct_statfs
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-type Fsid C.fsid_t
-
-// File system limits
-
-const (
-	PathMax = C.PATH_MAX
-)
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
-	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
-	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
-	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
-	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
-	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
-	SizeofLinger           = C.sizeof_struct_linger
-	SizeofIPMreq           = C.sizeof_struct_ip_mreq
-	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
-	SizeofMsghdr           = C.sizeof_struct_msghdr
-	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
-	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
-	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
-	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
-)
-
-// Ptrace requests
-
-const (
-	PTRACE_TRACEME = C.PT_TRACE_ME
-	PTRACE_CONT    = C.PT_CONTINUE
-	PTRACE_KILL    = C.PT_KILL
-)
-
-// Events (kqueue, kevent)
-
-type Kevent_t C.struct_kevent
-
-// Select
-
-type FdSet C.fd_set
-
-// Routing and interface messages
-
-const (
-	SizeofIfMsghdr         = C.sizeof_struct_if_msghdr
-	SizeofIfData           = C.sizeof_struct_if_data
-	SizeofIfaMsghdr        = C.sizeof_struct_ifa_msghdr
-	SizeofIfAnnounceMsghdr = C.sizeof_struct_if_announcemsghdr
-	SizeofRtMsghdr         = C.sizeof_struct_rt_msghdr
-	SizeofRtMetrics        = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type IfAnnounceMsghdr C.struct_if_announcemsghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-type Mclpool C.struct_mclpool
-
-// Berkeley packet filter
-
-const (
-	SizeofBpfVersion = C.sizeof_struct_bpf_version
-	SizeofBpfStat    = C.sizeof_struct_bpf_stat
-	SizeofBpfProgram = C.sizeof_struct_bpf_program
-	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
-	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfHdr C.struct_bpf_hdr
-
-type BpfTimeval C.struct_bpf_timeval
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Winsize C.struct_winsize
-
-// fchmodat-like syscalls.
-
-const (
-	AT_FDCWD            = C.AT_FDCWD
-	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
-	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-)
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
-	POLLERR    = C.POLLERR
-	POLLHUP    = C.POLLHUP
-	POLLIN     = C.POLLIN
-	POLLNVAL   = C.POLLNVAL
-	POLLOUT    = C.POLLOUT
-	POLLPRI    = C.POLLPRI
-	POLLRDBAND = C.POLLRDBAND
-	POLLRDNORM = C.POLLRDNORM
-	POLLWRBAND = C.POLLWRBAND
-	POLLWRNORM = C.POLLWRNORM
-)
-
-// Signal Sets
-
-type Sigset_t C.sigset_t
-
-// Uname
-
-type Utsname C.struct_utsname
-
-// Uvmexp
-
-const SizeofUvmexp = C.sizeof_struct_uvmexp
-
-type Uvmexp C.struct_uvmexp
-
-// Clockinfo
-
-const SizeofClockinfo = C.sizeof_struct_clockinfo
-
-type Clockinfo C.struct_clockinfo
diff --git a/vendor/golang.org/x/sys/unix/types_solaris.go b/vendor/golang.org/x/sys/unix/types_solaris.go
deleted file mode 100644
index 2b716f934..000000000
--- a/vendor/golang.org/x/sys/unix/types_solaris.go
+++ /dev/null
@@ -1,266 +0,0 @@
-// Copyright 2009 The Go 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 ignore
-
-/*
-Input to cgo -godefs.  See README.md
-*/
-
-// +godefs map struct_in_addr [4]byte /* in_addr */
-// +godefs map struct_in6_addr [16]byte /* in6_addr */
-
-package unix
-
-/*
-#define KERNEL
-// These defines ensure that builds done on newer versions of Solaris are
-// backwards-compatible with older versions of Solaris and
-// OpenSolaris-based derivatives.
-#define __USE_SUNOS_SOCKETS__          // msghdr
-#define __USE_LEGACY_PROTOTYPES__      // iovec
-#include <dirent.h>
-#include <fcntl.h>
-#include <netdb.h>
-#include <limits.h>
-#include <poll.h>
-#include <signal.h>
-#include <termios.h>
-#include <termio.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/param.h>
-#include <sys/resource.h>
-#include <sys/select.h>
-#include <sys/signal.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/statvfs.h>
-#include <sys/time.h>
-#include <sys/times.h>
-#include <sys/types.h>
-#include <sys/utsname.h>
-#include <sys/un.h>
-#include <sys/wait.h>
-#include <net/bpf.h>
-#include <net/if.h>
-#include <net/if_dl.h>
-#include <net/route.h>
-#include <netinet/in.h>
-#include <netinet/icmp6.h>
-#include <netinet/tcp.h>
-#include <ustat.h>
-#include <utime.h>
-
-enum {
-	sizeofPtr = sizeof(void*),
-};
-
-union sockaddr_all {
-	struct sockaddr s1;	// this one gets used for fields
-	struct sockaddr_in s2;	// these pad it out
-	struct sockaddr_in6 s3;
-	struct sockaddr_un s4;
-	struct sockaddr_dl s5;
-};
-
-struct sockaddr_any {
-	struct sockaddr addr;
-	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
-};
-
-*/
-import "C"
-
-// Machine characteristics
-
-const (
-	SizeofPtr      = C.sizeofPtr
-	SizeofShort    = C.sizeof_short
-	SizeofInt      = C.sizeof_int
-	SizeofLong     = C.sizeof_long
-	SizeofLongLong = C.sizeof_longlong
-	PathMax        = C.PATH_MAX
-	MaxHostNameLen = C.MAXHOSTNAMELEN
-)
-
-// Basic types
-
-type (
-	_C_short     C.short
-	_C_int       C.int
-	_C_long      C.long
-	_C_long_long C.longlong
-)
-
-// Time
-
-type Timespec C.struct_timespec
-
-type Timeval C.struct_timeval
-
-type Timeval32 C.struct_timeval32
-
-type Tms C.struct_tms
-
-type Utimbuf C.struct_utimbuf
-
-// Processes
-
-type Rusage C.struct_rusage
-
-type Rlimit C.struct_rlimit
-
-type _Gid_t C.gid_t
-
-// Files
-
-type Stat_t C.struct_stat
-
-type Flock_t C.struct_flock
-
-type Dirent C.struct_dirent
-
-// Filesystems
-
-type _Fsblkcnt_t C.fsblkcnt_t
-
-type Statvfs_t C.struct_statvfs
-
-// Sockets
-
-type RawSockaddrInet4 C.struct_sockaddr_in
-
-type RawSockaddrInet6 C.struct_sockaddr_in6
-
-type RawSockaddrUnix C.struct_sockaddr_un
-
-type RawSockaddrDatalink C.struct_sockaddr_dl
-
-type RawSockaddr C.struct_sockaddr
-
-type RawSockaddrAny C.struct_sockaddr_any
-
-type _Socklen C.socklen_t
-
-type Linger C.struct_linger
-
-type Iovec C.struct_iovec
-
-type IPMreq C.struct_ip_mreq
-
-type IPv6Mreq C.struct_ipv6_mreq
-
-type Msghdr C.struct_msghdr
-
-type Cmsghdr C.struct_cmsghdr
-
-type Inet6Pktinfo C.struct_in6_pktinfo
-
-type IPv6MTUInfo C.struct_ip6_mtuinfo
-
-type ICMPv6Filter C.struct_icmp6_filter
-
-const (
-	SizeofSockaddrInet4    = C.sizeof_struct_sockaddr_in
-	SizeofSockaddrInet6    = C.sizeof_struct_sockaddr_in6
-	SizeofSockaddrAny      = C.sizeof_struct_sockaddr_any
-	SizeofSockaddrUnix     = C.sizeof_struct_sockaddr_un
-	SizeofSockaddrDatalink = C.sizeof_struct_sockaddr_dl
-	SizeofLinger           = C.sizeof_struct_linger
-	SizeofIPMreq           = C.sizeof_struct_ip_mreq
-	SizeofIPv6Mreq         = C.sizeof_struct_ipv6_mreq
-	SizeofMsghdr           = C.sizeof_struct_msghdr
-	SizeofCmsghdr          = C.sizeof_struct_cmsghdr
-	SizeofInet6Pktinfo     = C.sizeof_struct_in6_pktinfo
-	SizeofIPv6MTUInfo      = C.sizeof_struct_ip6_mtuinfo
-	SizeofICMPv6Filter     = C.sizeof_struct_icmp6_filter
-)
-
-// Select
-
-type FdSet C.fd_set
-
-// Misc
-
-type Utsname C.struct_utsname
-
-type Ustat_t C.struct_ustat
-
-const (
-	AT_FDCWD            = C.AT_FDCWD
-	AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW
-	AT_SYMLINK_FOLLOW   = C.AT_SYMLINK_FOLLOW
-	AT_REMOVEDIR        = C.AT_REMOVEDIR
-	AT_EACCESS          = C.AT_EACCESS
-)
-
-// Routing and interface messages
-
-const (
-	SizeofIfMsghdr  = C.sizeof_struct_if_msghdr
-	SizeofIfData    = C.sizeof_struct_if_data
-	SizeofIfaMsghdr = C.sizeof_struct_ifa_msghdr
-	SizeofRtMsghdr  = C.sizeof_struct_rt_msghdr
-	SizeofRtMetrics = C.sizeof_struct_rt_metrics
-)
-
-type IfMsghdr C.struct_if_msghdr
-
-type IfData C.struct_if_data
-
-type IfaMsghdr C.struct_ifa_msghdr
-
-type RtMsghdr C.struct_rt_msghdr
-
-type RtMetrics C.struct_rt_metrics
-
-// Berkeley packet filter
-
-const (
-	SizeofBpfVersion = C.sizeof_struct_bpf_version
-	SizeofBpfStat    = C.sizeof_struct_bpf_stat
-	SizeofBpfProgram = C.sizeof_struct_bpf_program
-	SizeofBpfInsn    = C.sizeof_struct_bpf_insn
-	SizeofBpfHdr     = C.sizeof_struct_bpf_hdr
-)
-
-type BpfVersion C.struct_bpf_version
-
-type BpfStat C.struct_bpf_stat
-
-type BpfProgram C.struct_bpf_program
-
-type BpfInsn C.struct_bpf_insn
-
-type BpfTimeval C.struct_bpf_timeval
-
-type BpfHdr C.struct_bpf_hdr
-
-// Terminal handling
-
-type Termios C.struct_termios
-
-type Termio C.struct_termio
-
-type Winsize C.struct_winsize
-
-// poll
-
-type PollFd C.struct_pollfd
-
-const (
-	POLLERR    = C.POLLERR
-	POLLHUP    = C.POLLHUP
-	POLLIN     = C.POLLIN
-	POLLNVAL   = C.POLLNVAL
-	POLLOUT    = C.POLLOUT
-	POLLPRI    = C.POLLPRI
-	POLLRDBAND = C.POLLRDBAND
-	POLLRDNORM = C.POLLRDNORM
-	POLLWRBAND = C.POLLWRBAND
-	POLLWRNORM = C.POLLWRNORM
-)
diff --git a/vendor/golang.org/x/text/encoding/charmap/maketables.go b/vendor/golang.org/x/text/encoding/charmap/maketables.go
deleted file mode 100644
index f7941701e..000000000
--- a/vendor/golang.org/x/text/encoding/charmap/maketables.go
+++ /dev/null
@@ -1,556 +0,0 @@
-// Copyright 2013 The Go 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 ignore
-
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"log"
-	"net/http"
-	"sort"
-	"strings"
-	"unicode/utf8"
-
-	"golang.org/x/text/encoding"
-	"golang.org/x/text/internal/gen"
-)
-
-const ascii = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
-	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
-	` !"#$%&'()*+,-./0123456789:;<=>?` +
-	`@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` +
-	"`abcdefghijklmnopqrstuvwxyz{|}~\u007f"
-
-var encodings = []struct {
-	name        string
-	mib         string
-	comment     string
-	varName     string
-	replacement byte
-	mapping     string
-}{
-	{
-		"IBM Code Page 037",
-		"IBM037",
-		"",
-		"CodePage037",
-		0x3f,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM037-2.1.2.ucm",
-	},
-	{
-		"IBM Code Page 437",
-		"PC8CodePage437",
-		"",
-		"CodePage437",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM437-2.1.2.ucm",
-	},
-	{
-		"IBM Code Page 850",
-		"PC850Multilingual",
-		"",
-		"CodePage850",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM850-2.1.2.ucm",
-	},
-	{
-		"IBM Code Page 852",
-		"PCp852",
-		"",
-		"CodePage852",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM852-2.1.2.ucm",
-	},
-	{
-		"IBM Code Page 855",
-		"IBM855",
-		"",
-		"CodePage855",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM855-2.1.2.ucm",
-	},
-	{
-		"Windows Code Page 858", // PC latin1 with Euro
-		"IBM00858",
-		"",
-		"CodePage858",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/windows-858-2000.ucm",
-	},
-	{
-		"IBM Code Page 860",
-		"IBM860",
-		"",
-		"CodePage860",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM860-2.1.2.ucm",
-	},
-	{
-		"IBM Code Page 862",
-		"PC862LatinHebrew",
-		"",
-		"CodePage862",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM862-2.1.2.ucm",
-	},
-	{
-		"IBM Code Page 863",
-		"IBM863",
-		"",
-		"CodePage863",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM863-2.1.2.ucm",
-	},
-	{
-		"IBM Code Page 865",
-		"IBM865",
-		"",
-		"CodePage865",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM865-2.1.2.ucm",
-	},
-	{
-		"IBM Code Page 866",
-		"IBM866",
-		"",
-		"CodePage866",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-ibm866.txt",
-	},
-	{
-		"IBM Code Page 1047",
-		"IBM1047",
-		"",
-		"CodePage1047",
-		0x3f,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/glibc-IBM1047-2.1.2.ucm",
-	},
-	{
-		"IBM Code Page 1140",
-		"IBM01140",
-		"",
-		"CodePage1140",
-		0x3f,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/ibm-1140_P100-1997.ucm",
-	},
-	{
-		"ISO 8859-1",
-		"ISOLatin1",
-		"",
-		"ISO8859_1",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/iso-8859_1-1998.ucm",
-	},
-	{
-		"ISO 8859-2",
-		"ISOLatin2",
-		"",
-		"ISO8859_2",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-2.txt",
-	},
-	{
-		"ISO 8859-3",
-		"ISOLatin3",
-		"",
-		"ISO8859_3",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-3.txt",
-	},
-	{
-		"ISO 8859-4",
-		"ISOLatin4",
-		"",
-		"ISO8859_4",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-4.txt",
-	},
-	{
-		"ISO 8859-5",
-		"ISOLatinCyrillic",
-		"",
-		"ISO8859_5",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-5.txt",
-	},
-	{
-		"ISO 8859-6",
-		"ISOLatinArabic",
-		"",
-		"ISO8859_6,ISO8859_6E,ISO8859_6I",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-6.txt",
-	},
-	{
-		"ISO 8859-7",
-		"ISOLatinGreek",
-		"",
-		"ISO8859_7",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-7.txt",
-	},
-	{
-		"ISO 8859-8",
-		"ISOLatinHebrew",
-		"",
-		"ISO8859_8,ISO8859_8E,ISO8859_8I",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-8.txt",
-	},
-	{
-		"ISO 8859-9",
-		"ISOLatin5",
-		"",
-		"ISO8859_9",
-		encoding.ASCIISub,
-		"http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/iso-8859_9-1999.ucm",
-	},
-	{
-		"ISO 8859-10",
-		"ISOLatin6",
-		"",
-		"ISO8859_10",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-10.txt",
-	},
-	{
-		"ISO 8859-13",
-		"ISO885913",
-		"",
-		"ISO8859_13",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-13.txt",
-	},
-	{
-		"ISO 8859-14",
-		"ISO885914",
-		"",
-		"ISO8859_14",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-14.txt",
-	},
-	{
-		"ISO 8859-15",
-		"ISO885915",
-		"",
-		"ISO8859_15",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-15.txt",
-	},
-	{
-		"ISO 8859-16",
-		"ISO885916",
-		"",
-		"ISO8859_16",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-iso-8859-16.txt",
-	},
-	{
-		"KOI8-R",
-		"KOI8R",
-		"",
-		"KOI8R",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-koi8-r.txt",
-	},
-	{
-		"KOI8-U",
-		"KOI8U",
-		"",
-		"KOI8U",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-koi8-u.txt",
-	},
-	{
-		"Macintosh",
-		"Macintosh",
-		"",
-		"Macintosh",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-macintosh.txt",
-	},
-	{
-		"Macintosh Cyrillic",
-		"MacintoshCyrillic",
-		"",
-		"MacintoshCyrillic",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-x-mac-cyrillic.txt",
-	},
-	{
-		"Windows 874",
-		"Windows874",
-		"",
-		"Windows874",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-874.txt",
-	},
-	{
-		"Windows 1250",
-		"Windows1250",
-		"",
-		"Windows1250",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-1250.txt",
-	},
-	{
-		"Windows 1251",
-		"Windows1251",
-		"",
-		"Windows1251",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-1251.txt",
-	},
-	{
-		"Windows 1252",
-		"Windows1252",
-		"",
-		"Windows1252",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-1252.txt",
-	},
-	{
-		"Windows 1253",
-		"Windows1253",
-		"",
-		"Windows1253",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-1253.txt",
-	},
-	{
-		"Windows 1254",
-		"Windows1254",
-		"",
-		"Windows1254",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-1254.txt",
-	},
-	{
-		"Windows 1255",
-		"Windows1255",
-		"",
-		"Windows1255",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-1255.txt",
-	},
-	{
-		"Windows 1256",
-		"Windows1256",
-		"",
-		"Windows1256",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-1256.txt",
-	},
-	{
-		"Windows 1257",
-		"Windows1257",
-		"",
-		"Windows1257",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-1257.txt",
-	},
-	{
-		"Windows 1258",
-		"Windows1258",
-		"",
-		"Windows1258",
-		encoding.ASCIISub,
-		"http://encoding.spec.whatwg.org/index-windows-1258.txt",
-	},
-	{
-		"X-User-Defined",
-		"XUserDefined",
-		"It is defined at http://encoding.spec.whatwg.org/#x-user-defined",
-		"XUserDefined",
-		encoding.ASCIISub,
-		ascii +
-			"\uf780\uf781\uf782\uf783\uf784\uf785\uf786\uf787" +
-			"\uf788\uf789\uf78a\uf78b\uf78c\uf78d\uf78e\uf78f" +
-			"\uf790\uf791\uf792\uf793\uf794\uf795\uf796\uf797" +
-			"\uf798\uf799\uf79a\uf79b\uf79c\uf79d\uf79e\uf79f" +
-			"\uf7a0\uf7a1\uf7a2\uf7a3\uf7a4\uf7a5\uf7a6\uf7a7" +
-			"\uf7a8\uf7a9\uf7aa\uf7ab\uf7ac\uf7ad\uf7ae\uf7af" +
-			"\uf7b0\uf7b1\uf7b2\uf7b3\uf7b4\uf7b5\uf7b6\uf7b7" +
-			"\uf7b8\uf7b9\uf7ba\uf7bb\uf7bc\uf7bd\uf7be\uf7bf" +
-			"\uf7c0\uf7c1\uf7c2\uf7c3\uf7c4\uf7c5\uf7c6\uf7c7" +
-			"\uf7c8\uf7c9\uf7ca\uf7cb\uf7cc\uf7cd\uf7ce\uf7cf" +
-			"\uf7d0\uf7d1\uf7d2\uf7d3\uf7d4\uf7d5\uf7d6\uf7d7" +
-			"\uf7d8\uf7d9\uf7da\uf7db\uf7dc\uf7dd\uf7de\uf7df" +
-			"\uf7e0\uf7e1\uf7e2\uf7e3\uf7e4\uf7e5\uf7e6\uf7e7" +
-			"\uf7e8\uf7e9\uf7ea\uf7eb\uf7ec\uf7ed\uf7ee\uf7ef" +
-			"\uf7f0\uf7f1\uf7f2\uf7f3\uf7f4\uf7f5\uf7f6\uf7f7" +
-			"\uf7f8\uf7f9\uf7fa\uf7fb\uf7fc\uf7fd\uf7fe\uf7ff",
-	},
-}
-
-func getWHATWG(url string) string {
-	res, err := http.Get(url)
-	if err != nil {
-		log.Fatalf("%q: Get: %v", url, err)
-	}
-	defer res.Body.Close()
-
-	mapping := make([]rune, 128)
-	for i := range mapping {
-		mapping[i] = '\ufffd'
-	}
-
-	scanner := bufio.NewScanner(res.Body)
-	for scanner.Scan() {
-		s := strings.TrimSpace(scanner.Text())
-		if s == "" || s[0] == '#' {
-			continue
-		}
-		x, y := 0, 0
-		if _, err := fmt.Sscanf(s, "%d\t0x%x", &x, &y); err != nil {
-			log.Fatalf("could not parse %q", s)
-		}
-		if x < 0 || 128 <= x {
-			log.Fatalf("code %d is out of range", x)
-		}
-		if 0x80 <= y && y < 0xa0 {
-			// We diverge from the WHATWG spec by mapping control characters
-			// in the range [0x80, 0xa0) to U+FFFD.
-			continue
-		}
-		mapping[x] = rune(y)
-	}
-	return ascii + string(mapping)
-}
-
-func getUCM(url string) string {
-	res, err := http.Get(url)
-	if err != nil {
-		log.Fatalf("%q: Get: %v", url, err)
-	}
-	defer res.Body.Close()
-
-	mapping := make([]rune, 256)
-	for i := range mapping {
-		mapping[i] = '\ufffd'
-	}
-
-	charsFound := 0
-	scanner := bufio.NewScanner(res.Body)
-	for scanner.Scan() {
-		s := strings.TrimSpace(scanner.Text())
-		if s == "" || s[0] == '#' {
-			continue
-		}
-		var c byte
-		var r rune
-		if _, err := fmt.Sscanf(s, `<U%x> \x%x |0`, &r, &c); err != nil {
-			continue
-		}
-		mapping[c] = r
-		charsFound++
-	}
-
-	if charsFound < 200 {
-		log.Fatalf("%q: only %d characters found (wrong page format?)", url, charsFound)
-	}
-
-	return string(mapping)
-}
-
-func main() {
-	mibs := map[string]bool{}
-	all := []string{}
-
-	w := gen.NewCodeWriter()
-	defer w.WriteGoFile("tables.go", "charmap")
-
-	printf := func(s string, a ...interface{}) { fmt.Fprintf(w, s, a...) }
-
-	printf("import (\n")
-	printf("\t\"golang.org/x/text/encoding\"\n")
-	printf("\t\"golang.org/x/text/encoding/internal/identifier\"\n")
-	printf(")\n\n")
-	for _, e := range encodings {
-		varNames := strings.Split(e.varName, ",")
-		all = append(all, varNames...)
-		varName := varNames[0]
-		switch {
-		case strings.HasPrefix(e.mapping, "http://encoding.spec.whatwg.org/"):
-			e.mapping = getWHATWG(e.mapping)
-		case strings.HasPrefix(e.mapping, "http://source.icu-project.org/repos/icu/data/trunk/charset/data/ucm/"):
-			e.mapping = getUCM(e.mapping)
-		}
-
-		asciiSuperset, low := strings.HasPrefix(e.mapping, ascii), 0x00
-		if asciiSuperset {
-			low = 0x80
-		}
-		lvn := 1
-		if strings.HasPrefix(varName, "ISO") || strings.HasPrefix(varName, "KOI") {
-			lvn = 3
-		}
-		lowerVarName := strings.ToLower(varName[:lvn]) + varName[lvn:]
-		printf("// %s is the %s encoding.\n", varName, e.name)
-		if e.comment != "" {
-			printf("//\n// %s\n", e.comment)
-		}
-		printf("var %s *Charmap = &%s\n\nvar %s = Charmap{\nname: %q,\n",
-			varName, lowerVarName, lowerVarName, e.name)
-		if mibs[e.mib] {
-			log.Fatalf("MIB type %q declared multiple times.", e.mib)
-		}
-		printf("mib: identifier.%s,\n", e.mib)
-		printf("asciiSuperset: %t,\n", asciiSuperset)
-		printf("low: 0x%02x,\n", low)
-		printf("replacement: 0x%02x,\n", e.replacement)
-
-		printf("decode: [256]utf8Enc{\n")
-		i, backMapping := 0, map[rune]byte{}
-		for _, c := range e.mapping {
-			if _, ok := backMapping[c]; !ok && c != utf8.RuneError {
-				backMapping[c] = byte(i)
-			}
-			var buf [8]byte
-			n := utf8.EncodeRune(buf[:], c)
-			if n > 3 {
-				panic(fmt.Sprintf("rune %q (%U) is too long", c, c))
-			}
-			printf("{%d,[3]byte{0x%02x,0x%02x,0x%02x}},", n, buf[0], buf[1], buf[2])
-			if i%2 == 1 {
-				printf("\n")
-			}
-			i++
-		}
-		printf("},\n")
-
-		printf("encode: [256]uint32{\n")
-		encode := make([]uint32, 0, 256)
-		for c, i := range backMapping {
-			encode = append(encode, uint32(i)<<24|uint32(c))
-		}
-		sort.Sort(byRune(encode))
-		for len(encode) < cap(encode) {
-			encode = append(encode, encode[len(encode)-1])
-		}
-		for i, enc := range encode {
-			printf("0x%08x,", enc)
-			if i%8 == 7 {
-				printf("\n")
-			}
-		}
-		printf("},\n}\n")
-
-		// Add an estimate of the size of a single Charmap{} struct value, which
-		// includes two 256 elem arrays of 4 bytes and some extra fields, which
-		// align to 3 uint64s on 64-bit architectures.
-		w.Size += 2*4*256 + 3*8
-	}
-	// TODO: add proper line breaking.
-	printf("var listAll = []encoding.Encoding{\n%s,\n}\n\n", strings.Join(all, ",\n"))
-}
-
-type byRune []uint32
-
-func (b byRune) Len() int           { return len(b) }
-func (b byRune) Less(i, j int) bool { return b[i]&0xffffff < b[j]&0xffffff }
-func (b byRune) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/encoding/htmlindex/gen.go b/vendor/golang.org/x/text/encoding/htmlindex/gen.go
deleted file mode 100644
index ac6b4a77f..000000000
--- a/vendor/golang.org/x/text/encoding/htmlindex/gen.go
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright 2015 The Go 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 ignore
-
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"log"
-	"strings"
-
-	"golang.org/x/text/internal/gen"
-)
-
-type group struct {
-	Encodings []struct {
-		Labels []string
-		Name   string
-	}
-}
-
-func main() {
-	gen.Init()
-
-	r := gen.Open("https://encoding.spec.whatwg.org", "whatwg", "encodings.json")
-	var groups []group
-	if err := json.NewDecoder(r).Decode(&groups); err != nil {
-		log.Fatalf("Error reading encodings.json: %v", err)
-	}
-
-	w := &bytes.Buffer{}
-	fmt.Fprintln(w, "type htmlEncoding byte")
-	fmt.Fprintln(w, "const (")
-	for i, g := range groups {
-		for _, e := range g.Encodings {
-			key := strings.ToLower(e.Name)
-			name := consts[key]
-			if name == "" {
-				log.Fatalf("No const defined for %s.", key)
-			}
-			if i == 0 {
-				fmt.Fprintf(w, "%s htmlEncoding = iota\n", name)
-			} else {
-				fmt.Fprintf(w, "%s\n", name)
-			}
-		}
-	}
-	fmt.Fprintln(w, "numEncodings")
-	fmt.Fprint(w, ")\n\n")
-
-	fmt.Fprintln(w, "var canonical = [numEncodings]string{")
-	for _, g := range groups {
-		for _, e := range g.Encodings {
-			fmt.Fprintf(w, "%q,\n", strings.ToLower(e.Name))
-		}
-	}
-	fmt.Fprint(w, "}\n\n")
-
-	fmt.Fprintln(w, "var nameMap = map[string]htmlEncoding{")
-	for _, g := range groups {
-		for _, e := range g.Encodings {
-			for _, l := range e.Labels {
-				key := strings.ToLower(e.Name)
-				name := consts[key]
-				fmt.Fprintf(w, "%q: %s,\n", l, name)
-			}
-		}
-	}
-	fmt.Fprint(w, "}\n\n")
-
-	var tags []string
-	fmt.Fprintln(w, "var localeMap = []htmlEncoding{")
-	for _, loc := range locales {
-		tags = append(tags, loc.tag)
-		fmt.Fprintf(w, "%s, // %s \n", consts[loc.name], loc.tag)
-	}
-	fmt.Fprint(w, "}\n\n")
-
-	fmt.Fprintf(w, "const locales = %q\n", strings.Join(tags, " "))
-
-	gen.WriteGoFile("tables.go", "htmlindex", w.Bytes())
-}
-
-// consts maps canonical encoding name to internal constant.
-var consts = map[string]string{
-	"utf-8":          "utf8",
-	"ibm866":         "ibm866",
-	"iso-8859-2":     "iso8859_2",
-	"iso-8859-3":     "iso8859_3",
-	"iso-8859-4":     "iso8859_4",
-	"iso-8859-5":     "iso8859_5",
-	"iso-8859-6":     "iso8859_6",
-	"iso-8859-7":     "iso8859_7",
-	"iso-8859-8":     "iso8859_8",
-	"iso-8859-8-i":   "iso8859_8I",
-	"iso-8859-10":    "iso8859_10",
-	"iso-8859-13":    "iso8859_13",
-	"iso-8859-14":    "iso8859_14",
-	"iso-8859-15":    "iso8859_15",
-	"iso-8859-16":    "iso8859_16",
-	"koi8-r":         "koi8r",
-	"koi8-u":         "koi8u",
-	"macintosh":      "macintosh",
-	"windows-874":    "windows874",
-	"windows-1250":   "windows1250",
-	"windows-1251":   "windows1251",
-	"windows-1252":   "windows1252",
-	"windows-1253":   "windows1253",
-	"windows-1254":   "windows1254",
-	"windows-1255":   "windows1255",
-	"windows-1256":   "windows1256",
-	"windows-1257":   "windows1257",
-	"windows-1258":   "windows1258",
-	"x-mac-cyrillic": "macintoshCyrillic",
-	"gbk":            "gbk",
-	"gb18030":        "gb18030",
-	// "hz-gb-2312":     "hzgb2312", // Was removed from WhatWG
-	"big5":           "big5",
-	"euc-jp":         "eucjp",
-	"iso-2022-jp":    "iso2022jp",
-	"shift_jis":      "shiftJIS",
-	"euc-kr":         "euckr",
-	"replacement":    "replacement",
-	"utf-16be":       "utf16be",
-	"utf-16le":       "utf16le",
-	"x-user-defined": "xUserDefined",
-}
-
-// locales is taken from
-// https://html.spec.whatwg.org/multipage/syntax.html#encoding-sniffing-algorithm.
-var locales = []struct{ tag, name string }{
-	// The default value. Explicitly state latin to benefit from the exact
-	// script option, while still making 1252 the default encoding for languages
-	// written in Latin script.
-	{"und_Latn", "windows-1252"},
-	{"ar", "windows-1256"},
-	{"ba", "windows-1251"},
-	{"be", "windows-1251"},
-	{"bg", "windows-1251"},
-	{"cs", "windows-1250"},
-	{"el", "iso-8859-7"},
-	{"et", "windows-1257"},
-	{"fa", "windows-1256"},
-	{"he", "windows-1255"},
-	{"hr", "windows-1250"},
-	{"hu", "iso-8859-2"},
-	{"ja", "shift_jis"},
-	{"kk", "windows-1251"},
-	{"ko", "euc-kr"},
-	{"ku", "windows-1254"},
-	{"ky", "windows-1251"},
-	{"lt", "windows-1257"},
-	{"lv", "windows-1257"},
-	{"mk", "windows-1251"},
-	{"pl", "iso-8859-2"},
-	{"ru", "windows-1251"},
-	{"sah", "windows-1251"},
-	{"sk", "windows-1250"},
-	{"sl", "iso-8859-2"},
-	{"sr", "windows-1251"},
-	{"tg", "windows-1251"},
-	{"th", "windows-874"},
-	{"tr", "windows-1254"},
-	{"tt", "windows-1251"},
-	{"uk", "windows-1251"},
-	{"vi", "windows-1258"},
-	{"zh-hans", "gb18030"},
-	{"zh-hant", "big5"},
-}
diff --git a/vendor/golang.org/x/text/encoding/internal/identifier/gen.go b/vendor/golang.org/x/text/encoding/internal/identifier/gen.go
deleted file mode 100644
index 26cfef9c6..000000000
--- a/vendor/golang.org/x/text/encoding/internal/identifier/gen.go
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright 2015 The Go 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 ignore
-
-package main
-
-import (
-	"bytes"
-	"encoding/xml"
-	"fmt"
-	"io"
-	"log"
-	"strings"
-
-	"golang.org/x/text/internal/gen"
-)
-
-type registry struct {
-	XMLName  xml.Name `xml:"registry"`
-	Updated  string   `xml:"updated"`
-	Registry []struct {
-		ID     string `xml:"id,attr"`
-		Record []struct {
-			Name string `xml:"name"`
-			Xref []struct {
-				Type string `xml:"type,attr"`
-				Data string `xml:"data,attr"`
-			} `xml:"xref"`
-			Desc struct {
-				Data string `xml:",innerxml"`
-				// Any []struct {
-				// 	Data string `xml:",chardata"`
-				// } `xml:",any"`
-				// Data string `xml:",chardata"`
-			} `xml:"description,"`
-			MIB   string   `xml:"value"`
-			Alias []string `xml:"alias"`
-			MIME  string   `xml:"preferred_alias"`
-		} `xml:"record"`
-	} `xml:"registry"`
-}
-
-func main() {
-	r := gen.OpenIANAFile("assignments/character-sets/character-sets.xml")
-	reg := &registry{}
-	if err := xml.NewDecoder(r).Decode(&reg); err != nil && err != io.EOF {
-		log.Fatalf("Error decoding charset registry: %v", err)
-	}
-	if len(reg.Registry) == 0 || reg.Registry[0].ID != "character-sets-1" {
-		log.Fatalf("Unexpected ID %s", reg.Registry[0].ID)
-	}
-
-	w := &bytes.Buffer{}
-	fmt.Fprintf(w, "const (\n")
-	for _, rec := range reg.Registry[0].Record {
-		constName := ""
-		for _, a := range rec.Alias {
-			if strings.HasPrefix(a, "cs") && strings.IndexByte(a, '-') == -1 {
-				// Some of the constant definitions have comments in them. Strip those.
-				constName = strings.Title(strings.SplitN(a[2:], "\n", 2)[0])
-			}
-		}
-		if constName == "" {
-			switch rec.MIB {
-			case "2085":
-				constName = "HZGB2312" // Not listed as alias for some reason.
-			default:
-				log.Fatalf("No cs alias defined for %s.", rec.MIB)
-			}
-		}
-		if rec.MIME != "" {
-			rec.MIME = fmt.Sprintf(" (MIME: %s)", rec.MIME)
-		}
-		fmt.Fprintf(w, "// %s is the MIB identifier with IANA name %s%s.\n//\n", constName, rec.Name, rec.MIME)
-		if len(rec.Desc.Data) > 0 {
-			fmt.Fprint(w, "// ")
-			d := xml.NewDecoder(strings.NewReader(rec.Desc.Data))
-			inElem := true
-			attr := ""
-			for {
-				t, err := d.Token()
-				if err != nil {
-					if err != io.EOF {
-						log.Fatal(err)
-					}
-					break
-				}
-				switch x := t.(type) {
-				case xml.CharData:
-					attr = "" // Don't need attribute info.
-					a := bytes.Split([]byte(x), []byte("\n"))
-					for i, b := range a {
-						if b = bytes.TrimSpace(b); len(b) != 0 {
-							if !inElem && i > 0 {
-								fmt.Fprint(w, "\n// ")
-							}
-							inElem = false
-							fmt.Fprintf(w, "%s ", string(b))
-						}
-					}
-				case xml.StartElement:
-					if x.Name.Local == "xref" {
-						inElem = true
-						use := false
-						for _, a := range x.Attr {
-							if a.Name.Local == "type" {
-								use = use || a.Value != "person"
-							}
-							if a.Name.Local == "data" && use {
-								// Patch up URLs to use https. From some links, the
-								// https version is different from the http one.
-								s := a.Value
-								s = strings.Replace(s, "http://", "https://", -1)
-								s = strings.Replace(s, "/unicode/", "/", -1)
-								attr = s + " "
-							}
-						}
-					}
-				case xml.EndElement:
-					inElem = false
-					fmt.Fprint(w, attr)
-				}
-			}
-			fmt.Fprint(w, "\n")
-		}
-		for _, x := range rec.Xref {
-			switch x.Type {
-			case "rfc":
-				fmt.Fprintf(w, "// Reference: %s\n", strings.ToUpper(x.Data))
-			case "uri":
-				fmt.Fprintf(w, "// Reference: %s\n", x.Data)
-			}
-		}
-		fmt.Fprintf(w, "%s MIB = %s\n", constName, rec.MIB)
-		fmt.Fprintln(w)
-	}
-	fmt.Fprintln(w, ")")
-
-	gen.WriteGoFile("mib.go", "identifier", w.Bytes())
-}
diff --git a/vendor/golang.org/x/text/encoding/japanese/maketables.go b/vendor/golang.org/x/text/encoding/japanese/maketables.go
deleted file mode 100644
index 023957a67..000000000
--- a/vendor/golang.org/x/text/encoding/japanese/maketables.go
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright 2013 The Go 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 ignore
-
-package main
-
-// This program generates tables.go:
-//	go run maketables.go | gofmt > tables.go
-
-// TODO: Emoji extensions?
-// https://www.unicode.org/faq/emoji_dingbats.html
-// https://www.unicode.org/Public/UNIDATA/EmojiSources.txt
-
-import (
-	"bufio"
-	"fmt"
-	"log"
-	"net/http"
-	"sort"
-	"strings"
-)
-
-type entry struct {
-	jisCode, table int
-}
-
-func main() {
-	fmt.Printf("// generated by go run maketables.go; DO NOT EDIT\n\n")
-	fmt.Printf("// Package japanese provides Japanese encodings such as EUC-JP and Shift JIS.\n")
-	fmt.Printf(`package japanese // import "golang.org/x/text/encoding/japanese"` + "\n\n")
-
-	reverse := [65536]entry{}
-	for i := range reverse {
-		reverse[i].table = -1
-	}
-
-	tables := []struct {
-		url  string
-		name string
-	}{
-		{"http://encoding.spec.whatwg.org/index-jis0208.txt", "0208"},
-		{"http://encoding.spec.whatwg.org/index-jis0212.txt", "0212"},
-	}
-	for i, table := range tables {
-		res, err := http.Get(table.url)
-		if err != nil {
-			log.Fatalf("%q: Get: %v", table.url, err)
-		}
-		defer res.Body.Close()
-
-		mapping := [65536]uint16{}
-
-		scanner := bufio.NewScanner(res.Body)
-		for scanner.Scan() {
-			s := strings.TrimSpace(scanner.Text())
-			if s == "" || s[0] == '#' {
-				continue
-			}
-			x, y := 0, uint16(0)
-			if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
-				log.Fatalf("%q: could not parse %q", table.url, s)
-			}
-			if x < 0 || 120*94 <= x {
-				log.Fatalf("%q: JIS code %d is out of range", table.url, x)
-			}
-			mapping[x] = y
-			if reverse[y].table == -1 {
-				reverse[y] = entry{jisCode: x, table: i}
-			}
-		}
-		if err := scanner.Err(); err != nil {
-			log.Fatalf("%q: scanner error: %v", table.url, err)
-		}
-
-		fmt.Printf("// jis%sDecode is the decoding table from JIS %s code to Unicode.\n// It is defined at %s\n",
-			table.name, table.name, table.url)
-		fmt.Printf("var jis%sDecode = [...]uint16{\n", table.name)
-		for i, m := range mapping {
-			if m != 0 {
-				fmt.Printf("\t%d: 0x%04X,\n", i, m)
-			}
-		}
-		fmt.Printf("}\n\n")
-	}
-
-	// Any run of at least separation continuous zero entries in the reverse map will
-	// be a separate encode table.
-	const separation = 1024
-
-	intervals := []interval(nil)
-	low, high := -1, -1
-	for i, v := range reverse {
-		if v.table == -1 {
-			continue
-		}
-		if low < 0 {
-			low = i
-		} else if i-high >= separation {
-			if high >= 0 {
-				intervals = append(intervals, interval{low, high})
-			}
-			low = i
-		}
-		high = i + 1
-	}
-	if high >= 0 {
-		intervals = append(intervals, interval{low, high})
-	}
-	sort.Sort(byDecreasingLength(intervals))
-
-	fmt.Printf("const (\n")
-	fmt.Printf("\tjis0208    = 1\n")
-	fmt.Printf("\tjis0212    = 2\n")
-	fmt.Printf("\tcodeMask   = 0x7f\n")
-	fmt.Printf("\tcodeShift  = 7\n")
-	fmt.Printf("\ttableShift = 14\n")
-	fmt.Printf(")\n\n")
-
-	fmt.Printf("const numEncodeTables = %d\n\n", len(intervals))
-	fmt.Printf("// encodeX are the encoding tables from Unicode to JIS code,\n")
-	fmt.Printf("// sorted by decreasing length.\n")
-	for i, v := range intervals {
-		fmt.Printf("// encode%d: %5d entries for runes in [%5d, %5d).\n", i, v.len(), v.low, v.high)
-	}
-	fmt.Printf("//\n")
-	fmt.Printf("// The high two bits of the value record whether the JIS code comes from the\n")
-	fmt.Printf("// JIS0208 table (high bits == 1) or the JIS0212 table (high bits == 2).\n")
-	fmt.Printf("// The low 14 bits are two 7-bit unsigned integers j1 and j2 that form the\n")
-	fmt.Printf("// JIS code (94*j1 + j2) within that table.\n")
-	fmt.Printf("\n")
-
-	for i, v := range intervals {
-		fmt.Printf("const encode%dLow, encode%dHigh = %d, %d\n\n", i, i, v.low, v.high)
-		fmt.Printf("var encode%d = [...]uint16{\n", i)
-		for j := v.low; j < v.high; j++ {
-			x := reverse[j]
-			if x.table == -1 {
-				continue
-			}
-			fmt.Printf("\t%d - %d: jis%s<<14 | 0x%02X<<7 | 0x%02X,\n",
-				j, v.low, tables[x.table].name, x.jisCode/94, x.jisCode%94)
-		}
-		fmt.Printf("}\n\n")
-	}
-}
-
-// interval is a half-open interval [low, high).
-type interval struct {
-	low, high int
-}
-
-func (i interval) len() int { return i.high - i.low }
-
-// byDecreasingLength sorts intervals by decreasing length.
-type byDecreasingLength []interval
-
-func (b byDecreasingLength) Len() int           { return len(b) }
-func (b byDecreasingLength) Less(i, j int) bool { return b[i].len() > b[j].len() }
-func (b byDecreasingLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/encoding/korean/maketables.go b/vendor/golang.org/x/text/encoding/korean/maketables.go
deleted file mode 100644
index c84034fb6..000000000
--- a/vendor/golang.org/x/text/encoding/korean/maketables.go
+++ /dev/null
@@ -1,143 +0,0 @@
-// Copyright 2013 The Go 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 ignore
-
-package main
-
-// This program generates tables.go:
-//	go run maketables.go | gofmt > tables.go
-
-import (
-	"bufio"
-	"fmt"
-	"log"
-	"net/http"
-	"sort"
-	"strings"
-)
-
-func main() {
-	fmt.Printf("// generated by go run maketables.go; DO NOT EDIT\n\n")
-	fmt.Printf("// Package korean provides Korean encodings such as EUC-KR.\n")
-	fmt.Printf(`package korean // import "golang.org/x/text/encoding/korean"` + "\n\n")
-
-	res, err := http.Get("http://encoding.spec.whatwg.org/index-euc-kr.txt")
-	if err != nil {
-		log.Fatalf("Get: %v", err)
-	}
-	defer res.Body.Close()
-
-	mapping := [65536]uint16{}
-	reverse := [65536]uint16{}
-
-	scanner := bufio.NewScanner(res.Body)
-	for scanner.Scan() {
-		s := strings.TrimSpace(scanner.Text())
-		if s == "" || s[0] == '#' {
-			continue
-		}
-		x, y := uint16(0), uint16(0)
-		if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
-			log.Fatalf("could not parse %q", s)
-		}
-		if x < 0 || 178*(0xc7-0x81)+(0xfe-0xc7)*94+(0xff-0xa1) <= x {
-			log.Fatalf("EUC-KR code %d is out of range", x)
-		}
-		mapping[x] = y
-		if reverse[y] == 0 {
-			c0, c1 := uint16(0), uint16(0)
-			if x < 178*(0xc7-0x81) {
-				c0 = uint16(x/178) + 0x81
-				c1 = uint16(x % 178)
-				switch {
-				case c1 < 1*26:
-					c1 += 0x41
-				case c1 < 2*26:
-					c1 += 0x47
-				default:
-					c1 += 0x4d
-				}
-			} else {
-				x -= 178 * (0xc7 - 0x81)
-				c0 = uint16(x/94) + 0xc7
-				c1 = uint16(x%94) + 0xa1
-			}
-			reverse[y] = c0<<8 | c1
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		log.Fatalf("scanner error: %v", err)
-	}
-
-	fmt.Printf("// decode is the decoding table from EUC-KR code to Unicode.\n")
-	fmt.Printf("// It is defined at http://encoding.spec.whatwg.org/index-euc-kr.txt\n")
-	fmt.Printf("var decode = [...]uint16{\n")
-	for i, v := range mapping {
-		if v != 0 {
-			fmt.Printf("\t%d: 0x%04X,\n", i, v)
-		}
-	}
-	fmt.Printf("}\n\n")
-
-	// Any run of at least separation continuous zero entries in the reverse map will
-	// be a separate encode table.
-	const separation = 1024
-
-	intervals := []interval(nil)
-	low, high := -1, -1
-	for i, v := range reverse {
-		if v == 0 {
-			continue
-		}
-		if low < 0 {
-			low = i
-		} else if i-high >= separation {
-			if high >= 0 {
-				intervals = append(intervals, interval{low, high})
-			}
-			low = i
-		}
-		high = i + 1
-	}
-	if high >= 0 {
-		intervals = append(intervals, interval{low, high})
-	}
-	sort.Sort(byDecreasingLength(intervals))
-
-	fmt.Printf("const numEncodeTables = %d\n\n", len(intervals))
-	fmt.Printf("// encodeX are the encoding tables from Unicode to EUC-KR code,\n")
-	fmt.Printf("// sorted by decreasing length.\n")
-	for i, v := range intervals {
-		fmt.Printf("// encode%d: %5d entries for runes in [%5d, %5d).\n", i, v.len(), v.low, v.high)
-	}
-	fmt.Printf("\n")
-
-	for i, v := range intervals {
-		fmt.Printf("const encode%dLow, encode%dHigh = %d, %d\n\n", i, i, v.low, v.high)
-		fmt.Printf("var encode%d = [...]uint16{\n", i)
-		for j := v.low; j < v.high; j++ {
-			x := reverse[j]
-			if x == 0 {
-				continue
-			}
-			fmt.Printf("\t%d-%d: 0x%04X,\n", j, v.low, x)
-		}
-		fmt.Printf("}\n\n")
-	}
-}
-
-// interval is a half-open interval [low, high).
-type interval struct {
-	low, high int
-}
-
-func (i interval) len() int { return i.high - i.low }
-
-// byDecreasingLength sorts intervals by decreasing length.
-type byDecreasingLength []interval
-
-func (b byDecreasingLength) Len() int           { return len(b) }
-func (b byDecreasingLength) Less(i, j int) bool { return b[i].len() > b[j].len() }
-func (b byDecreasingLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/encoding/simplifiedchinese/maketables.go b/vendor/golang.org/x/text/encoding/simplifiedchinese/maketables.go
deleted file mode 100644
index 55016c786..000000000
--- a/vendor/golang.org/x/text/encoding/simplifiedchinese/maketables.go
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright 2013 The Go 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 ignore
-
-package main
-
-// This program generates tables.go:
-//	go run maketables.go | gofmt > tables.go
-
-import (
-	"bufio"
-	"fmt"
-	"log"
-	"net/http"
-	"sort"
-	"strings"
-)
-
-func main() {
-	fmt.Printf("// generated by go run maketables.go; DO NOT EDIT\n\n")
-	fmt.Printf("// Package simplifiedchinese provides Simplified Chinese encodings such as GBK.\n")
-	fmt.Printf(`package simplifiedchinese // import "golang.org/x/text/encoding/simplifiedchinese"` + "\n\n")
-
-	printGB18030()
-	printGBK()
-}
-
-func printGB18030() {
-	res, err := http.Get("http://encoding.spec.whatwg.org/index-gb18030.txt")
-	if err != nil {
-		log.Fatalf("Get: %v", err)
-	}
-	defer res.Body.Close()
-
-	fmt.Printf("// gb18030 is the table from http://encoding.spec.whatwg.org/index-gb18030.txt\n")
-	fmt.Printf("var gb18030 = [...][2]uint16{\n")
-	scanner := bufio.NewScanner(res.Body)
-	for scanner.Scan() {
-		s := strings.TrimSpace(scanner.Text())
-		if s == "" || s[0] == '#' {
-			continue
-		}
-		x, y := uint32(0), uint32(0)
-		if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
-			log.Fatalf("could not parse %q", s)
-		}
-		if x < 0x10000 && y < 0x10000 {
-			fmt.Printf("\t{0x%04x, 0x%04x},\n", x, y)
-		}
-	}
-	fmt.Printf("}\n\n")
-}
-
-func printGBK() {
-	res, err := http.Get("http://encoding.spec.whatwg.org/index-gbk.txt")
-	if err != nil {
-		log.Fatalf("Get: %v", err)
-	}
-	defer res.Body.Close()
-
-	mapping := [65536]uint16{}
-	reverse := [65536]uint16{}
-
-	scanner := bufio.NewScanner(res.Body)
-	for scanner.Scan() {
-		s := strings.TrimSpace(scanner.Text())
-		if s == "" || s[0] == '#' {
-			continue
-		}
-		x, y := uint16(0), uint16(0)
-		if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
-			log.Fatalf("could not parse %q", s)
-		}
-		if x < 0 || 126*190 <= x {
-			log.Fatalf("GBK code %d is out of range", x)
-		}
-		mapping[x] = y
-		if reverse[y] == 0 {
-			c0, c1 := x/190, x%190
-			if c1 >= 0x3f {
-				c1++
-			}
-			reverse[y] = (0x81+c0)<<8 | (0x40 + c1)
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		log.Fatalf("scanner error: %v", err)
-	}
-
-	fmt.Printf("// decode is the decoding table from GBK code to Unicode.\n")
-	fmt.Printf("// It is defined at http://encoding.spec.whatwg.org/index-gbk.txt\n")
-	fmt.Printf("var decode = [...]uint16{\n")
-	for i, v := range mapping {
-		if v != 0 {
-			fmt.Printf("\t%d: 0x%04X,\n", i, v)
-		}
-	}
-	fmt.Printf("}\n\n")
-
-	// Any run of at least separation continuous zero entries in the reverse map will
-	// be a separate encode table.
-	const separation = 1024
-
-	intervals := []interval(nil)
-	low, high := -1, -1
-	for i, v := range reverse {
-		if v == 0 {
-			continue
-		}
-		if low < 0 {
-			low = i
-		} else if i-high >= separation {
-			if high >= 0 {
-				intervals = append(intervals, interval{low, high})
-			}
-			low = i
-		}
-		high = i + 1
-	}
-	if high >= 0 {
-		intervals = append(intervals, interval{low, high})
-	}
-	sort.Sort(byDecreasingLength(intervals))
-
-	fmt.Printf("const numEncodeTables = %d\n\n", len(intervals))
-	fmt.Printf("// encodeX are the encoding tables from Unicode to GBK code,\n")
-	fmt.Printf("// sorted by decreasing length.\n")
-	for i, v := range intervals {
-		fmt.Printf("// encode%d: %5d entries for runes in [%5d, %5d).\n", i, v.len(), v.low, v.high)
-	}
-	fmt.Printf("\n")
-
-	for i, v := range intervals {
-		fmt.Printf("const encode%dLow, encode%dHigh = %d, %d\n\n", i, i, v.low, v.high)
-		fmt.Printf("var encode%d = [...]uint16{\n", i)
-		for j := v.low; j < v.high; j++ {
-			x := reverse[j]
-			if x == 0 {
-				continue
-			}
-			fmt.Printf("\t%d-%d: 0x%04X,\n", j, v.low, x)
-		}
-		fmt.Printf("}\n\n")
-	}
-}
-
-// interval is a half-open interval [low, high).
-type interval struct {
-	low, high int
-}
-
-func (i interval) len() int { return i.high - i.low }
-
-// byDecreasingLength sorts intervals by decreasing length.
-type byDecreasingLength []interval
-
-func (b byDecreasingLength) Len() int           { return len(b) }
-func (b byDecreasingLength) Less(i, j int) bool { return b[i].len() > b[j].len() }
-func (b byDecreasingLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/encoding/traditionalchinese/maketables.go b/vendor/golang.org/x/text/encoding/traditionalchinese/maketables.go
deleted file mode 100644
index cf7fdb31a..000000000
--- a/vendor/golang.org/x/text/encoding/traditionalchinese/maketables.go
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright 2013 The Go 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 ignore
-
-package main
-
-// This program generates tables.go:
-//	go run maketables.go | gofmt > tables.go
-
-import (
-	"bufio"
-	"fmt"
-	"log"
-	"net/http"
-	"sort"
-	"strings"
-)
-
-func main() {
-	fmt.Printf("// generated by go run maketables.go; DO NOT EDIT\n\n")
-	fmt.Printf("// Package traditionalchinese provides Traditional Chinese encodings such as Big5.\n")
-	fmt.Printf(`package traditionalchinese // import "golang.org/x/text/encoding/traditionalchinese"` + "\n\n")
-
-	res, err := http.Get("http://encoding.spec.whatwg.org/index-big5.txt")
-	if err != nil {
-		log.Fatalf("Get: %v", err)
-	}
-	defer res.Body.Close()
-
-	mapping := [65536]uint32{}
-	reverse := [65536 * 4]uint16{}
-
-	scanner := bufio.NewScanner(res.Body)
-	for scanner.Scan() {
-		s := strings.TrimSpace(scanner.Text())
-		if s == "" || s[0] == '#' {
-			continue
-		}
-		x, y := uint16(0), uint32(0)
-		if _, err := fmt.Sscanf(s, "%d 0x%x", &x, &y); err != nil {
-			log.Fatalf("could not parse %q", s)
-		}
-		if x < 0 || 126*157 <= x {
-			log.Fatalf("Big5 code %d is out of range", x)
-		}
-		mapping[x] = y
-
-		// The WHATWG spec http://encoding.spec.whatwg.org/#indexes says that
-		// "The index pointer for code point in index is the first pointer
-		// corresponding to code point in index", which would normally mean
-		// that the code below should be guarded by "if reverse[y] == 0", but
-		// last instead of first seems to match the behavior of
-		// "iconv -f UTF-8 -t BIG5". For example, U+8005 者 occurs twice in
-		// http://encoding.spec.whatwg.org/index-big5.txt, as index 2148
-		// (encoded as "\x8e\xcd") and index 6543 (encoded as "\xaa\xcc")
-		// and "echo 者 | iconv -f UTF-8 -t BIG5 | xxd" gives "\xaa\xcc".
-		c0, c1 := x/157, x%157
-		if c1 < 0x3f {
-			c1 += 0x40
-		} else {
-			c1 += 0x62
-		}
-		reverse[y] = (0x81+c0)<<8 | c1
-	}
-	if err := scanner.Err(); err != nil {
-		log.Fatalf("scanner error: %v", err)
-	}
-
-	fmt.Printf("// decode is the decoding table from Big5 code to Unicode.\n")
-	fmt.Printf("// It is defined at http://encoding.spec.whatwg.org/index-big5.txt\n")
-	fmt.Printf("var decode = [...]uint32{\n")
-	for i, v := range mapping {
-		if v != 0 {
-			fmt.Printf("\t%d: 0x%08X,\n", i, v)
-		}
-	}
-	fmt.Printf("}\n\n")
-
-	// Any run of at least separation continuous zero entries in the reverse map will
-	// be a separate encode table.
-	const separation = 1024
-
-	intervals := []interval(nil)
-	low, high := -1, -1
-	for i, v := range reverse {
-		if v == 0 {
-			continue
-		}
-		if low < 0 {
-			low = i
-		} else if i-high >= separation {
-			if high >= 0 {
-				intervals = append(intervals, interval{low, high})
-			}
-			low = i
-		}
-		high = i + 1
-	}
-	if high >= 0 {
-		intervals = append(intervals, interval{low, high})
-	}
-	sort.Sort(byDecreasingLength(intervals))
-
-	fmt.Printf("const numEncodeTables = %d\n\n", len(intervals))
-	fmt.Printf("// encodeX are the encoding tables from Unicode to Big5 code,\n")
-	fmt.Printf("// sorted by decreasing length.\n")
-	for i, v := range intervals {
-		fmt.Printf("// encode%d: %5d entries for runes in [%6d, %6d).\n", i, v.len(), v.low, v.high)
-	}
-	fmt.Printf("\n")
-
-	for i, v := range intervals {
-		fmt.Printf("const encode%dLow, encode%dHigh = %d, %d\n\n", i, i, v.low, v.high)
-		fmt.Printf("var encode%d = [...]uint16{\n", i)
-		for j := v.low; j < v.high; j++ {
-			x := reverse[j]
-			if x == 0 {
-				continue
-			}
-			fmt.Printf("\t%d-%d: 0x%04X,\n", j, v.low, x)
-		}
-		fmt.Printf("}\n\n")
-	}
-}
-
-// interval is a half-open interval [low, high).
-type interval struct {
-	low, high int
-}
-
-func (i interval) len() int { return i.high - i.low }
-
-// byDecreasingLength sorts intervals by decreasing length.
-type byDecreasingLength []interval
-
-func (b byDecreasingLength) Len() int           { return len(b) }
-func (b byDecreasingLength) Less(i, j int) bool { return b[i].len() > b[j].len() }
-func (b byDecreasingLength) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
diff --git a/vendor/golang.org/x/text/internal/language/compact/gen.go b/vendor/golang.org/x/text/internal/language/compact/gen.go
deleted file mode 100644
index 0c36a052f..000000000
--- a/vendor/golang.org/x/text/internal/language/compact/gen.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2013 The Go 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 ignore
-
-// Language tag table generator.
-// Data read from the web.
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-
-	"golang.org/x/text/internal/gen"
-	"golang.org/x/text/unicode/cldr"
-)
-
-var (
-	test = flag.Bool("test",
-		false,
-		"test existing tables; can be used to compare web data with package data.")
-	outputFile = flag.String("output",
-		"tables.go",
-		"output file for generated tables")
-)
-
-func main() {
-	gen.Init()
-
-	w := gen.NewCodeWriter()
-	defer w.WriteGoFile("tables.go", "compact")
-
-	fmt.Fprintln(w, `import "golang.org/x/text/internal/language"`)
-
-	b := newBuilder(w)
-	gen.WriteCLDRVersion(w)
-
-	b.writeCompactIndex()
-}
-
-type builder struct {
-	w    *gen.CodeWriter
-	data *cldr.CLDR
-	supp *cldr.SupplementalData
-}
-
-func newBuilder(w *gen.CodeWriter) *builder {
-	r := gen.OpenCLDRCoreZip()
-	defer r.Close()
-	d := &cldr.Decoder{}
-	data, err := d.DecodeZip(r)
-	if err != nil {
-		log.Fatal(err)
-	}
-	b := builder{
-		w:    w,
-		data: data,
-		supp: data.Supplemental(),
-	}
-	return &b
-}
diff --git a/vendor/golang.org/x/text/internal/language/compact/gen_index.go b/vendor/golang.org/x/text/internal/language/compact/gen_index.go
deleted file mode 100644
index 136cefaf0..000000000
--- a/vendor/golang.org/x/text/internal/language/compact/gen_index.go
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright 2015 The Go 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 ignore
-
-package main
-
-// This file generates derivative tables based on the language package itself.
-
-import (
-	"fmt"
-	"log"
-	"sort"
-	"strings"
-
-	"golang.org/x/text/internal/language"
-)
-
-// Compact indices:
-// Note -va-X variants only apply to localization variants.
-// BCP variants only ever apply to language.
-// The only ambiguity between tags is with regions.
-
-func (b *builder) writeCompactIndex() {
-	// Collect all language tags for which we have any data in CLDR.
-	m := map[language.Tag]bool{}
-	for _, lang := range b.data.Locales() {
-		// We include all locales unconditionally to be consistent with en_US.
-		// We want en_US, even though it has no data associated with it.
-
-		// TODO: put any of the languages for which no data exists at the end
-		// of the index. This allows all components based on ICU to use that
-		// as the cutoff point.
-		// if x := data.RawLDML(lang); false ||
-		// 	x.LocaleDisplayNames != nil ||
-		// 	x.Characters != nil ||
-		// 	x.Delimiters != nil ||
-		// 	x.Measurement != nil ||
-		// 	x.Dates != nil ||
-		// 	x.Numbers != nil ||
-		// 	x.Units != nil ||
-		// 	x.ListPatterns != nil ||
-		// 	x.Collations != nil ||
-		// 	x.Segmentations != nil ||
-		// 	x.Rbnf != nil ||
-		// 	x.Annotations != nil ||
-		// 	x.Metadata != nil {
-
-		// TODO: support POSIX natively, albeit non-standard.
-		tag := language.Make(strings.Replace(lang, "_POSIX", "-u-va-posix", 1))
-		m[tag] = true
-		// }
-	}
-
-	// TODO: plural rules are also defined for the deprecated tags:
-	//    iw mo sh tl
-	// Consider removing these as compact tags.
-
-	// Include locales for plural rules, which uses a different structure.
-	for _, plurals := range b.supp.Plurals {
-		for _, rules := range plurals.PluralRules {
-			for _, lang := range strings.Split(rules.Locales, " ") {
-				m[language.Make(lang)] = true
-			}
-		}
-	}
-
-	var coreTags []language.CompactCoreInfo
-	var special []string
-
-	for t := range m {
-		if x := t.Extensions(); len(x) != 0 && fmt.Sprint(x) != "[u-va-posix]" {
-			log.Fatalf("Unexpected extension %v in %v", x, t)
-		}
-		if len(t.Variants()) == 0 && len(t.Extensions()) == 0 {
-			cci, ok := language.GetCompactCore(t)
-			if !ok {
-				log.Fatalf("Locale for non-basic language %q", t)
-			}
-			coreTags = append(coreTags, cci)
-		} else {
-			special = append(special, t.String())
-		}
-	}
-
-	w := b.w
-
-	sort.Slice(coreTags, func(i, j int) bool { return coreTags[i] < coreTags[j] })
-	sort.Strings(special)
-
-	w.WriteComment(`
-	NumCompactTags is the number of common tags. The maximum tag is
-	NumCompactTags-1.`)
-	w.WriteConst("NumCompactTags", len(m))
-
-	fmt.Fprintln(w, "const (")
-	for i, t := range coreTags {
-		fmt.Fprintf(w, "%s ID = %d\n", ident(t.Tag().String()), i)
-	}
-	for i, t := range special {
-		fmt.Fprintf(w, "%s ID = %d\n", ident(t), i+len(coreTags))
-	}
-	fmt.Fprintln(w, ")")
-
-	w.WriteVar("coreTags", coreTags)
-
-	w.WriteConst("specialTagsStr", strings.Join(special, " "))
-}
-
-func ident(s string) string {
-	return strings.Replace(s, "-", "", -1) + "Index"
-}
diff --git a/vendor/golang.org/x/text/internal/language/compact/gen_parents.go b/vendor/golang.org/x/text/internal/language/compact/gen_parents.go
deleted file mode 100644
index 9543d5832..000000000
--- a/vendor/golang.org/x/text/internal/language/compact/gen_parents.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2018 The Go 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 ignore
-
-package main
-
-import (
-	"log"
-
-	"golang.org/x/text/internal/gen"
-	"golang.org/x/text/internal/language"
-	"golang.org/x/text/internal/language/compact"
-	"golang.org/x/text/unicode/cldr"
-)
-
-func main() {
-	r := gen.OpenCLDRCoreZip()
-	defer r.Close()
-
-	d := &cldr.Decoder{}
-	data, err := d.DecodeZip(r)
-	if err != nil {
-		log.Fatalf("DecodeZip: %v", err)
-	}
-
-	w := gen.NewCodeWriter()
-	defer w.WriteGoFile("parents.go", "compact")
-
-	// Create parents table.
-	type ID uint16
-	parents := make([]ID, compact.NumCompactTags)
-	for _, loc := range data.Locales() {
-		tag := language.MustParse(loc)
-		index, ok := compact.FromTag(tag)
-		if !ok {
-			continue
-		}
-		parentIndex := compact.ID(0) // und
-		for p := tag.Parent(); p != language.Und; p = p.Parent() {
-			if x, ok := compact.FromTag(p); ok {
-				parentIndex = x
-				break
-			}
-		}
-		parents[index] = ID(parentIndex)
-	}
-
-	w.WriteComment(`
-	parents maps a compact index of a tag to the compact index of the parent of
-	this tag.`)
-	w.WriteVar("parents", parents)
-}
diff --git a/vendor/golang.org/x/text/internal/language/gen.go b/vendor/golang.org/x/text/internal/language/gen.go
deleted file mode 100644
index cdcc7febc..000000000
--- a/vendor/golang.org/x/text/internal/language/gen.go
+++ /dev/null
@@ -1,1520 +0,0 @@
-// Copyright 2013 The Go 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 ignore
-
-// Language tag table generator.
-// Data read from the web.
-
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"math"
-	"reflect"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-
-	"golang.org/x/text/internal/gen"
-	"golang.org/x/text/internal/tag"
-	"golang.org/x/text/unicode/cldr"
-)
-
-var (
-	test = flag.Bool("test",
-		false,
-		"test existing tables; can be used to compare web data with package data.")
-	outputFile = flag.String("output",
-		"tables.go",
-		"output file for generated tables")
-)
-
-var comment = []string{
-	`
-lang holds an alphabetically sorted list of ISO-639 language identifiers.
-All entries are 4 bytes. The index of the identifier (divided by 4) is the language tag.
-For 2-byte language identifiers, the two successive bytes have the following meaning:
-    - if the first letter of the 2- and 3-letter ISO codes are the same:
-      the second and third letter of the 3-letter ISO code.
-    - otherwise: a 0 and a by 2 bits right-shifted index into altLangISO3.
-For 3-byte language identifiers the 4th byte is 0.`,
-	`
-langNoIndex is a bit vector of all 3-letter language codes that are not used as an index
-in lookup tables. The language ids for these language codes are derived directly
-from the letters and are not consecutive.`,
-	`
-altLangISO3 holds an alphabetically sorted list of 3-letter language code alternatives
-to 2-letter language codes that cannot be derived using the method described above.
-Each 3-letter code is followed by its 1-byte langID.`,
-	`
-altLangIndex is used to convert indexes in altLangISO3 to langIDs.`,
-	`
-AliasMap maps langIDs to their suggested replacements.`,
-	`
-script is an alphabetically sorted list of ISO 15924 codes. The index
-of the script in the string, divided by 4, is the internal scriptID.`,
-	`
-isoRegionOffset needs to be added to the index of regionISO to obtain the regionID
-for 2-letter ISO codes. (The first isoRegionOffset regionIDs are reserved for
-the UN.M49 codes used for groups.)`,
-	`
-regionISO holds a list of alphabetically sorted 2-letter ISO region codes.
-Each 2-letter codes is followed by two bytes with the following meaning:
-    - [A-Z}{2}: the first letter of the 2-letter code plus these two
-                letters form the 3-letter ISO code.
-    - 0, n:     index into altRegionISO3.`,
-	`
-regionTypes defines the status of a region for various standards.`,
-	`
-m49 maps regionIDs to UN.M49 codes. The first isoRegionOffset entries are
-codes indicating collections of regions.`,
-	`
-m49Index gives indexes into fromM49 based on the three most significant bits
-of a 10-bit UN.M49 code. To search an UN.M49 code in fromM49, search in
-   fromM49[m49Index[msb39(code)]:m49Index[msb3(code)+1]]
-for an entry where the first 7 bits match the 7 lsb of the UN.M49 code.
-The region code is stored in the 9 lsb of the indexed value.`,
-	`
-fromM49 contains entries to map UN.M49 codes to regions. See m49Index for details.`,
-	`
-altRegionISO3 holds a list of 3-letter region codes that cannot be
-mapped to 2-letter codes using the default algorithm. This is a short list.`,
-	`
-altRegionIDs holds a list of regionIDs the positions of which match those
-of the 3-letter ISO codes in altRegionISO3.`,
-	`
-variantNumSpecialized is the number of specialized variants in variants.`,
-	`
-suppressScript is an index from langID to the dominant script for that language,
-if it exists.  If a script is given, it should be suppressed from the language tag.`,
-	`
-likelyLang is a lookup table, indexed by langID, for the most likely
-scripts and regions given incomplete information. If more entries exist for a
-given language, region and script are the index and size respectively
-of the list in likelyLangList.`,
-	`
-likelyLangList holds lists info associated with likelyLang.`,
-	`
-likelyRegion is a lookup table, indexed by regionID, for the most likely
-languages and scripts given incomplete information. If more entries exist
-for a given regionID, lang and script are the index and size respectively
-of the list in likelyRegionList.
-TODO: exclude containers and user-definable regions from the list.`,
-	`
-likelyRegionList holds lists info associated with likelyRegion.`,
-	`
-likelyScript is a lookup table, indexed by scriptID, for the most likely
-languages and regions given a script.`,
-	`
-nRegionGroups is the number of region groups.`,
-	`
-regionInclusion maps region identifiers to sets of regions in regionInclusionBits,
-where each set holds all groupings that are directly connected in a region
-containment graph.`,
-	`
-regionInclusionBits is an array of bit vectors where every vector represents
-a set of region groupings.  These sets are used to compute the distance
-between two regions for the purpose of language matching.`,
-	`
-regionInclusionNext marks, for each entry in regionInclusionBits, the set of
-all groups that are reachable from the groups set in the respective entry.`,
-}
-
-// TODO: consider changing some of these structures to tries. This can reduce
-// memory, but may increase the need for memory allocations. This could be
-// mitigated if we can piggyback on language tags for common cases.
-
-func failOnError(e error) {
-	if e != nil {
-		log.Panic(e)
-	}
-}
-
-type setType int
-
-const (
-	Indexed setType = 1 + iota // all elements must be of same size
-	Linear
-)
-
-type stringSet struct {
-	s              []string
-	sorted, frozen bool
-
-	// We often need to update values after the creation of an index is completed.
-	// We include a convenience map for keeping track of this.
-	update map[string]string
-	typ    setType // used for checking.
-}
-
-func (ss *stringSet) clone() stringSet {
-	c := *ss
-	c.s = append([]string(nil), c.s...)
-	return c
-}
-
-func (ss *stringSet) setType(t setType) {
-	if ss.typ != t && ss.typ != 0 {
-		log.Panicf("type %d cannot be assigned as it was already %d", t, ss.typ)
-	}
-}
-
-// parse parses a whitespace-separated string and initializes ss with its
-// components.
-func (ss *stringSet) parse(s string) {
-	scan := bufio.NewScanner(strings.NewReader(s))
-	scan.Split(bufio.ScanWords)
-	for scan.Scan() {
-		ss.add(scan.Text())
-	}
-}
-
-func (ss *stringSet) assertChangeable() {
-	if ss.frozen {
-		log.Panic("attempt to modify a frozen stringSet")
-	}
-}
-
-func (ss *stringSet) add(s string) {
-	ss.assertChangeable()
-	ss.s = append(ss.s, s)
-	ss.sorted = ss.frozen
-}
-
-func (ss *stringSet) freeze() {
-	ss.compact()
-	ss.frozen = true
-}
-
-func (ss *stringSet) compact() {
-	if ss.sorted {
-		return
-	}
-	a := ss.s
-	sort.Strings(a)
-	k := 0
-	for i := 1; i < len(a); i++ {
-		if a[k] != a[i] {
-			a[k+1] = a[i]
-			k++
-		}
-	}
-	ss.s = a[:k+1]
-	ss.sorted = ss.frozen
-}
-
-type funcSorter struct {
-	fn func(a, b string) bool
-	sort.StringSlice
-}
-
-func (s funcSorter) Less(i, j int) bool {
-	return s.fn(s.StringSlice[i], s.StringSlice[j])
-}
-
-func (ss *stringSet) sortFunc(f func(a, b string) bool) {
-	ss.compact()
-	sort.Sort(funcSorter{f, sort.StringSlice(ss.s)})
-}
-
-func (ss *stringSet) remove(s string) {
-	ss.assertChangeable()
-	if i, ok := ss.find(s); ok {
-		copy(ss.s[i:], ss.s[i+1:])
-		ss.s = ss.s[:len(ss.s)-1]
-	}
-}
-
-func (ss *stringSet) replace(ol, nu string) {
-	ss.s[ss.index(ol)] = nu
-	ss.sorted = ss.frozen
-}
-
-func (ss *stringSet) index(s string) int {
-	ss.setType(Indexed)
-	i, ok := ss.find(s)
-	if !ok {
-		if i < len(ss.s) {
-			log.Panicf("find: item %q is not in list. Closest match is %q.", s, ss.s[i])
-		}
-		log.Panicf("find: item %q is not in list", s)
-
-	}
-	return i
-}
-
-func (ss *stringSet) find(s string) (int, bool) {
-	ss.compact()
-	i := sort.SearchStrings(ss.s, s)
-	return i, i != len(ss.s) && ss.s[i] == s
-}
-
-func (ss *stringSet) slice() []string {
-	ss.compact()
-	return ss.s
-}
-
-func (ss *stringSet) updateLater(v, key string) {
-	if ss.update == nil {
-		ss.update = map[string]string{}
-	}
-	ss.update[v] = key
-}
-
-// join joins the string and ensures that all entries are of the same length.
-func (ss *stringSet) join() string {
-	ss.setType(Indexed)
-	n := len(ss.s[0])
-	for _, s := range ss.s {
-		if len(s) != n {
-			log.Panicf("join: not all entries are of the same length: %q", s)
-		}
-	}
-	ss.s = append(ss.s, strings.Repeat("\xff", n))
-	return strings.Join(ss.s, "")
-}
-
-// ianaEntry holds information for an entry in the IANA Language Subtag Repository.
-// All types use the same entry.
-// See http://tools.ietf.org/html/bcp47#section-5.1 for a description of the various
-// fields.
-type ianaEntry struct {
-	typ            string
-	description    []string
-	scope          string
-	added          string
-	preferred      string
-	deprecated     string
-	suppressScript string
-	macro          string
-	prefix         []string
-}
-
-type builder struct {
-	w    *gen.CodeWriter
-	hw   io.Writer // MultiWriter for w and w.Hash
-	data *cldr.CLDR
-	supp *cldr.SupplementalData
-
-	// indices
-	locale      stringSet // common locales
-	lang        stringSet // canonical language ids (2 or 3 letter ISO codes) with data
-	langNoIndex stringSet // 3-letter ISO codes with no associated data
-	script      stringSet // 4-letter ISO codes
-	region      stringSet // 2-letter ISO or 3-digit UN M49 codes
-	variant     stringSet // 4-8-alphanumeric variant code.
-
-	// Region codes that are groups with their corresponding group IDs.
-	groups map[int]index
-
-	// langInfo
-	registry map[string]*ianaEntry
-}
-
-type index uint
-
-func newBuilder(w *gen.CodeWriter) *builder {
-	r := gen.OpenCLDRCoreZip()
-	defer r.Close()
-	d := &cldr.Decoder{}
-	data, err := d.DecodeZip(r)
-	failOnError(err)
-	b := builder{
-		w:    w,
-		hw:   io.MultiWriter(w, w.Hash),
-		data: data,
-		supp: data.Supplemental(),
-	}
-	b.parseRegistry()
-	return &b
-}
-
-func (b *builder) parseRegistry() {
-	r := gen.OpenIANAFile("assignments/language-subtag-registry")
-	defer r.Close()
-	b.registry = make(map[string]*ianaEntry)
-
-	scan := bufio.NewScanner(r)
-	scan.Split(bufio.ScanWords)
-	var record *ianaEntry
-	for more := scan.Scan(); more; {
-		key := scan.Text()
-		more = scan.Scan()
-		value := scan.Text()
-		switch key {
-		case "Type:":
-			record = &ianaEntry{typ: value}
-		case "Subtag:", "Tag:":
-			if s := strings.SplitN(value, "..", 2); len(s) > 1 {
-				for a := s[0]; a <= s[1]; a = inc(a) {
-					b.addToRegistry(a, record)
-				}
-			} else {
-				b.addToRegistry(value, record)
-			}
-		case "Suppress-Script:":
-			record.suppressScript = value
-		case "Added:":
-			record.added = value
-		case "Deprecated:":
-			record.deprecated = value
-		case "Macrolanguage:":
-			record.macro = value
-		case "Preferred-Value:":
-			record.preferred = value
-		case "Prefix:":
-			record.prefix = append(record.prefix, value)
-		case "Scope:":
-			record.scope = value
-		case "Description:":
-			buf := []byte(value)
-			for more = scan.Scan(); more; more = scan.Scan() {
-				b := scan.Bytes()
-				if b[0] == '%' || b[len(b)-1] == ':' {
-					break
-				}
-				buf = append(buf, ' ')
-				buf = append(buf, b...)
-			}
-			record.description = append(record.description, string(buf))
-			continue
-		default:
-			continue
-		}
-		more = scan.Scan()
-	}
-	if scan.Err() != nil {
-		log.Panic(scan.Err())
-	}
-}
-
-func (b *builder) addToRegistry(key string, entry *ianaEntry) {
-	if info, ok := b.registry[key]; ok {
-		if info.typ != "language" || entry.typ != "extlang" {
-			log.Fatalf("parseRegistry: tag %q already exists", key)
-		}
-	} else {
-		b.registry[key] = entry
-	}
-}
-
-var commentIndex = make(map[string]string)
-
-func init() {
-	for _, s := range comment {
-		key := strings.TrimSpace(strings.SplitN(s, " ", 2)[0])
-		commentIndex[key] = s
-	}
-}
-
-func (b *builder) comment(name string) {
-	if s := commentIndex[name]; len(s) > 0 {
-		b.w.WriteComment(s)
-	} else {
-		fmt.Fprintln(b.w)
-	}
-}
-
-func (b *builder) pf(f string, x ...interface{}) {
-	fmt.Fprintf(b.hw, f, x...)
-	fmt.Fprint(b.hw, "\n")
-}
-
-func (b *builder) p(x ...interface{}) {
-	fmt.Fprintln(b.hw, x...)
-}
-
-func (b *builder) addSize(s int) {
-	b.w.Size += s
-	b.pf("// Size: %d bytes", s)
-}
-
-func (b *builder) writeConst(name string, x interface{}) {
-	b.comment(name)
-	b.w.WriteConst(name, x)
-}
-
-// writeConsts computes f(v) for all v in values and writes the results
-// as constants named _v to a single constant block.
-func (b *builder) writeConsts(f func(string) int, values ...string) {
-	b.pf("const (")
-	for _, v := range values {
-		b.pf("\t_%s = %v", v, f(v))
-	}
-	b.pf(")")
-}
-
-// writeType writes the type of the given value, which must be a struct.
-func (b *builder) writeType(value interface{}) {
-	b.comment(reflect.TypeOf(value).Name())
-	b.w.WriteType(value)
-}
-
-func (b *builder) writeSlice(name string, ss interface{}) {
-	b.writeSliceAddSize(name, 0, ss)
-}
-
-func (b *builder) writeSliceAddSize(name string, extraSize int, ss interface{}) {
-	b.comment(name)
-	b.w.Size += extraSize
-	v := reflect.ValueOf(ss)
-	t := v.Type().Elem()
-	b.pf("// Size: %d bytes, %d elements", v.Len()*int(t.Size())+extraSize, v.Len())
-
-	fmt.Fprintf(b.w, "var %s = ", name)
-	b.w.WriteArray(ss)
-	b.p()
-}
-
-type FromTo struct {
-	From, To uint16
-}
-
-func (b *builder) writeSortedMap(name string, ss *stringSet, index func(s string) uint16) {
-	ss.sortFunc(func(a, b string) bool {
-		return index(a) < index(b)
-	})
-	m := []FromTo{}
-	for _, s := range ss.s {
-		m = append(m, FromTo{index(s), index(ss.update[s])})
-	}
-	b.writeSlice(name, m)
-}
-
-const base = 'z' - 'a' + 1
-
-func strToInt(s string) uint {
-	v := uint(0)
-	for i := 0; i < len(s); i++ {
-		v *= base
-		v += uint(s[i] - 'a')
-	}
-	return v
-}
-
-// converts the given integer to the original ASCII string passed to strToInt.
-// len(s) must match the number of characters obtained.
-func intToStr(v uint, s []byte) {
-	for i := len(s) - 1; i >= 0; i-- {
-		s[i] = byte(v%base) + 'a'
-		v /= base
-	}
-}
-
-func (b *builder) writeBitVector(name string, ss []string) {
-	vec := make([]uint8, int(math.Ceil(math.Pow(base, float64(len(ss[0])))/8)))
-	for _, s := range ss {
-		v := strToInt(s)
-		vec[v/8] |= 1 << (v % 8)
-	}
-	b.writeSlice(name, vec)
-}
-
-// TODO: convert this type into a list or two-stage trie.
-func (b *builder) writeMapFunc(name string, m map[string]string, f func(string) uint16) {
-	b.comment(name)
-	v := reflect.ValueOf(m)
-	sz := v.Len() * (2 + int(v.Type().Key().Size()))
-	for _, k := range m {
-		sz += len(k)
-	}
-	b.addSize(sz)
-	keys := []string{}
-	b.pf(`var %s = map[string]uint16{`, name)
-	for k := range m {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	for _, k := range keys {
-		b.pf("\t%q: %v,", k, f(m[k]))
-	}
-	b.p("}")
-}
-
-func (b *builder) writeMap(name string, m interface{}) {
-	b.comment(name)
-	v := reflect.ValueOf(m)
-	sz := v.Len() * (2 + int(v.Type().Key().Size()) + int(v.Type().Elem().Size()))
-	b.addSize(sz)
-	f := strings.FieldsFunc(fmt.Sprintf("%#v", m), func(r rune) bool {
-		return strings.IndexRune("{}, ", r) != -1
-	})
-	sort.Strings(f[1:])
-	b.pf(`var %s = %s{`, name, f[0])
-	for _, kv := range f[1:] {
-		b.pf("\t%s,", kv)
-	}
-	b.p("}")
-}
-
-func (b *builder) langIndex(s string) uint16 {
-	if s == "und" {
-		return 0
-	}
-	if i, ok := b.lang.find(s); ok {
-		return uint16(i)
-	}
-	return uint16(strToInt(s)) + uint16(len(b.lang.s))
-}
-
-// inc advances the string to its lexicographical successor.
-func inc(s string) string {
-	const maxTagLength = 4
-	var buf [maxTagLength]byte
-	intToStr(strToInt(strings.ToLower(s))+1, buf[:len(s)])
-	for i := 0; i < len(s); i++ {
-		if s[i] <= 'Z' {
-			buf[i] -= 'a' - 'A'
-		}
-	}
-	return string(buf[:len(s)])
-}
-
-func (b *builder) parseIndices() {
-	meta := b.supp.Metadata
-
-	for k, v := range b.registry {
-		var ss *stringSet
-		switch v.typ {
-		case "language":
-			if len(k) == 2 || v.suppressScript != "" || v.scope == "special" {
-				b.lang.add(k)
-				continue
-			} else {
-				ss = &b.langNoIndex
-			}
-		case "region":
-			ss = &b.region
-		case "script":
-			ss = &b.script
-		case "variant":
-			ss = &b.variant
-		default:
-			continue
-		}
-		ss.add(k)
-	}
-	// Include any language for which there is data.
-	for _, lang := range b.data.Locales() {
-		if x := b.data.RawLDML(lang); false ||
-			x.LocaleDisplayNames != nil ||
-			x.Characters != nil ||
-			x.Delimiters != nil ||
-			x.Measurement != nil ||
-			x.Dates != nil ||
-			x.Numbers != nil ||
-			x.Units != nil ||
-			x.ListPatterns != nil ||
-			x.Collations != nil ||
-			x.Segmentations != nil ||
-			x.Rbnf != nil ||
-			x.Annotations != nil ||
-			x.Metadata != nil {
-
-			from := strings.Split(lang, "_")
-			if lang := from[0]; lang != "root" {
-				b.lang.add(lang)
-			}
-		}
-	}
-	// Include locales for plural rules, which uses a different structure.
-	for _, plurals := range b.data.Supplemental().Plurals {
-		for _, rules := range plurals.PluralRules {
-			for _, lang := range strings.Split(rules.Locales, " ") {
-				if lang = strings.Split(lang, "_")[0]; lang != "root" {
-					b.lang.add(lang)
-				}
-			}
-		}
-	}
-	// Include languages in likely subtags.
-	for _, m := range b.supp.LikelySubtags.LikelySubtag {
-		from := strings.Split(m.From, "_")
-		b.lang.add(from[0])
-	}
-	// Include ISO-639 alpha-3 bibliographic entries.
-	for _, a := range meta.Alias.LanguageAlias {
-		if a.Reason == "bibliographic" {
-			b.langNoIndex.add(a.Type)
-		}
-	}
-	// Include regions in territoryAlias (not all are in the IANA registry!)
-	for _, reg := range b.supp.Metadata.Alias.TerritoryAlias {
-		if len(reg.Type) == 2 {
-			b.region.add(reg.Type)
-		}
-	}
-
-	for _, s := range b.lang.s {
-		if len(s) == 3 {
-			b.langNoIndex.remove(s)
-		}
-	}
-	b.writeConst("NumLanguages", len(b.lang.slice())+len(b.langNoIndex.slice()))
-	b.writeConst("NumScripts", len(b.script.slice()))
-	b.writeConst("NumRegions", len(b.region.slice()))
-
-	// Add dummy codes at the start of each list to represent "unspecified".
-	b.lang.add("---")
-	b.script.add("----")
-	b.region.add("---")
-
-	// common locales
-	b.locale.parse(meta.DefaultContent.Locales)
-}
-
-// TODO: region inclusion data will probably not be use used in future matchers.
-
-func (b *builder) computeRegionGroups() {
-	b.groups = make(map[int]index)
-
-	// Create group indices.
-	for i := 1; b.region.s[i][0] < 'A'; i++ { // Base M49 indices on regionID.
-		b.groups[i] = index(len(b.groups))
-	}
-	for _, g := range b.supp.TerritoryContainment.Group {
-		// Skip UN and EURO zone as they are flattening the containment
-		// relationship.
-		if g.Type == "EZ" || g.Type == "UN" {
-			continue
-		}
-		group := b.region.index(g.Type)
-		if _, ok := b.groups[group]; !ok {
-			b.groups[group] = index(len(b.groups))
-		}
-	}
-	if len(b.groups) > 64 {
-		log.Fatalf("only 64 groups supported, found %d", len(b.groups))
-	}
-	b.writeConst("nRegionGroups", len(b.groups))
-}
-
-var langConsts = []string{
-	"af", "am", "ar", "az", "bg", "bn", "ca", "cs", "da", "de", "el", "en", "es",
-	"et", "fa", "fi", "fil", "fr", "gu", "he", "hi", "hr", "hu", "hy", "id", "is",
-	"it", "ja", "ka", "kk", "km", "kn", "ko", "ky", "lo", "lt", "lv", "mk", "ml",
-	"mn", "mo", "mr", "ms", "mul", "my", "nb", "ne", "nl", "no", "pa", "pl", "pt",
-	"ro", "ru", "sh", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th",
-	"tl", "tn", "tr", "uk", "ur", "uz", "vi", "zh", "zu",
-
-	// constants for grandfathered tags (if not already defined)
-	"jbo", "ami", "bnn", "hak", "tlh", "lb", "nv", "pwn", "tao", "tay", "tsu",
-	"nn", "sfb", "vgt", "sgg", "cmn", "nan", "hsn",
-}
-
-// writeLanguage generates all tables needed for language canonicalization.
-func (b *builder) writeLanguage() {
-	meta := b.supp.Metadata
-
-	b.writeConst("nonCanonicalUnd", b.lang.index("und"))
-	b.writeConsts(func(s string) int { return int(b.langIndex(s)) }, langConsts...)
-	b.writeConst("langPrivateStart", b.langIndex("qaa"))
-	b.writeConst("langPrivateEnd", b.langIndex("qtz"))
-
-	// Get language codes that need to be mapped (overlong 3-letter codes,
-	// deprecated 2-letter codes, legacy and grandfathered tags.)
-	langAliasMap := stringSet{}
-	aliasTypeMap := map[string]AliasType{}
-
-	// altLangISO3 get the alternative ISO3 names that need to be mapped.
-	altLangISO3 := stringSet{}
-	// Add dummy start to avoid the use of index 0.
-	altLangISO3.add("---")
-	altLangISO3.updateLater("---", "aa")
-
-	lang := b.lang.clone()
-	for _, a := range meta.Alias.LanguageAlias {
-		if a.Replacement == "" {
-			a.Replacement = "und"
-		}
-		// TODO: support mapping to tags
-		repl := strings.SplitN(a.Replacement, "_", 2)[0]
-		if a.Reason == "overlong" {
-			if len(a.Replacement) == 2 && len(a.Type) == 3 {
-				lang.updateLater(a.Replacement, a.Type)
-			}
-		} else if len(a.Type) <= 3 {
-			switch a.Reason {
-			case "macrolanguage":
-				aliasTypeMap[a.Type] = Macro
-			case "deprecated":
-				// handled elsewhere
-				continue
-			case "bibliographic", "legacy":
-				if a.Type == "no" {
-					continue
-				}
-				aliasTypeMap[a.Type] = Legacy
-			default:
-				log.Fatalf("new %s alias: %s", a.Reason, a.Type)
-			}
-			langAliasMap.add(a.Type)
-			langAliasMap.updateLater(a.Type, repl)
-		}
-	}
-	// Manually add the mapping of "nb" (Norwegian) to its macro language.
-	// This can be removed if CLDR adopts this change.
-	langAliasMap.add("nb")
-	langAliasMap.updateLater("nb", "no")
-	aliasTypeMap["nb"] = Macro
-
-	for k, v := range b.registry {
-		// Also add deprecated values for 3-letter ISO codes, which CLDR omits.
-		if v.typ == "language" && v.deprecated != "" && v.preferred != "" {
-			langAliasMap.add(k)
-			langAliasMap.updateLater(k, v.preferred)
-			aliasTypeMap[k] = Deprecated
-		}
-	}
-	// Fix CLDR mappings.
-	lang.updateLater("tl", "tgl")
-	lang.updateLater("sh", "hbs")
-	lang.updateLater("mo", "mol")
-	lang.updateLater("no", "nor")
-	lang.updateLater("tw", "twi")
-	lang.updateLater("nb", "nob")
-	lang.updateLater("ak", "aka")
-	lang.updateLater("bh", "bih")
-
-	// Ensure that each 2-letter code is matched with a 3-letter code.
-	for _, v := range lang.s[1:] {
-		s, ok := lang.update[v]
-		if !ok {
-			if s, ok = lang.update[langAliasMap.update[v]]; !ok {
-				continue
-			}
-			lang.update[v] = s
-		}
-		if v[0] != s[0] {
-			altLangISO3.add(s)
-			altLangISO3.updateLater(s, v)
-		}
-	}
-
-	// Complete canonicalized language tags.
-	lang.freeze()
-	for i, v := range lang.s {
-		// We can avoid these manual entries by using the IANA registry directly.
-		// Seems easier to update the list manually, as changes are rare.
-		// The panic in this loop will trigger if we miss an entry.
-		add := ""
-		if s, ok := lang.update[v]; ok {
-			if s[0] == v[0] {
-				add = s[1:]
-			} else {
-				add = string([]byte{0, byte(altLangISO3.index(s))})
-			}
-		} else if len(v) == 3 {
-			add = "\x00"
-		} else {
-			log.Panicf("no data for long form of %q", v)
-		}
-		lang.s[i] += add
-	}
-	b.writeConst("lang", tag.Index(lang.join()))
-
-	b.writeConst("langNoIndexOffset", len(b.lang.s))
-
-	// space of all valid 3-letter language identifiers.
-	b.writeBitVector("langNoIndex", b.langNoIndex.slice())
-
-	altLangIndex := []uint16{}
-	for i, s := range altLangISO3.slice() {
-		altLangISO3.s[i] += string([]byte{byte(len(altLangIndex))})
-		if i > 0 {
-			idx := b.lang.index(altLangISO3.update[s])
-			altLangIndex = append(altLangIndex, uint16(idx))
-		}
-	}
-	b.writeConst("altLangISO3", tag.Index(altLangISO3.join()))
-	b.writeSlice("altLangIndex", altLangIndex)
-
-	b.writeSortedMap("AliasMap", &langAliasMap, b.langIndex)
-	types := make([]AliasType, len(langAliasMap.s))
-	for i, s := range langAliasMap.s {
-		types[i] = aliasTypeMap[s]
-	}
-	b.writeSlice("AliasTypes", types)
-}
-
-var scriptConsts = []string{
-	"Latn", "Hani", "Hans", "Hant", "Qaaa", "Qaai", "Qabx", "Zinh", "Zyyy",
-	"Zzzz",
-}
-
-func (b *builder) writeScript() {
-	b.writeConsts(b.script.index, scriptConsts...)
-	b.writeConst("script", tag.Index(b.script.join()))
-
-	supp := make([]uint8, len(b.lang.slice()))
-	for i, v := range b.lang.slice()[1:] {
-		if sc := b.registry[v].suppressScript; sc != "" {
-			supp[i+1] = uint8(b.script.index(sc))
-		}
-	}
-	b.writeSlice("suppressScript", supp)
-
-	// There is only one deprecated script in CLDR. This value is hard-coded.
-	// We check here if the code must be updated.
-	for _, a := range b.supp.Metadata.Alias.ScriptAlias {
-		if a.Type != "Qaai" {
-			log.Panicf("unexpected deprecated stript %q", a.Type)
-		}
-	}
-}
-
-func parseM49(s string) int16 {
-	if len(s) == 0 {
-		return 0
-	}
-	v, err := strconv.ParseUint(s, 10, 10)
-	failOnError(err)
-	return int16(v)
-}
-
-var regionConsts = []string{
-	"001", "419", "BR", "CA", "ES", "GB", "MD", "PT", "UK", "US",
-	"ZZ", "XA", "XC", "XK", // Unofficial tag for Kosovo.
-}
-
-func (b *builder) writeRegion() {
-	b.writeConsts(b.region.index, regionConsts...)
-
-	isoOffset := b.region.index("AA")
-	m49map := make([]int16, len(b.region.slice()))
-	fromM49map := make(map[int16]int)
-	altRegionISO3 := ""
-	altRegionIDs := []uint16{}
-
-	b.writeConst("isoRegionOffset", isoOffset)
-
-	// 2-letter region lookup and mapping to numeric codes.
-	regionISO := b.region.clone()
-	regionISO.s = regionISO.s[isoOffset:]
-	regionISO.sorted = false
-
-	regionTypes := make([]byte, len(b.region.s))
-
-	// Is the region valid BCP 47?
-	for s, e := range b.registry {
-		if len(s) == 2 && s == strings.ToUpper(s) {
-			i := b.region.index(s)
-			for _, d := range e.description {
-				if strings.Contains(d, "Private use") {
-					regionTypes[i] = iso3166UserAssigned
-				}
-			}
-			regionTypes[i] |= bcp47Region
-		}
-	}
-
-	// Is the region a valid ccTLD?
-	r := gen.OpenIANAFile("domains/root/db")
-	defer r.Close()
-
-	buf, err := ioutil.ReadAll(r)
-	failOnError(err)
-	re := regexp.MustCompile(`"/domains/root/db/([a-z]{2}).html"`)
-	for _, m := range re.FindAllSubmatch(buf, -1) {
-		i := b.region.index(strings.ToUpper(string(m[1])))
-		regionTypes[i] |= ccTLD
-	}
-
-	b.writeSlice("regionTypes", regionTypes)
-
-	iso3Set := make(map[string]int)
-	update := func(iso2, iso3 string) {
-		i := regionISO.index(iso2)
-		if j, ok := iso3Set[iso3]; !ok && iso3[0] == iso2[0] {
-			regionISO.s[i] += iso3[1:]
-			iso3Set[iso3] = -1
-		} else {
-			if ok && j >= 0 {
-				regionISO.s[i] += string([]byte{0, byte(j)})
-			} else {
-				iso3Set[iso3] = len(altRegionISO3)
-				regionISO.s[i] += string([]byte{0, byte(len(altRegionISO3))})
-				altRegionISO3 += iso3
-				altRegionIDs = append(altRegionIDs, uint16(isoOffset+i))
-			}
-		}
-	}
-	for _, tc := range b.supp.CodeMappings.TerritoryCodes {
-		i := regionISO.index(tc.Type) + isoOffset
-		if d := m49map[i]; d != 0 {
-			log.Panicf("%s found as a duplicate UN.M49 code of %03d", tc.Numeric, d)
-		}
-		m49 := parseM49(tc.Numeric)
-		m49map[i] = m49
-		if r := fromM49map[m49]; r == 0 {
-			fromM49map[m49] = i
-		} else if r != i {
-			dep := b.registry[regionISO.s[r-isoOffset]].deprecated
-			if t := b.registry[tc.Type]; t != nil && dep != "" && (t.deprecated == "" || t.deprecated > dep) {
-				fromM49map[m49] = i
-			}
-		}
-	}
-	for _, ta := range b.supp.Metadata.Alias.TerritoryAlias {
-		if len(ta.Type) == 3 && ta.Type[0] <= '9' && len(ta.Replacement) == 2 {
-			from := parseM49(ta.Type)
-			if r := fromM49map[from]; r == 0 {
-				fromM49map[from] = regionISO.index(ta.Replacement) + isoOffset
-			}
-		}
-	}
-	for _, tc := range b.supp.CodeMappings.TerritoryCodes {
-		if len(tc.Alpha3) == 3 {
-			update(tc.Type, tc.Alpha3)
-		}
-	}
-	// This entries are not included in territoryCodes. Mostly 3-letter variants
-	// of deleted codes and an entry for QU.
-	for _, m := range []struct{ iso2, iso3 string }{
-		{"CT", "CTE"},
-		{"DY", "DHY"},
-		{"HV", "HVO"},
-		{"JT", "JTN"},
-		{"MI", "MID"},
-		{"NH", "NHB"},
-		{"NQ", "ATN"},
-		{"PC", "PCI"},
-		{"PU", "PUS"},
-		{"PZ", "PCZ"},
-		{"RH", "RHO"},
-		{"VD", "VDR"},
-		{"WK", "WAK"},
-		// These three-letter codes are used for others as well.
-		{"FQ", "ATF"},
-	} {
-		update(m.iso2, m.iso3)
-	}
-	for i, s := range regionISO.s {
-		if len(s) != 4 {
-			regionISO.s[i] = s + "  "
-		}
-	}
-	b.writeConst("regionISO", tag.Index(regionISO.join()))
-	b.writeConst("altRegionISO3", altRegionISO3)
-	b.writeSlice("altRegionIDs", altRegionIDs)
-
-	// Create list of deprecated regions.
-	// TODO: consider inserting SF -> FI. Not included by CLDR, but is the only
-	// Transitionally-reserved mapping not included.
-	regionOldMap := stringSet{}
-	// Include regions in territoryAlias (not all are in the IANA registry!)
-	for _, reg := range b.supp.Metadata.Alias.TerritoryAlias {
-		if len(reg.Type) == 2 && reg.Reason == "deprecated" && len(reg.Replacement) == 2 {
-			regionOldMap.add(reg.Type)
-			regionOldMap.updateLater(reg.Type, reg.Replacement)
-			i, _ := regionISO.find(reg.Type)
-			j, _ := regionISO.find(reg.Replacement)
-			if k := m49map[i+isoOffset]; k == 0 {
-				m49map[i+isoOffset] = m49map[j+isoOffset]
-			}
-		}
-	}
-	b.writeSortedMap("regionOldMap", &regionOldMap, func(s string) uint16 {
-		return uint16(b.region.index(s))
-	})
-	// 3-digit region lookup, groupings.
-	for i := 1; i < isoOffset; i++ {
-		m := parseM49(b.region.s[i])
-		m49map[i] = m
-		fromM49map[m] = i
-	}
-	b.writeSlice("m49", m49map)
-
-	const (
-		searchBits = 7
-		regionBits = 9
-	)
-	if len(m49map) >= 1<<regionBits {
-		log.Fatalf("Maximum number of regions exceeded: %d > %d", len(m49map), 1<<regionBits)
-	}
-	m49Index := [9]int16{}
-	fromM49 := []uint16{}
-	m49 := []int{}
-	for k, _ := range fromM49map {
-		m49 = append(m49, int(k))
-	}
-	sort.Ints(m49)
-	for _, k := range m49[1:] {
-		val := (k & (1<<searchBits - 1)) << regionBits
-		fromM49 = append(fromM49, uint16(val|fromM49map[int16(k)]))
-		m49Index[1:][k>>searchBits] = int16(len(fromM49))
-	}
-	b.writeSlice("m49Index", m49Index)
-	b.writeSlice("fromM49", fromM49)
-}
-
-const (
-	// TODO: put these lists in regionTypes as user data? Could be used for
-	// various optimizations and refinements and could be exposed in the API.
-	iso3166Except = "AC CP DG EA EU FX IC SU TA UK"
-	iso3166Trans  = "AN BU CS NT TP YU ZR" // SF is not in our set of Regions.
-	// DY and RH are actually not deleted, but indeterminately reserved.
-	iso3166DelCLDR = "CT DD DY FQ HV JT MI NH NQ PC PU PZ RH VD WK YD"
-)
-
-const (
-	iso3166UserAssigned = 1 << iota
-	ccTLD
-	bcp47Region
-)
-
-func find(list []string, s string) int {
-	for i, t := range list {
-		if t == s {
-			return i
-		}
-	}
-	return -1
-}
-
-// writeVariants generates per-variant information and creates a map from variant
-// name to index value. We assign index values such that sorting multiple
-// variants by index value will result in the correct order.
-// There are two types of variants: specialized and general. Specialized variants
-// are only applicable to certain language or language-script pairs. Generalized
-// variants apply to any language. Generalized variants always sort after
-// specialized variants.  We will therefore always assign a higher index value
-// to a generalized variant than any other variant. Generalized variants are
-// sorted alphabetically among themselves.
-// Specialized variants may also sort after other specialized variants. Such
-// variants will be ordered after any of the variants they may follow.
-// We assume that if a variant x is followed by a variant y, then for any prefix
-// p of x, p-x is a prefix of y. This allows us to order tags based on the
-// maximum of the length of any of its prefixes.
-// TODO: it is possible to define a set of Prefix values on variants such that
-// a total order cannot be defined to the point that this algorithm breaks.
-// In other words, we cannot guarantee the same order of variants for the
-// future using the same algorithm or for non-compliant combinations of
-// variants. For this reason, consider using simple alphabetic sorting
-// of variants and ignore Prefix restrictions altogether.
-func (b *builder) writeVariant() {
-	generalized := stringSet{}
-	specialized := stringSet{}
-	specializedExtend := stringSet{}
-	// Collate the variants by type and check assumptions.
-	for _, v := range b.variant.slice() {
-		e := b.registry[v]
-		if len(e.prefix) == 0 {
-			generalized.add(v)
-			continue
-		}
-		c := strings.Split(e.prefix[0], "-")
-		hasScriptOrRegion := false
-		if len(c) > 1 {
-			_, hasScriptOrRegion = b.script.find(c[1])
-			if !hasScriptOrRegion {
-				_, hasScriptOrRegion = b.region.find(c[1])
-
-			}
-		}
-		if len(c) == 1 || len(c) == 2 && hasScriptOrRegion {
-			// Variant is preceded by a language.
-			specialized.add(v)
-			continue
-		}
-		// Variant is preceded by another variant.
-		specializedExtend.add(v)
-		prefix := c[0] + "-"
-		if hasScriptOrRegion {
-			prefix += c[1]
-		}
-		for _, p := range e.prefix {
-			// Verify that the prefix minus the last element is a prefix of the
-			// predecessor element.
-			i := strings.LastIndex(p, "-")
-			pred := b.registry[p[i+1:]]
-			if find(pred.prefix, p[:i]) < 0 {
-				log.Fatalf("prefix %q for variant %q not consistent with predecessor spec", p, v)
-			}
-			// The sorting used below does not work in the general case. It works
-			// if we assume that variants that may be followed by others only have
-			// prefixes of the same length. Verify this.
-			count := strings.Count(p[:i], "-")
-			for _, q := range pred.prefix {
-				if c := strings.Count(q, "-"); c != count {
-					log.Fatalf("variant %q preceding %q has a prefix %q of size %d; want %d", p[i+1:], v, q, c, count)
-				}
-			}
-			if !strings.HasPrefix(p, prefix) {
-				log.Fatalf("prefix %q of variant %q should start with %q", p, v, prefix)
-			}
-		}
-	}
-
-	// Sort extended variants.
-	a := specializedExtend.s
-	less := func(v, w string) bool {
-		// Sort by the maximum number of elements.
-		maxCount := func(s string) (max int) {
-			for _, p := range b.registry[s].prefix {
-				if c := strings.Count(p, "-"); c > max {
-					max = c
-				}
-			}
-			return
-		}
-		if cv, cw := maxCount(v), maxCount(w); cv != cw {
-			return cv < cw
-		}
-		// Sort by name as tie breaker.
-		return v < w
-	}
-	sort.Sort(funcSorter{less, sort.StringSlice(a)})
-	specializedExtend.frozen = true
-
-	// Create index from variant name to index.
-	variantIndex := make(map[string]uint8)
-	add := func(s []string) {
-		for _, v := range s {
-			variantIndex[v] = uint8(len(variantIndex))
-		}
-	}
-	add(specialized.slice())
-	add(specializedExtend.s)
-	numSpecialized := len(variantIndex)
-	add(generalized.slice())
-	if n := len(variantIndex); n > 255 {
-		log.Fatalf("maximum number of variants exceeded: was %d; want <= 255", n)
-	}
-	b.writeMap("variantIndex", variantIndex)
-	b.writeConst("variantNumSpecialized", numSpecialized)
-}
-
-func (b *builder) writeLanguageInfo() {
-}
-
-// writeLikelyData writes tables that are used both for finding parent relations and for
-// language matching.  Each entry contains additional bits to indicate the status of the
-// data to know when it cannot be used for parent relations.
-func (b *builder) writeLikelyData() {
-	const (
-		isList = 1 << iota
-		scriptInFrom
-		regionInFrom
-	)
-	type ( // generated types
-		likelyScriptRegion struct {
-			region uint16
-			script uint8
-			flags  uint8
-		}
-		likelyLangScript struct {
-			lang   uint16
-			script uint8
-			flags  uint8
-		}
-		likelyLangRegion struct {
-			lang   uint16
-			region uint16
-		}
-		// likelyTag is used for getting likely tags for group regions, where
-		// the likely region might be a region contained in the group.
-		likelyTag struct {
-			lang   uint16
-			region uint16
-			script uint8
-		}
-	)
-	var ( // generated variables
-		likelyRegionGroup = make([]likelyTag, len(b.groups))
-		likelyLang        = make([]likelyScriptRegion, len(b.lang.s))
-		likelyRegion      = make([]likelyLangScript, len(b.region.s))
-		likelyScript      = make([]likelyLangRegion, len(b.script.s))
-		likelyLangList    = []likelyScriptRegion{}
-		likelyRegionList  = []likelyLangScript{}
-	)
-	type fromTo struct {
-		from, to []string
-	}
-	langToOther := map[int][]fromTo{}
-	regionToOther := map[int][]fromTo{}
-	for _, m := range b.supp.LikelySubtags.LikelySubtag {
-		from := strings.Split(m.From, "_")
-		to := strings.Split(m.To, "_")
-		if len(to) != 3 {
-			log.Fatalf("invalid number of subtags in %q: found %d, want 3", m.To, len(to))
-		}
-		if len(from) > 3 {
-			log.Fatalf("invalid number of subtags: found %d, want 1-3", len(from))
-		}
-		if from[0] != to[0] && from[0] != "und" {
-			log.Fatalf("unexpected language change in expansion: %s -> %s", from, to)
-		}
-		if len(from) == 3 {
-			if from[2] != to[2] {
-				log.Fatalf("unexpected region change in expansion: %s -> %s", from, to)
-			}
-			if from[0] != "und" {
-				log.Fatalf("unexpected fully specified from tag: %s -> %s", from, to)
-			}
-		}
-		if len(from) == 1 || from[0] != "und" {
-			id := 0
-			if from[0] != "und" {
-				id = b.lang.index(from[0])
-			}
-			langToOther[id] = append(langToOther[id], fromTo{from, to})
-		} else if len(from) == 2 && len(from[1]) == 4 {
-			sid := b.script.index(from[1])
-			likelyScript[sid].lang = uint16(b.langIndex(to[0]))
-			likelyScript[sid].region = uint16(b.region.index(to[2]))
-		} else {
-			r := b.region.index(from[len(from)-1])
-			if id, ok := b.groups[r]; ok {
-				if from[0] != "und" {
-					log.Fatalf("region changed unexpectedly: %s -> %s", from, to)
-				}
-				likelyRegionGroup[id].lang = uint16(b.langIndex(to[0]))
-				likelyRegionGroup[id].script = uint8(b.script.index(to[1]))
-				likelyRegionGroup[id].region = uint16(b.region.index(to[2]))
-			} else {
-				regionToOther[r] = append(regionToOther[r], fromTo{from, to})
-			}
-		}
-	}
-	b.writeType(likelyLangRegion{})
-	b.writeSlice("likelyScript", likelyScript)
-
-	for id := range b.lang.s {
-		list := langToOther[id]
-		if len(list) == 1 {
-			likelyLang[id].region = uint16(b.region.index(list[0].to[2]))
-			likelyLang[id].script = uint8(b.script.index(list[0].to[1]))
-		} else if len(list) > 1 {
-			likelyLang[id].flags = isList
-			likelyLang[id].region = uint16(len(likelyLangList))
-			likelyLang[id].script = uint8(len(list))
-			for _, x := range list {
-				flags := uint8(0)
-				if len(x.from) > 1 {
-					if x.from[1] == x.to[2] {
-						flags = regionInFrom
-					} else {
-						flags = scriptInFrom
-					}
-				}
-				likelyLangList = append(likelyLangList, likelyScriptRegion{
-					region: uint16(b.region.index(x.to[2])),
-					script: uint8(b.script.index(x.to[1])),
-					flags:  flags,
-				})
-			}
-		}
-	}
-	// TODO: merge suppressScript data with this table.
-	b.writeType(likelyScriptRegion{})
-	b.writeSlice("likelyLang", likelyLang)
-	b.writeSlice("likelyLangList", likelyLangList)
-
-	for id := range b.region.s {
-		list := regionToOther[id]
-		if len(list) == 1 {
-			likelyRegion[id].lang = uint16(b.langIndex(list[0].to[0]))
-			likelyRegion[id].script = uint8(b.script.index(list[0].to[1]))
-			if len(list[0].from) > 2 {
-				likelyRegion[id].flags = scriptInFrom
-			}
-		} else if len(list) > 1 {
-			likelyRegion[id].flags = isList
-			likelyRegion[id].lang = uint16(len(likelyRegionList))
-			likelyRegion[id].script = uint8(len(list))
-			for i, x := range list {
-				if len(x.from) == 2 && i != 0 || i > 0 && len(x.from) != 3 {
-					log.Fatalf("unspecified script must be first in list: %v at %d", x.from, i)
-				}
-				x := likelyLangScript{
-					lang:   uint16(b.langIndex(x.to[0])),
-					script: uint8(b.script.index(x.to[1])),
-				}
-				if len(list[0].from) > 2 {
-					x.flags = scriptInFrom
-				}
-				likelyRegionList = append(likelyRegionList, x)
-			}
-		}
-	}
-	b.writeType(likelyLangScript{})
-	b.writeSlice("likelyRegion", likelyRegion)
-	b.writeSlice("likelyRegionList", likelyRegionList)
-
-	b.writeType(likelyTag{})
-	b.writeSlice("likelyRegionGroup", likelyRegionGroup)
-}
-
-func (b *builder) writeRegionInclusionData() {
-	var (
-		// mm holds for each group the set of groups with a distance of 1.
-		mm = make(map[int][]index)
-
-		// containment holds for each group the transitive closure of
-		// containment of other groups.
-		containment = make(map[index][]index)
-	)
-	for _, g := range b.supp.TerritoryContainment.Group {
-		// Skip UN and EURO zone as they are flattening the containment
-		// relationship.
-		if g.Type == "EZ" || g.Type == "UN" {
-			continue
-		}
-		group := b.region.index(g.Type)
-		groupIdx := b.groups[group]
-		for _, mem := range strings.Split(g.Contains, " ") {
-			r := b.region.index(mem)
-			mm[r] = append(mm[r], groupIdx)
-			if g, ok := b.groups[r]; ok {
-				mm[group] = append(mm[group], g)
-				containment[groupIdx] = append(containment[groupIdx], g)
-			}
-		}
-	}
-
-	regionContainment := make([]uint64, len(b.groups))
-	for _, g := range b.groups {
-		l := containment[g]
-
-		// Compute the transitive closure of containment.
-		for i := 0; i < len(l); i++ {
-			l = append(l, containment[l[i]]...)
-		}
-
-		// Compute the bitmask.
-		regionContainment[g] = 1 << g
-		for _, v := range l {
-			regionContainment[g] |= 1 << v
-		}
-	}
-	b.writeSlice("regionContainment", regionContainment)
-
-	regionInclusion := make([]uint8, len(b.region.s))
-	bvs := make(map[uint64]index)
-	// Make the first bitvector positions correspond with the groups.
-	for r, i := range b.groups {
-		bv := uint64(1 << i)
-		for _, g := range mm[r] {
-			bv |= 1 << g
-		}
-		bvs[bv] = i
-		regionInclusion[r] = uint8(bvs[bv])
-	}
-	for r := 1; r < len(b.region.s); r++ {
-		if _, ok := b.groups[r]; !ok {
-			bv := uint64(0)
-			for _, g := range mm[r] {
-				bv |= 1 << g
-			}
-			if bv == 0 {
-				// Pick the world for unspecified regions.
-				bv = 1 << b.groups[b.region.index("001")]
-			}
-			if _, ok := bvs[bv]; !ok {
-				bvs[bv] = index(len(bvs))
-			}
-			regionInclusion[r] = uint8(bvs[bv])
-		}
-	}
-	b.writeSlice("regionInclusion", regionInclusion)
-	regionInclusionBits := make([]uint64, len(bvs))
-	for k, v := range bvs {
-		regionInclusionBits[v] = uint64(k)
-	}
-	// Add bit vectors for increasingly large distances until a fixed point is reached.
-	regionInclusionNext := []uint8{}
-	for i := 0; i < len(regionInclusionBits); i++ {
-		bits := regionInclusionBits[i]
-		next := bits
-		for i := uint(0); i < uint(len(b.groups)); i++ {
-			if bits&(1<<i) != 0 {
-				next |= regionInclusionBits[i]
-			}
-		}
-		if _, ok := bvs[next]; !ok {
-			bvs[next] = index(len(bvs))
-			regionInclusionBits = append(regionInclusionBits, next)
-		}
-		regionInclusionNext = append(regionInclusionNext, uint8(bvs[next]))
-	}
-	b.writeSlice("regionInclusionBits", regionInclusionBits)
-	b.writeSlice("regionInclusionNext", regionInclusionNext)
-}
-
-type parentRel struct {
-	lang       uint16
-	script     uint8
-	maxScript  uint8
-	toRegion   uint16
-	fromRegion []uint16
-}
-
-func (b *builder) writeParents() {
-	b.writeType(parentRel{})
-
-	parents := []parentRel{}
-
-	// Construct parent overrides.
-	n := 0
-	for _, p := range b.data.Supplemental().ParentLocales.ParentLocale {
-		// Skipping non-standard scripts to root is implemented using addTags.
-		if p.Parent == "root" {
-			continue
-		}
-
-		sub := strings.Split(p.Parent, "_")
-		parent := parentRel{lang: b.langIndex(sub[0])}
-		if len(sub) == 2 {
-			// TODO: check that all undefined scripts are indeed Latn in these
-			// cases.
-			parent.maxScript = uint8(b.script.index("Latn"))
-			parent.toRegion = uint16(b.region.index(sub[1]))
-		} else {
-			parent.script = uint8(b.script.index(sub[1]))
-			parent.maxScript = parent.script
-			parent.toRegion = uint16(b.region.index(sub[2]))
-		}
-		for _, c := range strings.Split(p.Locales, " ") {
-			region := b.region.index(c[strings.LastIndex(c, "_")+1:])
-			parent.fromRegion = append(parent.fromRegion, uint16(region))
-		}
-		parents = append(parents, parent)
-		n += len(parent.fromRegion)
-	}
-	b.writeSliceAddSize("parents", n*2, parents)
-}
-
-func main() {
-	gen.Init()
-
-	gen.Repackage("gen_common.go", "common.go", "language")
-
-	w := gen.NewCodeWriter()
-	defer w.WriteGoFile("tables.go", "language")
-
-	fmt.Fprintln(w, `import "golang.org/x/text/internal/tag"`)
-
-	b := newBuilder(w)
-	gen.WriteCLDRVersion(w)
-
-	b.parseIndices()
-	b.writeType(FromTo{})
-	b.writeLanguage()
-	b.writeScript()
-	b.writeRegion()
-	b.writeVariant()
-	// TODO: b.writeLocale()
-	b.computeRegionGroups()
-	b.writeLikelyData()
-	b.writeRegionInclusionData()
-	b.writeParents()
-}
diff --git a/vendor/golang.org/x/text/internal/language/gen_common.go b/vendor/golang.org/x/text/internal/language/gen_common.go
deleted file mode 100644
index c419ceeb1..000000000
--- a/vendor/golang.org/x/text/internal/language/gen_common.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2014 The Go 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 ignore
-
-package main
-
-// This file contains code common to the maketables.go and the package code.
-
-// AliasType is the type of an alias in AliasMap.
-type AliasType int8
-
-const (
-	Deprecated AliasType = iota
-	Macro
-	Legacy
-
-	AliasTypeUnknown AliasType = -1
-)
diff --git a/vendor/golang.org/x/text/language/gen.go b/vendor/golang.org/x/text/language/gen.go
deleted file mode 100644
index 3004eb42c..000000000
--- a/vendor/golang.org/x/text/language/gen.go
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright 2013 The Go 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 ignore
-
-// Language tag table generator.
-// Data read from the web.
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"sort"
-	"strconv"
-	"strings"
-
-	"golang.org/x/text/internal/gen"
-	"golang.org/x/text/internal/language"
-	"golang.org/x/text/unicode/cldr"
-)
-
-var (
-	test = flag.Bool("test",
-		false,
-		"test existing tables; can be used to compare web data with package data.")
-	outputFile = flag.String("output",
-		"tables.go",
-		"output file for generated tables")
-)
-
-func main() {
-	gen.Init()
-
-	w := gen.NewCodeWriter()
-	defer w.WriteGoFile("tables.go", "language")
-
-	b := newBuilder(w)
-	gen.WriteCLDRVersion(w)
-
-	b.writeConstants()
-	b.writeMatchData()
-}
-
-type builder struct {
-	w    *gen.CodeWriter
-	hw   io.Writer // MultiWriter for w and w.Hash
-	data *cldr.CLDR
-	supp *cldr.SupplementalData
-}
-
-func (b *builder) langIndex(s string) uint16 {
-	return uint16(language.MustParseBase(s))
-}
-
-func (b *builder) regionIndex(s string) int {
-	return int(language.MustParseRegion(s))
-}
-
-func (b *builder) scriptIndex(s string) int {
-	return int(language.MustParseScript(s))
-}
-
-func newBuilder(w *gen.CodeWriter) *builder {
-	r := gen.OpenCLDRCoreZip()
-	defer r.Close()
-	d := &cldr.Decoder{}
-	data, err := d.DecodeZip(r)
-	if err != nil {
-		log.Fatal(err)
-	}
-	b := builder{
-		w:    w,
-		hw:   io.MultiWriter(w, w.Hash),
-		data: data,
-		supp: data.Supplemental(),
-	}
-	return &b
-}
-
-// writeConsts computes f(v) for all v in values and writes the results
-// as constants named _v to a single constant block.
-func (b *builder) writeConsts(f func(string) int, values ...string) {
-	fmt.Fprintln(b.w, "const (")
-	for _, v := range values {
-		fmt.Fprintf(b.w, "\t_%s = %v\n", v, f(v))
-	}
-	fmt.Fprintln(b.w, ")")
-}
-
-// TODO: region inclusion data will probably not be use used in future matchers.
-
-var langConsts = []string{
-	"de", "en", "fr", "it", "mo", "no", "nb", "pt", "sh", "mul", "und",
-}
-
-var scriptConsts = []string{
-	"Latn", "Hani", "Hans", "Hant", "Qaaa", "Qaai", "Qabx", "Zinh", "Zyyy",
-	"Zzzz",
-}
-
-var regionConsts = []string{
-	"001", "419", "BR", "CA", "ES", "GB", "MD", "PT", "UK", "US",
-	"ZZ", "XA", "XC", "XK", // Unofficial tag for Kosovo.
-}
-
-func (b *builder) writeConstants() {
-	b.writeConsts(func(s string) int { return int(b.langIndex(s)) }, langConsts...)
-	b.writeConsts(b.regionIndex, regionConsts...)
-	b.writeConsts(b.scriptIndex, scriptConsts...)
-}
-
-type mutualIntelligibility struct {
-	want, have uint16
-	distance   uint8
-	oneway     bool
-}
-
-type scriptIntelligibility struct {
-	wantLang, haveLang     uint16
-	wantScript, haveScript uint8
-	distance               uint8
-	// Always oneway
-}
-
-type regionIntelligibility struct {
-	lang     uint16 // compact language id
-	script   uint8  // 0 means any
-	group    uint8  // 0 means any; if bit 7 is set it means inverse
-	distance uint8
-	// Always twoway.
-}
-
-// writeMatchData writes tables with languages and scripts for which there is
-// mutual intelligibility. The data is based on CLDR's languageMatching data.
-// Note that we use a different algorithm than the one defined by CLDR and that
-// we slightly modify the data. For example, we convert scores to confidence levels.
-// We also drop all region-related data as we use a different algorithm to
-// determine region equivalence.
-func (b *builder) writeMatchData() {
-	lm := b.supp.LanguageMatching.LanguageMatches
-	cldr.MakeSlice(&lm).SelectAnyOf("type", "written_new")
-
-	regionHierarchy := map[string][]string{}
-	for _, g := range b.supp.TerritoryContainment.Group {
-		regions := strings.Split(g.Contains, " ")
-		regionHierarchy[g.Type] = append(regionHierarchy[g.Type], regions...)
-	}
-	regionToGroups := make([]uint8, language.NumRegions)
-
-	idToIndex := map[string]uint8{}
-	for i, mv := range lm[0].MatchVariable {
-		if i > 6 {
-			log.Fatalf("Too many groups: %d", i)
-		}
-		idToIndex[mv.Id] = uint8(i + 1)
-		// TODO: also handle '-'
-		for _, r := range strings.Split(mv.Value, "+") {
-			todo := []string{r}
-			for k := 0; k < len(todo); k++ {
-				r := todo[k]
-				regionToGroups[b.regionIndex(r)] |= 1 << uint8(i)
-				todo = append(todo, regionHierarchy[r]...)
-			}
-		}
-	}
-	b.w.WriteVar("regionToGroups", regionToGroups)
-
-	// maps language id to in- and out-of-group region.
-	paradigmLocales := [][3]uint16{}
-	locales := strings.Split(lm[0].ParadigmLocales[0].Locales, " ")
-	for i := 0; i < len(locales); i += 2 {
-		x := [3]uint16{}
-		for j := 0; j < 2; j++ {
-			pc := strings.SplitN(locales[i+j], "-", 2)
-			x[0] = b.langIndex(pc[0])
-			if len(pc) == 2 {
-				x[1+j] = uint16(b.regionIndex(pc[1]))
-			}
-		}
-		paradigmLocales = append(paradigmLocales, x)
-	}
-	b.w.WriteVar("paradigmLocales", paradigmLocales)
-
-	b.w.WriteType(mutualIntelligibility{})
-	b.w.WriteType(scriptIntelligibility{})
-	b.w.WriteType(regionIntelligibility{})
-
-	matchLang := []mutualIntelligibility{}
-	matchScript := []scriptIntelligibility{}
-	matchRegion := []regionIntelligibility{}
-	// Convert the languageMatch entries in lists keyed by desired language.
-	for _, m := range lm[0].LanguageMatch {
-		// Different versions of CLDR use different separators.
-		desired := strings.Replace(m.Desired, "-", "_", -1)
-		supported := strings.Replace(m.Supported, "-", "_", -1)
-		d := strings.Split(desired, "_")
-		s := strings.Split(supported, "_")
-		if len(d) != len(s) {
-			log.Fatalf("not supported: desired=%q; supported=%q", desired, supported)
-			continue
-		}
-		distance, _ := strconv.ParseInt(m.Distance, 10, 8)
-		switch len(d) {
-		case 2:
-			if desired == supported && desired == "*_*" {
-				continue
-			}
-			// language-script pair.
-			matchScript = append(matchScript, scriptIntelligibility{
-				wantLang:   uint16(b.langIndex(d[0])),
-				haveLang:   uint16(b.langIndex(s[0])),
-				wantScript: uint8(b.scriptIndex(d[1])),
-				haveScript: uint8(b.scriptIndex(s[1])),
-				distance:   uint8(distance),
-			})
-			if m.Oneway != "true" {
-				matchScript = append(matchScript, scriptIntelligibility{
-					wantLang:   uint16(b.langIndex(s[0])),
-					haveLang:   uint16(b.langIndex(d[0])),
-					wantScript: uint8(b.scriptIndex(s[1])),
-					haveScript: uint8(b.scriptIndex(d[1])),
-					distance:   uint8(distance),
-				})
-			}
-		case 1:
-			if desired == supported && desired == "*" {
-				continue
-			}
-			if distance == 1 {
-				// nb == no is already handled by macro mapping. Check there
-				// really is only this case.
-				if d[0] != "no" || s[0] != "nb" {
-					log.Fatalf("unhandled equivalence %s == %s", s[0], d[0])
-				}
-				continue
-			}
-			// TODO: consider dropping oneway field and just doubling the entry.
-			matchLang = append(matchLang, mutualIntelligibility{
-				want:     uint16(b.langIndex(d[0])),
-				have:     uint16(b.langIndex(s[0])),
-				distance: uint8(distance),
-				oneway:   m.Oneway == "true",
-			})
-		case 3:
-			if desired == supported && desired == "*_*_*" {
-				continue
-			}
-			if desired != supported {
-				// This is now supported by CLDR, but only one case, which
-				// should already be covered by paradigm locales. For instance,
-				// test case "und, en, en-GU, en-IN, en-GB ; en-ZA ; en-GB" in
-				// testdata/CLDRLocaleMatcherTest.txt tests this.
-				if supported != "en_*_GB" {
-					log.Fatalf("not supported: desired=%q; supported=%q", desired, supported)
-				}
-				continue
-			}
-			ri := regionIntelligibility{
-				lang:     b.langIndex(d[0]),
-				distance: uint8(distance),
-			}
-			if d[1] != "*" {
-				ri.script = uint8(b.scriptIndex(d[1]))
-			}
-			switch {
-			case d[2] == "*":
-				ri.group = 0x80 // not contained in anything
-			case strings.HasPrefix(d[2], "$!"):
-				ri.group = 0x80
-				d[2] = "$" + d[2][len("$!"):]
-				fallthrough
-			case strings.HasPrefix(d[2], "$"):
-				ri.group |= idToIndex[d[2]]
-			}
-			matchRegion = append(matchRegion, ri)
-		default:
-			log.Fatalf("not supported: desired=%q; supported=%q", desired, supported)
-		}
-	}
-	sort.SliceStable(matchLang, func(i, j int) bool {
-		return matchLang[i].distance < matchLang[j].distance
-	})
-	b.w.WriteComment(`
-		matchLang holds pairs of langIDs of base languages that are typically
-		mutually intelligible. Each pair is associated with a confidence and
-		whether the intelligibility goes one or both ways.`)
-	b.w.WriteVar("matchLang", matchLang)
-
-	b.w.WriteComment(`
-		matchScript holds pairs of scriptIDs where readers of one script
-		can typically also read the other. Each is associated with a confidence.`)
-	sort.SliceStable(matchScript, func(i, j int) bool {
-		return matchScript[i].distance < matchScript[j].distance
-	})
-	b.w.WriteVar("matchScript", matchScript)
-
-	sort.SliceStable(matchRegion, func(i, j int) bool {
-		return matchRegion[i].distance < matchRegion[j].distance
-	})
-	b.w.WriteVar("matchRegion", matchRegion)
-}
diff --git a/vendor/golang.org/x/text/unicode/bidi/gen.go b/vendor/golang.org/x/text/unicode/bidi/gen.go
deleted file mode 100644
index 987fc169c..000000000
--- a/vendor/golang.org/x/text/unicode/bidi/gen.go
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright 2015 The Go 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 ignore
-
-package main
-
-import (
-	"flag"
-	"log"
-
-	"golang.org/x/text/internal/gen"
-	"golang.org/x/text/internal/triegen"
-	"golang.org/x/text/internal/ucd"
-)
-
-var outputFile = flag.String("out", "tables.go", "output file")
-
-func main() {
-	gen.Init()
-	gen.Repackage("gen_trieval.go", "trieval.go", "bidi")
-	gen.Repackage("gen_ranges.go", "ranges_test.go", "bidi")
-
-	genTables()
-}
-
-// bidiClass names and codes taken from class "bc" in
-// https://www.unicode.org/Public/8.0.0/ucd/PropertyValueAliases.txt
-var bidiClass = map[string]Class{
-	"AL":  AL,  // ArabicLetter
-	"AN":  AN,  // ArabicNumber
-	"B":   B,   // ParagraphSeparator
-	"BN":  BN,  // BoundaryNeutral
-	"CS":  CS,  // CommonSeparator
-	"EN":  EN,  // EuropeanNumber
-	"ES":  ES,  // EuropeanSeparator
-	"ET":  ET,  // EuropeanTerminator
-	"L":   L,   // LeftToRight
-	"NSM": NSM, // NonspacingMark
-	"ON":  ON,  // OtherNeutral
-	"R":   R,   // RightToLeft
-	"S":   S,   // SegmentSeparator
-	"WS":  WS,  // WhiteSpace
-
-	"FSI": Control,
-	"PDF": Control,
-	"PDI": Control,
-	"LRE": Control,
-	"LRI": Control,
-	"LRO": Control,
-	"RLE": Control,
-	"RLI": Control,
-	"RLO": Control,
-}
-
-func genTables() {
-	if numClass > 0x0F {
-		log.Fatalf("Too many Class constants (%#x > 0x0F).", numClass)
-	}
-	w := gen.NewCodeWriter()
-	defer w.WriteVersionedGoFile(*outputFile, "bidi")
-
-	gen.WriteUnicodeVersion(w)
-
-	t := triegen.NewTrie("bidi")
-
-	// Build data about bracket mapping. These bits need to be or-ed with
-	// any other bits.
-	orMask := map[rune]uint64{}
-
-	xorMap := map[rune]int{}
-	xorMasks := []rune{0} // First value is no-op.
-
-	ucd.Parse(gen.OpenUCDFile("BidiBrackets.txt"), func(p *ucd.Parser) {
-		r1 := p.Rune(0)
-		r2 := p.Rune(1)
-		xor := r1 ^ r2
-		if _, ok := xorMap[xor]; !ok {
-			xorMap[xor] = len(xorMasks)
-			xorMasks = append(xorMasks, xor)
-		}
-		entry := uint64(xorMap[xor]) << xorMaskShift
-		switch p.String(2) {
-		case "o":
-			entry |= openMask
-		case "c", "n":
-		default:
-			log.Fatalf("Unknown bracket class %q.", p.String(2))
-		}
-		orMask[r1] = entry
-	})
-
-	w.WriteComment(`
-	xorMasks contains masks to be xor-ed with brackets to get the reverse
-	version.`)
-	w.WriteVar("xorMasks", xorMasks)
-
-	done := map[rune]bool{}
-
-	insert := func(r rune, c Class) {
-		if !done[r] {
-			t.Insert(r, orMask[r]|uint64(c))
-			done[r] = true
-		}
-	}
-
-	// Insert the derived BiDi properties.
-	ucd.Parse(gen.OpenUCDFile("extracted/DerivedBidiClass.txt"), func(p *ucd.Parser) {
-		r := p.Rune(0)
-		class, ok := bidiClass[p.String(1)]
-		if !ok {
-			log.Fatalf("%U: Unknown BiDi class %q", r, p.String(1))
-		}
-		insert(r, class)
-	})
-	visitDefaults(insert)
-
-	// TODO: use sparse blocks. This would reduce table size considerably
-	// from the looks of it.
-
-	sz, err := t.Gen(w)
-	if err != nil {
-		log.Fatal(err)
-	}
-	w.Size += sz
-}
-
-// dummy values to make methods in gen_common compile. The real versions
-// will be generated by this file to tables.go.
-var (
-	xorMasks []rune
-)
diff --git a/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go b/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go
deleted file mode 100644
index 02c3b505d..000000000
--- a/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2015 The Go 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 ignore
-
-package main
-
-import (
-	"unicode"
-
-	"golang.org/x/text/internal/gen"
-	"golang.org/x/text/internal/ucd"
-	"golang.org/x/text/unicode/rangetable"
-)
-
-// These tables are hand-extracted from:
-// https://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedBidiClass.txt
-func visitDefaults(fn func(r rune, c Class)) {
-	// first write default values for ranges listed above.
-	visitRunes(fn, AL, []rune{
-		0x0600, 0x07BF, // Arabic
-		0x08A0, 0x08FF, // Arabic Extended-A
-		0xFB50, 0xFDCF, // Arabic Presentation Forms
-		0xFDF0, 0xFDFF,
-		0xFE70, 0xFEFF,
-		0x0001EE00, 0x0001EEFF, // Arabic Mathematical Alpha Symbols
-	})
-	visitRunes(fn, R, []rune{
-		0x0590, 0x05FF, // Hebrew
-		0x07C0, 0x089F, // Nko et al.
-		0xFB1D, 0xFB4F,
-		0x00010800, 0x00010FFF, // Cypriot Syllabary et. al.
-		0x0001E800, 0x0001EDFF,
-		0x0001EF00, 0x0001EFFF,
-	})
-	visitRunes(fn, ET, []rune{ // European Terminator
-		0x20A0, 0x20Cf, // Currency symbols
-	})
-	rangetable.Visit(unicode.Noncharacter_Code_Point, func(r rune) {
-		fn(r, BN) // Boundary Neutral
-	})
-	ucd.Parse(gen.OpenUCDFile("DerivedCoreProperties.txt"), func(p *ucd.Parser) {
-		if p.String(1) == "Default_Ignorable_Code_Point" {
-			fn(p.Rune(0), BN) // Boundary Neutral
-		}
-	})
-}
-
-func visitRunes(fn func(r rune, c Class), c Class, runes []rune) {
-	for i := 0; i < len(runes); i += 2 {
-		lo, hi := runes[i], runes[i+1]
-		for j := lo; j <= hi; j++ {
-			fn(j, c)
-		}
-	}
-}
diff --git a/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go b/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go
deleted file mode 100644
index 9cb994289..000000000
--- a/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2015 The Go 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 ignore
-
-package main
-
-// Class is the Unicode BiDi class. Each rune has a single class.
-type Class uint
-
-const (
-	L       Class = iota // LeftToRight
-	R                    // RightToLeft
-	EN                   // EuropeanNumber
-	ES                   // EuropeanSeparator
-	ET                   // EuropeanTerminator
-	AN                   // ArabicNumber
-	CS                   // CommonSeparator
-	B                    // ParagraphSeparator
-	S                    // SegmentSeparator
-	WS                   // WhiteSpace
-	ON                   // OtherNeutral
-	BN                   // BoundaryNeutral
-	NSM                  // NonspacingMark
-	AL                   // ArabicLetter
-	Control              // Control LRO - PDI
-
-	numClass
-
-	LRO // LeftToRightOverride
-	RLO // RightToLeftOverride
-	LRE // LeftToRightEmbedding
-	RLE // RightToLeftEmbedding
-	PDF // PopDirectionalFormat
-	LRI // LeftToRightIsolate
-	RLI // RightToLeftIsolate
-	FSI // FirstStrongIsolate
-	PDI // PopDirectionalIsolate
-
-	unknownClass = ^Class(0)
-)
-
-var controlToClass = map[rune]Class{
-	0x202D: LRO, // LeftToRightOverride,
-	0x202E: RLO, // RightToLeftOverride,
-	0x202A: LRE, // LeftToRightEmbedding,
-	0x202B: RLE, // RightToLeftEmbedding,
-	0x202C: PDF, // PopDirectionalFormat,
-	0x2066: LRI, // LeftToRightIsolate,
-	0x2067: RLI, // RightToLeftIsolate,
-	0x2068: FSI, // FirstStrongIsolate,
-	0x2069: PDI, // PopDirectionalIsolate,
-}
-
-// A trie entry has the following bits:
-// 7..5  XOR mask for brackets
-// 4     1: Bracket open, 0: Bracket close
-// 3..0  Class type
-
-const (
-	openMask     = 0x10
-	xorMaskShift = 5
-)
diff --git a/vendor/golang.org/x/text/unicode/norm/maketables.go b/vendor/golang.org/x/text/unicode/norm/maketables.go
deleted file mode 100644
index 30a3aa933..000000000
--- a/vendor/golang.org/x/text/unicode/norm/maketables.go
+++ /dev/null
@@ -1,986 +0,0 @@
-// Copyright 2011 The Go 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 ignore
-
-// Normalization table generator.
-// Data read from the web.
-// See forminfo.go for a description of the trie values associated with each rune.
-
-package main
-
-import (
-	"bytes"
-	"encoding/binary"
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"sort"
-	"strconv"
-	"strings"
-
-	"golang.org/x/text/internal/gen"
-	"golang.org/x/text/internal/triegen"
-	"golang.org/x/text/internal/ucd"
-)
-
-func main() {
-	gen.Init()
-	loadUnicodeData()
-	compactCCC()
-	loadCompositionExclusions()
-	completeCharFields(FCanonical)
-	completeCharFields(FCompatibility)
-	computeNonStarterCounts()
-	verifyComputed()
-	printChars()
-	testDerived()
-	printTestdata()
-	makeTables()
-}
-
-var (
-	tablelist = flag.String("tables",
-		"all",
-		"comma-separated list of which tables to generate; "+
-			"can be 'decomp', 'recomp', 'info' and 'all'")
-	test = flag.Bool("test",
-		false,
-		"test existing tables against DerivedNormalizationProps and generate test data for regression testing")
-	verbose = flag.Bool("verbose",
-		false,
-		"write data to stdout as it is parsed")
-)
-
-const MaxChar = 0x10FFFF // anything above this shouldn't exist
-
-// Quick Check properties of runes allow us to quickly
-// determine whether a rune may occur in a normal form.
-// For a given normal form, a rune may be guaranteed to occur
-// verbatim (QC=Yes), may or may not combine with another
-// rune (QC=Maybe), or may not occur (QC=No).
-type QCResult int
-
-const (
-	QCUnknown QCResult = iota
-	QCYes
-	QCNo
-	QCMaybe
-)
-
-func (r QCResult) String() string {
-	switch r {
-	case QCYes:
-		return "Yes"
-	case QCNo:
-		return "No"
-	case QCMaybe:
-		return "Maybe"
-	}
-	return "***UNKNOWN***"
-}
-
-const (
-	FCanonical     = iota // NFC or NFD
-	FCompatibility        // NFKC or NFKD
-	FNumberOfFormTypes
-)
-
-const (
-	MComposed   = iota // NFC or NFKC
-	MDecomposed        // NFD or NFKD
-	MNumberOfModes
-)
-
-// This contains only the properties we're interested in.
-type Char struct {
-	name          string
-	codePoint     rune  // if zero, this index is not a valid code point.
-	ccc           uint8 // canonical combining class
-	origCCC       uint8
-	excludeInComp bool // from CompositionExclusions.txt
-	compatDecomp  bool // it has a compatibility expansion
-
-	nTrailingNonStarters uint8
-	nLeadingNonStarters  uint8 // must be equal to trailing if non-zero
-
-	forms [FNumberOfFormTypes]FormInfo // For FCanonical and FCompatibility
-
-	state State
-}
-
-var chars = make([]Char, MaxChar+1)
-var cccMap = make(map[uint8]uint8)
-
-func (c Char) String() string {
-	buf := new(bytes.Buffer)
-
-	fmt.Fprintf(buf, "%U [%s]:\n", c.codePoint, c.name)
-	fmt.Fprintf(buf, "  ccc: %v\n", c.ccc)
-	fmt.Fprintf(buf, "  excludeInComp: %v\n", c.excludeInComp)
-	fmt.Fprintf(buf, "  compatDecomp: %v\n", c.compatDecomp)
-	fmt.Fprintf(buf, "  state: %v\n", c.state)
-	fmt.Fprintf(buf, "  NFC:\n")
-	fmt.Fprint(buf, c.forms[FCanonical])
-	fmt.Fprintf(buf, "  NFKC:\n")
-	fmt.Fprint(buf, c.forms[FCompatibility])
-
-	return buf.String()
-}
-
-// In UnicodeData.txt, some ranges are marked like this:
-//	3400;<CJK Ideograph Extension A, First>;Lo;0;L;;;;;N;;;;;
-//	4DB5;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;;
-// parseCharacter keeps a state variable indicating the weirdness.
-type State int
-
-const (
-	SNormal State = iota // known to be zero for the type
-	SFirst
-	SLast
-	SMissing
-)
-
-var lastChar = rune('\u0000')
-
-func (c Char) isValid() bool {
-	return c.codePoint != 0 && c.state != SMissing
-}
-
-type FormInfo struct {
-	quickCheck [MNumberOfModes]QCResult // index: MComposed or MDecomposed
-	verified   [MNumberOfModes]bool     // index: MComposed or MDecomposed
-
-	combinesForward  bool // May combine with rune on the right
-	combinesBackward bool // May combine with rune on the left
-	isOneWay         bool // Never appears in result
-	inDecomp         bool // Some decompositions result in this char.
-	decomp           Decomposition
-	expandedDecomp   Decomposition
-}
-
-func (f FormInfo) String() string {
-	buf := bytes.NewBuffer(make([]byte, 0))
-
-	fmt.Fprintf(buf, "    quickCheck[C]: %v\n", f.quickCheck[MComposed])
-	fmt.Fprintf(buf, "    quickCheck[D]: %v\n", f.quickCheck[MDecomposed])
-	fmt.Fprintf(buf, "    cmbForward: %v\n", f.combinesForward)
-	fmt.Fprintf(buf, "    cmbBackward: %v\n", f.combinesBackward)
-	fmt.Fprintf(buf, "    isOneWay: %v\n", f.isOneWay)
-	fmt.Fprintf(buf, "    inDecomp: %v\n", f.inDecomp)
-	fmt.Fprintf(buf, "    decomposition: %X\n", f.decomp)
-	fmt.Fprintf(buf, "    expandedDecomp: %X\n", f.expandedDecomp)
-
-	return buf.String()
-}
-
-type Decomposition []rune
-
-func parseDecomposition(s string, skipfirst bool) (a []rune, err error) {
-	decomp := strings.Split(s, " ")
-	if len(decomp) > 0 && skipfirst {
-		decomp = decomp[1:]
-	}
-	for _, d := range decomp {
-		point, err := strconv.ParseUint(d, 16, 64)
-		if err != nil {
-			return a, err
-		}
-		a = append(a, rune(point))
-	}
-	return a, nil
-}
-
-func loadUnicodeData() {
-	f := gen.OpenUCDFile("UnicodeData.txt")
-	defer f.Close()
-	p := ucd.New(f)
-	for p.Next() {
-		r := p.Rune(ucd.CodePoint)
-		char := &chars[r]
-
-		char.ccc = uint8(p.Uint(ucd.CanonicalCombiningClass))
-		decmap := p.String(ucd.DecompMapping)
-
-		exp, err := parseDecomposition(decmap, false)
-		isCompat := false
-		if err != nil {
-			if len(decmap) > 0 {
-				exp, err = parseDecomposition(decmap, true)
-				if err != nil {
-					log.Fatalf(`%U: bad decomp |%v|: "%s"`, r, decmap, err)
-				}
-				isCompat = true
-			}
-		}
-
-		char.name = p.String(ucd.Name)
-		char.codePoint = r
-		char.forms[FCompatibility].decomp = exp
-		if !isCompat {
-			char.forms[FCanonical].decomp = exp
-		} else {
-			char.compatDecomp = true
-		}
-		if len(decmap) > 0 {
-			char.forms[FCompatibility].decomp = exp
-		}
-	}
-	if err := p.Err(); err != nil {
-		log.Fatal(err)
-	}
-}
-
-// compactCCC converts the sparse set of CCC values to a continguous one,
-// reducing the number of bits needed from 8 to 6.
-func compactCCC() {
-	m := make(map[uint8]uint8)
-	for i := range chars {
-		c := &chars[i]
-		m[c.ccc] = 0
-	}
-	cccs := []int{}
-	for v, _ := range m {
-		cccs = append(cccs, int(v))
-	}
-	sort.Ints(cccs)
-	for i, c := range cccs {
-		cccMap[uint8(i)] = uint8(c)
-		m[uint8(c)] = uint8(i)
-	}
-	for i := range chars {
-		c := &chars[i]
-		c.origCCC = c.ccc
-		c.ccc = m[c.ccc]
-	}
-	if len(m) >= 1<<6 {
-		log.Fatalf("too many difference CCC values: %d >= 64", len(m))
-	}
-}
-
-// CompositionExclusions.txt has form:
-// 0958    # ...
-// See https://unicode.org/reports/tr44/ for full explanation
-func loadCompositionExclusions() {
-	f := gen.OpenUCDFile("CompositionExclusions.txt")
-	defer f.Close()
-	p := ucd.New(f)
-	for p.Next() {
-		c := &chars[p.Rune(0)]
-		if c.excludeInComp {
-			log.Fatalf("%U: Duplicate entry in exclusions.", c.codePoint)
-		}
-		c.excludeInComp = true
-	}
-	if e := p.Err(); e != nil {
-		log.Fatal(e)
-	}
-}
-
-// hasCompatDecomp returns true if any of the recursive
-// decompositions contains a compatibility expansion.
-// In this case, the character may not occur in NFK*.
-func hasCompatDecomp(r rune) bool {
-	c := &chars[r]
-	if c.compatDecomp {
-		return true
-	}
-	for _, d := range c.forms[FCompatibility].decomp {
-		if hasCompatDecomp(d) {
-			return true
-		}
-	}
-	return false
-}
-
-// Hangul related constants.
-const (
-	HangulBase = 0xAC00
-	HangulEnd  = 0xD7A4 // hangulBase + Jamo combinations (19 * 21 * 28)
-
-	JamoLBase = 0x1100
-	JamoLEnd  = 0x1113
-	JamoVBase = 0x1161
-	JamoVEnd  = 0x1176
-	JamoTBase = 0x11A8
-	JamoTEnd  = 0x11C3
-
-	JamoLVTCount = 19 * 21 * 28
-	JamoTCount   = 28
-)
-
-func isHangul(r rune) bool {
-	return HangulBase <= r && r < HangulEnd
-}
-
-func isHangulWithoutJamoT(r rune) bool {
-	if !isHangul(r) {
-		return false
-	}
-	r -= HangulBase
-	return r < JamoLVTCount && r%JamoTCount == 0
-}
-
-func ccc(r rune) uint8 {
-	return chars[r].ccc
-}
-
-// Insert a rune in a buffer, ordered by Canonical Combining Class.
-func insertOrdered(b Decomposition, r rune) Decomposition {
-	n := len(b)
-	b = append(b, 0)
-	cc := ccc(r)
-	if cc > 0 {
-		// Use bubble sort.
-		for ; n > 0; n-- {
-			if ccc(b[n-1]) <= cc {
-				break
-			}
-			b[n] = b[n-1]
-		}
-	}
-	b[n] = r
-	return b
-}
-
-// Recursively decompose.
-func decomposeRecursive(form int, r rune, d Decomposition) Decomposition {
-	dcomp := chars[r].forms[form].decomp
-	if len(dcomp) == 0 {
-		return insertOrdered(d, r)
-	}
-	for _, c := range dcomp {
-		d = decomposeRecursive(form, c, d)
-	}
-	return d
-}
-
-func completeCharFields(form int) {
-	// Phase 0: pre-expand decomposition.
-	for i := range chars {
-		f := &chars[i].forms[form]
-		if len(f.decomp) == 0 {
-			continue
-		}
-		exp := make(Decomposition, 0)
-		for _, c := range f.decomp {
-			exp = decomposeRecursive(form, c, exp)
-		}
-		f.expandedDecomp = exp
-	}
-
-	// Phase 1: composition exclusion, mark decomposition.
-	for i := range chars {
-		c := &chars[i]
-		f := &c.forms[form]
-
-		// Marks script-specific exclusions and version restricted.
-		f.isOneWay = c.excludeInComp
-
-		// Singletons
-		f.isOneWay = f.isOneWay || len(f.decomp) == 1
-
-		// Non-starter decompositions
-		if len(f.decomp) > 1 {
-			chk := c.ccc != 0 || chars[f.decomp[0]].ccc != 0
-			f.isOneWay = f.isOneWay || chk
-		}
-
-		// Runes that decompose into more than two runes.
-		f.isOneWay = f.isOneWay || len(f.decomp) > 2
-
-		if form == FCompatibility {
-			f.isOneWay = f.isOneWay || hasCompatDecomp(c.codePoint)
-		}
-
-		for _, r := range f.decomp {
-			chars[r].forms[form].inDecomp = true
-		}
-	}
-
-	// Phase 2: forward and backward combining.
-	for i := range chars {
-		c := &chars[i]
-		f := &c.forms[form]
-
-		if !f.isOneWay && len(f.decomp) == 2 {
-			f0 := &chars[f.decomp[0]].forms[form]
-			f1 := &chars[f.decomp[1]].forms[form]
-			if !f0.isOneWay {
-				f0.combinesForward = true
-			}
-			if !f1.isOneWay {
-				f1.combinesBackward = true
-			}
-		}
-		if isHangulWithoutJamoT(rune(i)) {
-			f.combinesForward = true
-		}
-	}
-
-	// Phase 3: quick check values.
-	for i := range chars {
-		c := &chars[i]
-		f := &c.forms[form]
-
-		switch {
-		case len(f.decomp) > 0:
-			f.quickCheck[MDecomposed] = QCNo
-		case isHangul(rune(i)):
-			f.quickCheck[MDecomposed] = QCNo
-		default:
-			f.quickCheck[MDecomposed] = QCYes
-		}
-		switch {
-		case f.isOneWay:
-			f.quickCheck[MComposed] = QCNo
-		case (i & 0xffff00) == JamoLBase:
-			f.quickCheck[MComposed] = QCYes
-			if JamoLBase <= i && i < JamoLEnd {
-				f.combinesForward = true
-			}
-			if JamoVBase <= i && i < JamoVEnd {
-				f.quickCheck[MComposed] = QCMaybe
-				f.combinesBackward = true
-				f.combinesForward = true
-			}
-			if JamoTBase <= i && i < JamoTEnd {
-				f.quickCheck[MComposed] = QCMaybe
-				f.combinesBackward = true
-			}
-		case !f.combinesBackward:
-			f.quickCheck[MComposed] = QCYes
-		default:
-			f.quickCheck[MComposed] = QCMaybe
-		}
-	}
-}
-
-func computeNonStarterCounts() {
-	// Phase 4: leading and trailing non-starter count
-	for i := range chars {
-		c := &chars[i]
-
-		runes := []rune{rune(i)}
-		// We always use FCompatibility so that the CGJ insertion points do not
-		// change for repeated normalizations with different forms.
-		if exp := c.forms[FCompatibility].expandedDecomp; len(exp) > 0 {
-			runes = exp
-		}
-		// We consider runes that combine backwards to be non-starters for the
-		// purpose of Stream-Safe Text Processing.
-		for _, r := range runes {
-			if cr := &chars[r]; cr.ccc == 0 && !cr.forms[FCompatibility].combinesBackward {
-				break
-			}
-			c.nLeadingNonStarters++
-		}
-		for i := len(runes) - 1; i >= 0; i-- {
-			if cr := &chars[runes[i]]; cr.ccc == 0 && !cr.forms[FCompatibility].combinesBackward {
-				break
-			}
-			c.nTrailingNonStarters++
-		}
-		if c.nTrailingNonStarters > 3 {
-			log.Fatalf("%U: Decomposition with more than 3 (%d) trailing modifiers (%U)", i, c.nTrailingNonStarters, runes)
-		}
-
-		if isHangul(rune(i)) {
-			c.nTrailingNonStarters = 2
-			if isHangulWithoutJamoT(rune(i)) {
-				c.nTrailingNonStarters = 1
-			}
-		}
-
-		if l, t := c.nLeadingNonStarters, c.nTrailingNonStarters; l > 0 && l != t {
-			log.Fatalf("%U: number of leading and trailing non-starters should be equal (%d vs %d)", i, l, t)
-		}
-		if t := c.nTrailingNonStarters; t > 3 {
-			log.Fatalf("%U: number of trailing non-starters is %d > 3", t)
-		}
-	}
-}
-
-func printBytes(w io.Writer, b []byte, name string) {
-	fmt.Fprintf(w, "// %s: %d bytes\n", name, len(b))
-	fmt.Fprintf(w, "var %s = [...]byte {", name)
-	for i, c := range b {
-		switch {
-		case i%64 == 0:
-			fmt.Fprintf(w, "\n// Bytes %x - %x\n", i, i+63)
-		case i%8 == 0:
-			fmt.Fprintf(w, "\n")
-		}
-		fmt.Fprintf(w, "0x%.2X, ", c)
-	}
-	fmt.Fprint(w, "\n}\n\n")
-}
-
-// See forminfo.go for format.
-func makeEntry(f *FormInfo, c *Char) uint16 {
-	e := uint16(0)
-	if r := c.codePoint; HangulBase <= r && r < HangulEnd {
-		e |= 0x40
-	}
-	if f.combinesForward {
-		e |= 0x20
-	}
-	if f.quickCheck[MDecomposed] == QCNo {
-		e |= 0x4
-	}
-	switch f.quickCheck[MComposed] {
-	case QCYes:
-	case QCNo:
-		e |= 0x10
-	case QCMaybe:
-		e |= 0x18
-	default:
-		log.Fatalf("Illegal quickcheck value %v.", f.quickCheck[MComposed])
-	}
-	e |= uint16(c.nTrailingNonStarters)
-	return e
-}
-
-// decompSet keeps track of unique decompositions, grouped by whether
-// the decomposition is followed by a trailing and/or leading CCC.
-type decompSet [7]map[string]bool
-
-const (
-	normalDecomp = iota
-	firstMulti
-	firstCCC
-	endMulti
-	firstLeadingCCC
-	firstCCCZeroExcept
-	firstStarterWithNLead
-	lastDecomp
-)
-
-var cname = []string{"firstMulti", "firstCCC", "endMulti", "firstLeadingCCC", "firstCCCZeroExcept", "firstStarterWithNLead", "lastDecomp"}
-
-func makeDecompSet() decompSet {
-	m := decompSet{}
-	for i := range m {
-		m[i] = make(map[string]bool)
-	}
-	return m
-}
-func (m *decompSet) insert(key int, s string) {
-	m[key][s] = true
-}
-
-func printCharInfoTables(w io.Writer) int {
-	mkstr := func(r rune, f *FormInfo) (int, string) {
-		d := f.expandedDecomp
-		s := string([]rune(d))
-		if max := 1 << 6; len(s) >= max {
-			const msg = "%U: too many bytes in decomposition: %d >= %d"
-			log.Fatalf(msg, r, len(s), max)
-		}
-		head := uint8(len(s))
-		if f.quickCheck[MComposed] != QCYes {
-			head |= 0x40
-		}
-		if f.combinesForward {
-			head |= 0x80
-		}
-		s = string([]byte{head}) + s
-
-		lccc := ccc(d[0])
-		tccc := ccc(d[len(d)-1])
-		cc := ccc(r)
-		if cc != 0 && lccc == 0 && tccc == 0 {
-			log.Fatalf("%U: trailing and leading ccc are 0 for non-zero ccc %d", r, cc)
-		}
-		if tccc < lccc && lccc != 0 {
-			const msg = "%U: lccc (%d) must be <= tcc (%d)"
-			log.Fatalf(msg, r, lccc, tccc)
-		}
-		index := normalDecomp
-		nTrail := chars[r].nTrailingNonStarters
-		nLead := chars[r].nLeadingNonStarters
-		if tccc > 0 || lccc > 0 || nTrail > 0 {
-			tccc <<= 2
-			tccc |= nTrail
-			s += string([]byte{tccc})
-			index = endMulti
-			for _, r := range d[1:] {
-				if ccc(r) == 0 {
-					index = firstCCC
-				}
-			}
-			if lccc > 0 || nLead > 0 {
-				s += string([]byte{lccc})
-				if index == firstCCC {
-					log.Fatalf("%U: multi-segment decomposition not supported for decompositions with leading CCC != 0", r)
-				}
-				index = firstLeadingCCC
-			}
-			if cc != lccc {
-				if cc != 0 {
-					log.Fatalf("%U: for lccc != ccc, expected ccc to be 0; was %d", r, cc)
-				}
-				index = firstCCCZeroExcept
-			}
-		} else if len(d) > 1 {
-			index = firstMulti
-		}
-		return index, s
-	}
-
-	decompSet := makeDecompSet()
-	const nLeadStr = "\x00\x01" // 0-byte length and tccc with nTrail.
-	decompSet.insert(firstStarterWithNLead, nLeadStr)
-
-	// Store the uniqued decompositions in a byte buffer,
-	// preceded by their byte length.
-	for _, c := range chars {
-		for _, f := range c.forms {
-			if len(f.expandedDecomp) == 0 {
-				continue
-			}
-			if f.combinesBackward {
-				log.Fatalf("%U: combinesBackward and decompose", c.codePoint)
-			}
-			index, s := mkstr(c.codePoint, &f)
-			decompSet.insert(index, s)
-		}
-	}
-
-	decompositions := bytes.NewBuffer(make([]byte, 0, 10000))
-	size := 0
-	positionMap := make(map[string]uint16)
-	decompositions.WriteString("\000")
-	fmt.Fprintln(w, "const (")
-	for i, m := range decompSet {
-		sa := []string{}
-		for s := range m {
-			sa = append(sa, s)
-		}
-		sort.Strings(sa)
-		for _, s := range sa {
-			p := decompositions.Len()
-			decompositions.WriteString(s)
-			positionMap[s] = uint16(p)
-		}
-		if cname[i] != "" {
-			fmt.Fprintf(w, "%s = 0x%X\n", cname[i], decompositions.Len())
-		}
-	}
-	fmt.Fprintln(w, "maxDecomp = 0x8000")
-	fmt.Fprintln(w, ")")
-	b := decompositions.Bytes()
-	printBytes(w, b, "decomps")
-	size += len(b)
-
-	varnames := []string{"nfc", "nfkc"}
-	for i := 0; i < FNumberOfFormTypes; i++ {
-		trie := triegen.NewTrie(varnames[i])
-
-		for r, c := range chars {
-			f := c.forms[i]
-			d := f.expandedDecomp
-			if len(d) != 0 {
-				_, key := mkstr(c.codePoint, &f)
-				trie.Insert(rune(r), uint64(positionMap[key]))
-				if c.ccc != ccc(d[0]) {
-					// We assume the lead ccc of a decomposition !=0 in this case.
-					if ccc(d[0]) == 0 {
-						log.Fatalf("Expected leading CCC to be non-zero; ccc is %d", c.ccc)
-					}
-				}
-			} else if c.nLeadingNonStarters > 0 && len(f.expandedDecomp) == 0 && c.ccc == 0 && !f.combinesBackward {
-				// Handle cases where it can't be detected that the nLead should be equal
-				// to nTrail.
-				trie.Insert(c.codePoint, uint64(positionMap[nLeadStr]))
-			} else if v := makeEntry(&f, &c)<<8 | uint16(c.ccc); v != 0 {
-				trie.Insert(c.codePoint, uint64(0x8000|v))
-			}
-		}
-		sz, err := trie.Gen(w, triegen.Compact(&normCompacter{name: varnames[i]}))
-		if err != nil {
-			log.Fatal(err)
-		}
-		size += sz
-	}
-	return size
-}
-
-func contains(sa []string, s string) bool {
-	for _, a := range sa {
-		if a == s {
-			return true
-		}
-	}
-	return false
-}
-
-func makeTables() {
-	w := &bytes.Buffer{}
-
-	size := 0
-	if *tablelist == "" {
-		return
-	}
-	list := strings.Split(*tablelist, ",")
-	if *tablelist == "all" {
-		list = []string{"recomp", "info"}
-	}
-
-	// Compute maximum decomposition size.
-	max := 0
-	for _, c := range chars {
-		if n := len(string(c.forms[FCompatibility].expandedDecomp)); n > max {
-			max = n
-		}
-	}
-	fmt.Fprintln(w, `import "sync"`)
-	fmt.Fprintln(w)
-
-	fmt.Fprintln(w, "const (")
-	fmt.Fprintln(w, "\t// Version is the Unicode edition from which the tables are derived.")
-	fmt.Fprintf(w, "\tVersion = %q\n", gen.UnicodeVersion())
-	fmt.Fprintln(w)
-	fmt.Fprintln(w, "\t// MaxTransformChunkSize indicates the maximum number of bytes that Transform")
-	fmt.Fprintln(w, "\t// may need to write atomically for any Form. Making a destination buffer at")
-	fmt.Fprintln(w, "\t// least this size ensures that Transform can always make progress and that")
-	fmt.Fprintln(w, "\t// the user does not need to grow the buffer on an ErrShortDst.")
-	fmt.Fprintf(w, "\tMaxTransformChunkSize = %d+maxNonStarters*4\n", len(string(0x034F))+max)
-	fmt.Fprintln(w, ")\n")
-
-	// Print the CCC remap table.
-	size += len(cccMap)
-	fmt.Fprintf(w, "var ccc = [%d]uint8{", len(cccMap))
-	for i := 0; i < len(cccMap); i++ {
-		if i%8 == 0 {
-			fmt.Fprintln(w)
-		}
-		fmt.Fprintf(w, "%3d, ", cccMap[uint8(i)])
-	}
-	fmt.Fprintln(w, "\n}\n")
-
-	if contains(list, "info") {
-		size += printCharInfoTables(w)
-	}
-
-	if contains(list, "recomp") {
-		// Note that we use 32 bit keys, instead of 64 bit.
-		// This clips the bits of three entries, but we know
-		// this won't cause a collision. The compiler will catch
-		// any changes made to UnicodeData.txt that introduces
-		// a collision.
-		// Note that the recomposition map for NFC and NFKC
-		// are identical.
-
-		// Recomposition map
-		nrentries := 0
-		for _, c := range chars {
-			f := c.forms[FCanonical]
-			if !f.isOneWay && len(f.decomp) > 0 {
-				nrentries++
-			}
-		}
-		sz := nrentries * 8
-		size += sz
-		fmt.Fprintf(w, "// recompMap: %d bytes (entries only)\n", sz)
-		fmt.Fprintln(w, "var recompMap map[uint32]rune")
-		fmt.Fprintln(w, "var recompMapOnce sync.Once\n")
-		fmt.Fprintln(w, `const recompMapPacked = "" +`)
-		var buf [8]byte
-		for i, c := range chars {
-			f := c.forms[FCanonical]
-			d := f.decomp
-			if !f.isOneWay && len(d) > 0 {
-				key := uint32(uint16(d[0]))<<16 + uint32(uint16(d[1]))
-				binary.BigEndian.PutUint32(buf[:4], key)
-				binary.BigEndian.PutUint32(buf[4:], uint32(i))
-				fmt.Fprintf(w, "\t\t%q + // 0x%.8X: 0x%.8X\n", string(buf[:]), key, uint32(i))
-			}
-		}
-		// hack so we don't have to special case the trailing plus sign
-		fmt.Fprintf(w, `	""`)
-		fmt.Fprintln(w)
-	}
-
-	fmt.Fprintf(w, "// Total size of tables: %dKB (%d bytes)\n", (size+512)/1024, size)
-	gen.WriteVersionedGoFile("tables.go", "norm", w.Bytes())
-}
-
-func printChars() {
-	if *verbose {
-		for _, c := range chars {
-			if !c.isValid() || c.state == SMissing {
-				continue
-			}
-			fmt.Println(c)
-		}
-	}
-}
-
-// verifyComputed does various consistency tests.
-func verifyComputed() {
-	for i, c := range chars {
-		for _, f := range c.forms {
-			isNo := (f.quickCheck[MDecomposed] == QCNo)
-			if (len(f.decomp) > 0) != isNo && !isHangul(rune(i)) {
-				log.Fatalf("%U: NF*D QC must be No if rune decomposes", i)
-			}
-
-			isMaybe := f.quickCheck[MComposed] == QCMaybe
-			if f.combinesBackward != isMaybe {
-				log.Fatalf("%U: NF*C QC must be Maybe if combinesBackward", i)
-			}
-			if len(f.decomp) > 0 && f.combinesForward && isMaybe {
-				log.Fatalf("%U: NF*C QC must be Yes or No if combinesForward and decomposes", i)
-			}
-
-			if len(f.expandedDecomp) != 0 {
-				continue
-			}
-			if a, b := c.nLeadingNonStarters > 0, (c.ccc > 0 || f.combinesBackward); a != b {
-				// We accept these runes to be treated differently (it only affects
-				// segment breaking in iteration, most likely on improper use), but
-				// reconsider if more characters are added.
-				// U+FF9E HALFWIDTH KATAKANA VOICED SOUND MARK;Lm;0;L;<narrow> 3099;;;;N;;;;;
-				// U+FF9F HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK;Lm;0;L;<narrow> 309A;;;;N;;;;;
-				// U+3133 HANGUL LETTER KIYEOK-SIOS;Lo;0;L;<compat> 11AA;;;;N;HANGUL LETTER GIYEOG SIOS;;;;
-				// U+318E HANGUL LETTER ARAEAE;Lo;0;L;<compat> 11A1;;;;N;HANGUL LETTER ALAE AE;;;;
-				// U+FFA3 HALFWIDTH HANGUL LETTER KIYEOK-SIOS;Lo;0;L;<narrow> 3133;;;;N;HALFWIDTH HANGUL LETTER GIYEOG SIOS;;;;
-				// U+FFDC HALFWIDTH HANGUL LETTER I;Lo;0;L;<narrow> 3163;;;;N;;;;;
-				if i != 0xFF9E && i != 0xFF9F && !(0x3133 <= i && i <= 0x318E) && !(0xFFA3 <= i && i <= 0xFFDC) {
-					log.Fatalf("%U: nLead was %v; want %v", i, a, b)
-				}
-			}
-		}
-		nfc := c.forms[FCanonical]
-		nfkc := c.forms[FCompatibility]
-		if nfc.combinesBackward != nfkc.combinesBackward {
-			log.Fatalf("%U: Cannot combine combinesBackward\n", c.codePoint)
-		}
-	}
-}
-
-// Use values in DerivedNormalizationProps.txt to compare against the
-// values we computed.
-// DerivedNormalizationProps.txt has form:
-// 00C0..00C5    ; NFD_QC; N # ...
-// 0374          ; NFD_QC; N # ...
-// See https://unicode.org/reports/tr44/ for full explanation
-func testDerived() {
-	f := gen.OpenUCDFile("DerivedNormalizationProps.txt")
-	defer f.Close()
-	p := ucd.New(f)
-	for p.Next() {
-		r := p.Rune(0)
-		c := &chars[r]
-
-		var ftype, mode int
-		qt := p.String(1)
-		switch qt {
-		case "NFC_QC":
-			ftype, mode = FCanonical, MComposed
-		case "NFD_QC":
-			ftype, mode = FCanonical, MDecomposed
-		case "NFKC_QC":
-			ftype, mode = FCompatibility, MComposed
-		case "NFKD_QC":
-			ftype, mode = FCompatibility, MDecomposed
-		default:
-			continue
-		}
-		var qr QCResult
-		switch p.String(2) {
-		case "Y":
-			qr = QCYes
-		case "N":
-			qr = QCNo
-		case "M":
-			qr = QCMaybe
-		default:
-			log.Fatalf(`Unexpected quick check value "%s"`, p.String(2))
-		}
-		if got := c.forms[ftype].quickCheck[mode]; got != qr {
-			log.Printf("%U: FAILED %s (was %v need %v)\n", r, qt, got, qr)
-		}
-		c.forms[ftype].verified[mode] = true
-	}
-	if err := p.Err(); err != nil {
-		log.Fatal(err)
-	}
-	// Any unspecified value must be QCYes. Verify this.
-	for i, c := range chars {
-		for j, fd := range c.forms {
-			for k, qr := range fd.quickCheck {
-				if !fd.verified[k] && qr != QCYes {
-					m := "%U: FAIL F:%d M:%d (was %v need Yes) %s\n"
-					log.Printf(m, i, j, k, qr, c.name)
-				}
-			}
-		}
-	}
-}
-
-var testHeader = `const (
-	Yes = iota
-	No
-	Maybe
-)
-
-type formData struct {
-	qc              uint8
-	combinesForward bool
-	decomposition   string
-}
-
-type runeData struct {
-	r      rune
-	ccc    uint8
-	nLead  uint8
-	nTrail uint8
-	f      [2]formData // 0: canonical; 1: compatibility
-}
-
-func f(qc uint8, cf bool, dec string) [2]formData {
-	return [2]formData{{qc, cf, dec}, {qc, cf, dec}}
-}
-
-func g(qc, qck uint8, cf, cfk bool, d, dk string) [2]formData {
-	return [2]formData{{qc, cf, d}, {qck, cfk, dk}}
-}
-
-var testData = []runeData{
-`
-
-func printTestdata() {
-	type lastInfo struct {
-		ccc    uint8
-		nLead  uint8
-		nTrail uint8
-		f      string
-	}
-
-	last := lastInfo{}
-	w := &bytes.Buffer{}
-	fmt.Fprintf(w, testHeader)
-	for r, c := range chars {
-		f := c.forms[FCanonical]
-		qc, cf, d := f.quickCheck[MComposed], f.combinesForward, string(f.expandedDecomp)
-		f = c.forms[FCompatibility]
-		qck, cfk, dk := f.quickCheck[MComposed], f.combinesForward, string(f.expandedDecomp)
-		s := ""
-		if d == dk && qc == qck && cf == cfk {
-			s = fmt.Sprintf("f(%s, %v, %q)", qc, cf, d)
-		} else {
-			s = fmt.Sprintf("g(%s, %s, %v, %v, %q, %q)", qc, qck, cf, cfk, d, dk)
-		}
-		current := lastInfo{c.ccc, c.nLeadingNonStarters, c.nTrailingNonStarters, s}
-		if last != current {
-			fmt.Fprintf(w, "\t{0x%x, %d, %d, %d, %s},\n", r, c.origCCC, c.nLeadingNonStarters, c.nTrailingNonStarters, s)
-			last = current
-		}
-	}
-	fmt.Fprintln(w, "}")
-	gen.WriteVersionedGoFile("data_test.go", "norm", w.Bytes())
-}
diff --git a/vendor/golang.org/x/text/unicode/norm/triegen.go b/vendor/golang.org/x/text/unicode/norm/triegen.go
deleted file mode 100644
index 45d711900..000000000
--- a/vendor/golang.org/x/text/unicode/norm/triegen.go
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright 2011 The Go 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 ignore
-
-// Trie table generator.
-// Used by make*tables tools to generate a go file with trie data structures
-// for mapping UTF-8 to a 16-bit value. All but the last byte in a UTF-8 byte
-// sequence are used to lookup offsets in the index table to be used for the
-// next byte. The last byte is used to index into a table with 16-bit values.
-
-package main
-
-import (
-	"fmt"
-	"io"
-)
-
-const maxSparseEntries = 16
-
-type normCompacter struct {
-	sparseBlocks [][]uint64
-	sparseOffset []uint16
-	sparseCount  int
-	name         string
-}
-
-func mostFrequentStride(a []uint64) int {
-	counts := make(map[int]int)
-	var v int
-	for _, x := range a {
-		if stride := int(x) - v; v != 0 && stride >= 0 {
-			counts[stride]++
-		}
-		v = int(x)
-	}
-	var maxs, maxc int
-	for stride, cnt := range counts {
-		if cnt > maxc || (cnt == maxc && stride < maxs) {
-			maxs, maxc = stride, cnt
-		}
-	}
-	return maxs
-}
-
-func countSparseEntries(a []uint64) int {
-	stride := mostFrequentStride(a)
-	var v, count int
-	for _, tv := range a {
-		if int(tv)-v != stride {
-			if tv != 0 {
-				count++
-			}
-		}
-		v = int(tv)
-	}
-	return count
-}
-
-func (c *normCompacter) Size(v []uint64) (sz int, ok bool) {
-	if n := countSparseEntries(v); n <= maxSparseEntries {
-		return (n+1)*4 + 2, true
-	}
-	return 0, false
-}
-
-func (c *normCompacter) Store(v []uint64) uint32 {
-	h := uint32(len(c.sparseOffset))
-	c.sparseBlocks = append(c.sparseBlocks, v)
-	c.sparseOffset = append(c.sparseOffset, uint16(c.sparseCount))
-	c.sparseCount += countSparseEntries(v) + 1
-	return h
-}
-
-func (c *normCompacter) Handler() string {
-	return c.name + "Sparse.lookup"
-}
-
-func (c *normCompacter) Print(w io.Writer) (retErr error) {
-	p := func(f string, x ...interface{}) {
-		if _, err := fmt.Fprintf(w, f, x...); retErr == nil && err != nil {
-			retErr = err
-		}
-	}
-
-	ls := len(c.sparseBlocks)
-	p("// %sSparseOffset: %d entries, %d bytes\n", c.name, ls, ls*2)
-	p("var %sSparseOffset = %#v\n\n", c.name, c.sparseOffset)
-
-	ns := c.sparseCount
-	p("// %sSparseValues: %d entries, %d bytes\n", c.name, ns, ns*4)
-	p("var %sSparseValues = [%d]valueRange {", c.name, ns)
-	for i, b := range c.sparseBlocks {
-		p("\n// Block %#x, offset %#x", i, c.sparseOffset[i])
-		var v int
-		stride := mostFrequentStride(b)
-		n := countSparseEntries(b)
-		p("\n{value:%#04x,lo:%#02x},", stride, uint8(n))
-		for i, nv := range b {
-			if int(nv)-v != stride {
-				if v != 0 {
-					p(",hi:%#02x},", 0x80+i-1)
-				}
-				if nv != 0 {
-					p("\n{value:%#04x,lo:%#02x", nv, 0x80+i)
-				}
-			}
-			v = int(nv)
-		}
-		if v != 0 {
-			p(",hi:%#02x},", 0x80+len(b)-1)
-		}
-	}
-	p("\n}\n\n")
-	return
-}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 31a34c6f4..9446197b2 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -1,11 +1,11 @@
 # cloud.google.com/go v0.45.1
 cloud.google.com/go/compute/metadata
-cloud.google.com/go/storage
 cloud.google.com/go/iam
 cloud.google.com/go/internal
 cloud.google.com/go/internal/optional
 cloud.google.com/go/internal/trace
 cloud.google.com/go/internal/version
+cloud.google.com/go/storage
 # contrib.go.opencensus.io/exporter/ocagent v0.5.0
 contrib.go.opencensus.io/exporter/ocagent
 # github.com/1and1/oneandone-cloudserver-sdk-go v1.0.1
@@ -14,42 +14,42 @@ github.com/1and1/oneandone-cloudserver-sdk-go
 github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-04-01/compute
 github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute
 github.com/Azure/azure-sdk-for-go/services/network/mgmt/2018-01-01/network
+github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-06-01/subscriptions
 github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2018-02-01/resources
 github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2017-10-01/storage
 github.com/Azure/azure-sdk-for-go/storage
-github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-06-01/subscriptions
 github.com/Azure/azure-sdk-for-go/version
 # github.com/Azure/go-autorest v12.0.0+incompatible
 github.com/Azure/go-autorest/autorest
 github.com/Azure/go-autorest/autorest/adal
 github.com/Azure/go-autorest/autorest/azure
-github.com/Azure/go-autorest/autorest/to
 github.com/Azure/go-autorest/autorest/date
+github.com/Azure/go-autorest/autorest/to
 github.com/Azure/go-autorest/autorest/validation
-github.com/Azure/go-autorest/tracing
 github.com/Azure/go-autorest/logger
+github.com/Azure/go-autorest/tracing
 # github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4
 github.com/Azure/go-ntlmssp
 # github.com/ChrisTrenkamp/goxpath v0.0.0-20170625215350-4fe035839290
 github.com/ChrisTrenkamp/goxpath
-github.com/ChrisTrenkamp/goxpath/tree/xmltree
-github.com/ChrisTrenkamp/goxpath/tree
 github.com/ChrisTrenkamp/goxpath/internal/execxp
-github.com/ChrisTrenkamp/goxpath/internal/parser
-github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlbuilder
-github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlele
 github.com/ChrisTrenkamp/goxpath/internal/lexer
+github.com/ChrisTrenkamp/goxpath/internal/parser
 github.com/ChrisTrenkamp/goxpath/internal/parser/findutil
 github.com/ChrisTrenkamp/goxpath/internal/parser/intfns
 github.com/ChrisTrenkamp/goxpath/internal/parser/pathexpr
 github.com/ChrisTrenkamp/goxpath/internal/xconst
 github.com/ChrisTrenkamp/goxpath/internal/xsort
+github.com/ChrisTrenkamp/goxpath/tree
+github.com/ChrisTrenkamp/goxpath/tree/xmltree
+github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlbuilder
+github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlele
 github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlnode
 # github.com/NaverCloudPlatform/ncloud-sdk-go v0.0.0-20180110055012-c2e73f942591
-github.com/NaverCloudPlatform/ncloud-sdk-go/sdk
 github.com/NaverCloudPlatform/ncloud-sdk-go/common
-github.com/NaverCloudPlatform/ncloud-sdk-go/request
 github.com/NaverCloudPlatform/ncloud-sdk-go/oauth
+github.com/NaverCloudPlatform/ncloud-sdk-go/request
+github.com/NaverCloudPlatform/ncloud-sdk-go/sdk
 # github.com/PuerkitoBio/goquery v1.5.0
 github.com/PuerkitoBio/goquery
 # github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d
@@ -57,18 +57,18 @@ github.com/StackExchange/wmi
 # github.com/Telmate/proxmox-api-go v0.0.0-20190815172943-ef9222844e60
 github.com/Telmate/proxmox-api-go/proxmox
 # github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190418113227-25233c783f4e
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses
-github.com/aliyun/alibaba-cloud-sdk-go/services/ecs
-github.com/aliyun/alibaba-cloud-sdk-go/services/ram
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils
 github.com/aliyun/alibaba-cloud-sdk-go/sdk
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider
-github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses
+github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils
+github.com/aliyun/alibaba-cloud-sdk-go/services/ecs
+github.com/aliyun/alibaba-cloud-sdk-go/services/ram
 # github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20170113022742-e6dbea820a9f
 github.com/aliyun/aliyun-oss-go-sdk/oss
 # github.com/andybalholm/cascadia v1.0.0
@@ -93,49 +93,49 @@ github.com/armon/go-metrics
 github.com/armon/go-radix
 # github.com/aws/aws-sdk-go v1.24.1
 github.com/aws/aws-sdk-go/aws
-github.com/aws/aws-sdk-go/aws/ec2metadata
-github.com/aws/aws-sdk-go/aws/session
-github.com/aws/aws-sdk-go/service/ec2
 github.com/aws/aws-sdk-go/aws/awserr
-github.com/aws/aws-sdk-go/aws/credentials
-github.com/aws/aws-sdk-go/aws/request
-github.com/aws/aws-sdk-go/service/ec2/ec2iface
-github.com/aws/aws-sdk-go/service/sts
-github.com/aws/aws-sdk-go/service/ecr
-github.com/aws/aws-sdk-go/service/s3
-github.com/aws/aws-sdk-go/service/s3/s3manager
-github.com/aws/aws-sdk-go/aws/endpoints
-github.com/aws/aws-sdk-go/internal/sdkio
+github.com/aws/aws-sdk-go/aws/awsutil
 github.com/aws/aws-sdk-go/aws/client
 github.com/aws/aws-sdk-go/aws/client/metadata
 github.com/aws/aws-sdk-go/aws/corehandlers
-github.com/aws/aws-sdk-go/internal/sdkuri
+github.com/aws/aws-sdk-go/aws/credentials
+github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds
+github.com/aws/aws-sdk-go/aws/credentials/endpointcreds
 github.com/aws/aws-sdk-go/aws/credentials/processcreds
 github.com/aws/aws-sdk-go/aws/credentials/stscreds
 github.com/aws/aws-sdk-go/aws/csm
 github.com/aws/aws-sdk-go/aws/defaults
-github.com/aws/aws-sdk-go/internal/ini
-github.com/aws/aws-sdk-go/internal/shareddefaults
-github.com/aws/aws-sdk-go/aws/awsutil
+github.com/aws/aws-sdk-go/aws/ec2metadata
+github.com/aws/aws-sdk-go/aws/endpoints
+github.com/aws/aws-sdk-go/aws/request
+github.com/aws/aws-sdk-go/aws/session
 github.com/aws/aws-sdk-go/aws/signer/v4
+github.com/aws/aws-sdk-go/internal/ini
+github.com/aws/aws-sdk-go/internal/s3err
+github.com/aws/aws-sdk-go/internal/sdkio
+github.com/aws/aws-sdk-go/internal/sdkmath
+github.com/aws/aws-sdk-go/internal/sdkrand
+github.com/aws/aws-sdk-go/internal/sdkuri
+github.com/aws/aws-sdk-go/internal/shareddefaults
 github.com/aws/aws-sdk-go/private/protocol
 github.com/aws/aws-sdk-go/private/protocol/ec2query
-github.com/aws/aws-sdk-go/private/protocol/query
-github.com/aws/aws-sdk-go/private/protocol/jsonrpc
-github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds
-github.com/aws/aws-sdk-go/internal/s3err
 github.com/aws/aws-sdk-go/private/protocol/eventstream
 github.com/aws/aws-sdk-go/private/protocol/eventstream/eventstreamapi
+github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
+github.com/aws/aws-sdk-go/private/protocol/jsonrpc
+github.com/aws/aws-sdk-go/private/protocol/query
+github.com/aws/aws-sdk-go/private/protocol/query/queryutil
 github.com/aws/aws-sdk-go/private/protocol/rest
 github.com/aws/aws-sdk-go/private/protocol/restxml
 github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
+github.com/aws/aws-sdk-go/service/ec2
+github.com/aws/aws-sdk-go/service/ec2/ec2iface
+github.com/aws/aws-sdk-go/service/ecr
+github.com/aws/aws-sdk-go/service/s3
 github.com/aws/aws-sdk-go/service/s3/s3iface
-github.com/aws/aws-sdk-go/internal/sdkrand
+github.com/aws/aws-sdk-go/service/s3/s3manager
+github.com/aws/aws-sdk-go/service/sts
 github.com/aws/aws-sdk-go/service/sts/stsiface
-github.com/aws/aws-sdk-go/aws/credentials/endpointcreds
-github.com/aws/aws-sdk-go/internal/sdkmath
-github.com/aws/aws-sdk-go/private/protocol/query/queryutil
-github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
 # github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d
 github.com/bgentry/go-netrc/netrc
 # github.com/bgentry/speakeasy v0.1.0
@@ -195,11 +195,11 @@ github.com/go-ole/go-ole/oleutil
 # github.com/gobwas/glob v0.2.3
 github.com/gobwas/glob
 github.com/gobwas/glob/compiler
-github.com/gobwas/glob/syntax
 github.com/gobwas/glob/match
+github.com/gobwas/glob/syntax
 github.com/gobwas/glob/syntax/ast
-github.com/gobwas/glob/util/runes
 github.com/gobwas/glob/syntax/lexer
+github.com/gobwas/glob/util/runes
 github.com/gobwas/glob/util/strings
 # github.com/gocolly/colly v1.2.0
 github.com/gocolly/colly
@@ -212,19 +212,19 @@ github.com/gofrs/uuid
 # github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
 github.com/golang-collections/collections/stack
 # github.com/golang/protobuf v1.3.2
-github.com/golang/protobuf/proto
-github.com/golang/protobuf/ptypes/timestamp
-github.com/golang/protobuf/ptypes
 github.com/golang/protobuf/jsonpb
+github.com/golang/protobuf/proto
 github.com/golang/protobuf/protoc-gen-go/descriptor
+github.com/golang/protobuf/protoc-gen-go/generator
+github.com/golang/protobuf/protoc-gen-go/generator/internal/remap
+github.com/golang/protobuf/protoc-gen-go/plugin
+github.com/golang/protobuf/ptypes
 github.com/golang/protobuf/ptypes/any
 github.com/golang/protobuf/ptypes/duration
 github.com/golang/protobuf/ptypes/empty
 github.com/golang/protobuf/ptypes/struct
+github.com/golang/protobuf/ptypes/timestamp
 github.com/golang/protobuf/ptypes/wrappers
-github.com/golang/protobuf/protoc-gen-go/generator
-github.com/golang/protobuf/protoc-gen-go/generator/internal/remap
-github.com/golang/protobuf/protoc-gen-go/plugin
 # github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db
 github.com/golang/snappy
 # github.com/google/go-cmp v0.3.0
@@ -243,6 +243,7 @@ github.com/google/uuid
 github.com/googleapis/gax-go/v2
 # github.com/gophercloud/gophercloud v0.2.0
 github.com/gophercloud/gophercloud
+github.com/gophercloud/gophercloud/internal
 github.com/gophercloud/gophercloud/openstack
 github.com/gophercloud/gophercloud/openstack/blockstorage/extensions/volumeactions
 github.com/gophercloud/gophercloud/openstack/blockstorage/v3/volumes
@@ -251,19 +252,18 @@ github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/bootfromvolum
 github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/keypairs
 github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/startstop
 github.com/gophercloud/gophercloud/openstack/compute/v2/flavors
+github.com/gophercloud/gophercloud/openstack/compute/v2/images
 github.com/gophercloud/gophercloud/openstack/compute/v2/servers
+github.com/gophercloud/gophercloud/openstack/identity/v2/tenants
+github.com/gophercloud/gophercloud/openstack/identity/v2/tokens
+github.com/gophercloud/gophercloud/openstack/identity/v3/tokens
 github.com/gophercloud/gophercloud/openstack/imageservice/v2/images
 github.com/gophercloud/gophercloud/openstack/imageservice/v2/members
 github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/external
 github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/layer3/floatingips
 github.com/gophercloud/gophercloud/openstack/networking/v2/networks
-github.com/gophercloud/gophercloud/pagination
-github.com/gophercloud/gophercloud/openstack/identity/v2/tokens
-github.com/gophercloud/gophercloud/openstack/identity/v3/tokens
 github.com/gophercloud/gophercloud/openstack/utils
-github.com/gophercloud/gophercloud/openstack/compute/v2/images
-github.com/gophercloud/gophercloud/internal
-github.com/gophercloud/gophercloud/openstack/identity/v2/tenants
+github.com/gophercloud/gophercloud/pagination
 # github.com/gophercloud/utils v0.0.0-20190124192022-a5c25e7a53a6
 github.com/gophercloud/utils/openstack/clientconfig
 # github.com/gorilla/websocket v0.0.0-20170319172727-a91eba7f9777
@@ -271,9 +271,9 @@ github.com/gorilla/websocket
 # github.com/grpc-ecosystem/go-grpc-middleware v1.1.0
 github.com/grpc-ecosystem/go-grpc-middleware
 # github.com/grpc-ecosystem/grpc-gateway v1.8.5
+github.com/grpc-ecosystem/grpc-gateway/internal
 github.com/grpc-ecosystem/grpc-gateway/runtime
 github.com/grpc-ecosystem/grpc-gateway/utilities
-github.com/grpc-ecosystem/grpc-gateway/internal
 # github.com/hashicorp/consul v1.4.0
 github.com/hashicorp/consul/api
 # github.com/hashicorp/errwrap v1.0.0
@@ -290,9 +290,9 @@ github.com/hashicorp/go-immutable-radix
 # github.com/hashicorp/go-multierror v1.0.0
 github.com/hashicorp/go-multierror
 # github.com/hashicorp/go-oracle-terraform v0.0.0-20181016190316-007121241b79
+github.com/hashicorp/go-oracle-terraform/client
 github.com/hashicorp/go-oracle-terraform/compute
 github.com/hashicorp/go-oracle-terraform/opc
-github.com/hashicorp/go-oracle-terraform/client
 # github.com/hashicorp/go-retryablehttp v0.5.2
 github.com/hashicorp/go-retryablehttp
 # github.com/hashicorp/go-rootcerts v0.0.0-20160503143440-6bb64b370b90
@@ -311,21 +311,21 @@ github.com/hashicorp/golang-lru/simplelru
 github.com/hashicorp/hcl
 github.com/hashicorp/hcl/hcl/ast
 github.com/hashicorp/hcl/hcl/parser
-github.com/hashicorp/hcl/hcl/token
-github.com/hashicorp/hcl/json/parser
 github.com/hashicorp/hcl/hcl/scanner
 github.com/hashicorp/hcl/hcl/strconv
+github.com/hashicorp/hcl/hcl/token
+github.com/hashicorp/hcl/json/parser
 github.com/hashicorp/hcl/json/scanner
 github.com/hashicorp/hcl/json/token
 # github.com/hashicorp/serf v0.8.2
 github.com/hashicorp/serf/coordinate
 # github.com/hashicorp/vault v1.1.0
 github.com/hashicorp/vault/api
+github.com/hashicorp/vault/helper/compressutil
 github.com/hashicorp/vault/helper/consts
 github.com/hashicorp/vault/helper/hclutil
 github.com/hashicorp/vault/helper/jsonutil
 github.com/hashicorp/vault/helper/parseutil
-github.com/hashicorp/vault/helper/compressutil
 github.com/hashicorp/vault/helper/strutil
 # github.com/hashicorp/yamux v0.0.0-20181012175058-2f1d1f20f75d
 github.com/hashicorp/yamux
@@ -336,15 +336,15 @@ github.com/hetznercloud/hcloud-go/hcloud/schema
 github.com/hyperonecom/h1-client-go
 # github.com/jdcloud-api/jdcloud-sdk-go v1.9.1-0.20190605102154-3d81a50ca961
 github.com/jdcloud-api/jdcloud-sdk-go/core
+github.com/jdcloud-api/jdcloud-sdk-go/services/charge/models
+github.com/jdcloud-api/jdcloud-sdk-go/services/common/models
+github.com/jdcloud-api/jdcloud-sdk-go/services/disk/models
 github.com/jdcloud-api/jdcloud-sdk-go/services/vm/apis
 github.com/jdcloud-api/jdcloud-sdk-go/services/vm/client
 github.com/jdcloud-api/jdcloud-sdk-go/services/vm/models
 github.com/jdcloud-api/jdcloud-sdk-go/services/vpc/apis
 github.com/jdcloud-api/jdcloud-sdk-go/services/vpc/client
 github.com/jdcloud-api/jdcloud-sdk-go/services/vpc/models
-github.com/jdcloud-api/jdcloud-sdk-go/services/common/models
-github.com/jdcloud-api/jdcloud-sdk-go/services/charge/models
-github.com/jdcloud-api/jdcloud-sdk-go/services/disk/models
 # github.com/jehiah/go-strftime v0.0.0-20171201141054-1d33003b3869
 github.com/jehiah/go-strftime
 # github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af
@@ -352,10 +352,10 @@ github.com/jmespath/go-jmespath
 # github.com/joyent/triton-go v0.0.0-20180116165742-545edbe0d564
 github.com/joyent/triton-go
 github.com/joyent/triton-go/authentication
+github.com/joyent/triton-go/client
 github.com/joyent/triton-go/compute
 github.com/joyent/triton-go/errors
 github.com/joyent/triton-go/network
-github.com/joyent/triton-go/client
 # github.com/json-iterator/go v1.1.6
 github.com/json-iterator/go
 # github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1
@@ -444,8 +444,8 @@ github.com/pkg/sftp
 github.com/pmezard/go-difflib/difflib
 # github.com/posener/complete v1.1.1
 github.com/posener/complete
-github.com/posener/complete/cmd/install
 github.com/posener/complete/cmd
+github.com/posener/complete/cmd/install
 github.com/posener/complete/match
 # github.com/profitbricks/profitbricks-sdk-go v4.0.2+incompatible
 github.com/profitbricks/profitbricks-sdk-go
@@ -459,15 +459,15 @@ github.com/saintfish/chardet
 github.com/satori/go.uuid
 # github.com/scaleway/scaleway-cli v0.0.0-20180921094345-7b12c9699d70
 github.com/scaleway/scaleway-cli/pkg/api
-github.com/scaleway/scaleway-cli/pkg/utils
 github.com/scaleway/scaleway-cli/pkg/sshcommand
+github.com/scaleway/scaleway-cli/pkg/utils
 # github.com/shirou/gopsutil v2.18.12+incompatible
-github.com/shirou/gopsutil/process
 github.com/shirou/gopsutil/cpu
 github.com/shirou/gopsutil/host
 github.com/shirou/gopsutil/internal/common
 github.com/shirou/gopsutil/mem
 github.com/shirou/gopsutil/net
+github.com/shirou/gopsutil/process
 # github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4
 github.com/shirou/w32
 # github.com/sirupsen/logrus v1.4.2
@@ -480,11 +480,13 @@ github.com/temoto/robotstxt
 # github.com/tencentcloud/tencentcloud-sdk-go v3.0.71+incompatible
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors
+github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312
-github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http
 # github.com/ucloud/ucloud-sdk-go v0.8.7
+github.com/ucloud/ucloud-sdk-go/private/protocol/http
+github.com/ucloud/ucloud-sdk-go/private/utils
 github.com/ucloud/ucloud-sdk-go/services/uaccount
 github.com/ucloud/ucloud-sdk-go/services/uhost
 github.com/ucloud/ucloud-sdk-go/services/unet
@@ -492,70 +494,64 @@ github.com/ucloud/ucloud-sdk-go/services/vpc
 github.com/ucloud/ucloud-sdk-go/ucloud
 github.com/ucloud/ucloud-sdk-go/ucloud/auth
 github.com/ucloud/ucloud-sdk-go/ucloud/error
+github.com/ucloud/ucloud-sdk-go/ucloud/log
 github.com/ucloud/ucloud-sdk-go/ucloud/request
 github.com/ucloud/ucloud-sdk-go/ucloud/response
-github.com/ucloud/ucloud-sdk-go/private/utils
-github.com/ucloud/ucloud-sdk-go/ucloud/log
-github.com/ucloud/ucloud-sdk-go/private/protocol/http
 github.com/ucloud/ucloud-sdk-go/ucloud/version
 # github.com/ugorji/go v0.0.0-20151218193438-646ae4a518c1
 github.com/ugorji/go/codec
 # github.com/ulikunitz/xz v0.5.5
 github.com/ulikunitz/xz
+github.com/ulikunitz/xz/internal/hash
 github.com/ulikunitz/xz/internal/xlog
 github.com/ulikunitz/xz/lzma
-github.com/ulikunitz/xz/internal/hash
 # github.com/vmware/govmomi v0.0.0-20170707011325-c2105a174311
 github.com/vmware/govmomi
 github.com/vmware/govmomi/find
+github.com/vmware/govmomi/list
 github.com/vmware/govmomi/object
-github.com/vmware/govmomi/vim25/types
 github.com/vmware/govmomi/property
 github.com/vmware/govmomi/session
-github.com/vmware/govmomi/vim25
-github.com/vmware/govmomi/vim25/soap
-github.com/vmware/govmomi/list
-github.com/vmware/govmomi/vim25/mo
 github.com/vmware/govmomi/task
-github.com/vmware/govmomi/vim25/methods
-github.com/vmware/govmomi/vim25/progress
+github.com/vmware/govmomi/vim25
 github.com/vmware/govmomi/vim25/debug
+github.com/vmware/govmomi/vim25/methods
+github.com/vmware/govmomi/vim25/mo
+github.com/vmware/govmomi/vim25/progress
+github.com/vmware/govmomi/vim25/soap
+github.com/vmware/govmomi/vim25/types
 github.com/vmware/govmomi/vim25/xml
 # github.com/xanzy/go-cloudstack v0.0.0-20190526095453-42f262b63ed0
 github.com/xanzy/go-cloudstack/cloudstack
 # github.com/yandex-cloud/go-genproto v0.0.0-20190916101622-7617782d381e
-github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint
-github.com/yandex-cloud/go-genproto/yandex/cloud/vpc/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud
+github.com/yandex-cloud/go-genproto/yandex/cloud/access
 github.com/yandex-cloud/go-genproto/yandex/cloud/api
-github.com/yandex-cloud/go-genproto/yandex/cloud/operation
-github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/instancegroup
 github.com/yandex-cloud/go-genproto/yandex/cloud/containerregistry/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint
+github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility
+github.com/yandex-cloud/go-genproto/yandex/cloud/iot/devices/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/loadbalancer/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/config
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/config
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mysql/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mysql/v1/config
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config
 github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1
+github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1/config
+github.com/yandex-cloud/go-genproto/yandex/cloud/operation
 github.com/yandex-cloud/go-genproto/yandex/cloud/resourcemanager/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/serverless/functions/v1
 github.com/yandex-cloud/go-genproto/yandex/cloud/serverless/triggers/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/access
-github.com/yandex-cloud/go-genproto/yandex/cloud/iot/devices/v1
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/config
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/config
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mysql/v1/config
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config
-github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1/config
-github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility
+github.com/yandex-cloud/go-genproto/yandex/cloud/vpc/v1
 # github.com/yandex-cloud/go-sdk v0.0.0-20190916101744-c781afa45829
 github.com/yandex-cloud/go-sdk
-github.com/yandex-cloud/go-sdk/iamkey
-github.com/yandex-cloud/go-sdk/pkg/requestid
-github.com/yandex-cloud/go-sdk/pkg/retry
-github.com/yandex-cloud/go-sdk/sdkresolvers
 github.com/yandex-cloud/go-sdk/dial
 github.com/yandex-cloud/go-sdk/gen/apiendpoint
 github.com/yandex-cloud/go-sdk/gen/compute
@@ -563,6 +559,7 @@ github.com/yandex-cloud/go-sdk/gen/compute/instancegroup
 github.com/yandex-cloud/go-sdk/gen/containerregistry
 github.com/yandex-cloud/go-sdk/gen/functions
 github.com/yandex-cloud/go-sdk/gen/iam
+github.com/yandex-cloud/go-sdk/gen/iam/awscompatibility
 github.com/yandex-cloud/go-sdk/gen/iot/devices
 github.com/yandex-cloud/go-sdk/gen/loadbalancer
 github.com/yandex-cloud/go-sdk/gen/mdb/clickhouse
@@ -574,80 +571,78 @@ github.com/yandex-cloud/go-sdk/gen/operation
 github.com/yandex-cloud/go-sdk/gen/resourcemanager
 github.com/yandex-cloud/go-sdk/gen/triggers
 github.com/yandex-cloud/go-sdk/gen/vpc
+github.com/yandex-cloud/go-sdk/iamkey
 github.com/yandex-cloud/go-sdk/operation
 github.com/yandex-cloud/go-sdk/pkg/grpcclient
+github.com/yandex-cloud/go-sdk/pkg/requestid
+github.com/yandex-cloud/go-sdk/pkg/retry
 github.com/yandex-cloud/go-sdk/pkg/sdkerrors
 github.com/yandex-cloud/go-sdk/pkg/singleflight
-github.com/yandex-cloud/go-sdk/gen/iam/awscompatibility
+github.com/yandex-cloud/go-sdk/sdkresolvers
 # go.opencensus.io v0.22.0
-go.opencensus.io/plugin/ochttp
-go.opencensus.io/plugin/ochttp/propagation/tracecontext
-go.opencensus.io/stats/view
-go.opencensus.io/trace
 go.opencensus.io
-go.opencensus.io/plugin/ocgrpc
-go.opencensus.io/resource
-go.opencensus.io/stats
-go.opencensus.io/tag
-go.opencensus.io/trace/tracestate
-go.opencensus.io/plugin/ochttp/propagation/b3
-go.opencensus.io/trace/propagation
+go.opencensus.io/internal
 go.opencensus.io/internal/tagencoding
 go.opencensus.io/metric/metricdata
 go.opencensus.io/metric/metricproducer
+go.opencensus.io/plugin/ocgrpc
+go.opencensus.io/plugin/ochttp
+go.opencensus.io/plugin/ochttp/propagation/b3
+go.opencensus.io/plugin/ochttp/propagation/tracecontext
+go.opencensus.io/resource
+go.opencensus.io/stats
 go.opencensus.io/stats/internal
-go.opencensus.io/internal
+go.opencensus.io/stats/view
+go.opencensus.io/tag
+go.opencensus.io/trace
 go.opencensus.io/trace/internal
+go.opencensus.io/trace/propagation
+go.opencensus.io/trace/tracestate
 # golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5
-golang.org/x/crypto/ssh
-golang.org/x/crypto/ssh/agent
 golang.org/x/crypto/curve25519
 golang.org/x/crypto/ed25519
-golang.org/x/crypto/internal/chacha20
-golang.org/x/crypto/poly1305
-golang.org/x/crypto/md4
 golang.org/x/crypto/ed25519/internal/edwards25519
+golang.org/x/crypto/internal/chacha20
 golang.org/x/crypto/internal/subtle
+golang.org/x/crypto/md4
+golang.org/x/crypto/poly1305
+golang.org/x/crypto/ssh
+golang.org/x/crypto/ssh/agent
 golang.org/x/crypto/ssh/terminal
 # golang.org/x/net v0.0.0-20190620200207-3b0461eec859
-golang.org/x/net/proxy
-golang.org/x/net/http2
-golang.org/x/net/html/charset
-golang.org/x/net/trace
+golang.org/x/net/context
+golang.org/x/net/context/ctxhttp
 golang.org/x/net/html
-golang.org/x/net/internal/socks
+golang.org/x/net/html/atom
+golang.org/x/net/html/charset
 golang.org/x/net/http/httpguts
+golang.org/x/net/http2
 golang.org/x/net/http2/hpack
 golang.org/x/net/idna
-golang.org/x/net/context/ctxhttp
-golang.org/x/net/context
-golang.org/x/net/publicsuffix
+golang.org/x/net/internal/socks
 golang.org/x/net/internal/timeseries
-golang.org/x/net/html/atom
+golang.org/x/net/proxy
+golang.org/x/net/publicsuffix
+golang.org/x/net/trace
 # golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45
 golang.org/x/oauth2
 golang.org/x/oauth2/google
-golang.org/x/oauth2/jwt
 golang.org/x/oauth2/internal
 golang.org/x/oauth2/jws
+golang.org/x/oauth2/jwt
 # golang.org/x/sync v0.0.0-20190423024810-112230192c58
-golang.org/x/sync/semaphore
 golang.org/x/sync/errgroup
+golang.org/x/sync/semaphore
 # golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0
+golang.org/x/sys/cpu
 golang.org/x/sys/unix
 golang.org/x/sys/windows
-golang.org/x/sys/cpu
 # golang.org/x/text v0.3.2
 golang.org/x/text/encoding
 golang.org/x/text/encoding/charmap
 golang.org/x/text/encoding/htmlindex
-golang.org/x/text/transform
-golang.org/x/text/secure/bidirule
-golang.org/x/text/unicode/bidi
-golang.org/x/text/unicode/norm
-golang.org/x/text/language
-golang.org/x/text/encoding/internal/identifier
 golang.org/x/text/encoding/internal
+golang.org/x/text/encoding/internal/identifier
 golang.org/x/text/encoding/japanese
 golang.org/x/text/encoding/korean
 golang.org/x/text/encoding/simplifiedchinese
@@ -655,57 +650,63 @@ golang.org/x/text/encoding/traditionalchinese
 golang.org/x/text/encoding/unicode
 golang.org/x/text/internal/language
 golang.org/x/text/internal/language/compact
-golang.org/x/text/internal/utf8internal
-golang.org/x/text/runes
 golang.org/x/text/internal/tag
+golang.org/x/text/internal/utf8internal
+golang.org/x/text/language
+golang.org/x/text/runes
+golang.org/x/text/secure/bidirule
+golang.org/x/text/transform
+golang.org/x/text/unicode/bidi
+golang.org/x/text/unicode/norm
 # golang.org/x/time v0.0.0-20190308202827-9d24e82272b4
 golang.org/x/time/rate
 # google.golang.org/api v0.9.0
 google.golang.org/api/compute/v1
-google.golang.org/api/storage/v1
 google.golang.org/api/gensupport
 google.golang.org/api/googleapi
-google.golang.org/api/option
-google.golang.org/api/transport/http
-google.golang.org/api/iterator
 google.golang.org/api/googleapi/internal/uritemplates
-google.golang.org/api/internal
 google.golang.org/api/googleapi/transport
-google.golang.org/api/transport/http/internal/propagation
+google.golang.org/api/internal
+google.golang.org/api/iterator
+google.golang.org/api/option
+google.golang.org/api/storage/v1
 google.golang.org/api/support/bundler
+google.golang.org/api/transport/http
+google.golang.org/api/transport/http/internal/propagation
 # google.golang.org/appengine v1.6.1
 google.golang.org/appengine
-google.golang.org/appengine/urlfetch
 google.golang.org/appengine/internal
 google.golang.org/appengine/internal/app_identity
-google.golang.org/appengine/internal/modules
-google.golang.org/appengine/internal/urlfetch
 google.golang.org/appengine/internal/base
 google.golang.org/appengine/internal/datastore
 google.golang.org/appengine/internal/log
+google.golang.org/appengine/internal/modules
 google.golang.org/appengine/internal/remote_api
+google.golang.org/appengine/internal/urlfetch
+google.golang.org/appengine/urlfetch
 # google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55
 google.golang.org/genproto/googleapis/api/annotations
-google.golang.org/genproto/protobuf/field_mask
-google.golang.org/genproto/googleapis/rpc/errdetails
-google.golang.org/genproto/googleapis/rpc/status
-google.golang.org/genproto/googleapis/type/timeofday
+google.golang.org/genproto/googleapis/api/httpbody
 google.golang.org/genproto/googleapis/iam/v1
 google.golang.org/genproto/googleapis/rpc/code
+google.golang.org/genproto/googleapis/rpc/errdetails
+google.golang.org/genproto/googleapis/rpc/status
 google.golang.org/genproto/googleapis/type/expr
-google.golang.org/genproto/googleapis/api/httpbody
+google.golang.org/genproto/googleapis/type/timeofday
+google.golang.org/genproto/protobuf/field_mask
 # google.golang.org/grpc v1.21.1
 google.golang.org/grpc
-google.golang.org/grpc/codes
-google.golang.org/grpc/metadata
-google.golang.org/grpc/status
-google.golang.org/grpc/credentials
-google.golang.org/grpc/grpclog
 google.golang.org/grpc/balancer
+google.golang.org/grpc/balancer/base
 google.golang.org/grpc/balancer/roundrobin
+google.golang.org/grpc/binarylog/grpc_binarylog_v1
+google.golang.org/grpc/codes
 google.golang.org/grpc/connectivity
+google.golang.org/grpc/credentials
+google.golang.org/grpc/credentials/internal
 google.golang.org/grpc/encoding
 google.golang.org/grpc/encoding/proto
+google.golang.org/grpc/grpclog
 google.golang.org/grpc/internal
 google.golang.org/grpc/internal/backoff
 google.golang.org/grpc/internal/balancerload
@@ -714,19 +715,18 @@ google.golang.org/grpc/internal/channelz
 google.golang.org/grpc/internal/envconfig
 google.golang.org/grpc/internal/grpcrand
 google.golang.org/grpc/internal/grpcsync
+google.golang.org/grpc/internal/syscall
 google.golang.org/grpc/internal/transport
 google.golang.org/grpc/keepalive
+google.golang.org/grpc/metadata
 google.golang.org/grpc/naming
 google.golang.org/grpc/peer
 google.golang.org/grpc/resolver
 google.golang.org/grpc/resolver/dns
 google.golang.org/grpc/resolver/passthrough
 google.golang.org/grpc/stats
+google.golang.org/grpc/status
 google.golang.org/grpc/tap
-google.golang.org/grpc/credentials/internal
-google.golang.org/grpc/balancer/base
-google.golang.org/grpc/binarylog/grpc_binarylog_v1
-google.golang.org/grpc/internal/syscall
 # gopkg.in/ini.v1 v1.42.0
 gopkg.in/ini.v1
 # gopkg.in/resty.v1 v1.12.0

From 936ae42b0050f280a801a635d0ac1c27fb2c73b0 Mon Sep 17 00:00:00 2001
From: larohra <larohra@microsoft.com>
Date: Fri, 11 Oct 2019 15:29:02 -0700
Subject: [PATCH 052/155] Added a new parameter in config to override the
 default Azure Go SDK PollingDuration timeout

---
 builder/azure/arm/azure_client.go | 32 +++++++++++++++----------------
 builder/azure/arm/builder.go      |  1 +
 builder/azure/arm/config.go       | 15 +++++++++++++++
 3 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/builder/azure/arm/azure_client.go b/builder/azure/arm/azure_client.go
index 130eba2a0..5ca281c90 100644
--- a/builder/azure/arm/azure_client.go
+++ b/builder/azure/arm/azure_client.go
@@ -127,7 +127,7 @@ func byConcatDecorators(decorators ...autorest.RespondDecorator) autorest.Respon
 }
 
 func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string,
-	cloud *azure.Environment, SharedGalleryTimeout time.Duration,
+	cloud *azure.Environment, SharedGalleryTimeout time.Duration, PollingDuration time.Duration,
 	servicePrincipalToken, servicePrincipalTokenVault *adal.ServicePrincipalToken) (*AzureClient, error) {
 
 	var azureClient = &AzureClient{}
@@ -139,84 +139,84 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.DeploymentsClient.RequestInspector = withInspection(maxlen)
 	azureClient.DeploymentsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.DeploymentsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.DeploymentsClient.UserAgent)
-	azureClient.DeploymentsClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.DeploymentsClient.Client.PollingDuration = PollingDuration
 
 	azureClient.DeploymentOperationsClient = resources.NewDeploymentOperationsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.DeploymentOperationsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.DeploymentOperationsClient.RequestInspector = withInspection(maxlen)
 	azureClient.DeploymentOperationsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.DeploymentOperationsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.DeploymentOperationsClient.UserAgent)
-	azureClient.DeploymentOperationsClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.DeploymentOperationsClient.Client.PollingDuration = PollingDuration
 
 	azureClient.DisksClient = compute.NewDisksClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.DisksClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.DisksClient.RequestInspector = withInspection(maxlen)
 	azureClient.DisksClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.DisksClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.DisksClient.UserAgent)
-	azureClient.DisksClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.DisksClient.Client.PollingDuration = PollingDuration
 
 	azureClient.GroupsClient = resources.NewGroupsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.GroupsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.GroupsClient.RequestInspector = withInspection(maxlen)
 	azureClient.GroupsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.GroupsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.GroupsClient.UserAgent)
-	azureClient.GroupsClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.GroupsClient.Client.PollingDuration = PollingDuration
 
 	azureClient.ImagesClient = compute.NewImagesClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.ImagesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.ImagesClient.RequestInspector = withInspection(maxlen)
 	azureClient.ImagesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.ImagesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.ImagesClient.UserAgent)
-	azureClient.ImagesClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.ImagesClient.Client.PollingDuration = PollingDuration
 
 	azureClient.InterfacesClient = network.NewInterfacesClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.InterfacesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.InterfacesClient.RequestInspector = withInspection(maxlen)
 	azureClient.InterfacesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.InterfacesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.InterfacesClient.UserAgent)
-	azureClient.InterfacesClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.InterfacesClient.Client.PollingDuration = PollingDuration
 
 	azureClient.SubnetsClient = network.NewSubnetsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.SubnetsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.SubnetsClient.RequestInspector = withInspection(maxlen)
 	azureClient.SubnetsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.SubnetsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.SubnetsClient.UserAgent)
-	azureClient.SubnetsClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.SubnetsClient.Client.PollingDuration = PollingDuration
 
 	azureClient.VirtualNetworksClient = network.NewVirtualNetworksClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.VirtualNetworksClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.VirtualNetworksClient.RequestInspector = withInspection(maxlen)
 	azureClient.VirtualNetworksClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.VirtualNetworksClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VirtualNetworksClient.UserAgent)
-	azureClient.VirtualNetworksClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.VirtualNetworksClient.Client.PollingDuration = PollingDuration
 
 	azureClient.PublicIPAddressesClient = network.NewPublicIPAddressesClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.PublicIPAddressesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.PublicIPAddressesClient.RequestInspector = withInspection(maxlen)
 	azureClient.PublicIPAddressesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.PublicIPAddressesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.PublicIPAddressesClient.UserAgent)
-	azureClient.PublicIPAddressesClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.PublicIPAddressesClient.Client.PollingDuration = PollingDuration
 
 	azureClient.VirtualMachinesClient = compute.NewVirtualMachinesClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.VirtualMachinesClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.VirtualMachinesClient.RequestInspector = withInspection(maxlen)
 	azureClient.VirtualMachinesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), templateCapture(azureClient), errorCapture(azureClient))
 	azureClient.VirtualMachinesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VirtualMachinesClient.UserAgent)
-	azureClient.VirtualMachinesClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.VirtualMachinesClient.Client.PollingDuration = PollingDuration
 
 	azureClient.SnapshotsClient = compute.NewSnapshotsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.SnapshotsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.SnapshotsClient.RequestInspector = withInspection(maxlen)
 	azureClient.SnapshotsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.SnapshotsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.SnapshotsClient.UserAgent)
-	azureClient.SnapshotsClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.SnapshotsClient.Client.PollingDuration = PollingDuration
 
 	azureClient.AccountsClient = armStorage.NewAccountsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.AccountsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
 	azureClient.AccountsClient.RequestInspector = withInspection(maxlen)
 	azureClient.AccountsClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.AccountsClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.AccountsClient.UserAgent)
-	azureClient.AccountsClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.AccountsClient.Client.PollingDuration = PollingDuration
 
 	azureClient.GalleryImageVersionsClient = newCompute.NewGalleryImageVersionsClientWithBaseURI(cloud.ResourceManagerEndpoint, subscriptionID)
 	azureClient.GalleryImageVersionsClient.Authorizer = autorest.NewBearerAuthorizer(servicePrincipalToken)
@@ -230,7 +230,7 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.GalleryImagesClient.RequestInspector = withInspection(maxlen)
 	azureClient.GalleryImagesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.GalleryImagesClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.GalleryImagesClient.UserAgent)
-	azureClient.GalleryImageVersionsClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.GalleryImageVersionsClient.Client.PollingDuration = PollingDuration
 
 	keyVaultURL, err := url.Parse(cloud.KeyVaultEndpoint)
 	if err != nil {
@@ -242,7 +242,7 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.VaultClient.RequestInspector = withInspection(maxlen)
 	azureClient.VaultClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.VaultClient.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VaultClient.UserAgent)
-	azureClient.VaultClient.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.VaultClient.Client.PollingDuration = PollingDuration
 
 	// TODO(boumenot) - SDK still does not have a full KeyVault client.
 	// There are two ways that KeyVault has to be accessed, and each one has their own SPN.  An authenticated SPN
@@ -257,7 +257,7 @@ func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string
 	azureClient.VaultClientDelete.RequestInspector = withInspection(maxlen)
 	azureClient.VaultClientDelete.ResponseInspector = byConcatDecorators(byInspecting(maxlen), errorCapture(azureClient))
 	azureClient.VaultClientDelete.UserAgent = fmt.Sprintf("%s %s", useragent.String(), azureClient.VaultClientDelete.UserAgent)
-	azureClient.VaultClientDelete.Client.PollingDuration = SharedGalleryTimeout
+	azureClient.VaultClientDelete.Client.PollingDuration = PollingDuration
 
 	// If this is a managed disk build, this should be ignored.
 	if resourceGroupName != "" && storageAccountName != "" {
diff --git a/builder/azure/arm/builder.go b/builder/azure/arm/builder.go
index 27bc32a4a..f569ed19b 100644
--- a/builder/azure/arm/builder.go
+++ b/builder/azure/arm/builder.go
@@ -81,6 +81,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		b.config.StorageAccount,
 		b.config.ClientConfig.CloudEnvironment,
 		b.config.SharedGalleryTimeout,
+		b.config.PollingDurationTimeout,
 		spnCloud,
 		spnKeyVault)
 
diff --git a/builder/azure/arm/config.go b/builder/azure/arm/config.go
index 7243bd2a8..d830e3394 100644
--- a/builder/azure/arm/config.go
+++ b/builder/azure/arm/config.go
@@ -311,6 +311,14 @@ type Config struct {
 	// 4.  PlanPromotionCode
 	//
 	PlanInfo PlanInformation `mapstructure:"plan_info" required:"false"`
+	// The default PollingDuration for azure is 15mins, this property will override
+	// that value. See [Azure DefaultPollingDuration](https://godoc.org/github.com/Azure/go-autorest/autorest#pkg-constants)
+	// If your Packer build is failing on the
+	// ARM deployment step with the error `Original Error:
+	// context deadline exceeded`, then you probably need to increase this timeout from
+	// its default of "15m" (valid time units include `s` for seconds, `m` for
+	// minutes, and `h` for hours.)
+	PollingDurationTimeout time.Duration `mapstructure:"polling_duration_timeout" required:"false"`
 	// If either Linux or Windows is specified Packer will
 	// automatically configure authentication credentials for the provisioned
 	// machine. For Linux this configures an SSH authorized key. For Windows
@@ -889,6 +897,13 @@ func assertRequiredParametersSet(c *Config, errs *packer.MultiError) {
 		}
 	}
 
+	/////////////////////////////////////////////
+	// Polling Duration Timeout
+	if c.PollingDurationTimeout == 0 {
+		// In the sdk, the default is 15 m.
+		c.PollingDurationTimeout = 15 * time.Minute
+	}
+
 	/////////////////////////////////////////////
 	// OS
 	if strings.EqualFold(c.OSType, constants.Target_Linux) {

From 4ea3460617513c79292babb6f42dc03d69b4dc51 Mon Sep 17 00:00:00 2001
From: Landon Smith <landonasmith@gmail.com>
Date: Sun, 13 Oct 2019 16:32:47 -0700
Subject: [PATCH 053/155] Update user-variables.html.md

Looks like the vault variables description was copied from the environment variables section, and someone left a reference to a environment variables.
---
 website/source/docs/templates/user-variables.html.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/source/docs/templates/user-variables.html.md b/website/source/docs/templates/user-variables.html.md
index e8e6dcde1..a5b0c31a2 100644
--- a/website/source/docs/templates/user-variables.html.md
+++ b/website/source/docs/templates/user-variables.html.md
@@ -123,7 +123,7 @@ environment variables, as specified in the
 Secrets can be read from [Vault](https://www.vaultproject.io/) and used within
 your template as user variables. the `vault` function is available *only*
 within the default value of a user variable, allowing you to default a user
-variable to an environment variable.
+variable to a vault secret.
 
 An example of using a v2 kv engine:
 

From 9dc622af0568286c89cb963fd130dc0450870b5b Mon Sep 17 00:00:00 2001
From: larohra <larohra@microsoft.com>
Date: Mon, 14 Oct 2019 19:31:44 +0000
Subject: [PATCH 054/155] Fixed circleCi test

---
 .../builder/azure/arm/_Config-not-required.html.md        | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/website/source/partials/builder/azure/arm/_Config-not-required.html.md b/website/source/partials/builder/azure/arm/_Config-not-required.html.md
index af8816b87..ebeed1d38 100644
--- a/website/source/partials/builder/azure/arm/_Config-not-required.html.md
+++ b/website/source/partials/builder/azure/arm/_Config-not-required.html.md
@@ -187,6 +187,14 @@
     3.  PlanPublisher
     4.  PlanPromotionCode
     
+-   `polling_duration_timeout` (time.Duration) - The default PollingDuration for azure is 15mins, this property will override
+    that value. See [Azure DefaultPollingDuration](https://godoc.org/github.com/Azure/go-autorest/autorest#pkg-constants)
+    If your Packer build is failing on the
+    ARM deployment step with the error `Original Error:
+    context deadline exceeded`, then you probably need to increase this timeout from
+    its default of "15m" (valid time units include `s` for seconds, `m` for
+    minutes, and `h` for hours.)
+    
 -   `os_type` (string) - If either Linux or Windows is specified Packer will
     automatically configure authentication credentials for the provisioned
     machine. For Linux this configures an SSH authorized key. For Windows

From 44f91c9afc1884132f4d4cc69ceb1e04f4e4664c Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Mon, 14 Oct 2019 11:35:16 -0700
Subject: [PATCH 055/155] Revert "remove clean_ami_name and clean_image_name;
 complete the deprecation for these functions in favor of clean_resource_name"

This reverts commit 0026792d2f60f03abc04239640065e967581310c.
---
 builder/amazon/common/template_funcs.go      |  1 +
 builder/azure/common/template_funcs.go       |  1 +
 builder/googlecompute/template_funcs.go      |  1 +
 builder/yandex/template_func.go              | 12 +++++-------
 website/source/docs/templates/engine.html.md | 17 +++++++----------
 5 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/builder/amazon/common/template_funcs.go b/builder/amazon/common/template_funcs.go
index 14dd65d83..ad5821d6a 100644
--- a/builder/amazon/common/template_funcs.go
+++ b/builder/amazon/common/template_funcs.go
@@ -37,4 +37,5 @@ func templateCleanAMIName(s string) string {
 
 var TemplateFuncs = template.FuncMap{
 	"clean_resource_name": templateCleanAMIName,
+	"clean_ami_name":      packertpl.DeprecatedTemplateFunc("clean_ami_name", "clean_resource_name", templateCleanAMIName),
 }
diff --git a/builder/azure/common/template_funcs.go b/builder/azure/common/template_funcs.go
index faccd4f07..36aadf16e 100644
--- a/builder/azure/common/template_funcs.go
+++ b/builder/azure/common/template_funcs.go
@@ -37,4 +37,5 @@ func templateCleanImageName(s string) string {
 
 var TemplateFuncs = template.FuncMap{
 	"clean_resource_name": templateCleanImageName,
+	"clean_image_name":    packertpl.DeprecatedTemplateFunc("clean_image_name", "clean_resource_name", templateCleanImageName),
 }
diff --git a/builder/googlecompute/template_funcs.go b/builder/googlecompute/template_funcs.go
index 37557180f..9d7f5525a 100644
--- a/builder/googlecompute/template_funcs.go
+++ b/builder/googlecompute/template_funcs.go
@@ -35,4 +35,5 @@ func templateCleanImageName(s string) string {
 
 var TemplateFuncs = template.FuncMap{
 	"clean_resource_name": templateCleanImageName,
+	"clean_image_name":    packertpl.DeprecatedTemplateFunc("clean_image_name", "clean_resource_name", templateCleanImageName),
 }
diff --git a/builder/yandex/template_func.go b/builder/yandex/template_func.go
index 144ed14e3..91f83a9d5 100644
--- a/builder/yandex/template_func.go
+++ b/builder/yandex/template_func.go
@@ -1,9 +1,7 @@
 package yandex
 
-import (
-	"strings"
-	"text/template"
-)
+import "strings"
+import "text/template"
 
 func isalphanumeric(b byte) bool {
 	if '0' <= b && b <= '9' {
@@ -15,9 +13,9 @@ func isalphanumeric(b byte) bool {
 	return false
 }
 
-// Clean up resource name by replacing invalid characters with "-"
+// Clean up image name by replacing invalid characters with "-"
 // and converting upper cases to lower cases
-func templateCleanResourceName(s string) string {
+func templateCleanImageName(s string) string {
 	if reImageFamily.MatchString(s) {
 		return s
 	}
@@ -34,5 +32,5 @@ func templateCleanResourceName(s string) string {
 }
 
 var TemplateFuncs = template.FuncMap{
-	"clean_resource_name": templateCleanResourceName,
+	"clean_image_name": templateCleanImageName,
 }
diff --git a/website/source/docs/templates/engine.html.md b/website/source/docs/templates/engine.html.md
index 4c7883c88..8859c96e6 100644
--- a/website/source/docs/templates/engine.html.md
+++ b/website/source/docs/templates/engine.html.md
@@ -41,7 +41,7 @@ Here is a full list of the available functions for reference.
     will convert upper cases to lower cases and replace illegal characters with
     a "-" character.  Example:
 
-   `"mybuild-{{isotime | clean_resource_name}}"` will become
+   `"mybuild-{{isotime | clean_image_name}}"` will become
     `mybuild-2017-10-18t02-06-30z`.
 
     Note: Valid Azure image names must match the regex
@@ -57,9 +57,6 @@ Here is a full list of the available functions for reference.
     clean_resource_name}}"` will cause your build to fail because the image
     name will start with a number, which is why in the above example we prepend
     the isotime with "mybuild".
-    Exact behavior of `clean_resource_name` will depend on which builder it is
-    being applied to; refer to build-specific docs below for more detail on how
-    each function will behave.
 -   `env` - Returns environment variables. See example in [using home
     variable](/docs/templates/user-variables.html#using-home-variable)
 -   `isotime [FORMAT]` - UTC time, which can be
@@ -87,19 +84,19 @@ Here is a full list of the available functions for reference.
 
 #### Specific to Amazon builders:
 
--   `clean_resource_name` - AMI names
+-   `clean_ami_name` - DEPRECATED use `clean_resource_name` instead - AMI names
     can only contain certain characters. This function will replace illegal
     characters with a '-" character. Example usage since ":" is not a legal AMI
-    name is: `{{isotime | clean_resource_name}}`.
+    name is: `{{isotime | clean_ami_name}}`.
 
 #### Specific to Google Compute builders:
 
--   `clean_resource_name` - GCE
+-   `clean_image_name` - DEPRECATED use `clean_resource_name` instead - GCE
     image names can only contain certain characters and the maximum length is
     63. This function will convert upper cases to lower cases and replace
         illegal characters with a "-" character. Example:
 
-    `"mybuild-{{isotime | clean_resource_name}}"` will become
+    `"mybuild-{{isotime | clean_image_name}}"` will become
     `mybuild-2017-10-18t02-06-30z`.
 
     Note: Valid GCE image names must match the regex
@@ -114,12 +111,12 @@ Here is a full list of the available functions for reference.
 
 #### Specific to Azure builders:
 
--   `clean_resource_name` - Azure
+-   `clean_image_name` - DEPRECATED use `clean_resource_name` instead - Azure
     managed image names can only contain certain characters and the maximum
     length is 80. This function will replace illegal characters with a "-"
     character. Example:
 
-    `"mybuild-{{isotime | clean_resource_name}}"` will become
+    `"mybuild-{{isotime | clean_image_name}}"` will become
     `mybuild-2017-10-18t02-06-30z`.
 
     Note: Valid Azure image names must match the regex

From 9c782f4d04e3078691796c075f34489025bf9579 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Mon, 14 Oct 2019 13:08:59 -0700
Subject: [PATCH 056/155] Revert "Qemu builder disk size as a string"

This reverts commit 1ecfa032ba0e0e320f279a79394b6118c775dfb7.
---
 builder/qemu/builder.go                          | 16 ++++++++--------
 builder/qemu/builder_test.go                     | 10 +++++-----
 builder/qemu/step_create_disk.go                 |  2 +-
 builder/qemu/step_resize_disk.go                 |  3 ++-
 website/source/docs/builders/qemu.html.md.erb    |  2 +-
 .../builder/qemu/_Config-not-required.html.md    |  6 ++----
 6 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/builder/qemu/builder.go b/builder/qemu/builder.go
index 10c821b7e..a277e1d45 100644
--- a/builder/qemu/builder.go
+++ b/builder/qemu/builder.go
@@ -146,11 +146,9 @@ type Config struct {
 	// one of the other listed interfaces. Using the `scsi` interface under
 	// these circumstances will cause the build to fail.
 	DiskInterface string `mapstructure:"disk_interface" required:"false"`
-	// The size in bytes, suffixes of the first letter of common byte types
-	// like "k" or "K", "M" for megabytes, G for gigabytes, T for terabytes.
-	// Will create the of the hard disk of the VM. By default, this is
-	// `40960M` (40 GB).
-	DiskSize string `mapstructure:"disk_size" required:"false"`
+	// The size, in megabytes, of the hard disk to create
+	// for the VM. By default, this is 40960 (40 GB).
+	DiskSize uint `mapstructure:"disk_size" required:"false"`
 	// The cache mode to use for disk. Allowed values include any of
 	// `writethrough`, `writeback`, `none`, `unsafe` or `directsync`. By
 	// default, this is set to `writeback`.
@@ -318,6 +316,7 @@ type Config struct {
 	// "BUILDNAME" is the name of the build. Currently, no file extension will be
 	// used unless it is specified in this option.
 	VMName string `mapstructure:"vm_name" required:"false"`
+
 	// These are deprecated, but we keep them around for BC
 	// TODO(@mitchellh): remove
 	SSHWaitTimeout time.Duration `mapstructure:"ssh_wait_timeout" required:"false"`
@@ -345,10 +344,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 
 	var errs *packer.MultiError
 	warnings := make([]string, 0)
+
 	errs = packer.MultiErrorAppend(errs, b.config.ShutdownConfig.Prepare(&b.config.ctx)...)
 
-	if b.config.DiskSize == "" || b.config.DiskSize == "0" {
-		b.config.DiskSize = "40960M"
+	if b.config.DiskSize == 0 {
+		b.config.DiskSize = 40960
 	}
 
 	if b.config.DiskCache == "" {
@@ -700,7 +700,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		artifact.state["diskPaths"] = diskpaths
 	}
 	artifact.state["diskType"] = b.config.Format
-	artifact.state["diskSize"] = b.config.DiskSize
+	artifact.state["diskSize"] = uint64(b.config.DiskSize)
 	artifact.state["domainType"] = b.config.Accelerator
 
 	return artifact, nil
diff --git a/builder/qemu/builder_test.go b/builder/qemu/builder_test.go
index 15f3db8b3..122caa754 100644
--- a/builder/qemu/builder_test.go
+++ b/builder/qemu/builder_test.go
@@ -169,11 +169,11 @@ func TestBuilderPrepare_DiskSize(t *testing.T) {
 		t.Fatalf("bad err: %s", err)
 	}
 
-	if b.config.DiskSize != "40960M" {
-		t.Fatalf("bad size: %s", b.config.DiskSize)
+	if b.config.DiskSize != 40960 {
+		t.Fatalf("bad size: %d", b.config.DiskSize)
 	}
 
-	config["disk_size"] = "60000M"
+	config["disk_size"] = 60000
 	b = Builder{}
 	warns, err = b.Prepare(config)
 	if len(warns) > 0 {
@@ -183,8 +183,8 @@ func TestBuilderPrepare_DiskSize(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.DiskSize != "60000M" {
-		t.Fatalf("bad size: %s", b.config.DiskSize)
+	if b.config.DiskSize != 60000 {
+		t.Fatalf("bad size: %d", b.config.DiskSize)
 	}
 }
 
diff --git a/builder/qemu/step_create_disk.go b/builder/qemu/step_create_disk.go
index 12041565c..8fb18d025 100644
--- a/builder/qemu/step_create_disk.go
+++ b/builder/qemu/step_create_disk.go
@@ -29,7 +29,7 @@ func (s *stepCreateDisk) Run(ctx context.Context, state multistep.StateBag) mult
 	ui.Say("Creating required virtual machine disks")
 	// The 'main' or 'default' disk
 	diskFullPaths = append(diskFullPaths, filepath.Join(config.OutputDir, name))
-	diskSizes = append(diskSizes, fmt.Sprintf("%s", config.DiskSize))
+	diskSizes = append(diskSizes, fmt.Sprintf("%dM", uint64(config.DiskSize)))
 	// Additional disks
 	if len(config.AdditionalDiskSize) > 0 {
 		for i, diskSize := range config.AdditionalDiskSize {
diff --git a/builder/qemu/step_resize_disk.go b/builder/qemu/step_resize_disk.go
index f9dd5693e..d25ffaff4 100644
--- a/builder/qemu/step_resize_disk.go
+++ b/builder/qemu/step_resize_disk.go
@@ -23,8 +23,9 @@ func (s *stepResizeDisk) Run(ctx context.Context, state multistep.StateBag) mult
 		"resize",
 		"-f", config.Format,
 		path,
-		fmt.Sprintf("%s", config.DiskSize),
+		fmt.Sprintf("%vM", config.DiskSize),
 	}
+
 	if config.DiskImage == false {
 		return multistep.ActionContinue
 	}
diff --git a/website/source/docs/builders/qemu.html.md.erb b/website/source/docs/builders/qemu.html.md.erb
index 2e7db1dfc..78cf5f013 100644
--- a/website/source/docs/builders/qemu.html.md.erb
+++ b/website/source/docs/builders/qemu.html.md.erb
@@ -37,7 +37,7 @@ to files, URLS for ISOs and checksums.
       "iso_checksum_type": "md5",
       "output_directory": "output_centos_tdhtest",
       "shutdown_command": "echo 'packer' | sudo -S shutdown -P now",
-      "disk_size": "5000M",
+      "disk_size": 5000,
       "format": "qcow2",
       "accelerator": "kvm",
       "http_directory": "path/to/httpdir",
diff --git a/website/source/partials/builder/qemu/_Config-not-required.html.md b/website/source/partials/builder/qemu/_Config-not-required.html.md
index 723c53276..07ac4256a 100644
--- a/website/source/partials/builder/qemu/_Config-not-required.html.md
+++ b/website/source/partials/builder/qemu/_Config-not-required.html.md
@@ -47,10 +47,8 @@
     one of the other listed interfaces. Using the `scsi` interface under
     these circumstances will cause the build to fail.
     
--   `disk_size` (string) - The size in bytes, suffixes of the first letter of common byte types
-    like "k" or "K", "M" for megabytes, G for gigabytes, T for terabytes.
-    Will create the of the hard disk of the VM. By default, this is
-    `40960M` (40 GB).
+-   `disk_size` (uint) - The size, in megabytes, of the hard disk to create
+    for the VM. By default, this is 40960 (40 GB).
     
 -   `disk_cache` (string) - The cache mode to use for disk. Allowed values include any of
     `writethrough`, `writeback`, `none`, `unsafe` or `directsync`. By

From 0e70e0e5a4c570790f7f253e69c6e09ed18e38d1 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Mon, 14 Oct 2019 13:22:06 -0700
Subject: [PATCH 057/155] fix template imports

---
 builder/amazon/common/template_funcs.go | 2 ++
 builder/azure/common/template_funcs.go  | 2 ++
 builder/googlecompute/template_funcs.go | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/builder/amazon/common/template_funcs.go b/builder/amazon/common/template_funcs.go
index ad5821d6a..246a288e0 100644
--- a/builder/amazon/common/template_funcs.go
+++ b/builder/amazon/common/template_funcs.go
@@ -3,6 +3,8 @@ package common
 import (
 	"bytes"
 	"text/template"
+
+	packertpl "github.com/hashicorp/packer/common/template"
 )
 
 func isalphanumeric(b byte) bool {
diff --git a/builder/azure/common/template_funcs.go b/builder/azure/common/template_funcs.go
index 36aadf16e..1a399b53f 100644
--- a/builder/azure/common/template_funcs.go
+++ b/builder/azure/common/template_funcs.go
@@ -3,6 +3,8 @@ package common
 import (
 	"bytes"
 	"text/template"
+
+	packertpl "github.com/hashicorp/packer/common/template"
 )
 
 func isValidByteValue(b byte) bool {
diff --git a/builder/googlecompute/template_funcs.go b/builder/googlecompute/template_funcs.go
index 9d7f5525a..bf57f3d96 100644
--- a/builder/googlecompute/template_funcs.go
+++ b/builder/googlecompute/template_funcs.go
@@ -3,6 +3,8 @@ package googlecompute
 import (
 	"strings"
 	"text/template"
+
+	packertpl "github.com/hashicorp/packer/common/template"
 )
 
 func isalphanumeric(b byte) bool {

From f5a0810e7a6298955a5ad35eca0d090a531da454 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Mon, 14 Oct 2019 13:50:02 -0700
Subject: [PATCH 058/155] update changelog

---
 CHANGELOG.md | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 25b0900f1..696a9e236 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,12 @@
-## 1.5.0 (Upcoming)
+## 1.4.5 (Upcoming)
 
 ### IMPROVEMENTS:
 * builder/oracle-oci: Support defined tags for oci builder [GH-8172]
+* builder/proxmos: Add ability to select CPU type [GH-8201]
+* builder/proxmox: Add support for SCSI controller selection [GH-8199]
+* communicator/winrm: Prevent busy loop while waiting for WinRM connection
+    [GH-8213]
+* core: Add strftime function in templates [GH-8208]
 
 ### BUG FIXES:
 * builder/amazon: Fix spot instance bug where builder would fail if one
@@ -13,12 +18,8 @@
     already shut down [GH-8176]
 * post-processor/digitalocean-import: Fix panic when 'image_regions' not set
     [GH-8179]
-
-### BACKWARDS INCOMPATIBILITIES:
-* builder/qemu: Provide disk size as a string [GH-7546]
-* core: Finish deprecating old tempalte functions clean_ami_name and
-    clean_image_name in favor of generic clean_resource_name [GH-8193]
-
+* provisioner/powershell: Fix powershell syntax error causing failed builds
+    [GH-8195]
 
 ## 1.4.4 (October 1, 2019)
 

From 2e20facc8b986720d9eb2522aed7f38bc875e2f6 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Mon, 14 Oct 2019 14:13:21 -0700
Subject: [PATCH 059/155] fix tests

---
 builder/amazon/chroot/step_register_ami_test.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/builder/amazon/chroot/step_register_ami_test.go b/builder/amazon/chroot/step_register_ami_test.go
index f075755fb..a6a64b8fc 100644
--- a/builder/amazon/chroot/step_register_ami_test.go
+++ b/builder/amazon/chroot/step_register_ami_test.go
@@ -30,7 +30,7 @@ func TestStepRegisterAmi_buildRegisterOpts_pv(t *testing.T) {
 
 	blockDevices := []*ec2.BlockDeviceMapping{}
 
-	opts := buildRegisterOptsFromExistingImage(&config, &image, blockDevices, rootDeviceName)
+	opts := buildRegisterOptsFromExistingImage(&config, &image, blockDevices, rootDeviceName, config.AMIName)
 
 	expected := config.AMIVirtType
 	if *opts.VirtualizationType != expected {
@@ -64,7 +64,7 @@ func TestStepRegisterAmi_buildRegisterOpts_hvm(t *testing.T) {
 
 	blockDevices := []*ec2.BlockDeviceMapping{}
 
-	opts := buildRegisterOptsFromExistingImage(&config, &image, blockDevices, rootDeviceName)
+	opts := buildRegisterOptsFromExistingImage(&config, &image, blockDevices, rootDeviceName, config.AMIName)
 
 	expected := config.AMIVirtType
 	if *opts.VirtualizationType != expected {
@@ -99,7 +99,7 @@ func TestStepRegisterAmi_buildRegisterOptsFromScratch(t *testing.T) {
 		},
 		RootDeviceName: rootDeviceName,
 	}
-	registerOpts := buildBaseRegisterOpts(&config, nil, 10, snapshotID)
+	registerOpts := buildBaseRegisterOpts(&config, nil, 10, snapshotID, config.AMIName)
 
 	if len(registerOpts.BlockDeviceMappings) != 1 {
 		t.Fatal("Expected block device mapping of length 1")
@@ -138,7 +138,7 @@ func TestStepRegisterAmi_buildRegisterOptFromExistingImage(t *testing.T) {
 			},
 		},
 	}
-	registerOpts := buildBaseRegisterOpts(&config, &sourceImage, 15, snapshotID)
+	registerOpts := buildBaseRegisterOpts(&config, &sourceImage, 15, snapshotID, config.AMIName)
 
 	if len(registerOpts.BlockDeviceMappings) != 2 {
 		t.Fatal("Expected block device mapping of length 2")
@@ -196,7 +196,7 @@ func TestStepRegisterAmi_buildRegisterOptFromExistingImageWithBlockDeviceMapping
 			},
 		},
 	}
-	registerOpts := buildBaseRegisterOpts(&config, &sourceImage, 15, snapshotId)
+	registerOpts := buildBaseRegisterOpts(&config, &sourceImage, 15, snapshotId, config.AMIName)
 
 	if len(registerOpts.BlockDeviceMappings) != 1 {
 		t.Fatal("Expected block device mapping of length 1")

From 8628c75de18f394cfeb40bc738a10262a17d3eaa Mon Sep 17 00:00:00 2001
From: Joakim Westin <yooakim@gmail.com>
Date: Tue, 15 Oct 2019 10:34:48 +0200
Subject: [PATCH 060/155] Changed from jq to JMESPath queries

Changed the examples to use AZ CLI built-in JMESPath query instead of needing `jq` tool installed (functionally they are the same)
---
 .../source/docs/builders/azure-setup.html.md  | 22 ++++---------------
 1 file changed, 4 insertions(+), 18 deletions(-)

diff --git a/website/source/docs/builders/azure-setup.html.md b/website/source/docs/builders/azure-setup.html.md
index 6da8f184c..ee73b1715 100644
--- a/website/source/docs/builders/azure-setup.html.md
+++ b/website/source/docs/builders/azure-setup.html.md
@@ -90,17 +90,7 @@ To get the credentials above, we will need to install the Azure CLI. Please
 refer to Microsoft's official [installation
 guide](https://azure.microsoft.com/en-us/documentation/articles/xplat-cli-install/).
 
--&gt; The guides below also use a tool called
-[`jq`](https://stedolan.github.io/jq/) to simplify the output from the Azure
-CLI, though this is optional. If you use homebrew you can simply
-`brew install node jq`.
-
-You can also use the Azure CLI in Docker. It also comes with `jq`
-pre-installed:
-
-``` shell
-$ docker run -it microsoft/azure-cli
-```
+The guides below use [JMESPath](http://jmespath.org/) queries to select and reformat output from the AZ CLI commands. JMESPath is [part of the Azure CLI](https://docs.microsoft.com/en-us/cli/azure/query-azure-cli?view=azure-cli-latest) and can be used in the same way as the `jq` tool.
 
 ## Guided Setup
 
@@ -148,15 +138,11 @@ below:
 Get your account information
 
 ``` shell
-$ az account list --output json | jq -r '.[].name'
+$ az account list --output table --query '[].{Name:name,subscription_id:id}'
 $ az account set --subscription ACCOUNTNAME
-$ az account show --output json | jq -r '.id'
+$ az account show --output json --query 'id'
 ```
 
--&gt; Throughout this document when you see a command pipe to `jq` you may
-instead omit `--output json` and everything after it, but the output will be
-more verbose. For example you can simply run `az account list` instead.
-
 This will print out one line that look like this:
 
     4f562e88-8caf-421a-b4da-e3f6786c52ec
@@ -235,7 +221,7 @@ granular permissions, though this is out of scope. You can see a list of
 pre-configured roles via:
 
 ``` shell
-$ az role definition list --output json | jq ".[] | {name:.roleName, description:.description}"
+$ az role definition list --output table --query '[].{name:roleName, description:description}'
 ```
 
 If you would rather use a certificate to autenticate your service principal,

From 9c19cfdc6f05953e0dbab4558a4189ab4f31e12a Mon Sep 17 00:00:00 2001
From: Lars Lehtonen <lars.lehtonen@gmail.com>
Date: Tue, 15 Oct 2019 00:45:05 -0700
Subject: [PATCH 061/155] provisioner/shell: fix dropped error

---
 provisioner/shell/provisioner.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/provisioner/shell/provisioner.go b/provisioner/shell/provisioner.go
index 168c1c0e4..b022c94fc 100644
--- a/provisioner/shell/provisioner.go
+++ b/provisioner/shell/provisioner.go
@@ -266,6 +266,9 @@ func (p *Provisioner) Provision(ctx context.Context, ui packer.Ui, comm packer.C
 			p.config.envVarFile = remoteVFName
 			return nil
 		})
+		if err != nil {
+			return err
+		}
 	}
 
 	// Create environment variables to set before executing the command

From 8b8c2fc138dec15f4fcee36fcda9b00ec2b0ffac Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 15:54:33 +0200
Subject: [PATCH 062/155] builder.amazon.chroot: remove specific BlockDevice
 definition

because the common one already has a KmsKeyId field
---
 builder/amazon/chroot/block_device.go         | 69 -------------------
 builder/amazon/chroot/builder.go              |  3 +-
 .../amazon/chroot/step_register_ami_test.go   | 12 ++--
 3 files changed, 8 insertions(+), 76 deletions(-)
 delete mode 100644 builder/amazon/chroot/block_device.go

diff --git a/builder/amazon/chroot/block_device.go b/builder/amazon/chroot/block_device.go
deleted file mode 100644
index 7920273e8..000000000
--- a/builder/amazon/chroot/block_device.go
+++ /dev/null
@@ -1,69 +0,0 @@
-//go:generate struct-markdown
-
-package chroot
-
-import (
-	"fmt"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ec2"
-	awscommon "github.com/hashicorp/packer/builder/amazon/common"
-	"github.com/hashicorp/packer/template/interpolate"
-)
-
-type BlockDevice struct {
-	awscommon.BlockDevice `mapstructure:",squash"`
-	// ID, alias or ARN of the KMS key to use for boot volume encryption. This
-	// only applies to the main region, other regions where the AMI will be
-	// copied will be encrypted by the default EBS KMS key. For valid formats
-	// see KmsKeyId in the [AWS API docs -
-	// CopyImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopyImage.html)
-	// This field is validated by Packer, when using an alias, you will have to
-	// prefix kms_key_id with alias/.
-	KmsKeyId string `mapstructure:"kms_key_id" required:"false"`
-}
-
-type BlockDevices []BlockDevice
-
-func (bds BlockDevices) BuildEC2BlockDeviceMappings() []*ec2.BlockDeviceMapping {
-	var blockDevices []*ec2.BlockDeviceMapping
-
-	for _, blockDevice := range bds {
-		blockDevices = append(blockDevices, blockDevice.BuildEC2BlockDeviceMapping())
-	}
-	return blockDevices
-}
-
-func (blockDevice BlockDevice) BuildEC2BlockDeviceMapping() *ec2.BlockDeviceMapping {
-	mapping := blockDevice.BlockDevice.BuildEC2BlockDeviceMapping()
-
-	if blockDevice.KmsKeyId != "" {
-		mapping.Ebs.KmsKeyId = aws.String(blockDevice.KmsKeyId)
-	}
-	return mapping
-}
-
-func (b *BlockDevice) Prepare(ctx *interpolate.Context) error {
-	err := b.BlockDevice.Prepare(ctx)
-	if err != nil {
-		return err
-	}
-
-	// Warn that encrypted must be true when setting kms_key_id
-	if b.KmsKeyId != "" && b.Encrypted.True() {
-		return fmt.Errorf("The device %v, must also have `encrypted: "+
-			"true` when setting a kms_key_id.", b.DeviceName)
-	}
-
-	_, err = interpolate.RenderInterface(&b, ctx)
-	return err
-}
-
-func (bds BlockDevices) Prepare(ctx *interpolate.Context) (errs []error) {
-	for _, block := range bds {
-		if err := block.Prepare(ctx); err != nil {
-			errs = append(errs, err)
-		}
-	}
-	return errs
-}
diff --git a/builder/amazon/chroot/builder.go b/builder/amazon/chroot/builder.go
index f51ae9255..2277fa38c 100644
--- a/builder/amazon/chroot/builder.go
+++ b/builder/amazon/chroot/builder.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config,BlockDevices,BlockDevice
 
 // The chroot package is able to create an Amazon AMI without requiring the
 // launch of a new instance for every build. It does this by attaching and
@@ -37,7 +38,7 @@ type Config struct {
 	// entry for your root volume, `root_volume_size` and `root_device_name`.
 	// See the [BlockDevices](#block-devices-configuration) documentation for
 	// fields.
-	AMIMappings BlockDevices `mapstructure:"ami_block_device_mappings" required:"false"`
+	AMIMappings awscommon.BlockDevices `mapstructure:"ami_block_device_mappings" hcl2-schema-generator:"ami_block_device_mappings,direct" required:"false"`
 	// This is a list of devices to mount into the chroot environment. This
 	// configuration parameter requires some additional documentation which is
 	// in the Chroot Mounts section. Please read that section for more
diff --git a/builder/amazon/chroot/step_register_ami_test.go b/builder/amazon/chroot/step_register_ami_test.go
index a6a64b8fc..72922c7e6 100644
--- a/builder/amazon/chroot/step_register_ami_test.go
+++ b/builder/amazon/chroot/step_register_ami_test.go
@@ -92,10 +92,10 @@ func TestStepRegisterAmi_buildRegisterOptsFromScratch(t *testing.T) {
 	config := Config{
 		FromScratch:  true,
 		PackerConfig: common.PackerConfig{},
-		AMIMappings: []BlockDevice{
-			{BlockDevice: amazon.BlockDevice{
+		AMIMappings: []amazon.BlockDevice{
+			amazon.BlockDevice{
 				DeviceName: rootDeviceName,
-			}},
+			},
 		},
 		RootDeviceName: rootDeviceName,
 	}
@@ -167,10 +167,10 @@ func TestStepRegisterAmi_buildRegisterOptFromExistingImageWithBlockDeviceMapping
 	config := Config{
 		FromScratch:  false,
 		PackerConfig: common.PackerConfig{},
-		AMIMappings: []BlockDevice{
-			{BlockDevice: amazon.BlockDevice{
+		AMIMappings: []amazon.BlockDevice{
+			amazon.BlockDevice{
 				DeviceName: rootDeviceName,
-			}},
+			},
 		},
 		RootDeviceName: rootDeviceName,
 	}

From 221e72e9c3952e5ce925b9f549ec0054638f8b76 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 15:56:49 +0200
Subject: [PATCH 063/155] builder.amazon.common: remove pointer (*) from
 []*string and map[*string]*string types

because they make hcl2/cty decoding panic
---
 builder/amazon/common/build_filter.go         |  6 +++---
 builder/amazon/common/run_config.go           | 18 +++++++++++++-----
 builder/amazon/common/run_config_test.go      |  4 ++--
 builder/amazon/common/step_network_info.go    |  9 ++++-----
 builder/amazon/common/step_security_group.go  |  2 +-
 builder/amazon/common/step_source_ami_info.go |  2 +-
 6 files changed, 24 insertions(+), 17 deletions(-)

diff --git a/builder/amazon/common/build_filter.go b/builder/amazon/common/build_filter.go
index 8f621efc8..87600b5d0 100644
--- a/builder/amazon/common/build_filter.go
+++ b/builder/amazon/common/build_filter.go
@@ -5,12 +5,12 @@ import (
 )
 
 // Build a slice of EC2 (AMI/Subnet/VPC) filter options from the filters provided.
-func buildEc2Filters(input map[*string]*string) []*ec2.Filter {
+func buildEc2Filters(input map[string]string) []*ec2.Filter {
 	var filters []*ec2.Filter
 	for k, v := range input {
 		filters = append(filters, &ec2.Filter{
-			Name:   k,
-			Values: []*string{v},
+			Name:   &k,
+			Values: []*string{&v},
 		})
 	}
 	return filters
diff --git a/builder/amazon/common/run_config.go b/builder/amazon/common/run_config.go
index d42825032..2577d5216 100644
--- a/builder/amazon/common/run_config.go
+++ b/builder/amazon/common/run_config.go
@@ -18,11 +18,19 @@ import (
 var reShutdownBehavior = regexp.MustCompile("^(stop|terminate)$")
 
 type AmiFilterOptions struct {
-	Filters    map[*string]*string
-	Owners     []*string
+	Filters    map[string]string
+	Owners     []string
 	MostRecent bool `mapstructure:"most_recent"`
 }
 
+func (d *AmiFilterOptions) GetOwners() []*string {
+	res := make([]*string, 0, len(d.Owners))
+	for _, owner := range d.Owners {
+		res = append(res, &owner)
+	}
+	return res
+}
+
 func (d *AmiFilterOptions) Empty() bool {
 	return len(d.Owners) == 0 && len(d.Filters) == 0
 }
@@ -32,7 +40,7 @@ func (d *AmiFilterOptions) NoOwner() bool {
 }
 
 type SubnetFilterOptions struct {
-	Filters  map[*string]*string
+	Filters  map[string]string
 	MostFree bool `mapstructure:"most_free"`
 	Random   bool `mapstructure:"random"`
 }
@@ -42,7 +50,7 @@ func (d *SubnetFilterOptions) Empty() bool {
 }
 
 type VpcFilterOptions struct {
-	Filters map[*string]*string
+	Filters map[string]string
 }
 
 func (d *VpcFilterOptions) Empty() bool {
@@ -50,7 +58,7 @@ func (d *VpcFilterOptions) Empty() bool {
 }
 
 type SecurityGroupFilterOptions struct {
-	Filters map[*string]*string
+	Filters map[string]string
 }
 
 func (d *SecurityGroupFilterOptions) Empty() bool {
diff --git a/builder/amazon/common/run_config_test.go b/builder/amazon/common/run_config_test.go
index c876f4ce7..c01b31ebb 100644
--- a/builder/amazon/common/run_config_test.go
+++ b/builder/amazon/common/run_config_test.go
@@ -73,7 +73,7 @@ func TestRunConfigPrepare_SourceAmiFilterOwnersBlank(t *testing.T) {
 	c := testConfigFilter()
 	filter_key := "name"
 	filter_value := "foo"
-	c.SourceAmiFilter = AmiFilterOptions{Filters: map[*string]*string{&filter_key: &filter_value}}
+	c.SourceAmiFilter = AmiFilterOptions{Filters: map[string]string{filter_key: filter_value}}
 	if err := c.Prepare(nil); len(err) != 1 {
 		t.Fatalf("Should error if Owners is not specified)")
 	}
@@ -84,7 +84,7 @@ func TestRunConfigPrepare_SourceAmiFilterGood(t *testing.T) {
 	owner := "123"
 	filter_key := "name"
 	filter_value := "foo"
-	goodFilter := AmiFilterOptions{Owners: []*string{&owner}, Filters: map[*string]*string{&filter_key: &filter_value}}
+	goodFilter := AmiFilterOptions{Owners: []string{owner}, Filters: map[string]string{filter_key: filter_value}}
 	c.SourceAmiFilter = goodFilter
 	if err := c.Prepare(nil); len(err) != 0 {
 		t.Fatalf("err: %s", err)
diff --git a/builder/amazon/common/step_network_info.go b/builder/amazon/common/step_network_info.go
index 0c9e9946e..89d63590d 100644
--- a/builder/amazon/common/step_network_info.go
+++ b/builder/amazon/common/step_network_info.go
@@ -7,7 +7,6 @@ import (
 	"math/rand"
 	"sort"
 
-	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -53,7 +52,7 @@ func (s *StepNetworkInfo) Run(ctx context.Context, state multistep.StateBag) mul
 	if s.VpcId == "" && !s.VpcFilter.Empty() {
 		params := &ec2.DescribeVpcsInput{}
 		params.Filters = buildEc2Filters(s.VpcFilter.Filters)
-		s.VpcFilter.Filters[aws.String("state")] = aws.String("available")
+		s.VpcFilter.Filters["state"] = "available"
 
 		log.Printf("Using VPC Filters %v", params)
 
@@ -79,13 +78,13 @@ func (s *StepNetworkInfo) Run(ctx context.Context, state multistep.StateBag) mul
 	// Subnet
 	if s.SubnetId == "" && !s.SubnetFilter.Empty() {
 		params := &ec2.DescribeSubnetsInput{}
-		s.SubnetFilter.Filters[aws.String("state")] = aws.String("available")
+		s.SubnetFilter.Filters["state"] = "available"
 
 		if s.VpcId != "" {
-			s.SubnetFilter.Filters[aws.String("vpc-id")] = &s.VpcId
+			s.SubnetFilter.Filters["vpc-id"] = s.VpcId
 		}
 		if s.AvailabilityZone != "" {
-			s.SubnetFilter.Filters[aws.String("availability-zone")] = &s.AvailabilityZone
+			s.SubnetFilter.Filters["availabilityZone"] = s.AvailabilityZone
 		}
 		params.Filters = buildEc2Filters(s.SubnetFilter.Filters)
 		log.Printf("Using Subnet Filters %v", params)
diff --git a/builder/amazon/common/step_security_group.go b/builder/amazon/common/step_security_group.go
index 9b0b15829..a906848b8 100644
--- a/builder/amazon/common/step_security_group.go
+++ b/builder/amazon/common/step_security_group.go
@@ -51,7 +51,7 @@ func (s *StepSecurityGroup) Run(ctx context.Context, state multistep.StateBag) m
 
 		params := &ec2.DescribeSecurityGroupsInput{}
 		if vpcId != "" {
-			s.SecurityGroupFilter.Filters[aws.String("vpc-id")] = &vpcId
+			s.SecurityGroupFilter.Filters["vpc-id"] = vpcId
 		}
 		params.Filters = buildEc2Filters(s.SecurityGroupFilter.Filters)
 
diff --git a/builder/amazon/common/step_source_ami_info.go b/builder/amazon/common/step_source_ami_info.go
index c80f6a6cb..a3e4de37f 100644
--- a/builder/amazon/common/step_source_ami_info.go
+++ b/builder/amazon/common/step_source_ami_info.go
@@ -58,7 +58,7 @@ func (s *StepSourceAMIInfo) Run(ctx context.Context, state multistep.StateBag) m
 		params.Filters = buildEc2Filters(s.AmiFilters.Filters)
 	}
 	if len(s.AmiFilters.Owners) > 0 {
-		params.Owners = s.AmiFilters.Owners
+		params.Owners = s.AmiFilters.GetOwners()
 	}
 
 	log.Printf("Using AMI Filters %v", params)

From f8402f1b91dd130838f5cc2689315440aec6fa79 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 15:59:26 +0200
Subject: [PATCH 064/155] builder.azure.common: make CloudEnvironment private
 so it doesn't temper with hcl2 code generation

the struct is not read from file but later set after some computations
---
 builder/azure/arm/builder.go               |  2 +-
 builder/azure/arm/config_test.go           |  8 +++----
 builder/azure/common/client/config.go      | 27 +++++++++++++---------
 builder/azure/common/client/config_test.go |  8 +++----
 4 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/builder/azure/arm/builder.go b/builder/azure/arm/builder.go
index 27bc32a4a..2381e529f 100644
--- a/builder/azure/arm/builder.go
+++ b/builder/azure/arm/builder.go
@@ -79,7 +79,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		b.config.ClientConfig.SubscriptionID,
 		b.config.ResourceGroupName,
 		b.config.StorageAccount,
-		b.config.ClientConfig.CloudEnvironment,
+		b.config.ClientConfig.CloudEnvironment(),
 		b.config.SharedGalleryTimeout,
 		spnCloud,
 		spnKeyVault)
diff --git a/builder/azure/arm/config_test.go b/builder/azure/arm/config_test.go
index 9ed25fffa..b4643ffdc 100644
--- a/builder/azure/arm/config_test.go
+++ b/builder/azure/arm/config_test.go
@@ -277,8 +277,8 @@ func TestConfigShouldDefaultToPublicCloud(t *testing.T) {
 		t.Errorf("Expected 'CloudEnvironmentName' to default to 'Public', but got '%s'.", c.ClientConfig.CloudEnvironmentName)
 	}
 
-	if c.ClientConfig.CloudEnvironment == nil || c.ClientConfig.CloudEnvironment.Name != "AzurePublicCloud" {
-		t.Errorf("Expected 'cloudEnvironment' to be set to 'AzurePublicCloud', but got '%s'.", c.ClientConfig.CloudEnvironment)
+	if c.ClientConfig.CloudEnvironment() == nil || c.ClientConfig.CloudEnvironment().Name != "AzurePublicCloud" {
+		t.Errorf("Expected 'cloudEnvironment' to be set to 'AzurePublicCloud', but got '%s'.", c.ClientConfig.CloudEnvironment())
 	}
 }
 
@@ -327,8 +327,8 @@ func TestConfigInstantiatesCorrectAzureEnvironment(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		if c.ClientConfig.CloudEnvironment == nil || c.ClientConfig.CloudEnvironment.Name != x.environmentName {
-			t.Errorf("Expected 'cloudEnvironment' to be set to '%s', but got '%s'.", x.environmentName, c.ClientConfig.CloudEnvironment)
+		if c.ClientConfig.CloudEnvironment() == nil || c.ClientConfig.CloudEnvironment().Name != x.environmentName {
+			t.Errorf("Expected 'cloudEnvironment' to be set to '%s', but got '%s'.", x.environmentName, c.ClientConfig.CloudEnvironment())
 		}
 	}
 }
diff --git a/builder/azure/common/client/config.go b/builder/azure/common/client/config.go
index 9a4a736e8..601e7ac25 100644
--- a/builder/azure/common/client/config.go
+++ b/builder/azure/common/client/config.go
@@ -4,11 +4,12 @@ package client
 
 import (
 	"fmt"
-	"github.com/hashicorp/packer/builder/azure/common"
 	"os"
 	"strings"
 	"time"
 
+	"github.com/hashicorp/packer/builder/azure/common"
+
 	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure"
 	jwt "github.com/dgrijalva/jwt-go"
@@ -28,7 +29,7 @@ type Config struct {
 	// USGovernment. Defaults to Public. Long forms such as
 	// USGovernmentCloud and AzureUSGovernmentCloud are also supported.
 	CloudEnvironmentName string `mapstructure:"cloud_environment_name" required:"false"`
-	CloudEnvironment     *azure.Environment
+	cloudEnvironment     *azure.Environment
 
 	// Authentication fields
 
@@ -73,6 +74,10 @@ func (c *Config) SetDefaultValues() error {
 	return c.setCloudEnvironment()
 }
 
+func (c *Config) CloudEnvironment() *azure.Environment {
+	return c.cloudEnvironment
+}
+
 func (c *Config) setCloudEnvironment() error {
 	lookup := map[string]string{
 		"CHINA":           "AzureChinaCloud",
@@ -103,7 +108,7 @@ func (c *Config) setCloudEnvironment() error {
 	}
 
 	env, err := azure.EnvironmentFromName(envName)
-	c.CloudEnvironment = &env
+	c.cloudEnvironment = &env
 	return err
 }
 
@@ -210,22 +215,22 @@ func (c Config) GetServicePrincipalTokens(
 	switch c.authType {
 	case authTypeDeviceLogin:
 		say("Getting tokens using device flow")
-		auth = NewDeviceFlowOAuthTokenProvider(*c.CloudEnvironment, say, tenantID)
+		auth = NewDeviceFlowOAuthTokenProvider(*c.cloudEnvironment, say, tenantID)
 	case authTypeMSI:
 		say("Getting tokens using Managed Identity for Azure")
-		auth = NewMSIOAuthTokenProvider(*c.CloudEnvironment)
+		auth = NewMSIOAuthTokenProvider(*c.cloudEnvironment)
 	case authTypeClientSecret:
 		say("Getting tokens using client secret")
-		auth = NewSecretOAuthTokenProvider(*c.CloudEnvironment, c.ClientID, c.ClientSecret, tenantID)
+		auth = NewSecretOAuthTokenProvider(*c.cloudEnvironment, c.ClientID, c.ClientSecret, tenantID)
 	case authTypeClientCert:
 		say("Getting tokens using client certificate")
-		auth, err = NewCertOAuthTokenProvider(*c.CloudEnvironment, c.ClientID, c.ClientCertPath, tenantID)
+		auth, err = NewCertOAuthTokenProvider(*c.cloudEnvironment, c.ClientID, c.ClientCertPath, tenantID)
 		if err != nil {
 			return nil, nil, err
 		}
 	case authTypeClientBearerJWT:
 		say("Getting tokens using client bearer JWT")
-		auth = NewJWTOAuthTokenProvider(*c.CloudEnvironment, c.ClientID, c.ClientJWT, tenantID)
+		auth = NewJWTOAuthTokenProvider(*c.cloudEnvironment, c.ClientID, c.ClientJWT, tenantID)
 	default:
 		panic("authType not set, call FillParameters, or set explicitly")
 	}
@@ -241,7 +246,7 @@ func (c Config) GetServicePrincipalTokens(
 	}
 
 	servicePrincipalTokenVault, err = auth.getServicePrincipalTokenWithResource(
-		strings.TrimRight(c.CloudEnvironment.KeyVaultEndpoint, "/"))
+		strings.TrimRight(c.cloudEnvironment.KeyVaultEndpoint, "/"))
 	if err != nil {
 		return nil, nil, err
 	}
@@ -280,7 +285,7 @@ func (c *Config) FillParameters() error {
 		c.SubscriptionID = subscriptionID
 	}
 
-	if c.CloudEnvironment == nil {
+	if c.cloudEnvironment == nil {
 		err := c.setCloudEnvironment()
 		if err != nil {
 			return err
@@ -288,7 +293,7 @@ func (c *Config) FillParameters() error {
 	}
 
 	if c.TenantID == "" {
-		tenantID, err := findTenantID(*c.CloudEnvironment, c.SubscriptionID)
+		tenantID, err := findTenantID(*c.cloudEnvironment, c.SubscriptionID)
 		if err != nil {
 			return err
 		}
diff --git a/builder/azure/common/client/config_test.go b/builder/azure/common/client/config_test.go
index 3e76b4d2b..a914e25c3 100644
--- a/builder/azure/common/client/config_test.go
+++ b/builder/azure/common/client/config_test.go
@@ -133,7 +133,7 @@ func Test_ClientConfig_DeviceLogin(t *testing.T) {
 	getEnvOrSkip(t, "AZURE_DEVICE_LOGIN")
 	cfg := Config{
 		SubscriptionID:   getEnvOrSkip(t, "AZURE_SUBSCRIPTION"),
-		CloudEnvironment: getCloud(),
+		cloudEnvironment: getCloud(),
 	}
 	assertValid(t, cfg)
 
@@ -164,7 +164,7 @@ func Test_ClientConfig_ClientPassword(t *testing.T) {
 		ClientID:         getEnvOrSkip(t, "AZURE_CLIENTID"),
 		ClientSecret:     getEnvOrSkip(t, "AZURE_CLIENTSECRET"),
 		TenantID:         getEnvOrSkip(t, "AZURE_TENANTID"),
-		CloudEnvironment: getCloud(),
+		cloudEnvironment: getCloud(),
 	}
 	assertValid(t, cfg)
 
@@ -194,7 +194,7 @@ func Test_ClientConfig_ClientCert(t *testing.T) {
 		ClientID:         getEnvOrSkip(t, "AZURE_CLIENTID"),
 		ClientCertPath:   getEnvOrSkip(t, "AZURE_CLIENTCERT"),
 		TenantID:         getEnvOrSkip(t, "AZURE_TENANTID"),
-		CloudEnvironment: getCloud(),
+		cloudEnvironment: getCloud(),
 	}
 	assertValid(t, cfg)
 
@@ -224,7 +224,7 @@ func Test_ClientConfig_ClientJWT(t *testing.T) {
 		ClientID:         getEnvOrSkip(t, "AZURE_CLIENTID"),
 		ClientJWT:        getEnvOrSkip(t, "AZURE_CLIENTJWT"),
 		TenantID:         getEnvOrSkip(t, "AZURE_TENANTID"),
-		CloudEnvironment: getCloud(),
+		cloudEnvironment: getCloud(),
 	}
 	assertValid(t, cfg)
 

From 17c069baa56096dcaae7a6635f666cbf72d0dcef Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:02:19 +0200
Subject: [PATCH 065/155] builder.google:

* make CustomerEncryptionKey our own type so that it can be hcl2 generated
* make Account setting unexported so that it doesn't temper with HCL2 generation ( the field is set a bit later after processing )
---
 builder/googlecompute/builder.go              |  2 +-
 builder/googlecompute/config.go               | 26 ++++++++++++++++---
 builder/googlecompute/step_create_image.go    |  2 +-
 .../googlecompute/step_create_image_test.go   |  2 +-
 .../step_create_windows_password.go           |  4 +--
 5 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/builder/googlecompute/builder.go b/builder/googlecompute/builder.go
index 6b8dfd331..2a30d39c5 100644
--- a/builder/googlecompute/builder.go
+++ b/builder/googlecompute/builder.go
@@ -36,7 +36,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 // representing a GCE machine image.
 func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
 	driver, err := NewDriverGCE(
-		ui, b.config.ProjectId, b.config.Account, b.config.VaultGCPOauthEngine)
+		ui, b.config.ProjectId, b.config.account, b.config.VaultGCPOauthEngine)
 	if err != nil {
 		return nil, err
 	}
diff --git a/builder/googlecompute/config.go b/builder/googlecompute/config.go
index 2fb9dbfc4..eba106f22 100644
--- a/builder/googlecompute/config.go
+++ b/builder/googlecompute/config.go
@@ -72,7 +72,7 @@ type Config struct {
 	//     "kmsKeyName": "projects/${project}/locations/${region}/keyRings/computeEngine/cryptoKeys/computeEngine/cryptoKeyVersions/4"
 	//  }
 	//  ```
-	ImageEncryptionKey *compute.CustomerEncryptionKey `mapstructure:"image_encryption_key" required:"false"`
+	ImageEncryptionKey *CustomerEncryptionKey `mapstructure:"image_encryption_key" required:"false"`
 	// The name of the image family to which the resulting image belongs. You
 	// can create disks by specifying an image family instead of a specific
 	// image name. The image family always returns its latest image that is not
@@ -181,7 +181,7 @@ type Config struct {
 	// Example: "us-central1-a"
 	Zone string `mapstructure:"zone" required:"true"`
 
-	Account            *jwt.Config
+	account            *jwt.Config
 	stateTimeout       time.Duration
 	imageAlreadyExists bool
 	ctx                interpolate.Context
@@ -344,7 +344,7 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 		if err != nil {
 			errs = packer.MultiErrorAppend(errs, err)
 		}
-		c.Account = cfg
+		c.account = cfg
 	}
 
 	if c.OmitExternalIP && c.Address != "" {
@@ -391,3 +391,23 @@ func (c *Config) CalcTimeout() error {
 	c.stateTimeout = stateTimeout
 	return nil
 }
+
+type CustomerEncryptionKey struct {
+	// KmsKeyName: The name of the encryption key that is stored in Google
+	// Cloud KMS.
+	KmsKeyName string `json:"kmsKeyName,omitempty"`
+
+	// RawKey: Specifies a 256-bit customer-supplied encryption key, encoded
+	// in RFC 4648 base64 to either encrypt or decrypt this resource.
+	RawKey string `json:"rawKey,omitempty"`
+}
+
+func (k *CustomerEncryptionKey) ComputeType() *compute.CustomerEncryptionKey {
+	if k == nil {
+		return nil
+	}
+	return &compute.CustomerEncryptionKey{
+		KmsKeyName: k.KmsKeyName,
+		RawKey:     k.RawKey,
+	}
+}
diff --git a/builder/googlecompute/step_create_image.go b/builder/googlecompute/step_create_image.go
index 536cde6f8..389338c43 100644
--- a/builder/googlecompute/step_create_image.go
+++ b/builder/googlecompute/step_create_image.go
@@ -40,7 +40,7 @@ func (s *StepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
 
 	imageCh, errCh := driver.CreateImage(
 		config.ImageName, config.ImageDescription, config.ImageFamily, config.Zone,
-		config.DiskName, config.ImageLabels, config.ImageLicenses, config.ImageEncryptionKey)
+		config.DiskName, config.ImageLabels, config.ImageLicenses, config.ImageEncryptionKey.ComputeType())
 	var err error
 	select {
 	case err = <-errCh:
diff --git a/builder/googlecompute/step_create_image_test.go b/builder/googlecompute/step_create_image_test.go
index 2e84af218..956b13896 100644
--- a/builder/googlecompute/step_create_image_test.go
+++ b/builder/googlecompute/step_create_image_test.go
@@ -47,7 +47,7 @@ func TestStepCreateImage(t *testing.T) {
 	assert.Equal(t, d.CreateImageDisk, c.DiskName, "Incorrect disk passed to driver.")
 	assert.Equal(t, d.CreateImageLabels, c.ImageLabels, "Incorrect image_labels passed to driver.")
 	assert.Equal(t, d.CreateImageLicenses, c.ImageLicenses, "Incorrect image_licenses passed to driver.")
-	assert.Equal(t, d.CreateImageEncryptionKey, c.ImageEncryptionKey, "Incorrect image_encryption_key passed to driver.")
+	assert.Equal(t, d.CreateImageEncryptionKey, c.ImageEncryptionKey.ComputeType(), "Incorrect image_encryption_key passed to driver.")
 }
 
 func TestStepCreateImage_errorOnChannel(t *testing.T) {
diff --git a/builder/googlecompute/step_create_windows_password.go b/builder/googlecompute/step_create_windows_password.go
index 4f172c642..a5ddb5950 100644
--- a/builder/googlecompute/step_create_windows_password.go
+++ b/builder/googlecompute/step_create_windows_password.go
@@ -56,8 +56,8 @@ func (s *StepCreateWindowsPassword) Run(ctx context.Context, state multistep.Sta
 	binary.BigEndian.PutUint32(buf, uint32(priv.E))
 
 	email := ""
-	if c.Account != nil {
-		email = c.Account.Email
+	if c.account != nil {
+		email = c.account.Email
 	}
 
 	data := WindowsPasswordConfig{

From 3fa614b5e1ac091d0c7d915f124fcdbaeaee902a Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:08:16 +0200
Subject: [PATCH 066/155] builder.oracle.oci: make ConfigProvider unexported

so that it doesn't temper with hcl2 code generation & parsing.

The field is set only later on after further processing.
---
 builder/oracle/oci/builder.go     |  2 +-
 builder/oracle/oci/config.go      |  8 ++++++--
 builder/oracle/oci/config_test.go | 12 ++++++------
 builder/oracle/oci/driver_oci.go  |  4 ++--
 4 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/builder/oracle/oci/builder.go b/builder/oracle/oci/builder.go
index 7822b144f..a4b31b8e6 100644
--- a/builder/oracle/oci/builder.go
+++ b/builder/oracle/oci/builder.go
@@ -84,7 +84,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		return nil, rawErr.(error)
 	}
 
-	region, err := b.config.ConfigProvider.Region()
+	region, err := b.config.configProvider.Region()
 	if err != nil {
 		return nil, err
 	}
diff --git a/builder/oracle/oci/config.go b/builder/oracle/oci/config.go
index 014b9d207..acb3b1573 100644
--- a/builder/oracle/oci/config.go
+++ b/builder/oracle/oci/config.go
@@ -23,7 +23,7 @@ type Config struct {
 	common.PackerConfig `mapstructure:",squash"`
 	Comm                communicator.Config `mapstructure:",squash"`
 
-	ConfigProvider ocicommon.ConfigurationProvider
+	configProvider ocicommon.ConfigurationProvider
 
 	AccessCfgFile        string `mapstructure:"access_cfg_file"`
 	AccessCfgFileAccount string `mapstructure:"access_cfg_file_account"`
@@ -69,6 +69,10 @@ type Config struct {
 	ctx interpolate.Context
 }
 
+func (c *Config) ConfigProvider() ocicommon.ConfigurationProvider {
+	return c.configProvider
+}
+
 func NewConfig(raws ...interface{}) (*Config, error) {
 	c := &Config{}
 
@@ -158,7 +162,7 @@ func NewConfig(raws ...interface{}) (*Config, error) {
 			errs, errors.New("'key_file' must be specified"))
 	}
 
-	c.ConfigProvider = configProvider
+	c.configProvider = configProvider
 
 	if c.AvailabilityDomain == "" {
 		errs = packer.MultiErrorAppend(
diff --git a/builder/oracle/oci/config_test.go b/builder/oracle/oci/config_test.go
index 7084df61a..37d23a258 100644
--- a/builder/oracle/oci/config_test.go
+++ b/builder/oracle/oci/config_test.go
@@ -117,7 +117,7 @@ func TestConfig(t *testing.T) {
 			t.Fatalf("Unexpected error in configuration %+v", errs)
 		}
 
-		tenancy, err := c.ConfigProvider.TenancyOCID()
+		tenancy, err := c.configProvider.TenancyOCID()
 		if err != nil {
 			t.Fatalf("Unexpected error getting tenancy ocid: %v", err)
 		}
@@ -136,7 +136,7 @@ func TestConfig(t *testing.T) {
 			t.Fatalf("Unexpected error in configuration %+v", errs)
 		}
 
-		region, err := c.ConfigProvider.Region()
+		region, err := c.configProvider.Region()
 		if err != nil {
 			t.Fatalf("Unexpected error getting region: %v", err)
 		}
@@ -188,7 +188,7 @@ func TestConfig(t *testing.T) {
 			t.Fatalf("Unexpected error in configuration %+v", errs)
 		}
 
-		user, _ := c.ConfigProvider.UserOCID()
+		user, _ := c.configProvider.UserOCID()
 		if user != expected {
 			t.Errorf("Expected ConfigProvider.UserOCID: %s, got %s", expected, user)
 		}
@@ -204,7 +204,7 @@ func TestConfig(t *testing.T) {
 			t.Fatalf("Unexpected error in configuration %+v", errs)
 		}
 
-		tenancy, _ := c.ConfigProvider.TenancyOCID()
+		tenancy, _ := c.configProvider.TenancyOCID()
 		if tenancy != expected {
 			t.Errorf("Expected ConfigProvider.TenancyOCID: %s, got %s", expected, tenancy)
 		}
@@ -220,7 +220,7 @@ func TestConfig(t *testing.T) {
 			t.Fatalf("Unexpected error in configuration %+v", errs)
 		}
 
-		region, _ := c.ConfigProvider.Region()
+		region, _ := c.configProvider.Region()
 		if region != expected {
 			t.Errorf("Expected ConfigProvider.Region: %s, got %s", expected, region)
 		}
@@ -236,7 +236,7 @@ func TestConfig(t *testing.T) {
 			t.Fatalf("Unexpected error in configuration: %+v", errs)
 		}
 
-		fingerprint, _ := c.ConfigProvider.KeyFingerprint()
+		fingerprint, _ := c.configProvider.KeyFingerprint()
 		if fingerprint != expected {
 			t.Errorf("Expected ConfigProvider.KeyFingerprint: %s, got %s", expected, fingerprint)
 		}
diff --git a/builder/oracle/oci/driver_oci.go b/builder/oracle/oci/driver_oci.go
index 3f02aaab0..6c619f48c 100644
--- a/builder/oracle/oci/driver_oci.go
+++ b/builder/oracle/oci/driver_oci.go
@@ -20,12 +20,12 @@ type driverOCI struct {
 
 // NewDriverOCI Creates a new driverOCI with a connected compute client and a connected vcn client.
 func NewDriverOCI(cfg *Config) (Driver, error) {
-	coreClient, err := core.NewComputeClientWithConfigurationProvider(cfg.ConfigProvider)
+	coreClient, err := core.NewComputeClientWithConfigurationProvider(cfg.configProvider)
 	if err != nil {
 		return nil, err
 	}
 
-	vcnClient, err := core.NewVirtualNetworkClientWithConfigurationProvider(cfg.ConfigProvider)
+	vcnClient, err := core.NewVirtualNetworkClientWithConfigurationProvider(cfg.configProvider)
 	if err != nil {
 		return nil, err
 	}

From 40692a4e3812aaaece06e5b766821d2548e14890 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:09:27 +0200
Subject: [PATCH 067/155] builder.profitbricks: remove duplicate
 communicator.Config field

---
 builder/profitbricks/config.go | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/builder/profitbricks/config.go b/builder/profitbricks/config.go
index 4c9260a18..4cf4c9d32 100644
--- a/builder/profitbricks/config.go
+++ b/builder/profitbricks/config.go
@@ -23,13 +23,12 @@ type Config struct {
 	Region       string `mapstructure:"location"`
 	Image        string `mapstructure:"image"`
 	SSHKey       string
-	SnapshotName string              `mapstructure:"snapshot_name"`
-	DiskSize     int                 `mapstructure:"disk_size"`
-	DiskType     string              `mapstructure:"disk_type"`
-	Cores        int                 `mapstructure:"cores"`
-	Ram          int                 `mapstructure:"ram"`
-	Retries      int                 `mapstructure:"retries"`
-	CommConfig   communicator.Config `mapstructure:",squash"`
+	SnapshotName string `mapstructure:"snapshot_name"`
+	DiskSize     int    `mapstructure:"disk_size"`
+	DiskType     string `mapstructure:"disk_type"`
+	Cores        int    `mapstructure:"cores"`
+	Ram          int    `mapstructure:"ram"`
+	Retries      int    `mapstructure:"retries"`
 	ctx          interpolate.Context
 }
 

From 3fe1c96491b47288ac43fb6e7487e7c347dff0d7 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:10:35 +0200
Subject: [PATCH 068/155] builder.proxmox: make ProxmoxURL *url.URL field 
 unexported

the only exported field we/users care about is ProxmoxURLRaw
---
 builder/proxmox/builder.go | 2 +-
 builder/proxmox/config.go  | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/builder/proxmox/builder.go b/builder/proxmox/builder.go
index 2b12308e1..083cfeb3d 100644
--- a/builder/proxmox/builder.go
+++ b/builder/proxmox/builder.go
@@ -41,7 +41,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	tlsConfig := &tls.Config{
 		InsecureSkipVerify: b.config.SkipCertValidation,
 	}
-	b.proxmoxClient, err = proxmox.NewClient(b.config.ProxmoxURL.String(), nil, tlsConfig)
+	b.proxmoxClient, err = proxmox.NewClient(b.config.proxmoxURL.String(), nil, tlsConfig)
 	if err != nil {
 		return nil, err
 	}
diff --git a/builder/proxmox/config.go b/builder/proxmox/config.go
index 766d3e71d..5d0a9f1eb 100644
--- a/builder/proxmox/config.go
+++ b/builder/proxmox/config.go
@@ -27,7 +27,7 @@ type Config struct {
 	Comm                   communicator.Config `mapstructure:",squash"`
 
 	ProxmoxURLRaw      string `mapstructure:"proxmox_url"`
-	ProxmoxURL         *url.URL
+	proxmoxURL         *url.URL
 	SkipCertValidation bool   `mapstructure:"insecure_skip_tls_verify"`
 	Username           string `mapstructure:"username"`
 	Password           string `mapstructure:"password"`
@@ -184,7 +184,7 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 	if c.ProxmoxURLRaw == "" {
 		errs = packer.MultiErrorAppend(errs, errors.New("proxmox_url must be specified"))
 	}
-	if c.ProxmoxURL, err = url.Parse(c.ProxmoxURLRaw); err != nil {
+	if c.proxmoxURL, err = url.Parse(c.ProxmoxURLRaw); err != nil {
 		errs = packer.MultiErrorAppend(errs, errors.New(fmt.Sprintf("Could not parse proxmox_url: %s", err)))
 	}
 	if c.ISOFile == "" {

From 6fbd664b66b4690318f39705334ef3115ed14021 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:12:09 +0200
Subject: [PATCH 069/155] builder.vagrant: simplify communicator.Config field

---
 builder/vagrant/builder.go | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/builder/vagrant/builder.go b/builder/vagrant/builder.go
index 69c6fb3cf..72d8ac490 100644
--- a/builder/vagrant/builder.go
+++ b/builder/vagrant/builder.go
@@ -27,17 +27,14 @@ type Builder struct {
 	runner multistep.Runner
 }
 
-type SSHConfig struct {
-	Comm communicator.Config `mapstructure:",squash"`
-}
-
 type Config struct {
 	common.PackerConfig    `mapstructure:",squash"`
 	common.HTTPConfig      `mapstructure:",squash"`
 	common.ISOConfig       `mapstructure:",squash"`
 	common.FloppyConfig    `mapstructure:",squash"`
 	bootcommand.BootConfig `mapstructure:",squash"`
-	SSHConfig              `mapstructure:",squash"`
+
+	Comm communicator.Config `mapstructure:",squash"`
 	// The directory to create that will contain your output box. We always
 	// create this directory and run from inside of it to prevent Vagrant init
 	// collisions. If unset, it will be set to packer- plus your buildname.
@@ -281,9 +278,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			b.config.GlobalID,
 		},
 		&communicator.StepConnect{
-			Config:    &b.config.SSHConfig.Comm,
+			Config:    &b.config.Comm,
 			Host:      CommHost(),
-			SSHConfig: b.config.SSHConfig.Comm.SSHConfigFunc(),
+			SSHConfig: b.config.Comm.SSHConfigFunc(),
 		},
 		new(common.StepProvision),
 		&StepPackage{

From 00e3f97f5b5032ae8e2e73c6cb37058022ded787 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:14:02 +0200
Subject: [PATCH 070/155] builder.vmware.iso: remove duplicate Format field

---
 builder/vmware/iso/config.go | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/builder/vmware/iso/config.go b/builder/vmware/iso/config.go
index 23b24aa1f..8e3c5034d 100644
--- a/builder/vmware/iso/config.go
+++ b/builder/vmware/iso/config.go
@@ -81,13 +81,6 @@ type Config struct {
 	//   Guide](https://www.vmware.com/pdf/VirtualDiskManager.pdf) for desktop
 	//   VMware clients. For ESXi, refer to the proper ESXi documentation.
 	DiskTypeId string `mapstructure:"disk_type_id" required:"false"`
-	// Either "ovf", "ova" or "vmx", this specifies the output
-	// format of the exported virtual machine. This defaults to "ovf".
-	// Before using this option, you need to install ovftool. This option
-	// currently only works when option remote_type is set to "esx5".
-	// Since ovftool is only capable of password based authentication
-	// remote_password must be set when exporting the VM.
-	Format string `mapstructure:"format" required:"false"`
 	// The adapter type (or bus) that will be used
 	// by the cdrom device. This is chosen by default based on the disk adapter
 	// type. VMware tends to lean towards ide for the cdrom device unless

From 766e5c77efbcdab8ba09f0c4e004a5b68f41f520 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:14:29 +0200
Subject: [PATCH 071/155] builder.vmware.vmx: remove duplicate RemoteType
 field.

---
 builder/vmware/vmx/config.go | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/builder/vmware/vmx/config.go b/builder/vmware/vmx/config.go
index 279a76377..f28e98115 100644
--- a/builder/vmware/vmx/config.go
+++ b/builder/vmware/vmx/config.go
@@ -43,11 +43,6 @@ type Config struct {
 	// scenarios. Most users will wish to create a full clone instead. Defaults
 	// to false.
 	Linked bool `mapstructure:"linked" required:"false"`
-	// The type of remote machine that will be used to
-	// build this VM rather than a local desktop product. The only value accepted
-	// for this currently is esx5. If this is not set, a desktop product will
-	// be used. By default, this is not set.
-	RemoteType string `mapstructure:"remote_type" required:"false"`
 	// Path to the source VMX file to clone. If
 	// remote_type is enabled then this specifies a path on the remote_host.
 	SourcePath string `mapstructure:"source_path" required:"true"`

From 7be94f41a628ae0f1b6073d0e207cfc77c2d530b Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:15:47 +0200
Subject: [PATCH 072/155] common.shell-local: unexport Ctx field

so that it doesn't temper with hcl2 generation
---
 common/shell-local/config.go |  6 +++---
 common/shell-local/run.go    | 12 ++++++------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/common/shell-local/config.go b/common/shell-local/config.go
index ea9911469..d7b97db6a 100644
--- a/common/shell-local/config.go
+++ b/common/shell-local/config.go
@@ -55,18 +55,18 @@ type Config struct {
 
 	UseLinuxPathing bool `mapstructure:"use_linux_pathing"`
 
-	Ctx interpolate.Context
+	ctx interpolate.Context
 }
 
 func Decode(config *Config, raws ...interface{}) error {
 	//Create passthrough for winrm password so we can fill it in once we know it
-	config.Ctx.Data = &EnvVarsTemplate{
+	config.ctx.Data = &EnvVarsTemplate{
 		WinRMPassword: `{{.WinRMPassword}}`,
 	}
 
 	err := configHelper.Decode(&config, &configHelper.DecodeOpts{
 		Interpolate:        true,
-		InterpolateContext: &config.Ctx,
+		InterpolateContext: &config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
 			Exclude: []string{
 				"execute_command",
diff --git a/common/shell-local/run.go b/common/shell-local/run.go
index 8303f609c..39ac4bf97 100644
--- a/common/shell-local/run.go
+++ b/common/shell-local/run.go
@@ -124,13 +124,13 @@ func createInlineScriptFile(config *Config) (string, error) {
 	}
 
 	// generate context so you can interpolate the command
-	config.Ctx.Data = &EnvVarsTemplate{
+	config.ctx.Data = &EnvVarsTemplate{
 		WinRMPassword: getWinRMPassword(config.PackerBuildName),
 	}
 
 	for _, command := range config.Inline {
 		// interpolate command to check for template variables.
-		command, err := interpolate.Render(command, &config.Ctx)
+		command, err := interpolate.Render(command, &config.ctx)
 		if err != nil {
 			return "", err
 		}
@@ -155,7 +155,7 @@ func createInlineScriptFile(config *Config) (string, error) {
 // user-provided ExecuteCommand or defaulting to something that makes sense for
 // the host OS
 func createInterpolatedCommands(config *Config, script string, flattenedEnvVars string) ([]string, error) {
-	config.Ctx.Data = &ExecuteCommandTemplate{
+	config.ctx.Data = &ExecuteCommandTemplate{
 		Vars:          flattenedEnvVars,
 		Script:        script,
 		Command:       script,
@@ -164,7 +164,7 @@ func createInterpolatedCommands(config *Config, script string, flattenedEnvVars
 
 	interpolatedCmds := make([]string, len(config.ExecuteCommand))
 	for i, cmd := range config.ExecuteCommand {
-		interpolatedCmd, err := interpolate.Render(cmd, &config.Ctx)
+		interpolatedCmd, err := interpolate.Render(cmd, &config.ctx)
 		if err != nil {
 			return nil, fmt.Errorf("Error processing command: %s", err)
 		}
@@ -196,12 +196,12 @@ func createFlattenedEnvVars(config *Config) (string, error) {
 	}
 
 	// interpolate environment variables
-	config.Ctx.Data = &EnvVarsTemplate{
+	config.ctx.Data = &EnvVarsTemplate{
 		WinRMPassword: getWinRMPassword(config.PackerBuildName),
 	}
 	// Split vars into key/value components
 	for _, envVar := range config.Vars {
-		envVar, err := interpolate.Render(envVar, &config.Ctx)
+		envVar, err := interpolate.Render(envVar, &config.ctx)
 		if err != nil {
 			return "", err
 		}

From af08e2a4102c0bf38575744a7042709e2c4b4bbd Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:17:50 +0200
Subject: [PATCH 073/155] pp.alicloud-import: remove duplicate
 AlicloudImageName field

( already defined in packerecs.Config )
---
 post-processor/alicloud-import/post-processor.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/post-processor/alicloud-import/post-processor.go b/post-processor/alicloud-import/post-processor.go
index bb518a8c1..a05f1aa2f 100644
--- a/post-processor/alicloud-import/post-processor.go
+++ b/post-processor/alicloud-import/post-processor.go
@@ -3,13 +3,13 @@ package alicloudimport
 import (
 	"context"
 	"fmt"
-	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
 	"log"
 	"strconv"
 	"strings"
 	"time"
 
 	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
 	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
 	"github.com/aliyun/alibaba-cloud-sdk-go/services/ram"
@@ -61,7 +61,6 @@ type Config struct {
 	OSSKey                          string            `mapstructure:"oss_key_name"`
 	SkipClean                       bool              `mapstructure:"skip_clean"`
 	Tags                            map[string]string `mapstructure:"tags"`
-	AlicloudImageName               string            `mapstructure:"image_name"`
 	AlicloudImageDescription        string            `mapstructure:"image_description"`
 	AlicloudImageShareAccounts      []string          `mapstructure:"image_share_account"`
 	AlicloudImageDestinationRegions []string          `mapstructure:"image_copy_regions"`

From 771a6e55ef4f81334bc9d9abb25af0bab1c484e5 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:19:17 +0200
Subject: [PATCH 074/155] pp.google.[import|export]: unexport Account field

so it doesnt temper with hcl2 cfg generation
---
 post-processor/googlecompute-export/post-processor.go | 8 ++++----
 post-processor/googlecompute-import/post-processor.go | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/post-processor/googlecompute-export/post-processor.go b/post-processor/googlecompute-export/post-processor.go
index b3adebff3..640a512c6 100644
--- a/post-processor/googlecompute-export/post-processor.go
+++ b/post-processor/googlecompute-export/post-processor.go
@@ -28,7 +28,7 @@ type Config struct {
 	VaultGCPOauthEngine string   `mapstructure:"vault_gcp_oauth_engine"`
 	Zone                string   `mapstructure:"zone"`
 
-	Account *jwt.Config
+	account *jwt.Config
 	ctx     interpolate.Context
 }
 
@@ -108,14 +108,14 @@ func (p *PostProcessor) PostProcess(ctx context.Context, ui packer.Ui, artifact
 		if err != nil {
 			return nil, false, false, err
 		}
-		p.config.Account = cfg
+		p.config.account = cfg
 	}
 	if p.config.AccountFile != "" {
 		cfg, err := googlecompute.ProcessAccountFile(p.config.AccountFile)
 		if err != nil {
 			return nil, false, false, err
 		}
-		p.config.Account = cfg
+		p.config.account = cfg
 	}
 
 	// Set up exporter instance configuration.
@@ -150,7 +150,7 @@ func (p *PostProcessor) PostProcess(ctx context.Context, ui packer.Ui, artifact
 	exporterConfig.CalcTimeout()
 
 	driver, err := googlecompute.NewDriverGCE(ui, builderProjectId,
-		p.config.Account, p.config.VaultGCPOauthEngine)
+		p.config.account, p.config.VaultGCPOauthEngine)
 	if err != nil {
 		return nil, false, false, err
 	}
diff --git a/post-processor/googlecompute-import/post-processor.go b/post-processor/googlecompute-import/post-processor.go
index 105969af2..07741e680 100644
--- a/post-processor/googlecompute-import/post-processor.go
+++ b/post-processor/googlecompute-import/post-processor.go
@@ -36,7 +36,7 @@ type Config struct {
 	SkipClean            bool              `mapstructure:"skip_clean"`
 	VaultGCPOauthEngine  string            `mapstructure:"vault_gcp_oauth_engine"`
 
-	Account *jwt.Config
+	account *jwt.Config
 	ctx     interpolate.Context
 }
 
@@ -76,7 +76,7 @@ func (p *PostProcessor) Configure(raws ...interface{}) error {
 		if err != nil {
 			errs = packer.MultiErrorAppend(errs, err)
 		}
-		p.config.Account = cfg
+		p.config.account = cfg
 	}
 
 	if p.config.AccountFile != "" && p.config.VaultGCPOauthEngine != "" {
@@ -105,7 +105,7 @@ func (p *PostProcessor) Configure(raws ...interface{}) error {
 }
 
 func (p *PostProcessor) PostProcess(ctx context.Context, ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, bool, error) {
-	client, err := googlecompute.NewClientGCE(p.config.Account, p.config.VaultGCPOauthEngine)
+	client, err := googlecompute.NewClientGCE(p.config.account, p.config.VaultGCPOauthEngine)
 	if err != nil {
 		return nil, false, false, err
 	}

From 193d3e6bbdccde3d216e760a2b00654171d3194a Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:20:56 +0200
Subject: [PATCH 075/155] provisioner.windows-shell: demove duplicate
 ExecuteCommand field

---
 provisioner/windows-shell/provisioner.go | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/provisioner/windows-shell/provisioner.go b/provisioner/windows-shell/provisioner.go
index e3496fbd1..480568cc1 100644
--- a/provisioner/windows-shell/provisioner.go
+++ b/provisioner/windows-shell/provisioner.go
@@ -30,11 +30,6 @@ var retryableSleep = 2 * time.Second
 type Config struct {
 	shell.Provisioner `mapstructure:",squash"`
 
-	// The command used to execute the script. The '{{ .Path }}' variable
-	// should be used to specify where the script goes, {{ .Vars }}
-	// can be used to inject the environment_vars into the environment.
-	ExecuteCommand string `mapstructure:"execute_command"`
-
 	// The timeout for retrying to start the process. Until this timeout
 	// is reached, if the provisioner can't start a process, it retries.
 	// This can be set high to allow for reboots.

From 438f704333f5bc8ab0a8d36dcfbc5ca6678af234 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:41:37 +0200
Subject: [PATCH 076/155] fmt

---
 builder/jdcloud/credential_config.go  | 3 ++-
 builder/jdcloud/instance_config.go    | 1 +
 builder/ucloud/uhost/access_config.go | 3 ++-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/builder/jdcloud/credential_config.go b/builder/jdcloud/credential_config.go
index e7c12baf8..28768b8e7 100644
--- a/builder/jdcloud/credential_config.go
+++ b/builder/jdcloud/credential_config.go
@@ -2,11 +2,12 @@ package jdcloud
 
 import (
 	"fmt"
+	"os"
+
 	"github.com/hashicorp/packer/template/interpolate"
 	"github.com/jdcloud-api/jdcloud-sdk-go/core"
 	vm "github.com/jdcloud-api/jdcloud-sdk-go/services/vm/client"
 	vpc "github.com/jdcloud-api/jdcloud-sdk-go/services/vpc/client"
-	"os"
 )
 
 type JDCloudCredentialConfig struct {
diff --git a/builder/jdcloud/instance_config.go b/builder/jdcloud/instance_config.go
index 93f6a6115..c63ae046b 100644
--- a/builder/jdcloud/instance_config.go
+++ b/builder/jdcloud/instance_config.go
@@ -2,6 +2,7 @@ package jdcloud
 
 import (
 	"fmt"
+
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/template/interpolate"
 )
diff --git a/builder/ucloud/uhost/access_config.go b/builder/ucloud/uhost/access_config.go
index 2cdccc6a5..389d74578 100644
--- a/builder/ucloud/uhost/access_config.go
+++ b/builder/ucloud/uhost/access_config.go
@@ -2,6 +2,8 @@ package uhost
 
 import (
 	"fmt"
+	"os"
+
 	"github.com/hashicorp/packer/template/interpolate"
 	"github.com/hashicorp/packer/version"
 	"github.com/ucloud/ucloud-sdk-go/services/uaccount"
@@ -10,7 +12,6 @@ import (
 	"github.com/ucloud/ucloud-sdk-go/services/vpc"
 	"github.com/ucloud/ucloud-sdk-go/ucloud"
 	"github.com/ucloud/ucloud-sdk-go/ucloud/auth"
-	"os"
 )
 
 type AccessConfig struct {

From 0eb9090dcfa8cf0a7d61a3f780c584d70bcee497 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:43:41 +0200
Subject: [PATCH 077/155] Create mapstructure-to-hcl2.go

mapstructure-to-hcl2 fills the gaps between hcl2 and mapstructure for Packer

By generating a struct that the HCL2 ecosystem understands making use of
mapstructure tags.

Packer heavily uses the mapstructure decoding library to load/parse user
config files. Packer now needs to move to HCL2.

Here are a few differences/gaps betweens hcl2 and mapstructure:

 * in HCL2 all basic struct fields (string/int/struct) that are not pointers
  are required ( must be set ). In mapstructure everything is optional.

 * mapstructure allows to 'squash' fields
 (ex: Field CommonStructType `mapstructure:",squash"`) this allows to
 decorate structs and reuse configuration code. HCL2 parsing libs don't have
 anything similar.

mapstructure-to-hcl2 will parse Packer's config files and generate the HCL2
compliant code that will allow to not change any of the current builders in
order to move to HCL2 to softly move to HCL2.
---
 .../mapstructure-to-hcl2.go                   | 537 ++++++++++++++++++
 1 file changed, 537 insertions(+)
 create mode 100644 cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go

diff --git a/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go b/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go
new file mode 100644
index 000000000..51017843b
--- /dev/null
+++ b/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go
@@ -0,0 +1,537 @@
+// mapstructure-to-hcl2 fills the gaps between hcl2 and mapstructure for Packer
+
+// By generating a struct that the HCL2 ecosystem understands making use of
+// mapstructure tags.
+
+// Packer heavily uses the mapstructure decoding library to load/parse user
+// config files. Packer now needs to move to HCL2.
+
+// Here are a few differences/gaps betweens hcl2 and mapstructure:
+
+//  * in HCL2 all basic struct fields (string/int/struct) that are not pointers
+//   are required ( must be set ). In mapstructure everything is optional.
+
+//  * mapstructure allows to 'squash' fields
+//  (ex: Field CommonStructType `mapstructure:",squash"`) this allows to
+//  decorate structs and reuse configuration code. HCL2 parsing libs don't have
+//  anything similar.
+
+// mapstructure-to-hcl2 will parse Packer's config files and generate the HCL2
+// compliant code that will allow to not change any of the current builders in
+// order to move to HCL2 to softly move to HCL2.
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"go/types"
+	"io"
+	"log"
+	"os"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/fatih/structtag"
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+
+	"golang.org/x/tools/go/packages"
+)
+
+var (
+	typeNames  = flag.String("type", "", "comma-separated list of type names; must be set")
+	output     = flag.String("output", "", "output file name; default srcdir/<type>_hcl2.go")
+	trimprefix = flag.String("trimprefix", "", "trim the `prefix` from the generated constant names")
+)
+
+// Usage is a replacement usage function for the flags package.
+func Usage() {
+	fmt.Fprintf(os.Stderr, "Usage of flatten-mapstructure:\n")
+	fmt.Fprintf(os.Stderr, "\tflatten-mapstructure [flags] -type T[,T...] pkg\n")
+	fmt.Fprintf(os.Stderr, "Flags:\n")
+	flag.PrintDefaults()
+}
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("flatten-mapstructure: ")
+	flag.Usage = Usage
+	flag.Parse()
+	if len(*typeNames) == 0 {
+		flag.Usage()
+		os.Exit(2)
+	}
+	typeNames := strings.Split(*typeNames, ",")
+
+	// We accept either one directory or a list of files. Which do we have?
+	args := flag.Args()
+	if len(args) == 0 {
+		// Default: process whole package in current directory.
+		args = []string{"."}
+	}
+	outputPath := strings.ToLower(typeNames[0]) + ".hcl2spec.go"
+	if goFile := os.Getenv("GOFILE"); goFile != "" {
+		outputPath = goFile[:len(goFile)-2] + "hcl2spec.go"
+	}
+	log.SetPrefix(fmt.Sprintf("flatten-mapstructure: %s.%v: ", os.Getenv("GOPACKAGE"), typeNames))
+
+	cfg := &packages.Config{
+		Mode: packages.LoadSyntax,
+	}
+	pkgs, err := packages.Load(cfg, args...)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if len(pkgs) != 1 {
+		log.Fatalf("error: %d packages found", len(pkgs))
+	}
+	topPkg := pkgs[0]
+	sort.Strings(typeNames)
+
+	var structs []StructDef
+	usedImports := map[NamePath]*types.Package{}
+
+	for id, obj := range topPkg.TypesInfo.Defs {
+		if obj == nil {
+			continue
+		}
+		t := obj.Type()
+		nt, isANamedType := t.(*types.Named)
+		if !isANamedType {
+			continue
+		}
+		if nt.Obj().Pkg() != topPkg.Types {
+			// Sometimes a struct embeds another struct named the same. ex:
+			// builder/osc/bsuvolume.BlockDevice. This makes sure the type is
+			// defined in topPkg.
+			continue
+		}
+		ut := nt.Underlying()
+		utStruct, utOk := ut.(*types.Struct)
+		if !utOk {
+			continue
+		}
+		pos := sort.SearchStrings(typeNames, id.Name)
+		if pos >= len(typeNames) || typeNames[pos] != id.Name {
+			continue // not a struct we care about
+		}
+		// make sure each type is found once where somehow sometimes they can be found twice
+		typeNames = append(typeNames[:pos], typeNames[pos+1:]...)
+		flatenedStruct := getMapstructureSquashedStruct(obj.Pkg(), utStruct)
+		flatenedStruct = addCtyTagToStruct(flatenedStruct)
+		newStructName := "Flat" + id.Name
+		structs = append(structs, StructDef{
+			OriginalStructName: id.Name,
+			StructName:         newStructName,
+			Struct:             flatenedStruct,
+		})
+
+		for k, v := range getUsedImports(flatenedStruct) {
+			if _, found := usedImports[k]; !found {
+				usedImports[k] = v
+			}
+		}
+	}
+
+	out := bytes.NewBuffer(nil)
+
+	fmt.Fprintf(out, `// Code generated by "mapstructure-to-hcl2 %s"; DO NOT EDIT.`, strings.Join(os.Args[1:], " "))
+	fmt.Fprintf(out, "\npackage %s\n", topPkg.Name)
+
+	delete(usedImports, NamePath{topPkg.Name, topPkg.PkgPath})
+	usedImports[NamePath{"hcldec", "github.com/hashicorp/hcl/v2/hcldec"}] = types.NewPackage("hcldec", "github.com/hashicorp/hcl/v2/hcldec")
+	usedImports[NamePath{"cty", "github.com/zclconf/go-cty/cty"}] = types.NewPackage("cty", "github.com/zclconf/go-cty/cty")
+	outputImports(out, usedImports)
+
+	sort.Slice(structs, func(i int, j int) bool {
+		return structs[i].OriginalStructName < structs[j].OriginalStructName
+	})
+	for _, flatenedStruct := range structs {
+		fmt.Fprintf(out, "\n// %s is an auto-generated flat version of %s.", flatenedStruct.StructName, flatenedStruct.OriginalStructName)
+		fmt.Fprintf(out, "\n// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.")
+		fmt.Fprintf(out, "\ntype %s struct {\n", flatenedStruct.StructName)
+		outputStructFields(out, flatenedStruct.Struct)
+		fmt.Fprint(out, "}\n")
+
+		fmt.Fprintf(out, "\n// FlatMapstructure returns a new %s.", flatenedStruct.StructName)
+		fmt.Fprintf(out, "\n// %s is an auto-generated flat version of %s.", flatenedStruct.StructName, flatenedStruct.OriginalStructName)
+		fmt.Fprintf(out, "\n// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.")
+		fmt.Fprintf(out, "\nfunc (*%s) FlatMapstructure() interface{} {", flatenedStruct.OriginalStructName)
+		fmt.Fprintf(out, "return new(%s)", flatenedStruct.StructName)
+		fmt.Fprint(out, "}\n")
+
+		fmt.Fprintf(out, "\n// HCL2Spec returns the hcldec.Spec of a %s.", flatenedStruct.StructName)
+		fmt.Fprintf(out, "\n// This spec is used by HCL to read the fields of %s.", flatenedStruct.StructName)
+		fmt.Fprintf(out, "\nfunc (*%s) HCL2Spec() map[string]hcldec.Spec {\n", flatenedStruct.StructName)
+		outputStructHCL2SpecBody(out, flatenedStruct.Struct)
+		fmt.Fprint(out, "}\n")
+	}
+
+	for impt := range usedImports {
+		if strings.ContainsAny(impt.Path, "/") {
+			out = bytes.NewBuffer(bytes.ReplaceAll(out.Bytes(),
+				[]byte(impt.Path+"."),
+				[]byte(impt.Name+".")))
+		}
+	}
+
+	// avoid needing to import current pkg; there's probably a better way.
+	out = bytes.NewBuffer(bytes.ReplaceAll(out.Bytes(),
+		[]byte(topPkg.PkgPath+"."),
+		nil))
+
+	outputFile, err := os.Create(outputPath)
+	if err != nil {
+		log.Fatalf("os.Create: %v", err)
+	}
+
+	_, err = outputFile.Write(goFmt(out.Bytes()))
+	if err != nil {
+		log.Fatalf("failed to write file: %v", err)
+	}
+}
+
+type StructDef struct {
+	OriginalStructName string
+	StructName         string
+	Struct             *types.Struct
+}
+
+func outputStructHCL2SpecBody(w io.Writer, s *types.Struct) {
+	fmt.Fprintf(w, "s := map[string]hcldec.Spec{\n")
+
+	for i := 0; i < s.NumFields(); i++ {
+		field, tag := s.Field(i), s.Tag(i)
+		st, _ := structtag.Parse(tag)
+		ctyTag, _ := st.Get("cty")
+		fmt.Fprintf(w, "	\"%s\": ", ctyTag.Name)
+		outputHCL2SpecField(w, ctyTag.Name, field.Type(), st)
+		fmt.Fprintln(w, `,`)
+	}
+
+	fmt.Fprintln(w, `}`)
+	fmt.Fprintln(w, `return s`)
+}
+
+func outputHCL2SpecField(w io.Writer, accessor string, fieldType types.Type, tag *structtag.Tags) {
+	if m2h, err := tag.Get(""); err == nil && m2h.HasOption("self-defined") {
+		fmt.Fprintf(w, `(&%s{}).HCL2Spec()`, fieldType.String())
+		return
+	}
+	switch f := fieldType.(type) {
+	case *types.Pointer:
+		outputHCL2SpecField(w, accessor, f.Elem(), tag)
+	case *types.Basic:
+		fmt.Fprintf(w, `%#v`, &hcldec.AttrSpec{
+			Name:     accessor,
+			Type:     basicKindToCtyType(f.Kind()),
+			Required: false,
+		})
+	case *types.Map:
+		fmt.Fprintf(w, `%#v`, &hcldec.BlockAttrsSpec{
+			TypeName:    accessor,
+			ElementType: cty.String, // for now everything can be simplified to a map[string]string
+			Required:    false,
+		})
+	case *types.Slice:
+		elem := f.Elem()
+		if ptr, isPtr := elem.(*types.Pointer); isPtr {
+			elem = ptr.Elem()
+		}
+		switch elem := elem.(type) {
+		case *types.Basic:
+			fmt.Fprintf(w, `%#v`, &hcldec.AttrSpec{
+				Name:     accessor,
+				Type:     cty.List(basicKindToCtyType(elem.Kind())),
+				Required: false,
+			})
+		case *types.Named:
+			b := bytes.NewBuffer(nil)
+			outputHCL2SpecField(b, accessor, elem, tag)
+			fmt.Fprintf(w, `&hcldec.BlockListSpec{TypeName: "%s", Nested: %s}`, accessor, b.String())
+		case *types.Slice:
+			b := bytes.NewBuffer(nil)
+			outputHCL2SpecField(b, accessor, elem.Underlying(), tag)
+			fmt.Fprintf(w, `&hcldec.BlockListSpec{TypeName: "%s", Nested: %s}`, accessor, b.String())
+		default:
+			outputHCL2SpecField(w, accessor, elem.Underlying(), tag)
+		}
+	case *types.Named:
+		underlyingType := f.Underlying()
+		switch underlyingType.(type) {
+		case *types.Struct:
+			fmt.Fprintf(w, `&hcldec.BlockSpec{TypeName: "%s",`+
+				` Nested: hcldec.ObjectSpec((*%s)(nil).HCL2Spec())}`, accessor, f.String())
+		default:
+			outputHCL2SpecField(w, f.String(), underlyingType, tag)
+		}
+	case *types.Struct:
+		fmt.Fprintf(w, `&hcldec.BlockObjectSpec{TypeName: "%s",`+
+			` Nested: hcldec.ObjectSpec((*%s)(nil).HCL2Spec())}`, accessor, fieldType.String())
+	default:
+		fmt.Fprintf(w, `%#v`, &hcldec.AttrSpec{
+			Name:     accessor,
+			Type:     basicKindToCtyType(types.Bool),
+			Required: false,
+		})
+		fmt.Fprintf(w, `/* TODO(azr): could not find type */`)
+	}
+}
+
+func basicKindToCtyType(kind types.BasicKind) cty.Type {
+	switch kind {
+	case types.Bool:
+		return cty.Bool
+	case types.String:
+		return cty.String
+	case types.Int, types.Int8, types.Int16, types.Int32, types.Int64,
+		types.Uint, types.Uint8, types.Uint16, types.Uint32, types.Uint64,
+		types.Float32, types.Float64,
+		types.Complex64, types.Complex128:
+		return cty.Number
+	case types.Invalid:
+		return cty.String // TODO(azr): fix that beforehand ?
+	default:
+		log.Printf("Un handled basic kind: %d", kind)
+		return cty.String
+	}
+}
+
+func outputStructFields(w io.Writer, s *types.Struct) {
+	for i := 0; i < s.NumFields(); i++ {
+		field, tag := s.Field(i), s.Tag(i)
+		fmt.Fprintf(w, "	%s `%s`\n", strings.Replace(field.String(), "field ", "", 1), tag)
+	}
+}
+
+type NamePath struct {
+	Name, Path string
+}
+
+func outputImports(w io.Writer, imports map[NamePath]*types.Package) {
+	if len(imports) == 0 {
+		return
+	}
+	// naive implementation
+	pkgs := []NamePath{}
+	for k := range imports {
+		pkgs = append(pkgs, k)
+	}
+	sort.Slice(pkgs, func(i int, j int) bool {
+		return pkgs[i].Path < pkgs[j].Path
+	})
+
+	fmt.Fprint(w, "import (\n")
+	for _, pkg := range pkgs {
+		if pkg.Name == pkg.Path || strings.HasSuffix(pkg.Path, "/"+pkg.Name) {
+			fmt.Fprintf(w, "	\"%s\"\n", pkg.Path)
+		} else {
+			fmt.Fprintf(w, "	%s \"%s\"\n", pkg.Name, pkg.Path)
+		}
+	}
+	fmt.Fprint(w, ")\n")
+}
+
+func getUsedImports(s *types.Struct) map[NamePath]*types.Package {
+	res := map[NamePath]*types.Package{}
+	for i := 0; i < s.NumFields(); i++ {
+		fieldType := s.Field(i).Type()
+		if p, ok := fieldType.(*types.Pointer); ok {
+			fieldType = p.Elem()
+		}
+		if p, ok := fieldType.(*types.Slice); ok {
+			fieldType = p.Underlying()
+		}
+		namedType, ok := fieldType.(*types.Named)
+		if !ok {
+			continue
+		}
+		pkg := namedType.Obj().Pkg()
+		res[NamePath{pkg.Name(), pkg.Path()}] = pkg
+	}
+	return res
+}
+
+func addCtyTagToStruct(s *types.Struct) *types.Struct {
+	vars, tags := structFields(s)
+	for i := range tags {
+		field, tag := vars[i], tags[i]
+		ctyAccessor := ToSnakeCase(field.Name())
+		st, err := structtag.Parse(tag)
+		if err == nil {
+			if ms, err := st.Get("mapstructure"); err == nil && ms.Name != "" {
+				ctyAccessor = ms.Name
+			}
+		}
+		st.Set(&structtag.Tag{Key: "cty", Name: ctyAccessor})
+		// st.Set(&structtag.Tag{Key: "hcl", Name: ctyAccessor, Options: []string{"optional"}})
+		tags[i] = st.String()
+	}
+	return types.NewStruct(uniqueTags("cty", vars, tags))
+}
+
+func uniqueTags(tagName string, fields []*types.Var, tags []string) ([]*types.Var, []string) {
+	outVars := []*types.Var{}
+	outTags := []string{}
+	uniqueTags := map[string]bool{}
+	for i := range fields {
+		field, tag := fields[i], tags[i]
+		structtag, _ := structtag.Parse(tag)
+		h, err := structtag.Get(tagName)
+		if err == nil {
+			if uniqueTags[h.Name] {
+				log.Printf("skipping field %s ( duplicate `%s` %s tag  )", field.Name(), h.Name, tagName)
+				continue
+			}
+			uniqueTags[h.Name] = true
+		}
+		outVars = append(outVars, field)
+		outTags = append(outTags, tag)
+	}
+	return outVars, outTags
+}
+
+// getMapstructureSquashedStruct will return the same struct but embedded
+// fields with a `mapstructure:",squash"` tag will be un-nested.
+func getMapstructureSquashedStruct(topPkg *types.Package, utStruct *types.Struct) *types.Struct {
+	res := &types.Struct{}
+	for i := 0; i < utStruct.NumFields(); i++ {
+		field, tag := utStruct.Field(i), utStruct.Tag(i)
+		if !field.Exported() {
+			continue
+		}
+		if _, ok := field.Type().(*types.Signature); ok {
+			continue // ignore funcs
+		}
+		structtag, _ := structtag.Parse(tag)
+		if ms, err := structtag.Get("mapstructure"); err != nil {
+			//no mapstructure tag
+		} else if ms.HasOption("squash") {
+			ot := field.Type()
+			uot := ot.Underlying()
+			utStruct, utOk := uot.(*types.Struct)
+			if !utOk {
+				continue
+			}
+
+			res = squashStructs(res, getMapstructureSquashedStruct(topPkg, utStruct))
+			continue
+		}
+		if field.Pkg() != topPkg {
+			field = types.NewField(field.Pos(), topPkg, field.Name(), field.Type(), field.Embedded())
+		}
+		if p, isPointer := field.Type().(*types.Pointer); isPointer {
+			// in order to make the following switch simpler we 'unwrap' this
+			// pointer all structs are going to be made pointers anyways.
+			field = types.NewField(field.Pos(), field.Pkg(), field.Name(), p.Elem(), field.Embedded())
+		}
+		switch f := field.Type().(type) {
+		case *types.Named:
+			switch f.String() {
+			case "time.Duration":
+				field = types.NewField(field.Pos(), field.Pkg(), field.Name(), types.NewPointer(types.Typ[types.String]), field.Embedded())
+			case "github.com/hashicorp/packer/helper/config.Trilean": // TODO(azr): unhack this situation
+				field = types.NewField(field.Pos(), field.Pkg(), field.Name(), types.NewPointer(types.Typ[types.Bool]), field.Embedded())
+			case "github.com/hashicorp/packer/provisioner/powershell.ExecutionPolicy": // TODO(azr): unhack this situation
+				field = types.NewField(field.Pos(), field.Pkg(), field.Name(), types.NewPointer(types.Typ[types.String]), field.Embedded())
+			}
+			if str, isStruct := f.Underlying().(*types.Struct); isStruct {
+				obj := flattenNamed(f, str)
+				field = types.NewField(field.Pos(), field.Pkg(), field.Name(), obj, field.Embedded())
+				field = makePointer(field)
+			}
+			if slice, isSlice := f.Underlying().(*types.Slice); isSlice {
+				if f, fNamed := slice.Elem().(*types.Named); fNamed {
+					if str, isStruct := f.Underlying().(*types.Struct); isStruct {
+						// this is a slice of named structs; we want to change
+						// the struct ref to a 'FlatStruct'.
+						obj := flattenNamed(f, str)
+						slice := types.NewSlice(obj)
+						field = types.NewField(field.Pos(), field.Pkg(), field.Name(), slice, field.Embedded())
+					}
+				}
+			}
+		case *types.Slice:
+			if f, fNamed := f.Elem().(*types.Named); fNamed {
+				if str, isStruct := f.Underlying().(*types.Struct); isStruct {
+					obj := flattenNamed(f, str)
+					field = types.NewField(field.Pos(), field.Pkg(), field.Name(), types.NewSlice(obj), field.Embedded())
+				}
+			}
+		case *types.Basic:
+			// since everything is optional, everything must be a pointer
+			// non optional fields should be non pointers.
+			field = makePointer(field)
+		}
+		res = addFieldToStruct(res, field, tag)
+	}
+	return res
+}
+
+func flattenNamed(f *types.Named, underlying types.Type) *types.Named {
+	obj := f.Obj()
+	obj = types.NewTypeName(obj.Pos(), obj.Pkg(), "Flat"+obj.Name(), obj.Type())
+	return types.NewNamed(obj, underlying, nil)
+}
+
+func makePointer(field *types.Var) *types.Var {
+	return types.NewField(field.Pos(), field.Pkg(), field.Name(), types.NewPointer(field.Type()), field.Embedded())
+}
+
+func addFieldToStruct(s *types.Struct, field *types.Var, tag string) *types.Struct {
+	sf, st := structFields(s)
+	return types.NewStruct(uniqueFields(append(sf, field), append(st, tag)))
+}
+
+func squashStructs(a, b *types.Struct) *types.Struct {
+	va, ta := structFields(a)
+	vb, tb := structFields(b)
+	return types.NewStruct(uniqueFields(append(va, vb...), append(ta, tb...)))
+}
+
+func uniqueFields(fields []*types.Var, tags []string) ([]*types.Var, []string) {
+	outVars := []*types.Var{}
+	outTags := []string{}
+	fieldNames := map[string]bool{}
+	for i := range fields {
+		field, tag := fields[i], tags[i]
+		if fieldNames[field.Name()] {
+			log.Printf("skipping duplicate %s field", field.Name())
+			continue
+		}
+		fieldNames[field.Name()] = true
+		outVars = append(outVars, field)
+		outTags = append(outTags, tag)
+	}
+	return outVars, outTags
+}
+
+func structFields(s *types.Struct) (vars []*types.Var, tags []string) {
+	for i := 0; i < s.NumFields(); i++ {
+		field, tag := s.Field(i), s.Tag(i)
+		vars = append(vars, field)
+		tags = append(tags, tag)
+	}
+	return vars, tags
+}
+
+var matchFirstCap = regexp.MustCompile("(.)([A-Z][a-z]+)")
+var matchAllCap = regexp.MustCompile("([a-z0-9])([A-Z])")
+
+func ToSnakeCase(str string) string {
+	snake := matchFirstCap.ReplaceAllString(str, "${1}_${2}")
+	snake = matchAllCap.ReplaceAllString(snake, "${1}_${2}")
+	return strings.ToLower(snake)
+}
+
+func goFmt(b []byte) []byte {
+	fb, err := format.Source(b)
+	if err != nil {
+		log.Printf("formatting err: %v", err)
+		return b
+	}
+	return fb
+}

From 078ba7c8c38d30f988709a1b3d0d06d735a9d1c1 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:43:59 +0200
Subject: [PATCH 078/155] commit old code generation tool

for history
---
 builder/alicloud/ecs/builder.go               |   2 +
 builder/alicloud/ecs/builder.hcl2spec.go      | 237 +++++++++++++
 builder/amazon/chroot/builder.hcl2spec.go     | 140 ++++++++
 builder/amazon/common/access_config.go        |   1 +
 .../amazon/common/access_config.hcl2spec.go   |  33 ++
 builder/amazon/common/block_device.go         |   1 +
 .../amazon/common/block_device.hcl2spec.go    |  45 +++
 builder/amazon/common/run_config.go           |   1 +
 builder/amazon/common/run_config.hcl2spec.go  |  97 ++++++
 builder/amazon/ebs/builder.go                 |   1 +
 builder/amazon/ebs/builder.hcl2spec.go        | 244 ++++++++++++++
 builder/azure/arm/config.go                   |   1 +
 builder/azure/arm/config.hcl2spec.go          | 297 +++++++++++++++++
 builder/cloudstack/config.go                  |   1 +
 builder/cloudstack/config.hcl2spec.go         | 203 ++++++++++++
 builder/digitalocean/config.go                |   1 +
 builder/digitalocean/config.hcl2spec.go       | 151 +++++++++
 builder/docker/config.go                      |   1 +
 builder/docker/config.hcl2spec.go             | 169 ++++++++++
 builder/file/config.go                        |   2 +
 builder/file/config.hcl2spec.go               |  45 +++
 builder/googlecompute/config.go               |   1 +
 builder/googlecompute/config.hcl2spec.go      | 219 ++++++++++++
 builder/hcloud/config.go                      |   2 +
 builder/hcloud/config.hcl2spec.go             | 169 ++++++++++
 builder/hyperone/config.go                    |   1 +
 builder/hyperone/config.hcl2spec.go           | 185 +++++++++++
 builder/hyperv/common/output_config.go        |   1 +
 .../hyperv/common/output_config.hcl2spec.go   |  27 ++
 builder/hyperv/iso/builder.go                 |   1 +
 builder/hyperv/iso/builder.hcl2spec.go        | 215 ++++++++++++
 builder/hyperv/vmcx/builder.go                |   1 +
 builder/hyperv/vmcx/builder.hcl2spec.go       | 215 ++++++++++++
 builder/jdcloud/common.go                     |  11 +-
 builder/jdcloud/common.hcl2spec.go            | 145 ++++++++
 builder/linode/config.go                      |   2 +
 builder/linode/config.hcl2spec.go             | 143 ++++++++
 builder/lxd/config.go                         |   1 +
 builder/lxd/config.hcl2spec.go                |  55 +++
 builder/ncloud/config.go                      |   1 +
 builder/ncloud/config.hcl2spec.go             | 143 ++++++++
 builder/null/config.go                        |   2 +
 builder/null/config.hcl2spec.go               | 119 +++++++
 builder/oneandone/config.go                   |   9 +-
 builder/oneandone/config.hcl2spec.go          | 135 ++++++++
 builder/openstack/builder.go                  |   2 +
 builder/openstack/builder.hcl2spec.go         | 280 ++++++++++++++++
 builder/oracle/classic/config.go              |   2 +
 builder/oracle/classic/config.hcl2spec.go     | 160 +++++++++
 builder/oracle/oci/config.go                  |   2 +
 builder/oracle/oci/config.hcl2spec.go         | 161 +++++++++
 builder/osc/bsu/builder.go                    |   2 +
 builder/osc/bsu/builder.hcl2spec.go           | 226 +++++++++++++
 builder/osc/bsuvolume/builder.go              |   2 +
 builder/osc/bsuvolume/builder.hcl2spec.go     | 232 +++++++++++++
 builder/osc/chroot/builder.go                 |   2 +
 builder/osc/chroot/builder.hcl2spec.go        | 122 +++++++
 builder/osc/common/run_config.go              |   2 +
 builder/osc/common/run_config.hcl2spec.go     | 131 ++++++++
 builder/parallels/iso/builder.go              |   1 +
 builder/parallels/iso/builder.hcl2spec.go     | 195 +++++++++++
 builder/parallels/pvm/config.go               |   1 +
 builder/parallels/pvm/config.hcl2spec.go      | 161 +++++++++
 builder/profitbricks/config.go                |   2 +
 builder/profitbricks/config.hcl2spec.go       | 143 ++++++++
 builder/proxmox/config.go                     |   2 +
 builder/proxmox/config.hcl2spec.go            | 233 +++++++++++++
 builder/qemu/builder.go                       |   1 +
 builder/qemu/builder.hcl2spec.go              | 227 +++++++++++++
 builder/scaleway/config.go                    |   1 +
 builder/scaleway/config.hcl2spec.go           | 143 ++++++++
 builder/tencentcloud/cvm/builder.go           |   2 +
 builder/tencentcloud/cvm/builder.hcl2spec.go  | 191 +++++++++++
 builder/tencentcloud/cvm/run_config.go        |   1 +
 .../tencentcloud/cvm/run_config.hcl2spec.go   |  31 ++
 builder/triton/config.go                      |   2 +
 builder/triton/config.hcl2spec.go             | 161 +++++++++
 builder/triton/source_machine_config.go       |   1 +
 .../triton/source_machine_config.hcl2spec.go  |  41 +++
 builder/ucloud/uhost/builder.go               |   3 +
 builder/ucloud/uhost/builder.hcl2spec.go      | 153 +++++++++
 builder/ucloud/uhost/image_config.go          |   5 +-
 builder/ucloud/uhost/image_config.hcl2spec.go |  33 ++
 builder/ucloud/uhost/run_config.go            |   3 +-
 builder/vagrant/builder.go                    |   1 +
 builder/vagrant/builder.hcl2spec.go           | 197 +++++++++++
 builder/virtualbox/iso/builder.go             |   1 +
 builder/virtualbox/iso/builder.hcl2spec.go    | 227 +++++++++++++
 builder/virtualbox/ovf/config.go              |   1 +
 builder/virtualbox/ovf/config.hcl2spec.go     | 201 +++++++++++
 builder/virtualbox/vm/config.go               |   2 +
 builder/virtualbox/vm/config.hcl2spec.go      | 193 +++++++++++
 builder/vmware/common/export_config.go        |   1 +
 builder/vmware/common/hw_config.go            |   1 +
 builder/vmware/common/output_config.go        |   1 +
 builder/vmware/common/ssh_config.go           |   1 +
 builder/vmware/common/tools_config.go         |   1 +
 builder/vmware/iso/config.go                  |   1 +
 builder/vmware/iso/config.hcl2spec.go         | 261 +++++++++++++++
 builder/vmware/vmx/config.go                  |   1 +
 builder/vmware/vmx/config.hcl2spec.go         | 213 ++++++++++++
 builder/yandex/config.go                      |   2 +
 builder/yandex/config.hcl2spec.go             | 185 +++++++++++
 cmd/hcl2-schema/hcl2-schema.go                | 313 ++++++++++++++++++
 common/shell-local/config.go                  |   2 +
 common/shell-local/config.hcl2spec.go         |  61 ++++
 helper/communicator/config.go                 |   1 +
 helper/communicator/config.hcl2spec.go        | 217 ++++++++++++
 .../alicloud-import/post-processor.go         |   6 +-
 .../post-processor.hcl2spec.go                | 220 ++++++++++++
 .../amazon-import/post-processor.go           |   2 +
 .../amazon-import/post-processor.hcl2spec.go  |  94 ++++++
 post-processor/artifice/post-processor.go     |   2 +
 .../artifice/post-processor.hcl2spec.go       |  43 +++
 post-processor/checksum/post-processor.go     |   2 +
 .../checksum/post-processor.hcl2spec.go       |  45 +++
 post-processor/compress/post-processor.go     |   2 +
 .../compress/post-processor.hcl2spec.go       |  49 +++
 .../digitalocean-import/post-processor.go     |   2 +
 .../post-processor.hcl2spec.go                |  65 ++++
 .../docker-import/post-processor.go           |   2 +
 .../docker-import/post-processor.hcl2spec.go  |  45 +++
 post-processor/docker-push/post-processor.go  |   2 +
 .../docker-push/post-processor.hcl2spec.go    |  57 ++++
 post-processor/docker-save/post-processor.go  |   2 +
 .../docker-save/post-processor.hcl2spec.go    |  41 +++
 post-processor/docker-tag/post-processor.go   |   2 +
 .../docker-tag/post-processor.hcl2spec.go     |  45 +++
 .../exoscale-import/post-processor.go         |   2 +
 .../post-processor.hcl2spec.go                |  63 ++++
 .../googlecompute-export/post-processor.go    |   2 +
 .../post-processor.hcl2spec.go                |  57 ++++
 .../googlecompute-import/post-processor.go    |   2 +
 .../post-processor.hcl2spec.go                |  61 ++++
 post-processor/manifest/post-processor.go     |   2 +
 .../manifest/post-processor.hcl2spec.go       |  45 +++
 .../vagrant-cloud/post-processor.go           |   2 +
 .../vagrant-cloud/post-processor.hcl2spec.go  |  55 +++
 post-processor/vagrant/post-processor.go      |   2 +
 .../vagrant/post-processor.hcl2spec.go        |  51 +++
 .../vsphere-template/post-processor.go        |   2 +
 .../post-processor.hcl2spec.go                |  57 ++++
 post-processor/vsphere/post-processor.go      |   2 +
 .../vsphere/post-processor.hcl2spec.go        |  69 ++++
 provisioner/ansible-local/provisioner.go      |   2 +
 .../ansible-local/provisioner.hcl2spec.go     |  69 ++++
 provisioner/ansible/provisioner.go            |   2 +
 provisioner/ansible/provisioner.hcl2spec.go   |  79 +++++
 provisioner/breakpoint/provisioner.go         |   2 +
 .../breakpoint/provisioner.hcl2spec.go        |  43 +++
 provisioner/chef-client/provisioner.go        |   2 +
 .../chef-client/provisioner.hcl2spec.go       |  93 ++++++
 provisioner/chef-solo/provisioner.go          |   2 +
 provisioner/chef-solo/provisioner.hcl2spec.go |  75 +++++
 provisioner/converge/provisioner.go           |   2 +
 provisioner/converge/provisioner.hcl2spec.go  |  83 +++++
 provisioner/file/provisioner.go               |   2 +
 provisioner/file/provisioner.hcl2spec.go      |  49 +++
 provisioner/inspec/provisioner.go             |   2 +
 provisioner/inspec/provisioner.hcl2spec.go    |  65 ++++
 provisioner/powershell/provisioner.go         |   2 +
 .../powershell/provisioner.hcl2spec.go        |  71 ++++
 provisioner/puppet-masterless/provisioner.go  |   2 +
 .../puppet-masterless/provisioner.hcl2spec.go |  71 ++++
 provisioner/puppet-server/provisioner.go      |   2 +
 .../puppet-server/provisioner.hcl2spec.go     |  71 ++++
 provisioner/salt-masterless/provisioner.go    |   2 +
 .../salt-masterless/provisioner.hcl2spec.go   |  73 ++++
 provisioner/shell/provisioner.go              |   2 +
 provisioner/shell/provisioner.hcl2spec.go     |  71 ++++
 provisioner/sleep/provisioner.go              |   2 +
 provisioner/sleep/provisioner.hcl2spec.go     |  27 ++
 provisioner/windows-restart/provisioner.go    |   2 +
 .../windows-restart/provisioner.hcl2spec.go   |  49 +++
 provisioner/windows-shell/provisioner.go      |   2 +
 .../windows-shell/provisioner.hcl2spec.go     |  59 ++++
 template/template.go                          |   2 +
 template/template.hcl2spec.go                 |  39 +++
 .../chroot/_BlockDevice-not-required.html.md  |  10 -
 .../chroot/_Config-not-required.html.md       |   2 +-
 .../_Config-not-required.html.md              |   2 +-
 .../vmware/iso/_Config-not-required.html.md   |   7 -
 .../vmware/vmx/_Config-not-required.html.md   |   5 -
 183 files changed, 10936 insertions(+), 37 deletions(-)
 create mode 100644 builder/alicloud/ecs/builder.hcl2spec.go
 create mode 100644 builder/amazon/chroot/builder.hcl2spec.go
 create mode 100644 builder/amazon/common/access_config.hcl2spec.go
 create mode 100644 builder/amazon/common/block_device.hcl2spec.go
 create mode 100644 builder/amazon/common/run_config.hcl2spec.go
 create mode 100644 builder/amazon/ebs/builder.hcl2spec.go
 create mode 100644 builder/azure/arm/config.hcl2spec.go
 create mode 100644 builder/cloudstack/config.hcl2spec.go
 create mode 100644 builder/digitalocean/config.hcl2spec.go
 create mode 100644 builder/docker/config.hcl2spec.go
 create mode 100644 builder/file/config.hcl2spec.go
 create mode 100644 builder/googlecompute/config.hcl2spec.go
 create mode 100644 builder/hcloud/config.hcl2spec.go
 create mode 100644 builder/hyperone/config.hcl2spec.go
 create mode 100644 builder/hyperv/common/output_config.hcl2spec.go
 create mode 100644 builder/hyperv/iso/builder.hcl2spec.go
 create mode 100644 builder/hyperv/vmcx/builder.hcl2spec.go
 create mode 100644 builder/jdcloud/common.hcl2spec.go
 create mode 100644 builder/linode/config.hcl2spec.go
 create mode 100644 builder/lxd/config.hcl2spec.go
 create mode 100644 builder/ncloud/config.hcl2spec.go
 create mode 100644 builder/null/config.hcl2spec.go
 create mode 100644 builder/oneandone/config.hcl2spec.go
 create mode 100644 builder/openstack/builder.hcl2spec.go
 create mode 100644 builder/oracle/classic/config.hcl2spec.go
 create mode 100644 builder/oracle/oci/config.hcl2spec.go
 create mode 100644 builder/osc/bsu/builder.hcl2spec.go
 create mode 100644 builder/osc/bsuvolume/builder.hcl2spec.go
 create mode 100644 builder/osc/chroot/builder.hcl2spec.go
 create mode 100644 builder/osc/common/run_config.hcl2spec.go
 create mode 100644 builder/parallels/iso/builder.hcl2spec.go
 create mode 100644 builder/parallels/pvm/config.hcl2spec.go
 create mode 100644 builder/profitbricks/config.hcl2spec.go
 create mode 100644 builder/proxmox/config.hcl2spec.go
 create mode 100644 builder/qemu/builder.hcl2spec.go
 create mode 100644 builder/scaleway/config.hcl2spec.go
 create mode 100644 builder/tencentcloud/cvm/builder.hcl2spec.go
 create mode 100644 builder/tencentcloud/cvm/run_config.hcl2spec.go
 create mode 100644 builder/triton/config.hcl2spec.go
 create mode 100644 builder/triton/source_machine_config.hcl2spec.go
 create mode 100644 builder/ucloud/uhost/builder.hcl2spec.go
 create mode 100644 builder/ucloud/uhost/image_config.hcl2spec.go
 create mode 100644 builder/vagrant/builder.hcl2spec.go
 create mode 100644 builder/virtualbox/iso/builder.hcl2spec.go
 create mode 100644 builder/virtualbox/ovf/config.hcl2spec.go
 create mode 100644 builder/virtualbox/vm/config.hcl2spec.go
 create mode 100644 builder/vmware/iso/config.hcl2spec.go
 create mode 100644 builder/vmware/vmx/config.hcl2spec.go
 create mode 100644 builder/yandex/config.hcl2spec.go
 create mode 100644 cmd/hcl2-schema/hcl2-schema.go
 create mode 100644 common/shell-local/config.hcl2spec.go
 create mode 100644 helper/communicator/config.hcl2spec.go
 create mode 100644 post-processor/alicloud-import/post-processor.hcl2spec.go
 create mode 100644 post-processor/amazon-import/post-processor.hcl2spec.go
 create mode 100644 post-processor/artifice/post-processor.hcl2spec.go
 create mode 100644 post-processor/checksum/post-processor.hcl2spec.go
 create mode 100644 post-processor/compress/post-processor.hcl2spec.go
 create mode 100644 post-processor/digitalocean-import/post-processor.hcl2spec.go
 create mode 100644 post-processor/docker-import/post-processor.hcl2spec.go
 create mode 100644 post-processor/docker-push/post-processor.hcl2spec.go
 create mode 100644 post-processor/docker-save/post-processor.hcl2spec.go
 create mode 100644 post-processor/docker-tag/post-processor.hcl2spec.go
 create mode 100644 post-processor/exoscale-import/post-processor.hcl2spec.go
 create mode 100644 post-processor/googlecompute-export/post-processor.hcl2spec.go
 create mode 100644 post-processor/googlecompute-import/post-processor.hcl2spec.go
 create mode 100644 post-processor/manifest/post-processor.hcl2spec.go
 create mode 100644 post-processor/vagrant-cloud/post-processor.hcl2spec.go
 create mode 100644 post-processor/vagrant/post-processor.hcl2spec.go
 create mode 100644 post-processor/vsphere-template/post-processor.hcl2spec.go
 create mode 100644 post-processor/vsphere/post-processor.hcl2spec.go
 create mode 100644 provisioner/ansible-local/provisioner.hcl2spec.go
 create mode 100644 provisioner/ansible/provisioner.hcl2spec.go
 create mode 100644 provisioner/breakpoint/provisioner.hcl2spec.go
 create mode 100644 provisioner/chef-client/provisioner.hcl2spec.go
 create mode 100644 provisioner/chef-solo/provisioner.hcl2spec.go
 create mode 100644 provisioner/converge/provisioner.hcl2spec.go
 create mode 100644 provisioner/file/provisioner.hcl2spec.go
 create mode 100644 provisioner/inspec/provisioner.hcl2spec.go
 create mode 100644 provisioner/powershell/provisioner.hcl2spec.go
 create mode 100644 provisioner/puppet-masterless/provisioner.hcl2spec.go
 create mode 100644 provisioner/puppet-server/provisioner.hcl2spec.go
 create mode 100644 provisioner/salt-masterless/provisioner.hcl2spec.go
 create mode 100644 provisioner/shell/provisioner.hcl2spec.go
 create mode 100644 provisioner/sleep/provisioner.hcl2spec.go
 create mode 100644 provisioner/windows-restart/provisioner.hcl2spec.go
 create mode 100644 provisioner/windows-shell/provisioner.hcl2spec.go
 create mode 100644 template/template.hcl2spec.go
 delete mode 100644 website/source/partials/builder/amazon/chroot/_BlockDevice-not-required.html.md

diff --git a/builder/alicloud/ecs/builder.go b/builder/alicloud/ecs/builder.go
index 4c050b57e..5b593cee9 100644
--- a/builder/alicloud/ecs/builder.go
+++ b/builder/alicloud/ecs/builder.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config,AlicloudDiskDevice
+
 // The alicloud  contains a packer.Builder implementation that
 // builds ecs images for alicloud.
 package ecs
diff --git a/builder/alicloud/ecs/builder.hcl2spec.go b/builder/alicloud/ecs/builder.hcl2spec.go
new file mode 100644
index 000000000..595ada017
--- /dev/null
+++ b/builder/alicloud/ecs/builder.hcl2spec.go
@@ -0,0 +1,237 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,AlicloudDiskDevice"; DO NOT EDIT.
+package ecs
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatAlicloudDiskDevice is an auto-generated flat version of AlicloudDiskDevice.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatAlicloudDiskDevice struct {
+	DiskName           *string `mapstructure:"disk_name" required:"false" cty:"disk_name"`
+	DiskCategory       *string `mapstructure:"disk_category" required:"false" cty:"disk_category"`
+	DiskSize           *int    `mapstructure:"disk_size" required:"false" cty:"disk_size"`
+	SnapshotId         *string `mapstructure:"disk_snapshot_id" required:"false" cty:"disk_snapshot_id"`
+	Description        *string `mapstructure:"disk_description" required:"false" cty:"disk_description"`
+	DeleteWithInstance *bool   `mapstructure:"disk_delete_with_instance" required:"false" cty:"disk_delete_with_instance"`
+	Device             *string `mapstructure:"disk_device" required:"false" cty:"disk_device"`
+	Encrypted          *bool   `mapstructure:"disk_encrypted" required:"false" cty:"disk_encrypted"`
+}
+
+// FlatMapstructure returns a new FlatAlicloudDiskDevice.
+// FlatAlicloudDiskDevice is an auto-generated flat version of AlicloudDiskDevice.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*AlicloudDiskDevice) FlatMapstructure() interface{} { return new(FlatAlicloudDiskDevice) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatAlicloudDiskDevice.
+// This spec is used by HCL to read the fields of FlatAlicloudDiskDevice.
+func (*FlatAlicloudDiskDevice) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"disk_name":                 &hcldec.AttrSpec{Name: "disk_name", Type: cty.String, Required: false},
+		"disk_category":             &hcldec.AttrSpec{Name: "disk_category", Type: cty.String, Required: false},
+		"disk_size":                 &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"disk_snapshot_id":          &hcldec.AttrSpec{Name: "disk_snapshot_id", Type: cty.String, Required: false},
+		"disk_description":          &hcldec.AttrSpec{Name: "disk_description", Type: cty.String, Required: false},
+		"disk_delete_with_instance": &hcldec.AttrSpec{Name: "disk_delete_with_instance", Type: cty.Bool, Required: false},
+		"disk_device":               &hcldec.AttrSpec{Name: "disk_device", Type: cty.String, Required: false},
+		"disk_encrypted":            &hcldec.AttrSpec{Name: "disk_encrypted", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName                   *string                  `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType                 *string                  `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                       *bool                    `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                       *bool                    `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError                     *string                  `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars                    map[string]string        `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars               []string                 `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AlicloudAccessKey                 *string                  `mapstructure:"access_key" required:"true" cty:"access_key"`
+	AlicloudSecretKey                 *string                  `mapstructure:"secret_key" required:"true" cty:"secret_key"`
+	AlicloudRegion                    *string                  `mapstructure:"region" required:"true" cty:"region"`
+	AlicloudSkipValidation            *bool                    `mapstructure:"skip_region_validation" required:"false" cty:"skip_region_validation"`
+	SecurityToken                     *string                  `mapstructure:"security_token" required:"false" cty:"security_token"`
+	AlicloudImageName                 *string                  `mapstructure:"image_name" required:"true" cty:"image_name"`
+	AlicloudImageVersion              *string                  `mapstructure:"image_version" required:"false" cty:"image_version"`
+	AlicloudImageDescription          *string                  `mapstructure:"image_description" required:"false" cty:"image_description"`
+	AlicloudImageShareAccounts        []string                 `mapstructure:"image_share_account" required:"false" cty:"image_share_account"`
+	AlicloudImageUNShareAccounts      []string                 `mapstructure:"image_unshare_account" cty:"image_unshare_account"`
+	AlicloudImageDestinationRegions   []string                 `mapstructure:"image_copy_regions" required:"false" cty:"image_copy_regions"`
+	AlicloudImageDestinationNames     []string                 `mapstructure:"image_copy_names" required:"false" cty:"image_copy_names"`
+	ImageEncrypted                    *bool                    `mapstructure:"image_encrypted" required:"false" cty:"image_encrypted"`
+	AlicloudImageForceDelete          *bool                    `mapstructure:"image_force_delete" required:"false" cty:"image_force_delete"`
+	AlicloudImageForceDeleteSnapshots *bool                    `mapstructure:"image_force_delete_snapshots" required:"false" cty:"image_force_delete_snapshots"`
+	AlicloudImageForceDeleteInstances *bool                    `mapstructure:"image_force_delete_instances" cty:"image_force_delete_instances"`
+	AlicloudImageIgnoreDataDisks      *bool                    `mapstructure:"image_ignore_data_disks" required:"false" cty:"image_ignore_data_disks"`
+	AlicloudImageTags                 map[string]string        `mapstructure:"tags" required:"false" cty:"tags"`
+	ECSSystemDiskMapping              *FlatAlicloudDiskDevice  `mapstructure:"system_disk_mapping" required:"false" cty:"system_disk_mapping"`
+	ECSImagesDiskMappings             []FlatAlicloudDiskDevice `mapstructure:"image_disk_mappings" required:"false" cty:"image_disk_mappings"`
+	AssociatePublicIpAddress          *bool                    `mapstructure:"associate_public_ip_address" cty:"associate_public_ip_address"`
+	ZoneId                            *string                  `mapstructure:"zone_id" required:"false" cty:"zone_id"`
+	IOOptimized                       *bool                    `mapstructure:"io_optimized" required:"false" cty:"io_optimized"`
+	InstanceType                      *string                  `mapstructure:"instance_type" required:"true" cty:"instance_type"`
+	Description                       *string                  `mapstructure:"description" cty:"description"`
+	AlicloudSourceImage               *string                  `mapstructure:"source_image" required:"true" cty:"source_image"`
+	ForceStopInstance                 *bool                    `mapstructure:"force_stop_instance" required:"false" cty:"force_stop_instance"`
+	DisableStopInstance               *bool                    `mapstructure:"disable_stop_instance" required:"false" cty:"disable_stop_instance"`
+	SecurityGroupId                   *string                  `mapstructure:"security_group_id" required:"false" cty:"security_group_id"`
+	SecurityGroupName                 *string                  `mapstructure:"security_group_name" required:"false" cty:"security_group_name"`
+	UserData                          *string                  `mapstructure:"user_data" required:"false" cty:"user_data"`
+	UserDataFile                      *string                  `mapstructure:"user_data_file" required:"false" cty:"user_data_file"`
+	VpcId                             *string                  `mapstructure:"vpc_id" required:"false" cty:"vpc_id"`
+	VpcName                           *string                  `mapstructure:"vpc_name" required:"false" cty:"vpc_name"`
+	CidrBlock                         *string                  `mapstructure:"vpc_cidr_block" required:"false" cty:"vpc_cidr_block"`
+	VSwitchId                         *string                  `mapstructure:"vswitch_id" required:"false" cty:"vswitch_id"`
+	VSwitchName                       *string                  `mapstructure:"vswitch_name" required:"false" cty:"vswitch_name"`
+	InstanceName                      *string                  `mapstructure:"instance_name" required:"false" cty:"instance_name"`
+	InternetChargeType                *string                  `mapstructure:"internet_charge_type" required:"false" cty:"internet_charge_type"`
+	InternetMaxBandwidthOut           *int                     `mapstructure:"internet_max_bandwidth_out" required:"false" cty:"internet_max_bandwidth_out"`
+	WaitSnapshotReadyTimeout          *int                     `mapstructure:"wait_snapshot_ready_timeout" required:"false" cty:"wait_snapshot_ready_timeout"`
+	Type                              *string                  `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect                *string                  `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                           *string                  `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                           *int                     `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                       *string                  `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                       *string                  `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName                    *string                  `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName           *string                  `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys            *bool                    `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile                 *string                  `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                            *bool                    `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                        *string                  `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                      *bool                    `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding         *bool                    `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts              *int                     `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost                    *string                  `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort                    *int                     `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth               *bool                    `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername                *string                  `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword                *string                  `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile          *string                  `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod             *string                  `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                      *string                  `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                      *int                     `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername                  *string                  `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword                  *string                  `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval              *string                  `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout               *string                  `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels                  []string                 `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels                   []string                 `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                      []byte                   `cty:"ssh_public_key"`
+	SSHPrivateKey                     []byte                   `cty:"ssh_private_key"`
+	WinRMUser                         *string                  `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword                     *string                  `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                         *string                  `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                         *int                     `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                      *string                  `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                       *bool                    `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure                     *bool                    `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                      *bool                    `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHPrivateIp                      *bool                    `mapstructure:"ssh_private_ip" required:"false" cty:"ssh_private_ip"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"access_key":                   &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"secret_key":                   &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"region":                       &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"skip_region_validation":       &hcldec.AttrSpec{Name: "skip_region_validation", Type: cty.Bool, Required: false},
+		"security_token":               &hcldec.AttrSpec{Name: "security_token", Type: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_version":                &hcldec.AttrSpec{Name: "image_version", Type: cty.String, Required: false},
+		"image_description":            &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"image_share_account":          &hcldec.AttrSpec{Name: "image_share_account", Type: cty.List(cty.String), Required: false},
+		"image_unshare_account":        &hcldec.AttrSpec{Name: "image_unshare_account", Type: cty.List(cty.String), Required: false},
+		"image_copy_regions":           &hcldec.AttrSpec{Name: "image_copy_regions", Type: cty.List(cty.String), Required: false},
+		"image_copy_names":             &hcldec.AttrSpec{Name: "image_copy_names", Type: cty.List(cty.String), Required: false},
+		"image_encrypted":              &hcldec.AttrSpec{Name: "image_encrypted", Type: cty.Bool, Required: false},
+		"image_force_delete":           &hcldec.AttrSpec{Name: "image_force_delete", Type: cty.Bool, Required: false},
+		"image_force_delete_snapshots": &hcldec.AttrSpec{Name: "image_force_delete_snapshots", Type: cty.Bool, Required: false},
+		"image_force_delete_instances": &hcldec.AttrSpec{Name: "image_force_delete_instances", Type: cty.Bool, Required: false},
+		"image_ignore_data_disks":      &hcldec.AttrSpec{Name: "image_ignore_data_disks", Type: cty.Bool, Required: false},
+		"tags":                         &hcldec.BlockAttrsSpec{TypeName: "tags", ElementType: cty.String, Required: false},
+		"system_disk_mapping":          &hcldec.BlockSpec{TypeName: "system_disk_mapping", Nested: hcldec.ObjectSpec((*FlatAlicloudDiskDevice)(nil).HCL2Spec())},
+		"image_disk_mappings":          &hcldec.BlockListSpec{TypeName: "image_disk_mappings", Nested: &hcldec.BlockSpec{TypeName: "image_disk_mappings", Nested: hcldec.ObjectSpec((*FlatAlicloudDiskDevice)(nil).HCL2Spec())}},
+		"associate_public_ip_address":  &hcldec.AttrSpec{Name: "associate_public_ip_address", Type: cty.Bool, Required: false},
+		"zone_id":                      &hcldec.AttrSpec{Name: "zone_id", Type: cty.String, Required: false},
+		"io_optimized":                 &hcldec.AttrSpec{Name: "io_optimized", Type: cty.Bool, Required: false},
+		"instance_type":                &hcldec.AttrSpec{Name: "instance_type", Type: cty.String, Required: false},
+		"description":                  &hcldec.AttrSpec{Name: "description", Type: cty.String, Required: false},
+		"source_image":                 &hcldec.AttrSpec{Name: "source_image", Type: cty.String, Required: false},
+		"force_stop_instance":          &hcldec.AttrSpec{Name: "force_stop_instance", Type: cty.Bool, Required: false},
+		"disable_stop_instance":        &hcldec.AttrSpec{Name: "disable_stop_instance", Type: cty.Bool, Required: false},
+		"security_group_id":            &hcldec.AttrSpec{Name: "security_group_id", Type: cty.String, Required: false},
+		"security_group_name":          &hcldec.AttrSpec{Name: "security_group_name", Type: cty.String, Required: false},
+		"user_data":                    &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":               &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"vpc_id":                       &hcldec.AttrSpec{Name: "vpc_id", Type: cty.String, Required: false},
+		"vpc_name":                     &hcldec.AttrSpec{Name: "vpc_name", Type: cty.String, Required: false},
+		"vpc_cidr_block":               &hcldec.AttrSpec{Name: "vpc_cidr_block", Type: cty.String, Required: false},
+		"vswitch_id":                   &hcldec.AttrSpec{Name: "vswitch_id", Type: cty.String, Required: false},
+		"vswitch_name":                 &hcldec.AttrSpec{Name: "vswitch_name", Type: cty.String, Required: false},
+		"instance_name":                &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"internet_charge_type":         &hcldec.AttrSpec{Name: "internet_charge_type", Type: cty.String, Required: false},
+		"internet_max_bandwidth_out":   &hcldec.AttrSpec{Name: "internet_max_bandwidth_out", Type: cty.Number, Required: false},
+		"wait_snapshot_ready_timeout":  &hcldec.AttrSpec{Name: "wait_snapshot_ready_timeout", Type: cty.Number, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_private_ip":               &hcldec.AttrSpec{Name: "ssh_private_ip", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/amazon/chroot/builder.hcl2spec.go b/builder/amazon/chroot/builder.hcl2spec.go
new file mode 100644
index 000000000..f1f0a2c50
--- /dev/null
+++ b/builder/amazon/chroot/builder.hcl2spec.go
@@ -0,0 +1,140 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,BlockDevices,BlockDevice"; DO NOT EDIT.
+package chroot
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/hashicorp/packer/builder/amazon/common"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName         *string                           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType       *string                           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug             *bool                             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce             *bool                             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError           *string                           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars          map[string]string                 `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars     []string                          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AMIName                 *string                           `mapstructure:"ami_name" required:"true" cty:"ami_name"`
+	AMIDescription          *string                           `mapstructure:"ami_description" required:"false" cty:"ami_description"`
+	AMIVirtType             *string                           `mapstructure:"ami_virtualization_type" required:"false" cty:"ami_virtualization_type"`
+	AMIUsers                []string                          `mapstructure:"ami_users" required:"false" cty:"ami_users"`
+	AMIGroups               []string                          `mapstructure:"ami_groups" required:"false" cty:"ami_groups"`
+	AMIProductCodes         []string                          `mapstructure:"ami_product_codes" required:"false" cty:"ami_product_codes"`
+	AMIRegions              []string                          `mapstructure:"ami_regions" required:"false" cty:"ami_regions"`
+	AMISkipRegionValidation *bool                             `mapstructure:"skip_region_validation" required:"false" cty:"skip_region_validation"`
+	AMITags                 common.TagMap                     `mapstructure:"tags" required:"false" cty:"tags"`
+	AMIENASupport           *bool                             `mapstructure:"ena_support" required:"false" cty:"ena_support"`
+	AMISriovNetSupport      *bool                             `mapstructure:"sriov_support" required:"false" cty:"sriov_support"`
+	AMIForceDeregister      *bool                             `mapstructure:"force_deregister" required:"false" cty:"force_deregister"`
+	AMIForceDeleteSnapshot  *bool                             `mapstructure:"force_delete_snapshot" required:"false" cty:"force_delete_snapshot"`
+	AMIEncryptBootVolume    *bool                             `mapstructure:"encrypt_boot" required:"false" cty:"encrypt_boot"`
+	AMIKmsKeyId             *string                           `mapstructure:"kms_key_id" required:"false" cty:"kms_key_id"`
+	AMIRegionKMSKeyIDs      map[string]string                 `mapstructure:"region_kms_key_ids" required:"false" cty:"region_kms_key_ids"`
+	AMISkipBuildRegion      *bool                             `mapstructure:"skip_save_build_region" cty:"skip_save_build_region"`
+	SnapshotTags            common.TagMap                     `mapstructure:"snapshot_tags" required:"false" cty:"snapshot_tags"`
+	SnapshotUsers           []string                          `mapstructure:"snapshot_users" required:"false" cty:"snapshot_users"`
+	SnapshotGroups          []string                          `mapstructure:"snapshot_groups" required:"false" cty:"snapshot_groups"`
+	AccessKey               *string                           `mapstructure:"access_key" required:"true" cty:"access_key"`
+	CustomEndpointEc2       *string                           `mapstructure:"custom_endpoint_ec2" required:"false" cty:"custom_endpoint_ec2"`
+	DecodeAuthZMessages     *bool                             `mapstructure:"decode_authorization_messages" required:"false" cty:"decode_authorization_messages"`
+	InsecureSkipTLSVerify   *bool                             `mapstructure:"insecure_skip_tls_verify" required:"false" cty:"insecure_skip_tls_verify"`
+	MFACode                 *string                           `mapstructure:"mfa_code" required:"false" cty:"mfa_code"`
+	ProfileName             *string                           `mapstructure:"profile" required:"false" cty:"profile"`
+	RawRegion               *string                           `mapstructure:"region" required:"true" cty:"region"`
+	SecretKey               *string                           `mapstructure:"secret_key" required:"true" cty:"secret_key"`
+	SkipMetadataApiCheck    *bool                             `mapstructure:"skip_metadata_api_check" cty:"skip_metadata_api_check"`
+	Token                   *string                           `mapstructure:"token" required:"false" cty:"token"`
+	VaultAWSEngine          *common.FlatVaultAWSEngineOptions `mapstructure:"vault_aws_engine" required:"false" cty:"vault_aws_engine"`
+	AMIMappings             []common.FlatBlockDevice          `mapstructure:"ami_block_device_mappings" hcl2-schema-generator:"ami_block_device_mappings,direct" required:"false" cty:"ami_block_device_mappings"`
+	ChrootMounts            [][]string                        `mapstructure:"chroot_mounts" required:"false" cty:"chroot_mounts"`
+	CommandWrapper          *string                           `mapstructure:"command_wrapper" required:"false" cty:"command_wrapper"`
+	CopyFiles               []string                          `mapstructure:"copy_files" required:"false" cty:"copy_files"`
+	DevicePath              *string                           `mapstructure:"device_path" required:"false" cty:"device_path"`
+	NVMEDevicePath          *string                           `mapstructure:"nvme_device_path" required:"false" cty:"nvme_device_path"`
+	FromScratch             *bool                             `mapstructure:"from_scratch" required:"false" cty:"from_scratch"`
+	MountOptions            []string                          `mapstructure:"mount_options" required:"false" cty:"mount_options"`
+	MountPartition          *string                           `mapstructure:"mount_partition" required:"false" cty:"mount_partition"`
+	MountPath               *string                           `mapstructure:"mount_path" required:"false" cty:"mount_path"`
+	PostMountCommands       []string                          `mapstructure:"post_mount_commands" required:"false" cty:"post_mount_commands"`
+	PreMountCommands        []string                          `mapstructure:"pre_mount_commands" required:"false" cty:"pre_mount_commands"`
+	RootDeviceName          *string                           `mapstructure:"root_device_name" required:"false" cty:"root_device_name"`
+	RootVolumeSize          *int64                            `mapstructure:"root_volume_size" required:"false" cty:"root_volume_size"`
+	RootVolumeType          *string                           `mapstructure:"root_volume_type" required:"false" cty:"root_volume_type"`
+	SourceAmi               *string                           `mapstructure:"source_ami" required:"true" cty:"source_ami"`
+	SourceAmiFilter         *common.FlatAmiFilterOptions      `mapstructure:"source_ami_filter" required:"false" cty:"source_ami_filter"`
+	RootVolumeTags          common.TagMap                     `mapstructure:"root_volume_tags" required:"false" cty:"root_volume_tags"`
+	Architecture            *string                           `mapstructure:"ami_architecture" required:"false" cty:"ami_architecture"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":             &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":           &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                  &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                  &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":               &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":         &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":    &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"ami_name":                      &hcldec.AttrSpec{Name: "ami_name", Type: cty.String, Required: false},
+		"ami_description":               &hcldec.AttrSpec{Name: "ami_description", Type: cty.String, Required: false},
+		"ami_virtualization_type":       &hcldec.AttrSpec{Name: "ami_virtualization_type", Type: cty.String, Required: false},
+		"ami_users":                     &hcldec.AttrSpec{Name: "ami_users", Type: cty.List(cty.String), Required: false},
+		"ami_groups":                    &hcldec.AttrSpec{Name: "ami_groups", Type: cty.List(cty.String), Required: false},
+		"ami_product_codes":             &hcldec.AttrSpec{Name: "ami_product_codes", Type: cty.List(cty.String), Required: false},
+		"ami_regions":                   &hcldec.AttrSpec{Name: "ami_regions", Type: cty.List(cty.String), Required: false},
+		"skip_region_validation":        &hcldec.AttrSpec{Name: "skip_region_validation", Type: cty.Bool, Required: false},
+		"tags":                          &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+		"ena_support":                   &hcldec.AttrSpec{Name: "ena_support", Type: cty.Bool, Required: false},
+		"sriov_support":                 &hcldec.AttrSpec{Name: "sriov_support", Type: cty.Bool, Required: false},
+		"force_deregister":              &hcldec.AttrSpec{Name: "force_deregister", Type: cty.Bool, Required: false},
+		"force_delete_snapshot":         &hcldec.AttrSpec{Name: "force_delete_snapshot", Type: cty.Bool, Required: false},
+		"encrypt_boot":                  &hcldec.AttrSpec{Name: "encrypt_boot", Type: cty.Bool, Required: false},
+		"kms_key_id":                    &hcldec.AttrSpec{Name: "kms_key_id", Type: cty.String, Required: false},
+		"region_kms_key_ids":            &hcldec.BlockAttrsSpec{TypeName: "region_kms_key_ids", ElementType: cty.String, Required: false},
+		"skip_save_build_region":        &hcldec.AttrSpec{Name: "skip_save_build_region", Type: cty.Bool, Required: false},
+		"snapshot_tags":                 &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+		"snapshot_users":                &hcldec.AttrSpec{Name: "snapshot_users", Type: cty.List(cty.String), Required: false},
+		"snapshot_groups":               &hcldec.AttrSpec{Name: "snapshot_groups", Type: cty.List(cty.String), Required: false},
+		"access_key":                    &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"custom_endpoint_ec2":           &hcldec.AttrSpec{Name: "custom_endpoint_ec2", Type: cty.String, Required: false},
+		"decode_authorization_messages": &hcldec.AttrSpec{Name: "decode_authorization_messages", Type: cty.Bool, Required: false},
+		"insecure_skip_tls_verify":      &hcldec.AttrSpec{Name: "insecure_skip_tls_verify", Type: cty.Bool, Required: false},
+		"mfa_code":                      &hcldec.AttrSpec{Name: "mfa_code", Type: cty.String, Required: false},
+		"profile":                       &hcldec.AttrSpec{Name: "profile", Type: cty.String, Required: false},
+		"region":                        &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"secret_key":                    &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"skip_metadata_api_check":       &hcldec.AttrSpec{Name: "skip_metadata_api_check", Type: cty.Bool, Required: false},
+		"token":                         &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"vault_aws_engine":              &hcldec.BlockSpec{TypeName: "vault_aws_engine", Nested: hcldec.ObjectSpec((*common.FlatVaultAWSEngineOptions)(nil).HCL2Spec())},
+		"ami_block_device_mappings":     &hcldec.BlockListSpec{TypeName: "ami_block_device_mappings", Nested: &hcldec.BlockSpec{TypeName: "ami_block_device_mappings", Nested: hcldec.ObjectSpec((*common.FlatBlockDevice)(nil).HCL2Spec())}},
+		"chroot_mounts":                 &hcldec.BlockListSpec{TypeName: "chroot_mounts", Nested: &hcldec.AttrSpec{Name: "chroot_mounts", Type: cty.List(cty.String), Required: false}},
+		"command_wrapper":               &hcldec.AttrSpec{Name: "command_wrapper", Type: cty.String, Required: false},
+		"copy_files":                    &hcldec.AttrSpec{Name: "copy_files", Type: cty.List(cty.String), Required: false},
+		"device_path":                   &hcldec.AttrSpec{Name: "device_path", Type: cty.String, Required: false},
+		"nvme_device_path":              &hcldec.AttrSpec{Name: "nvme_device_path", Type: cty.String, Required: false},
+		"from_scratch":                  &hcldec.AttrSpec{Name: "from_scratch", Type: cty.Bool, Required: false},
+		"mount_options":                 &hcldec.AttrSpec{Name: "mount_options", Type: cty.List(cty.String), Required: false},
+		"mount_partition":               &hcldec.AttrSpec{Name: "mount_partition", Type: cty.String, Required: false},
+		"mount_path":                    &hcldec.AttrSpec{Name: "mount_path", Type: cty.String, Required: false},
+		"post_mount_commands":           &hcldec.AttrSpec{Name: "post_mount_commands", Type: cty.List(cty.String), Required: false},
+		"pre_mount_commands":            &hcldec.AttrSpec{Name: "pre_mount_commands", Type: cty.List(cty.String), Required: false},
+		"root_device_name":              &hcldec.AttrSpec{Name: "root_device_name", Type: cty.String, Required: false},
+		"root_volume_size":              &hcldec.AttrSpec{Name: "root_volume_size", Type: cty.Number, Required: false},
+		"root_volume_type":              &hcldec.AttrSpec{Name: "root_volume_type", Type: cty.String, Required: false},
+		"source_ami":                    &hcldec.AttrSpec{Name: "source_ami", Type: cty.String, Required: false},
+		"source_ami_filter":             &hcldec.BlockSpec{TypeName: "source_ami_filter", Nested: hcldec.ObjectSpec((*common.FlatAmiFilterOptions)(nil).HCL2Spec())},
+		"root_volume_tags":              &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+		"ami_architecture":              &hcldec.AttrSpec{Name: "ami_architecture", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/amazon/common/access_config.go b/builder/amazon/common/access_config.go
index 640f1fa31..9cee33c14 100644
--- a/builder/amazon/common/access_config.go
+++ b/builder/amazon/common/access_config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type VaultAWSEngineOptions
 
 package common
 
diff --git a/builder/amazon/common/access_config.hcl2spec.go b/builder/amazon/common/access_config.hcl2spec.go
new file mode 100644
index 000000000..b3bdad7e0
--- /dev/null
+++ b/builder/amazon/common/access_config.hcl2spec.go
@@ -0,0 +1,33 @@
+// Code generated by "mapstructure-to-hcl2 -type VaultAWSEngineOptions"; DO NOT EDIT.
+package common
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatVaultAWSEngineOptions is an auto-generated flat version of VaultAWSEngineOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatVaultAWSEngineOptions struct {
+	Name       *string `mapstructure:"name" cty:"name"`
+	RoleARN    *string `mapstructure:"role_arn" cty:"role_arn"`
+	TTL        *string `mapstructure:"ttl" required:"false" cty:"ttl"`
+	EngineName *string `mapstructure:"engine_name" cty:"engine_name"`
+}
+
+// FlatMapstructure returns a new FlatVaultAWSEngineOptions.
+// FlatVaultAWSEngineOptions is an auto-generated flat version of VaultAWSEngineOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*VaultAWSEngineOptions) FlatMapstructure() interface{} { return new(FlatVaultAWSEngineOptions) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatVaultAWSEngineOptions.
+// This spec is used by HCL to read the fields of FlatVaultAWSEngineOptions.
+func (*FlatVaultAWSEngineOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"name":        &hcldec.AttrSpec{Name: "name", Type: cty.String, Required: false},
+		"role_arn":    &hcldec.AttrSpec{Name: "role_arn", Type: cty.String, Required: false},
+		"ttl":         &hcldec.AttrSpec{Name: "ttl", Type: cty.String, Required: false},
+		"engine_name": &hcldec.AttrSpec{Name: "engine_name", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/amazon/common/block_device.go b/builder/amazon/common/block_device.go
index 7e6b4c47c..a60394ee3 100644
--- a/builder/amazon/common/block_device.go
+++ b/builder/amazon/common/block_device.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type BlockDevice
 
 package common
 
diff --git a/builder/amazon/common/block_device.hcl2spec.go b/builder/amazon/common/block_device.hcl2spec.go
new file mode 100644
index 000000000..1865bda3a
--- /dev/null
+++ b/builder/amazon/common/block_device.hcl2spec.go
@@ -0,0 +1,45 @@
+// Code generated by "mapstructure-to-hcl2 -type BlockDevice"; DO NOT EDIT.
+package common
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatBlockDevice is an auto-generated flat version of BlockDevice.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatBlockDevice struct {
+	DeleteOnTermination *bool   `mapstructure:"delete_on_termination" required:"false" cty:"delete_on_termination"`
+	DeviceName          *string `mapstructure:"device_name" required:"false" cty:"device_name"`
+	Encrypted           *bool   `mapstructure:"encrypted" required:"false" cty:"encrypted"`
+	IOPS                *int64  `mapstructure:"iops" required:"false" cty:"iops"`
+	NoDevice            *bool   `mapstructure:"no_device" required:"false" cty:"no_device"`
+	SnapshotId          *string `mapstructure:"snapshot_id" required:"false" cty:"snapshot_id"`
+	VirtualName         *string `mapstructure:"virtual_name" required:"false" cty:"virtual_name"`
+	VolumeType          *string `mapstructure:"volume_type" required:"false" cty:"volume_type"`
+	VolumeSize          *int64  `mapstructure:"volume_size" required:"false" cty:"volume_size"`
+	KmsKeyId            *string `mapstructure:"kms_key_id" required:"false" cty:"kms_key_id"`
+}
+
+// FlatMapstructure returns a new FlatBlockDevice.
+// FlatBlockDevice is an auto-generated flat version of BlockDevice.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*BlockDevice) FlatMapstructure() interface{} { return new(FlatBlockDevice) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatBlockDevice.
+// This spec is used by HCL to read the fields of FlatBlockDevice.
+func (*FlatBlockDevice) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"delete_on_termination": &hcldec.AttrSpec{Name: "delete_on_termination", Type: cty.Bool, Required: false},
+		"device_name":           &hcldec.AttrSpec{Name: "device_name", Type: cty.String, Required: false},
+		"encrypted":             &hcldec.AttrSpec{Name: "encrypted", Type: cty.Bool, Required: false},
+		"iops":                  &hcldec.AttrSpec{Name: "iops", Type: cty.Number, Required: false},
+		"no_device":             &hcldec.AttrSpec{Name: "no_device", Type: cty.Bool, Required: false},
+		"snapshot_id":           &hcldec.AttrSpec{Name: "snapshot_id", Type: cty.String, Required: false},
+		"virtual_name":          &hcldec.AttrSpec{Name: "virtual_name", Type: cty.String, Required: false},
+		"volume_type":           &hcldec.AttrSpec{Name: "volume_type", Type: cty.String, Required: false},
+		"volume_size":           &hcldec.AttrSpec{Name: "volume_size", Type: cty.Number, Required: false},
+		"kms_key_id":            &hcldec.AttrSpec{Name: "kms_key_id", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/amazon/common/run_config.go b/builder/amazon/common/run_config.go
index 2577d5216..63e735c8c 100644
--- a/builder/amazon/common/run_config.go
+++ b/builder/amazon/common/run_config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type AmiFilterOptions,SecurityGroupFilterOptions,SubnetFilterOptions,VpcFilterOptions
 
 package common
 
diff --git a/builder/amazon/common/run_config.hcl2spec.go b/builder/amazon/common/run_config.hcl2spec.go
new file mode 100644
index 000000000..9c4d3bdcc
--- /dev/null
+++ b/builder/amazon/common/run_config.hcl2spec.go
@@ -0,0 +1,97 @@
+// Code generated by "mapstructure-to-hcl2 -type AmiFilterOptions,SecurityGroupFilterOptions,SubnetFilterOptions,VpcFilterOptions"; DO NOT EDIT.
+package common
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatAmiFilterOptions is an auto-generated flat version of AmiFilterOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatAmiFilterOptions struct {
+	Filters    map[string]string `cty:"filters"`
+	Owners     []string          `cty:"owners"`
+	MostRecent *bool             `mapstructure:"most_recent" cty:"most_recent"`
+}
+
+// FlatMapstructure returns a new FlatAmiFilterOptions.
+// FlatAmiFilterOptions is an auto-generated flat version of AmiFilterOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*AmiFilterOptions) FlatMapstructure() interface{} { return new(FlatAmiFilterOptions) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatAmiFilterOptions.
+// This spec is used by HCL to read the fields of FlatAmiFilterOptions.
+func (*FlatAmiFilterOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"filters":     &hcldec.BlockAttrsSpec{TypeName: "filters", ElementType: cty.String, Required: false},
+		"owners":      &hcldec.AttrSpec{Name: "owners", Type: cty.List(cty.String), Required: false},
+		"most_recent": &hcldec.AttrSpec{Name: "most_recent", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatSecurityGroupFilterOptions is an auto-generated flat version of SecurityGroupFilterOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatSecurityGroupFilterOptions struct {
+	Filters map[string]string `cty:"filters"`
+}
+
+// FlatMapstructure returns a new FlatSecurityGroupFilterOptions.
+// FlatSecurityGroupFilterOptions is an auto-generated flat version of SecurityGroupFilterOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*SecurityGroupFilterOptions) FlatMapstructure() interface{} {
+	return new(FlatSecurityGroupFilterOptions)
+}
+
+// HCL2Spec returns the hcldec.Spec of a FlatSecurityGroupFilterOptions.
+// This spec is used by HCL to read the fields of FlatSecurityGroupFilterOptions.
+func (*FlatSecurityGroupFilterOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"filters": &hcldec.BlockAttrsSpec{TypeName: "filters", ElementType: cty.String, Required: false},
+	}
+	return s
+}
+
+// FlatSubnetFilterOptions is an auto-generated flat version of SubnetFilterOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatSubnetFilterOptions struct {
+	Filters  map[string]string `cty:"filters"`
+	MostFree *bool             `mapstructure:"most_free" cty:"most_free"`
+	Random   *bool             `mapstructure:"random" cty:"random"`
+}
+
+// FlatMapstructure returns a new FlatSubnetFilterOptions.
+// FlatSubnetFilterOptions is an auto-generated flat version of SubnetFilterOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*SubnetFilterOptions) FlatMapstructure() interface{} { return new(FlatSubnetFilterOptions) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatSubnetFilterOptions.
+// This spec is used by HCL to read the fields of FlatSubnetFilterOptions.
+func (*FlatSubnetFilterOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"filters":   &hcldec.BlockAttrsSpec{TypeName: "filters", ElementType: cty.String, Required: false},
+		"most_free": &hcldec.AttrSpec{Name: "most_free", Type: cty.Bool, Required: false},
+		"random":    &hcldec.AttrSpec{Name: "random", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatVpcFilterOptions is an auto-generated flat version of VpcFilterOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatVpcFilterOptions struct {
+	Filters map[string]string `cty:"filters"`
+}
+
+// FlatMapstructure returns a new FlatVpcFilterOptions.
+// FlatVpcFilterOptions is an auto-generated flat version of VpcFilterOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*VpcFilterOptions) FlatMapstructure() interface{} { return new(FlatVpcFilterOptions) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatVpcFilterOptions.
+// This spec is used by HCL to read the fields of FlatVpcFilterOptions.
+func (*FlatVpcFilterOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"filters": &hcldec.BlockAttrsSpec{TypeName: "filters", ElementType: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/amazon/ebs/builder.go b/builder/amazon/ebs/builder.go
index 2cbcbcbf4..70554af9f 100644
--- a/builder/amazon/ebs/builder.go
+++ b/builder/amazon/ebs/builder.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 // The amazonebs package contains a packer.Builder implementation that
 // builds AMIs for Amazon EC2.
diff --git a/builder/amazon/ebs/builder.hcl2spec.go b/builder/amazon/ebs/builder.hcl2spec.go
new file mode 100644
index 000000000..c884f66cb
--- /dev/null
+++ b/builder/amazon/ebs/builder.hcl2spec.go
@@ -0,0 +1,244 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package ebs
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/hashicorp/packer/builder/amazon/common"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName                   *string                                `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType                 *string                                `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                       *bool                                  `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                       *bool                                  `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError                     *string                                `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars                    map[string]string                      `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars               []string                               `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AccessKey                         *string                                `mapstructure:"access_key" required:"true" cty:"access_key"`
+	CustomEndpointEc2                 *string                                `mapstructure:"custom_endpoint_ec2" required:"false" cty:"custom_endpoint_ec2"`
+	DecodeAuthZMessages               *bool                                  `mapstructure:"decode_authorization_messages" required:"false" cty:"decode_authorization_messages"`
+	InsecureSkipTLSVerify             *bool                                  `mapstructure:"insecure_skip_tls_verify" required:"false" cty:"insecure_skip_tls_verify"`
+	MFACode                           *string                                `mapstructure:"mfa_code" required:"false" cty:"mfa_code"`
+	ProfileName                       *string                                `mapstructure:"profile" required:"false" cty:"profile"`
+	RawRegion                         *string                                `mapstructure:"region" required:"true" cty:"region"`
+	SecretKey                         *string                                `mapstructure:"secret_key" required:"true" cty:"secret_key"`
+	SkipValidation                    *bool                                  `mapstructure:"skip_region_validation" required:"false" cty:"skip_region_validation"`
+	SkipMetadataApiCheck              *bool                                  `mapstructure:"skip_metadata_api_check" cty:"skip_metadata_api_check"`
+	Token                             *string                                `mapstructure:"token" required:"false" cty:"token"`
+	VaultAWSEngine                    *common.FlatVaultAWSEngineOptions      `mapstructure:"vault_aws_engine" required:"false" cty:"vault_aws_engine"`
+	AMIName                           *string                                `mapstructure:"ami_name" required:"true" cty:"ami_name"`
+	AMIDescription                    *string                                `mapstructure:"ami_description" required:"false" cty:"ami_description"`
+	AMIVirtType                       *string                                `mapstructure:"ami_virtualization_type" required:"false" cty:"ami_virtualization_type"`
+	AMIUsers                          []string                               `mapstructure:"ami_users" required:"false" cty:"ami_users"`
+	AMIGroups                         []string                               `mapstructure:"ami_groups" required:"false" cty:"ami_groups"`
+	AMIProductCodes                   []string                               `mapstructure:"ami_product_codes" required:"false" cty:"ami_product_codes"`
+	AMIRegions                        []string                               `mapstructure:"ami_regions" required:"false" cty:"ami_regions"`
+	AMITags                           common.TagMap                          `mapstructure:"tags" required:"false" cty:"tags"`
+	AMIENASupport                     *bool                                  `mapstructure:"ena_support" required:"false" cty:"ena_support"`
+	AMISriovNetSupport                *bool                                  `mapstructure:"sriov_support" required:"false" cty:"sriov_support"`
+	AMIForceDeregister                *bool                                  `mapstructure:"force_deregister" required:"false" cty:"force_deregister"`
+	AMIForceDeleteSnapshot            *bool                                  `mapstructure:"force_delete_snapshot" required:"false" cty:"force_delete_snapshot"`
+	AMIEncryptBootVolume              *bool                                  `mapstructure:"encrypt_boot" required:"false" cty:"encrypt_boot"`
+	AMIKmsKeyId                       *string                                `mapstructure:"kms_key_id" required:"false" cty:"kms_key_id"`
+	AMIRegionKMSKeyIDs                map[string]string                      `mapstructure:"region_kms_key_ids" required:"false" cty:"region_kms_key_ids"`
+	AMISkipBuildRegion                *bool                                  `mapstructure:"skip_save_build_region" cty:"skip_save_build_region"`
+	SnapshotTags                      common.TagMap                          `mapstructure:"snapshot_tags" required:"false" cty:"snapshot_tags"`
+	SnapshotUsers                     []string                               `mapstructure:"snapshot_users" required:"false" cty:"snapshot_users"`
+	SnapshotGroups                    []string                               `mapstructure:"snapshot_groups" required:"false" cty:"snapshot_groups"`
+	AssociatePublicIpAddress          *bool                                  `mapstructure:"associate_public_ip_address" required:"false" cty:"associate_public_ip_address"`
+	AvailabilityZone                  *string                                `mapstructure:"availability_zone" required:"false" cty:"availability_zone"`
+	BlockDurationMinutes              *int64                                 `mapstructure:"block_duration_minutes" required:"false" cty:"block_duration_minutes"`
+	DisableStopInstance               *bool                                  `mapstructure:"disable_stop_instance" required:"false" cty:"disable_stop_instance"`
+	EbsOptimized                      *bool                                  `mapstructure:"ebs_optimized" required:"false" cty:"ebs_optimized"`
+	EnableT2Unlimited                 *bool                                  `mapstructure:"enable_t2_unlimited" required:"false" cty:"enable_t2_unlimited"`
+	IamInstanceProfile                *string                                `mapstructure:"iam_instance_profile" required:"false" cty:"iam_instance_profile"`
+	InstanceInitiatedShutdownBehavior *string                                `mapstructure:"shutdown_behavior" required:"false" cty:"shutdown_behavior"`
+	InstanceType                      *string                                `mapstructure:"instance_type" required:"true" cty:"instance_type"`
+	SecurityGroupFilter               *common.FlatSecurityGroupFilterOptions `mapstructure:"security_group_filter" required:"false" cty:"security_group_filter"`
+	RunTags                           map[string]string                      `mapstructure:"run_tags" required:"false" cty:"run_tags"`
+	SecurityGroupId                   *string                                `mapstructure:"security_group_id" required:"false" cty:"security_group_id"`
+	SecurityGroupIds                  []string                               `mapstructure:"security_group_ids" required:"false" cty:"security_group_ids"`
+	SourceAmi                         *string                                `mapstructure:"source_ami" required:"true" cty:"source_ami"`
+	SourceAmiFilter                   *common.FlatAmiFilterOptions           `mapstructure:"source_ami_filter" required:"false" cty:"source_ami_filter"`
+	SpotInstanceTypes                 []string                               `mapstructure:"spot_instance_types" required:"false" cty:"spot_instance_types"`
+	SpotPrice                         *string                                `mapstructure:"spot_price" required:"false" cty:"spot_price"`
+	SpotPriceAutoProduct              *string                                `mapstructure:"spot_price_auto_product" required:"false" cty:"spot_price_auto_product"`
+	SpotTags                          map[string]string                      `mapstructure:"spot_tags" required:"false" cty:"spot_tags"`
+	SubnetFilter                      *common.FlatSubnetFilterOptions        `mapstructure:"subnet_filter" required:"false" cty:"subnet_filter"`
+	SubnetId                          *string                                `mapstructure:"subnet_id" required:"false" cty:"subnet_id"`
+	TemporaryKeyPairName              *string                                `mapstructure:"temporary_key_pair_name" required:"false" cty:"temporary_key_pair_name"`
+	TemporarySGSourceCidrs            []string                               `mapstructure:"temporary_security_group_source_cidrs" required:"false" cty:"temporary_security_group_source_cidrs"`
+	UserData                          *string                                `mapstructure:"user_data" required:"false" cty:"user_data"`
+	UserDataFile                      *string                                `mapstructure:"user_data_file" required:"false" cty:"user_data_file"`
+	VpcFilter                         *common.FlatVpcFilterOptions           `mapstructure:"vpc_filter" required:"false" cty:"vpc_filter"`
+	VpcId                             *string                                `mapstructure:"vpc_id" required:"false" cty:"vpc_id"`
+	WindowsPasswordTimeout            *string                                `mapstructure:"windows_password_timeout" required:"false" cty:"windows_password_timeout"`
+	Type                              *string                                `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect                *string                                `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                           *string                                `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                           *int                                   `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                       *string                                `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                       *string                                `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName                    *string                                `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHClearAuthorizedKeys            *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile                 *string                                `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                            *bool                                  `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                        *string                                `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                      *bool                                  `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding         *bool                                  `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts              *int                                   `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost                    *string                                `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort                    *int                                   `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth               *bool                                  `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername                *string                                `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword                *string                                `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile          *string                                `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod             *string                                `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                      *string                                `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                      *int                                   `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername                  *string                                `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword                  *string                                `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval              *string                                `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout               *string                                `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels                  []string                               `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels                   []string                               `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                      []byte                                 `cty:"ssh_public_key"`
+	SSHPrivateKey                     []byte                                 `cty:"ssh_private_key"`
+	WinRMUser                         *string                                `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword                     *string                                `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                         *string                                `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                         *int                                   `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                      *string                                `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                       *bool                                  `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure                     *bool                                  `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                      *bool                                  `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHInterface                      *string                                `mapstructure:"ssh_interface" cty:"ssh_interface"`
+	AMIMappings                       []common.FlatBlockDevice               `mapstructure:"ami_block_device_mappings" required:"false" cty:"ami_block_device_mappings"`
+	LaunchMappings                    []common.FlatBlockDevice               `mapstructure:"launch_block_device_mappings" required:"false" cty:"launch_block_device_mappings"`
+	VolumeRunTags                     common.TagMap                          `mapstructure:"run_volume_tags" cty:"run_volume_tags"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":                     &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":                   &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                          &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                          &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                       &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":                 &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":            &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"access_key":                            &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"custom_endpoint_ec2":                   &hcldec.AttrSpec{Name: "custom_endpoint_ec2", Type: cty.String, Required: false},
+		"decode_authorization_messages":         &hcldec.AttrSpec{Name: "decode_authorization_messages", Type: cty.Bool, Required: false},
+		"insecure_skip_tls_verify":              &hcldec.AttrSpec{Name: "insecure_skip_tls_verify", Type: cty.Bool, Required: false},
+		"mfa_code":                              &hcldec.AttrSpec{Name: "mfa_code", Type: cty.String, Required: false},
+		"profile":                               &hcldec.AttrSpec{Name: "profile", Type: cty.String, Required: false},
+		"region":                                &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"secret_key":                            &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"skip_region_validation":                &hcldec.AttrSpec{Name: "skip_region_validation", Type: cty.Bool, Required: false},
+		"skip_metadata_api_check":               &hcldec.AttrSpec{Name: "skip_metadata_api_check", Type: cty.Bool, Required: false},
+		"token":                                 &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"vault_aws_engine":                      &hcldec.BlockSpec{TypeName: "vault_aws_engine", Nested: hcldec.ObjectSpec((*common.FlatVaultAWSEngineOptions)(nil).HCL2Spec())},
+		"ami_name":                              &hcldec.AttrSpec{Name: "ami_name", Type: cty.String, Required: false},
+		"ami_description":                       &hcldec.AttrSpec{Name: "ami_description", Type: cty.String, Required: false},
+		"ami_virtualization_type":               &hcldec.AttrSpec{Name: "ami_virtualization_type", Type: cty.String, Required: false},
+		"ami_users":                             &hcldec.AttrSpec{Name: "ami_users", Type: cty.List(cty.String), Required: false},
+		"ami_groups":                            &hcldec.AttrSpec{Name: "ami_groups", Type: cty.List(cty.String), Required: false},
+		"ami_product_codes":                     &hcldec.AttrSpec{Name: "ami_product_codes", Type: cty.List(cty.String), Required: false},
+		"ami_regions":                           &hcldec.AttrSpec{Name: "ami_regions", Type: cty.List(cty.String), Required: false},
+		"tags":                                  &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+		"ena_support":                           &hcldec.AttrSpec{Name: "ena_support", Type: cty.Bool, Required: false},
+		"sriov_support":                         &hcldec.AttrSpec{Name: "sriov_support", Type: cty.Bool, Required: false},
+		"force_deregister":                      &hcldec.AttrSpec{Name: "force_deregister", Type: cty.Bool, Required: false},
+		"force_delete_snapshot":                 &hcldec.AttrSpec{Name: "force_delete_snapshot", Type: cty.Bool, Required: false},
+		"encrypt_boot":                          &hcldec.AttrSpec{Name: "encrypt_boot", Type: cty.Bool, Required: false},
+		"kms_key_id":                            &hcldec.AttrSpec{Name: "kms_key_id", Type: cty.String, Required: false},
+		"region_kms_key_ids":                    &hcldec.BlockAttrsSpec{TypeName: "region_kms_key_ids", ElementType: cty.String, Required: false},
+		"skip_save_build_region":                &hcldec.AttrSpec{Name: "skip_save_build_region", Type: cty.Bool, Required: false},
+		"snapshot_tags":                         &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+		"snapshot_users":                        &hcldec.AttrSpec{Name: "snapshot_users", Type: cty.List(cty.String), Required: false},
+		"snapshot_groups":                       &hcldec.AttrSpec{Name: "snapshot_groups", Type: cty.List(cty.String), Required: false},
+		"associate_public_ip_address":           &hcldec.AttrSpec{Name: "associate_public_ip_address", Type: cty.Bool, Required: false},
+		"availability_zone":                     &hcldec.AttrSpec{Name: "availability_zone", Type: cty.String, Required: false},
+		"block_duration_minutes":                &hcldec.AttrSpec{Name: "block_duration_minutes", Type: cty.Number, Required: false},
+		"disable_stop_instance":                 &hcldec.AttrSpec{Name: "disable_stop_instance", Type: cty.Bool, Required: false},
+		"ebs_optimized":                         &hcldec.AttrSpec{Name: "ebs_optimized", Type: cty.Bool, Required: false},
+		"enable_t2_unlimited":                   &hcldec.AttrSpec{Name: "enable_t2_unlimited", Type: cty.Bool, Required: false},
+		"iam_instance_profile":                  &hcldec.AttrSpec{Name: "iam_instance_profile", Type: cty.String, Required: false},
+		"shutdown_behavior":                     &hcldec.AttrSpec{Name: "shutdown_behavior", Type: cty.String, Required: false},
+		"instance_type":                         &hcldec.AttrSpec{Name: "instance_type", Type: cty.String, Required: false},
+		"security_group_filter":                 &hcldec.BlockSpec{TypeName: "security_group_filter", Nested: hcldec.ObjectSpec((*common.FlatSecurityGroupFilterOptions)(nil).HCL2Spec())},
+		"run_tags":                              &hcldec.BlockAttrsSpec{TypeName: "run_tags", ElementType: cty.String, Required: false},
+		"security_group_id":                     &hcldec.AttrSpec{Name: "security_group_id", Type: cty.String, Required: false},
+		"security_group_ids":                    &hcldec.AttrSpec{Name: "security_group_ids", Type: cty.List(cty.String), Required: false},
+		"source_ami":                            &hcldec.AttrSpec{Name: "source_ami", Type: cty.String, Required: false},
+		"source_ami_filter":                     &hcldec.BlockSpec{TypeName: "source_ami_filter", Nested: hcldec.ObjectSpec((*common.FlatAmiFilterOptions)(nil).HCL2Spec())},
+		"spot_instance_types":                   &hcldec.AttrSpec{Name: "spot_instance_types", Type: cty.List(cty.String), Required: false},
+		"spot_price":                            &hcldec.AttrSpec{Name: "spot_price", Type: cty.String, Required: false},
+		"spot_price_auto_product":               &hcldec.AttrSpec{Name: "spot_price_auto_product", Type: cty.String, Required: false},
+		"spot_tags":                             &hcldec.BlockAttrsSpec{TypeName: "spot_tags", ElementType: cty.String, Required: false},
+		"subnet_filter":                         &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
+		"subnet_id":                             &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
+		"temporary_key_pair_name":               &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"temporary_security_group_source_cidrs": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidrs", Type: cty.List(cty.String), Required: false},
+		"user_data":                             &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":                        &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"vpc_filter":                            &hcldec.BlockSpec{TypeName: "vpc_filter", Nested: hcldec.ObjectSpec((*common.FlatVpcFilterOptions)(nil).HCL2Spec())},
+		"vpc_id":                                &hcldec.AttrSpec{Name: "vpc_id", Type: cty.String, Required: false},
+		"windows_password_timeout":              &hcldec.AttrSpec{Name: "windows_password_timeout", Type: cty.String, Required: false},
+		"communicator":                          &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":               &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                              &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                              &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                          &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                          &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":                      &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":             &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":                  &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                               &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                           &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                        &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":          &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":                &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":                      &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":                      &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":                &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":                  &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":                  &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":          &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":              &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                        &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                        &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":                    &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":                    &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":               &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":                &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":                    &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":                     &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                        &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                       &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                        &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                        &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                            &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                            &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                         &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                         &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                        &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                        &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_interface":                         &hcldec.AttrSpec{Name: "ssh_interface", Type: cty.String, Required: false},
+		"ami_block_device_mappings":             &hcldec.BlockListSpec{TypeName: "ami_block_device_mappings", Nested: &hcldec.BlockSpec{TypeName: "ami_block_device_mappings", Nested: hcldec.ObjectSpec((*common.FlatBlockDevice)(nil).HCL2Spec())}},
+		"launch_block_device_mappings":          &hcldec.BlockListSpec{TypeName: "launch_block_device_mappings", Nested: &hcldec.BlockSpec{TypeName: "launch_block_device_mappings", Nested: hcldec.ObjectSpec((*common.FlatBlockDevice)(nil).HCL2Spec())}},
+		"run_volume_tags":                       &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/azure/arm/config.go b/builder/azure/arm/config.go
index 7243bd2a8..fa3bd4aaf 100644
--- a/builder/azure/arm/config.go
+++ b/builder/azure/arm/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config,SharedImageGallery,SharedImageGalleryDestination,PlanInformation
 
 package arm
 
diff --git a/builder/azure/arm/config.hcl2spec.go b/builder/azure/arm/config.hcl2spec.go
new file mode 100644
index 000000000..3fe3eac09
--- /dev/null
+++ b/builder/azure/arm/config.hcl2spec.go
@@ -0,0 +1,297 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,SharedImageGallery,SharedImageGalleryDestination,PlanInformation"; DO NOT EDIT.
+package arm
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName                     *string                            `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType                   *string                            `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                         *bool                              `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                         *bool                              `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError                       *string                            `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars                      map[string]string                  `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars                 []string                           `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	CloudEnvironmentName                *string                            `mapstructure:"cloud_environment_name" required:"false" cty:"cloud_environment_name"`
+	ClientID                            *string                            `mapstructure:"client_id" cty:"client_id"`
+	ClientSecret                        *string                            `mapstructure:"client_secret" cty:"client_secret"`
+	ClientCertPath                      *string                            `mapstructure:"client_cert_path" cty:"client_cert_path"`
+	ClientJWT                           *string                            `mapstructure:"client_jwt" cty:"client_jwt"`
+	ObjectID                            *string                            `mapstructure:"object_id" cty:"object_id"`
+	TenantID                            *string                            `mapstructure:"tenant_id" required:"false" cty:"tenant_id"`
+	SubscriptionID                      *string                            `mapstructure:"subscription_id" cty:"subscription_id"`
+	CaptureNamePrefix                   *string                            `mapstructure:"capture_name_prefix" cty:"capture_name_prefix"`
+	CaptureContainerName                *string                            `mapstructure:"capture_container_name" cty:"capture_container_name"`
+	SharedGallery                       *FlatSharedImageGallery            `mapstructure:"shared_image_gallery" required:"false" cty:"shared_image_gallery"`
+	SharedGalleryDestination            *FlatSharedImageGalleryDestination `mapstructure:"shared_image_gallery_destination" cty:"shared_image_gallery_destination"`
+	SharedGalleryTimeout                *string                            `mapstructure:"shared_image_gallery_timeout" cty:"shared_image_gallery_timeout"`
+	ImagePublisher                      *string                            `mapstructure:"image_publisher" required:"true" cty:"image_publisher"`
+	ImageOffer                          *string                            `mapstructure:"image_offer" required:"true" cty:"image_offer"`
+	ImageSku                            *string                            `mapstructure:"image_sku" required:"true" cty:"image_sku"`
+	ImageVersion                        *string                            `mapstructure:"image_version" required:"false" cty:"image_version"`
+	ImageUrl                            *string                            `mapstructure:"image_url" required:"false" cty:"image_url"`
+	CustomManagedImageResourceGroupName *string                            `mapstructure:"custom_managed_image_resource_group_name" required:"false" cty:"custom_managed_image_resource_group_name"`
+	CustomManagedImageName              *string                            `mapstructure:"custom_managed_image_name" required:"false" cty:"custom_managed_image_name"`
+	Location                            *string                            `mapstructure:"location" cty:"location"`
+	VMSize                              *string                            `mapstructure:"vm_size" required:"false" cty:"vm_size"`
+	ManagedImageResourceGroupName       *string                            `mapstructure:"managed_image_resource_group_name" cty:"managed_image_resource_group_name"`
+	ManagedImageName                    *string                            `mapstructure:"managed_image_name" cty:"managed_image_name"`
+	ManagedImageStorageAccountType      *string                            `mapstructure:"managed_image_storage_account_type" required:"false" cty:"managed_image_storage_account_type"`
+	ManagedImageOSDiskSnapshotName      *string                            `mapstructure:"managed_image_os_disk_snapshot_name" required:"false" cty:"managed_image_os_disk_snapshot_name"`
+	ManagedImageDataDiskSnapshotPrefix  *string                            `mapstructure:"managed_image_data_disk_snapshot_prefix" required:"false" cty:"managed_image_data_disk_snapshot_prefix"`
+	ManagedImageZoneResilient           *bool                              `mapstructure:"managed_image_zone_resilient" required:"false" cty:"managed_image_zone_resilient"`
+	AzureTags                           map[string]*string                 `mapstructure:"azure_tags" required:"false" cty:"azure_tags"`
+	ResourceGroupName                   *string                            `mapstructure:"resource_group_name" cty:"resource_group_name"`
+	StorageAccount                      *string                            `mapstructure:"storage_account" cty:"storage_account"`
+	TempComputeName                     *string                            `mapstructure:"temp_compute_name" required:"false" cty:"temp_compute_name"`
+	TempResourceGroupName               *string                            `mapstructure:"temp_resource_group_name" cty:"temp_resource_group_name"`
+	BuildResourceGroupName              *string                            `mapstructure:"build_resource_group_name" cty:"build_resource_group_name"`
+	PrivateVirtualNetworkWithPublicIp   *bool                              `mapstructure:"private_virtual_network_with_public_ip" required:"false" cty:"private_virtual_network_with_public_ip"`
+	VirtualNetworkName                  *string                            `mapstructure:"virtual_network_name" required:"false" cty:"virtual_network_name"`
+	VirtualNetworkSubnetName            *string                            `mapstructure:"virtual_network_subnet_name" required:"false" cty:"virtual_network_subnet_name"`
+	VirtualNetworkResourceGroupName     *string                            `mapstructure:"virtual_network_resource_group_name" required:"false" cty:"virtual_network_resource_group_name"`
+	CustomDataFile                      *string                            `mapstructure:"custom_data_file" required:"false" cty:"custom_data_file"`
+	PlanInfo                            *FlatPlanInformation               `mapstructure:"plan_info" required:"false" cty:"plan_info"`
+	OSType                              *string                            `mapstructure:"os_type" required:"false" cty:"os_type"`
+	OSDiskSizeGB                        *int32                             `mapstructure:"os_disk_size_gb" required:"false" cty:"os_disk_size_gb"`
+	AdditionalDiskSize                  []int32                            `mapstructure:"disk_additional_size" required:"false" cty:"disk_additional_size"`
+	DiskCachingType                     *string                            `mapstructure:"disk_caching_type" required:"false" cty:"disk_caching_type"`
+	UserName                            *string                            `cty:"user_name"`
+	Password                            *string                            `cty:"password"`
+	Type                                *string                            `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect                  *string                            `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                             *string                            `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                             *int                               `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                         *string                            `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                         *string                            `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName                      *string                            `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName             *string                            `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys              *bool                              `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile                   *string                            `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                              *bool                              `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                          *string                            `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                        *bool                              `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding           *bool                              `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts                *int                               `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost                      *string                            `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort                      *int                               `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth                 *bool                              `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername                  *string                            `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword                  *string                            `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile            *string                            `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod               *string                            `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                        *string                            `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                        *int                               `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername                    *string                            `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword                    *string                            `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval                *string                            `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout                 *string                            `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels                    []string                           `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels                     []string                           `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                        []byte                             `cty:"ssh_public_key"`
+	SSHPrivateKey                       []byte                             `cty:"ssh_private_key"`
+	WinRMUser                           *string                            `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword                       *string                            `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                           *string                            `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                           *int                               `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                        *string                            `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                         *bool                              `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure                       *bool                              `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                        *bool                              `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	AsyncResourceGroupDelete            *bool                              `mapstructure:"async_resourcegroup_delete" required:"false" cty:"async_resourcegroup_delete"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":                        &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":                      &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                             &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                             &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                          &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":                    &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":               &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"cloud_environment_name":                   &hcldec.AttrSpec{Name: "cloud_environment_name", Type: cty.String, Required: false},
+		"client_id":                                &hcldec.AttrSpec{Name: "client_id", Type: cty.String, Required: false},
+		"client_secret":                            &hcldec.AttrSpec{Name: "client_secret", Type: cty.String, Required: false},
+		"client_cert_path":                         &hcldec.AttrSpec{Name: "client_cert_path", Type: cty.String, Required: false},
+		"client_jwt":                               &hcldec.AttrSpec{Name: "client_jwt", Type: cty.String, Required: false},
+		"object_id":                                &hcldec.AttrSpec{Name: "object_id", Type: cty.String, Required: false},
+		"tenant_id":                                &hcldec.AttrSpec{Name: "tenant_id", Type: cty.String, Required: false},
+		"subscription_id":                          &hcldec.AttrSpec{Name: "subscription_id", Type: cty.String, Required: false},
+		"capture_name_prefix":                      &hcldec.AttrSpec{Name: "capture_name_prefix", Type: cty.String, Required: false},
+		"capture_container_name":                   &hcldec.AttrSpec{Name: "capture_container_name", Type: cty.String, Required: false},
+		"shared_image_gallery":                     &hcldec.BlockSpec{TypeName: "shared_image_gallery", Nested: hcldec.ObjectSpec((*FlatSharedImageGallery)(nil).HCL2Spec())},
+		"shared_image_gallery_destination":         &hcldec.BlockSpec{TypeName: "shared_image_gallery_destination", Nested: hcldec.ObjectSpec((*FlatSharedImageGalleryDestination)(nil).HCL2Spec())},
+		"shared_image_gallery_timeout":             &hcldec.AttrSpec{Name: "shared_image_gallery_timeout", Type: cty.String, Required: false},
+		"image_publisher":                          &hcldec.AttrSpec{Name: "image_publisher", Type: cty.String, Required: false},
+		"image_offer":                              &hcldec.AttrSpec{Name: "image_offer", Type: cty.String, Required: false},
+		"image_sku":                                &hcldec.AttrSpec{Name: "image_sku", Type: cty.String, Required: false},
+		"image_version":                            &hcldec.AttrSpec{Name: "image_version", Type: cty.String, Required: false},
+		"image_url":                                &hcldec.AttrSpec{Name: "image_url", Type: cty.String, Required: false},
+		"custom_managed_image_resource_group_name": &hcldec.AttrSpec{Name: "custom_managed_image_resource_group_name", Type: cty.String, Required: false},
+		"custom_managed_image_name":                &hcldec.AttrSpec{Name: "custom_managed_image_name", Type: cty.String, Required: false},
+		"location":                                 &hcldec.AttrSpec{Name: "location", Type: cty.String, Required: false},
+		"vm_size":                                  &hcldec.AttrSpec{Name: "vm_size", Type: cty.String, Required: false},
+		"managed_image_resource_group_name":        &hcldec.AttrSpec{Name: "managed_image_resource_group_name", Type: cty.String, Required: false},
+		"managed_image_name":                       &hcldec.AttrSpec{Name: "managed_image_name", Type: cty.String, Required: false},
+		"managed_image_storage_account_type":       &hcldec.AttrSpec{Name: "managed_image_storage_account_type", Type: cty.String, Required: false},
+		"managed_image_os_disk_snapshot_name":      &hcldec.AttrSpec{Name: "managed_image_os_disk_snapshot_name", Type: cty.String, Required: false},
+		"managed_image_data_disk_snapshot_prefix":  &hcldec.AttrSpec{Name: "managed_image_data_disk_snapshot_prefix", Type: cty.String, Required: false},
+		"managed_image_zone_resilient":             &hcldec.AttrSpec{Name: "managed_image_zone_resilient", Type: cty.Bool, Required: false},
+		"azure_tags":                               &hcldec.BlockAttrsSpec{TypeName: "azure_tags", ElementType: cty.String, Required: false},
+		"resource_group_name":                      &hcldec.AttrSpec{Name: "resource_group_name", Type: cty.String, Required: false},
+		"storage_account":                          &hcldec.AttrSpec{Name: "storage_account", Type: cty.String, Required: false},
+		"temp_compute_name":                        &hcldec.AttrSpec{Name: "temp_compute_name", Type: cty.String, Required: false},
+		"temp_resource_group_name":                 &hcldec.AttrSpec{Name: "temp_resource_group_name", Type: cty.String, Required: false},
+		"build_resource_group_name":                &hcldec.AttrSpec{Name: "build_resource_group_name", Type: cty.String, Required: false},
+		"private_virtual_network_with_public_ip":   &hcldec.AttrSpec{Name: "private_virtual_network_with_public_ip", Type: cty.Bool, Required: false},
+		"virtual_network_name":                     &hcldec.AttrSpec{Name: "virtual_network_name", Type: cty.String, Required: false},
+		"virtual_network_subnet_name":              &hcldec.AttrSpec{Name: "virtual_network_subnet_name", Type: cty.String, Required: false},
+		"virtual_network_resource_group_name":      &hcldec.AttrSpec{Name: "virtual_network_resource_group_name", Type: cty.String, Required: false},
+		"custom_data_file":                         &hcldec.AttrSpec{Name: "custom_data_file", Type: cty.String, Required: false},
+		"plan_info":                                &hcldec.BlockSpec{TypeName: "plan_info", Nested: hcldec.ObjectSpec((*FlatPlanInformation)(nil).HCL2Spec())},
+		"os_type":                                  &hcldec.AttrSpec{Name: "os_type", Type: cty.String, Required: false},
+		"os_disk_size_gb":                          &hcldec.AttrSpec{Name: "os_disk_size_gb", Type: cty.Number, Required: false},
+		"disk_additional_size":                     &hcldec.AttrSpec{Name: "disk_additional_size", Type: cty.List(cty.Number), Required: false},
+		"disk_caching_type":                        &hcldec.AttrSpec{Name: "disk_caching_type", Type: cty.String, Required: false},
+		"user_name":                                &hcldec.AttrSpec{Name: "user_name", Type: cty.String, Required: false},
+		"password":                                 &hcldec.AttrSpec{Name: "password", Type: cty.String, Required: false},
+		"communicator":                             &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":                  &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                                 &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                                 &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                             &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                             &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":                         &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":                  &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":                &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":                     &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                                  &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                              &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                           &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":             &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":                   &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":                         &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":                         &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":                   &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":                     &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":                     &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":             &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":                 &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                           &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                           &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":                       &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":                       &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":                  &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":                   &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":                       &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":                        &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                           &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                          &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                           &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                           &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                               &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                               &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                            &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                            &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                           &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                           &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"async_resourcegroup_delete":               &hcldec.AttrSpec{Name: "async_resourcegroup_delete", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatPlanInformation is an auto-generated flat version of PlanInformation.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatPlanInformation struct {
+	PlanName          *string `mapstructure:"plan_name" cty:"plan_name"`
+	PlanProduct       *string `mapstructure:"plan_product" cty:"plan_product"`
+	PlanPublisher     *string `mapstructure:"plan_publisher" cty:"plan_publisher"`
+	PlanPromotionCode *string `mapstructure:"plan_promotion_code" cty:"plan_promotion_code"`
+}
+
+// FlatMapstructure returns a new FlatPlanInformation.
+// FlatPlanInformation is an auto-generated flat version of PlanInformation.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*PlanInformation) FlatMapstructure() interface{} { return new(FlatPlanInformation) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatPlanInformation.
+// This spec is used by HCL to read the fields of FlatPlanInformation.
+func (*FlatPlanInformation) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"plan_name":           &hcldec.AttrSpec{Name: "plan_name", Type: cty.String, Required: false},
+		"plan_product":        &hcldec.AttrSpec{Name: "plan_product", Type: cty.String, Required: false},
+		"plan_publisher":      &hcldec.AttrSpec{Name: "plan_publisher", Type: cty.String, Required: false},
+		"plan_promotion_code": &hcldec.AttrSpec{Name: "plan_promotion_code", Type: cty.String, Required: false},
+	}
+	return s
+}
+
+// FlatSharedImageGallery is an auto-generated flat version of SharedImageGallery.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatSharedImageGallery struct {
+	Subscription  *string `mapstructure:"subscription" cty:"subscription"`
+	ResourceGroup *string `mapstructure:"resource_group" cty:"resource_group"`
+	GalleryName   *string `mapstructure:"gallery_name" cty:"gallery_name"`
+	ImageName     *string `mapstructure:"image_name" cty:"image_name"`
+	ImageVersion  *string `mapstructure:"image_version" required:"false" cty:"image_version"`
+}
+
+// FlatMapstructure returns a new FlatSharedImageGallery.
+// FlatSharedImageGallery is an auto-generated flat version of SharedImageGallery.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*SharedImageGallery) FlatMapstructure() interface{} { return new(FlatSharedImageGallery) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatSharedImageGallery.
+// This spec is used by HCL to read the fields of FlatSharedImageGallery.
+func (*FlatSharedImageGallery) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"subscription":   &hcldec.AttrSpec{Name: "subscription", Type: cty.String, Required: false},
+		"resource_group": &hcldec.AttrSpec{Name: "resource_group", Type: cty.String, Required: false},
+		"gallery_name":   &hcldec.AttrSpec{Name: "gallery_name", Type: cty.String, Required: false},
+		"image_name":     &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_version":  &hcldec.AttrSpec{Name: "image_version", Type: cty.String, Required: false},
+	}
+	return s
+}
+
+// FlatSharedImageGalleryDestination is an auto-generated flat version of SharedImageGalleryDestination.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatSharedImageGalleryDestination struct {
+	SigDestinationResourceGroup      *string  `mapstructure:"resource_group" cty:"resource_group"`
+	SigDestinationGalleryName        *string  `mapstructure:"gallery_name" cty:"gallery_name"`
+	SigDestinationImageName          *string  `mapstructure:"image_name" cty:"image_name"`
+	SigDestinationImageVersion       *string  `mapstructure:"image_version" cty:"image_version"`
+	SigDestinationReplicationRegions []string `mapstructure:"replication_regions" cty:"replication_regions"`
+}
+
+// FlatMapstructure returns a new FlatSharedImageGalleryDestination.
+// FlatSharedImageGalleryDestination is an auto-generated flat version of SharedImageGalleryDestination.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*SharedImageGalleryDestination) FlatMapstructure() interface{} {
+	return new(FlatSharedImageGalleryDestination)
+}
+
+// HCL2Spec returns the hcldec.Spec of a FlatSharedImageGalleryDestination.
+// This spec is used by HCL to read the fields of FlatSharedImageGalleryDestination.
+func (*FlatSharedImageGalleryDestination) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"resource_group":      &hcldec.AttrSpec{Name: "resource_group", Type: cty.String, Required: false},
+		"gallery_name":        &hcldec.AttrSpec{Name: "gallery_name", Type: cty.String, Required: false},
+		"image_name":          &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_version":       &hcldec.AttrSpec{Name: "image_version", Type: cty.String, Required: false},
+		"replication_regions": &hcldec.AttrSpec{Name: "replication_regions", Type: cty.List(cty.String), Required: false},
+	}
+	return s
+}
diff --git a/builder/cloudstack/config.go b/builder/cloudstack/config.go
index 57486be4b..2dd430be8 100644
--- a/builder/cloudstack/config.go
+++ b/builder/cloudstack/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package cloudstack
 
diff --git a/builder/cloudstack/config.hcl2spec.go b/builder/cloudstack/config.hcl2spec.go
new file mode 100644
index 000000000..65816cdbb
--- /dev/null
+++ b/builder/cloudstack/config.hcl2spec.go
@@ -0,0 +1,203 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package cloudstack
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	APIURL                    *string           `mapstructure:"api_url" required:"true" cty:"api_url"`
+	APIKey                    *string           `mapstructure:"api_key" required:"true" cty:"api_key"`
+	SecretKey                 *string           `mapstructure:"secret_key" required:"true" cty:"secret_key"`
+	AsyncTimeout              *string           `mapstructure:"async_timeout" required:"false" cty:"async_timeout"`
+	HTTPGetOnly               *bool             `mapstructure:"http_get_only" required:"false" cty:"http_get_only"`
+	SSLNoVerify               *bool             `mapstructure:"ssl_no_verify" required:"false" cty:"ssl_no_verify"`
+	CIDRList                  []string          `mapstructure:"cidr_list" required:"false" cty:"cidr_list"`
+	CreateSecurityGroup       *bool             `mapstructure:"create_security_group" required:"false" cty:"create_security_group"`
+	DiskOffering              *string           `mapstructure:"disk_offering" required:"false" cty:"disk_offering"`
+	DiskSize                  *int64            `mapstructure:"disk_size" required:"false" cty:"disk_size"`
+	EjectISO                  *bool             `mapstructure:"eject_iso" cty:"eject_iso"`
+	EjectISODelay             *string           `mapstructure:"eject_iso_delay" cty:"eject_iso_delay"`
+	Expunge                   *bool             `mapstructure:"expunge" required:"false" cty:"expunge"`
+	Hypervisor                *string           `mapstructure:"hypervisor" required:"false" cty:"hypervisor"`
+	InstanceName              *string           `mapstructure:"instance_name" required:"false" cty:"instance_name"`
+	Network                   *string           `mapstructure:"network" required:"true" cty:"network"`
+	Project                   *string           `mapstructure:"project" required:"false" cty:"project"`
+	PublicIPAddress           *string           `mapstructure:"public_ip_address" required:"false" cty:"public_ip_address"`
+	PublicPort                *int              `mapstructure:"public_port" required:"false" cty:"public_port"`
+	SecurityGroups            []string          `mapstructure:"security_groups" required:"false" cty:"security_groups"`
+	ServiceOffering           *string           `mapstructure:"service_offering" required:"true" cty:"service_offering"`
+	PreventFirewallChanges    *bool             `mapstructure:"prevent_firewall_changes" required:"false" cty:"prevent_firewall_changes"`
+	SourceISO                 *string           `mapstructure:"source_iso" required:"true" cty:"source_iso"`
+	SourceTemplate            *string           `mapstructure:"source_template" required:"true" cty:"source_template"`
+	TemporaryKeypairName      *string           `mapstructure:"temporary_keypair_name" required:"false" cty:"temporary_keypair_name"`
+	UseLocalIPAddress         *bool             `mapstructure:"use_local_ip_address" required:"false" cty:"use_local_ip_address"`
+	UserData                  *string           `mapstructure:"user_data" required:"false" cty:"user_data"`
+	UserDataFile              *string           `mapstructure:"user_data_file" required:"false" cty:"user_data_file"`
+	Zone                      *string           `mapstructure:"zone" required:"true" cty:"zone"`
+	TemplateName              *string           `mapstructure:"template_name" required:"false" cty:"template_name"`
+	TemplateDisplayText       *string           `mapstructure:"template_display_text" required:"false" cty:"template_display_text"`
+	TemplateOS                *string           `mapstructure:"template_os" required:"true" cty:"template_os"`
+	TemplateFeatured          *bool             `mapstructure:"template_featured" required:"false" cty:"template_featured"`
+	TemplatePublic            *bool             `mapstructure:"template_public" required:"false" cty:"template_public"`
+	TemplatePasswordEnabled   *bool             `mapstructure:"template_password_enabled" required:"false" cty:"template_password_enabled"`
+	TemplateRequiresHVM       *bool             `mapstructure:"template_requires_hvm" required:"false" cty:"template_requires_hvm"`
+	TemplateScalable          *bool             `mapstructure:"template_scalable" required:"false" cty:"template_scalable"`
+	TemplateTag               *string           `mapstructure:"template_tag" cty:"template_tag"`
+	Tags                      map[string]string `mapstructure:"tags" cty:"tags"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":               &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"api_url":                      &hcldec.AttrSpec{Name: "api_url", Type: cty.String, Required: false},
+		"api_key":                      &hcldec.AttrSpec{Name: "api_key", Type: cty.String, Required: false},
+		"secret_key":                   &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"async_timeout":                &hcldec.AttrSpec{Name: "async_timeout", Type: cty.String, Required: false},
+		"http_get_only":                &hcldec.AttrSpec{Name: "http_get_only", Type: cty.Bool, Required: false},
+		"ssl_no_verify":                &hcldec.AttrSpec{Name: "ssl_no_verify", Type: cty.Bool, Required: false},
+		"cidr_list":                    &hcldec.AttrSpec{Name: "cidr_list", Type: cty.List(cty.String), Required: false},
+		"create_security_group":        &hcldec.AttrSpec{Name: "create_security_group", Type: cty.Bool, Required: false},
+		"disk_offering":                &hcldec.AttrSpec{Name: "disk_offering", Type: cty.String, Required: false},
+		"disk_size":                    &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"eject_iso":                    &hcldec.AttrSpec{Name: "eject_iso", Type: cty.Bool, Required: false},
+		"eject_iso_delay":              &hcldec.AttrSpec{Name: "eject_iso_delay", Type: cty.String, Required: false},
+		"expunge":                      &hcldec.AttrSpec{Name: "expunge", Type: cty.Bool, Required: false},
+		"hypervisor":                   &hcldec.AttrSpec{Name: "hypervisor", Type: cty.String, Required: false},
+		"instance_name":                &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"network":                      &hcldec.AttrSpec{Name: "network", Type: cty.String, Required: false},
+		"project":                      &hcldec.AttrSpec{Name: "project", Type: cty.String, Required: false},
+		"public_ip_address":            &hcldec.AttrSpec{Name: "public_ip_address", Type: cty.String, Required: false},
+		"public_port":                  &hcldec.AttrSpec{Name: "public_port", Type: cty.Number, Required: false},
+		"security_groups":              &hcldec.AttrSpec{Name: "security_groups", Type: cty.List(cty.String), Required: false},
+		"service_offering":             &hcldec.AttrSpec{Name: "service_offering", Type: cty.String, Required: false},
+		"prevent_firewall_changes":     &hcldec.AttrSpec{Name: "prevent_firewall_changes", Type: cty.Bool, Required: false},
+		"source_iso":                   &hcldec.AttrSpec{Name: "source_iso", Type: cty.String, Required: false},
+		"source_template":              &hcldec.AttrSpec{Name: "source_template", Type: cty.String, Required: false},
+		"temporary_keypair_name":       &hcldec.AttrSpec{Name: "temporary_keypair_name", Type: cty.String, Required: false},
+		"use_local_ip_address":         &hcldec.AttrSpec{Name: "use_local_ip_address", Type: cty.Bool, Required: false},
+		"user_data":                    &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":               &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"zone":                         &hcldec.AttrSpec{Name: "zone", Type: cty.String, Required: false},
+		"template_name":                &hcldec.AttrSpec{Name: "template_name", Type: cty.String, Required: false},
+		"template_display_text":        &hcldec.AttrSpec{Name: "template_display_text", Type: cty.String, Required: false},
+		"template_os":                  &hcldec.AttrSpec{Name: "template_os", Type: cty.String, Required: false},
+		"template_featured":            &hcldec.AttrSpec{Name: "template_featured", Type: cty.Bool, Required: false},
+		"template_public":              &hcldec.AttrSpec{Name: "template_public", Type: cty.Bool, Required: false},
+		"template_password_enabled":    &hcldec.AttrSpec{Name: "template_password_enabled", Type: cty.Bool, Required: false},
+		"template_requires_hvm":        &hcldec.AttrSpec{Name: "template_requires_hvm", Type: cty.Bool, Required: false},
+		"template_scalable":            &hcldec.AttrSpec{Name: "template_scalable", Type: cty.Bool, Required: false},
+		"template_tag":                 &hcldec.AttrSpec{Name: "template_tag", Type: cty.String, Required: false},
+		"tags":                         &hcldec.BlockAttrsSpec{TypeName: "tags", ElementType: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/digitalocean/config.go b/builder/digitalocean/config.go
index 5d0a2b9b7..eef4e5e13 100644
--- a/builder/digitalocean/config.go
+++ b/builder/digitalocean/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package digitalocean
 
diff --git a/builder/digitalocean/config.hcl2spec.go b/builder/digitalocean/config.hcl2spec.go
new file mode 100644
index 000000000..f39cc404d
--- /dev/null
+++ b/builder/digitalocean/config.hcl2spec.go
@@ -0,0 +1,151 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package digitalocean
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	APIToken                  *string           `mapstructure:"api_token" required:"true" cty:"api_token"`
+	APIURL                    *string           `mapstructure:"api_url" required:"false" cty:"api_url"`
+	Region                    *string           `mapstructure:"region" required:"true" cty:"region"`
+	Size                      *string           `mapstructure:"size" required:"true" cty:"size"`
+	Image                     *string           `mapstructure:"image" required:"true" cty:"image"`
+	PrivateNetworking         *bool             `mapstructure:"private_networking" required:"false" cty:"private_networking"`
+	Monitoring                *bool             `mapstructure:"monitoring" required:"false" cty:"monitoring"`
+	IPv6                      *bool             `mapstructure:"ipv6" required:"false" cty:"ipv6"`
+	SnapshotName              *string           `mapstructure:"snapshot_name" required:"false" cty:"snapshot_name"`
+	SnapshotRegions           []string          `mapstructure:"snapshot_regions" required:"false" cty:"snapshot_regions"`
+	StateTimeout              *string           `mapstructure:"state_timeout" required:"false" cty:"state_timeout"`
+	SnapshotTimeout           *string           `mapstructure:"snapshot_timeout" required:"false" cty:"snapshot_timeout"`
+	DropletName               *string           `mapstructure:"droplet_name" required:"false" cty:"droplet_name"`
+	UserData                  *string           `mapstructure:"user_data" required:"false" cty:"user_data"`
+	UserDataFile              *string           `mapstructure:"user_data_file" required:"false" cty:"user_data_file"`
+	Tags                      []string          `mapstructure:"tags" required:"false" cty:"tags"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"api_token":                    &hcldec.AttrSpec{Name: "api_token", Type: cty.String, Required: false},
+		"api_url":                      &hcldec.AttrSpec{Name: "api_url", Type: cty.String, Required: false},
+		"region":                       &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"size":                         &hcldec.AttrSpec{Name: "size", Type: cty.String, Required: false},
+		"image":                        &hcldec.AttrSpec{Name: "image", Type: cty.String, Required: false},
+		"private_networking":           &hcldec.AttrSpec{Name: "private_networking", Type: cty.Bool, Required: false},
+		"monitoring":                   &hcldec.AttrSpec{Name: "monitoring", Type: cty.Bool, Required: false},
+		"ipv6":                         &hcldec.AttrSpec{Name: "ipv6", Type: cty.Bool, Required: false},
+		"snapshot_name":                &hcldec.AttrSpec{Name: "snapshot_name", Type: cty.String, Required: false},
+		"snapshot_regions":             &hcldec.AttrSpec{Name: "snapshot_regions", Type: cty.List(cty.String), Required: false},
+		"state_timeout":                &hcldec.AttrSpec{Name: "state_timeout", Type: cty.String, Required: false},
+		"snapshot_timeout":             &hcldec.AttrSpec{Name: "snapshot_timeout", Type: cty.String, Required: false},
+		"droplet_name":                 &hcldec.AttrSpec{Name: "droplet_name", Type: cty.String, Required: false},
+		"user_data":                    &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":               &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"tags":                         &hcldec.AttrSpec{Name: "tags", Type: cty.List(cty.String), Required: false},
+	}
+	return s
+}
diff --git a/builder/docker/config.go b/builder/docker/config.go
index 297807b99..f67b48974 100644
--- a/builder/docker/config.go
+++ b/builder/docker/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package docker
 
diff --git a/builder/docker/config.hcl2spec.go b/builder/docker/config.hcl2spec.go
new file mode 100644
index 000000000..fe278055e
--- /dev/null
+++ b/builder/docker/config.hcl2spec.go
@@ -0,0 +1,169 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package docker
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	Author                    *string           `mapstructure:"author" cty:"author"`
+	Changes                   []string          `mapstructure:"changes" cty:"changes"`
+	Commit                    *bool             `mapstructure:"commit" required:"true" cty:"commit"`
+	ContainerDir              *string           `mapstructure:"container_dir" required:"false" cty:"container_dir"`
+	Discard                   *bool             `mapstructure:"discard" required:"true" cty:"discard"`
+	ExecUser                  *string           `mapstructure:"exec_user" required:"false" cty:"exec_user"`
+	ExportPath                *string           `mapstructure:"export_path" required:"true" cty:"export_path"`
+	Image                     *string           `mapstructure:"image" required:"true" cty:"image"`
+	Message                   *string           `mapstructure:"message" required:"true" cty:"message"`
+	Privileged                *bool             `mapstructure:"privileged" required:"false" cty:"privileged"`
+	Pty                       *bool             `cty:"pty"`
+	Pull                      *bool             `mapstructure:"pull" required:"false" cty:"pull"`
+	RunCommand                []string          `mapstructure:"run_command" required:"false" cty:"run_command"`
+	Volumes                   map[string]string `mapstructure:"volumes" required:"false" cty:"volumes"`
+	FixUploadOwner            *bool             `mapstructure:"fix_upload_owner" required:"false" cty:"fix_upload_owner"`
+	WindowsContainer          *bool             `mapstructure:"windows_container" required:"false" cty:"windows_container"`
+	Login                     *bool             `mapstructure:"login" required:"false" cty:"login"`
+	LoginPassword             *string           `mapstructure:"login_password" required:"false" cty:"login_password"`
+	LoginServer               *string           `mapstructure:"login_server" required:"false" cty:"login_server"`
+	LoginUsername             *string           `mapstructure:"login_username" required:"false" cty:"login_username"`
+	EcrLogin                  *bool             `mapstructure:"ecr_login" required:"false" cty:"ecr_login"`
+	AccessKey                 *string           `mapstructure:"aws_access_key" required:"false" cty:"aws_access_key"`
+	SecretKey                 *string           `mapstructure:"aws_secret_key" required:"false" cty:"aws_secret_key"`
+	Token                     *string           `mapstructure:"aws_token" required:"false" cty:"aws_token"`
+	Profile                   *string           `mapstructure:"aws_profile" required:"false" cty:"aws_profile"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"author":                       &hcldec.AttrSpec{Name: "author", Type: cty.String, Required: false},
+		"changes":                      &hcldec.AttrSpec{Name: "changes", Type: cty.List(cty.String), Required: false},
+		"commit":                       &hcldec.AttrSpec{Name: "commit", Type: cty.Bool, Required: false},
+		"container_dir":                &hcldec.AttrSpec{Name: "container_dir", Type: cty.String, Required: false},
+		"discard":                      &hcldec.AttrSpec{Name: "discard", Type: cty.Bool, Required: false},
+		"exec_user":                    &hcldec.AttrSpec{Name: "exec_user", Type: cty.String, Required: false},
+		"export_path":                  &hcldec.AttrSpec{Name: "export_path", Type: cty.String, Required: false},
+		"image":                        &hcldec.AttrSpec{Name: "image", Type: cty.String, Required: false},
+		"message":                      &hcldec.AttrSpec{Name: "message", Type: cty.String, Required: false},
+		"privileged":                   &hcldec.AttrSpec{Name: "privileged", Type: cty.Bool, Required: false},
+		"pty":                          &hcldec.AttrSpec{Name: "pty", Type: cty.Bool, Required: false},
+		"pull":                         &hcldec.AttrSpec{Name: "pull", Type: cty.Bool, Required: false},
+		"run_command":                  &hcldec.AttrSpec{Name: "run_command", Type: cty.List(cty.String), Required: false},
+		"volumes":                      &hcldec.BlockAttrsSpec{TypeName: "volumes", ElementType: cty.String, Required: false},
+		"fix_upload_owner":             &hcldec.AttrSpec{Name: "fix_upload_owner", Type: cty.Bool, Required: false},
+		"windows_container":            &hcldec.AttrSpec{Name: "windows_container", Type: cty.Bool, Required: false},
+		"login":                        &hcldec.AttrSpec{Name: "login", Type: cty.Bool, Required: false},
+		"login_password":               &hcldec.AttrSpec{Name: "login_password", Type: cty.String, Required: false},
+		"login_server":                 &hcldec.AttrSpec{Name: "login_server", Type: cty.String, Required: false},
+		"login_username":               &hcldec.AttrSpec{Name: "login_username", Type: cty.String, Required: false},
+		"ecr_login":                    &hcldec.AttrSpec{Name: "ecr_login", Type: cty.Bool, Required: false},
+		"aws_access_key":               &hcldec.AttrSpec{Name: "aws_access_key", Type: cty.String, Required: false},
+		"aws_secret_key":               &hcldec.AttrSpec{Name: "aws_secret_key", Type: cty.String, Required: false},
+		"aws_token":                    &hcldec.AttrSpec{Name: "aws_token", Type: cty.String, Required: false},
+		"aws_profile":                  &hcldec.AttrSpec{Name: "aws_profile", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/file/config.go b/builder/file/config.go
index 7fc6ebc22..fea112684 100644
--- a/builder/file/config.go
+++ b/builder/file/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package file
 
 import (
diff --git a/builder/file/config.hcl2spec.go b/builder/file/config.hcl2spec.go
new file mode 100644
index 000000000..f47193d7d
--- /dev/null
+++ b/builder/file/config.hcl2spec.go
@@ -0,0 +1,45 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package file
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Source              *string           `mapstructure:"source" cty:"source"`
+	Target              *string           `mapstructure:"target" cty:"target"`
+	Content             *string           `mapstructure:"content" cty:"content"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"source":                     &hcldec.AttrSpec{Name: "source", Type: cty.String, Required: false},
+		"target":                     &hcldec.AttrSpec{Name: "target", Type: cty.String, Required: false},
+		"content":                    &hcldec.AttrSpec{Name: "content", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/googlecompute/config.go b/builder/googlecompute/config.go
index eba106f22..bb7cd21b1 100644
--- a/builder/googlecompute/config.go
+++ b/builder/googlecompute/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config,CustomerEncryptionKey
 
 package googlecompute
 
diff --git a/builder/googlecompute/config.hcl2spec.go b/builder/googlecompute/config.hcl2spec.go
new file mode 100644
index 000000000..3f2e62d09
--- /dev/null
+++ b/builder/googlecompute/config.hcl2spec.go
@@ -0,0 +1,219 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,CustomerEncryptionKey"; DO NOT EDIT.
+package googlecompute
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName              *string                    `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType            *string                    `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                  *bool                      `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                  *bool                      `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError                *string                    `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars               map[string]string          `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars          []string                   `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                         *string                    `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect           *string                    `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                      *string                    `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                      *int                       `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                  *string                    `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                  *string                    `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName               *string                    `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName      *string                    `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys       *bool                      `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile            *string                    `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                       *bool                      `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                   *string                    `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                 *bool                      `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding    *bool                      `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts         *int                       `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost               *string                    `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort               *int                       `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth          *bool                      `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername           *string                    `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword           *string                    `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile     *string                    `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod        *string                    `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                 *string                    `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                 *int                       `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername             *string                    `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword             *string                    `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval         *string                    `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout          *string                    `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels             []string                   `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels              []string                   `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                 []byte                     `cty:"ssh_public_key"`
+	SSHPrivateKey                []byte                     `cty:"ssh_private_key"`
+	WinRMUser                    *string                    `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword                *string                    `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                    *string                    `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                    *int                       `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                 *string                    `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                  *bool                      `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure                *bool                      `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                 *bool                      `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	AccountFile                  *string                    `mapstructure:"account_file" required:"false" cty:"account_file"`
+	ProjectId                    *string                    `mapstructure:"project_id" required:"true" cty:"project_id"`
+	AcceleratorType              *string                    `mapstructure:"accelerator_type" required:"false" cty:"accelerator_type"`
+	AcceleratorCount             *int64                     `mapstructure:"accelerator_count" required:"false" cty:"accelerator_count"`
+	Address                      *string                    `mapstructure:"address" required:"false" cty:"address"`
+	DisableDefaultServiceAccount *bool                      `mapstructure:"disable_default_service_account" required:"false" cty:"disable_default_service_account"`
+	DiskName                     *string                    `mapstructure:"disk_name" required:"false" cty:"disk_name"`
+	DiskSizeGb                   *int64                     `mapstructure:"disk_size" required:"false" cty:"disk_size"`
+	DiskType                     *string                    `mapstructure:"disk_type" required:"false" cty:"disk_type"`
+	ImageName                    *string                    `mapstructure:"image_name" required:"false" cty:"image_name"`
+	ImageDescription             *string                    `mapstructure:"image_description" required:"false" cty:"image_description"`
+	ImageEncryptionKey           *FlatCustomerEncryptionKey `mapstructure:"image_encryption_key" required:"false" cty:"image_encryption_key"`
+	ImageFamily                  *string                    `mapstructure:"image_family" required:"false" cty:"image_family"`
+	ImageLabels                  map[string]string          `mapstructure:"image_labels" required:"false" cty:"image_labels"`
+	ImageLicenses                []string                   `mapstructure:"image_licenses" required:"false" cty:"image_licenses"`
+	InstanceName                 *string                    `mapstructure:"instance_name" required:"false" cty:"instance_name"`
+	Labels                       map[string]string          `mapstructure:"labels" required:"false" cty:"labels"`
+	MachineType                  *string                    `mapstructure:"machine_type" required:"false" cty:"machine_type"`
+	Metadata                     map[string]string          `mapstructure:"metadata" required:"false" cty:"metadata"`
+	MetadataFiles                map[string]string          `mapstructure:"metadata_files" cty:"metadata_files"`
+	MinCpuPlatform               *string                    `mapstructure:"min_cpu_platform" required:"false" cty:"min_cpu_platform"`
+	Network                      *string                    `mapstructure:"network" required:"false" cty:"network"`
+	NetworkProjectId             *string                    `mapstructure:"network_project_id" required:"false" cty:"network_project_id"`
+	OmitExternalIP               *bool                      `mapstructure:"omit_external_ip" required:"false" cty:"omit_external_ip"`
+	OnHostMaintenance            *string                    `mapstructure:"on_host_maintenance" required:"false" cty:"on_host_maintenance"`
+	Preemptible                  *bool                      `mapstructure:"preemptible" required:"false" cty:"preemptible"`
+	RawStateTimeout              *string                    `mapstructure:"state_timeout" required:"false" cty:"state_timeout"`
+	Region                       *string                    `mapstructure:"region" required:"false" cty:"region"`
+	Scopes                       []string                   `mapstructure:"scopes" required:"false" cty:"scopes"`
+	ServiceAccountEmail          *string                    `mapstructure:"service_account_email" required:"false" cty:"service_account_email"`
+	SourceImage                  *string                    `mapstructure:"source_image" required:"true" cty:"source_image"`
+	SourceImageFamily            *string                    `mapstructure:"source_image_family" required:"true" cty:"source_image_family"`
+	SourceImageProjectId         *string                    `mapstructure:"source_image_project_id" required:"false" cty:"source_image_project_id"`
+	StartupScriptFile            *string                    `mapstructure:"startup_script_file" required:"false" cty:"startup_script_file"`
+	Subnetwork                   *string                    `mapstructure:"subnetwork" required:"false" cty:"subnetwork"`
+	Tags                         []string                   `mapstructure:"tags" required:"false" cty:"tags"`
+	UseInternalIP                *bool                      `mapstructure:"use_internal_ip" required:"false" cty:"use_internal_ip"`
+	VaultGCPOauthEngine          *string                    `mapstructure:"vault_gcp_oauth_engine" cty:"vault_gcp_oauth_engine"`
+	Zone                         *string                    `mapstructure:"zone" required:"true" cty:"zone"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":               &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":             &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                    &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                    &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                 &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":           &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":      &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                    &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":         &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                        &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                        &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                    &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                    &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":                &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":         &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":       &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":            &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                         &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                     &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                  &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":    &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":          &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":                &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":                &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":          &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":            &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":            &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":    &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":        &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                  &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                  &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":              &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":              &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":         &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":          &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":              &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":               &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                  &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                 &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                  &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                  &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                      &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                      &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                   &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                   &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                  &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                  &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"account_file":                    &hcldec.AttrSpec{Name: "account_file", Type: cty.String, Required: false},
+		"project_id":                      &hcldec.AttrSpec{Name: "project_id", Type: cty.String, Required: false},
+		"accelerator_type":                &hcldec.AttrSpec{Name: "accelerator_type", Type: cty.String, Required: false},
+		"accelerator_count":               &hcldec.AttrSpec{Name: "accelerator_count", Type: cty.Number, Required: false},
+		"address":                         &hcldec.AttrSpec{Name: "address", Type: cty.String, Required: false},
+		"disable_default_service_account": &hcldec.AttrSpec{Name: "disable_default_service_account", Type: cty.Bool, Required: false},
+		"disk_name":                       &hcldec.AttrSpec{Name: "disk_name", Type: cty.String, Required: false},
+		"disk_size":                       &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"disk_type":                       &hcldec.AttrSpec{Name: "disk_type", Type: cty.String, Required: false},
+		"image_name":                      &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_description":               &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"image_encryption_key":            &hcldec.BlockSpec{TypeName: "image_encryption_key", Nested: hcldec.ObjectSpec((*FlatCustomerEncryptionKey)(nil).HCL2Spec())},
+		"image_family":                    &hcldec.AttrSpec{Name: "image_family", Type: cty.String, Required: false},
+		"image_labels":                    &hcldec.BlockAttrsSpec{TypeName: "image_labels", ElementType: cty.String, Required: false},
+		"image_licenses":                  &hcldec.AttrSpec{Name: "image_licenses", Type: cty.List(cty.String), Required: false},
+		"instance_name":                   &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"labels":                          &hcldec.BlockAttrsSpec{TypeName: "labels", ElementType: cty.String, Required: false},
+		"machine_type":                    &hcldec.AttrSpec{Name: "machine_type", Type: cty.String, Required: false},
+		"metadata":                        &hcldec.BlockAttrsSpec{TypeName: "metadata", ElementType: cty.String, Required: false},
+		"metadata_files":                  &hcldec.BlockAttrsSpec{TypeName: "metadata_files", ElementType: cty.String, Required: false},
+		"min_cpu_platform":                &hcldec.AttrSpec{Name: "min_cpu_platform", Type: cty.String, Required: false},
+		"network":                         &hcldec.AttrSpec{Name: "network", Type: cty.String, Required: false},
+		"network_project_id":              &hcldec.AttrSpec{Name: "network_project_id", Type: cty.String, Required: false},
+		"omit_external_ip":                &hcldec.AttrSpec{Name: "omit_external_ip", Type: cty.Bool, Required: false},
+		"on_host_maintenance":             &hcldec.AttrSpec{Name: "on_host_maintenance", Type: cty.String, Required: false},
+		"preemptible":                     &hcldec.AttrSpec{Name: "preemptible", Type: cty.Bool, Required: false},
+		"state_timeout":                   &hcldec.AttrSpec{Name: "state_timeout", Type: cty.String, Required: false},
+		"region":                          &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"scopes":                          &hcldec.AttrSpec{Name: "scopes", Type: cty.List(cty.String), Required: false},
+		"service_account_email":           &hcldec.AttrSpec{Name: "service_account_email", Type: cty.String, Required: false},
+		"source_image":                    &hcldec.AttrSpec{Name: "source_image", Type: cty.String, Required: false},
+		"source_image_family":             &hcldec.AttrSpec{Name: "source_image_family", Type: cty.String, Required: false},
+		"source_image_project_id":         &hcldec.AttrSpec{Name: "source_image_project_id", Type: cty.String, Required: false},
+		"startup_script_file":             &hcldec.AttrSpec{Name: "startup_script_file", Type: cty.String, Required: false},
+		"subnetwork":                      &hcldec.AttrSpec{Name: "subnetwork", Type: cty.String, Required: false},
+		"tags":                            &hcldec.AttrSpec{Name: "tags", Type: cty.List(cty.String), Required: false},
+		"use_internal_ip":                 &hcldec.AttrSpec{Name: "use_internal_ip", Type: cty.Bool, Required: false},
+		"vault_gcp_oauth_engine":          &hcldec.AttrSpec{Name: "vault_gcp_oauth_engine", Type: cty.String, Required: false},
+		"zone":                            &hcldec.AttrSpec{Name: "zone", Type: cty.String, Required: false},
+	}
+	return s
+}
+
+// FlatCustomerEncryptionKey is an auto-generated flat version of CustomerEncryptionKey.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatCustomerEncryptionKey struct {
+	KmsKeyName *string `json:"kmsKeyName,omitempty" cty:"kms_key_name"`
+	RawKey     *string `json:"rawKey,omitempty" cty:"raw_key"`
+}
+
+// FlatMapstructure returns a new FlatCustomerEncryptionKey.
+// FlatCustomerEncryptionKey is an auto-generated flat version of CustomerEncryptionKey.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*CustomerEncryptionKey) FlatMapstructure() interface{} { return new(FlatCustomerEncryptionKey) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatCustomerEncryptionKey.
+// This spec is used by HCL to read the fields of FlatCustomerEncryptionKey.
+func (*FlatCustomerEncryptionKey) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"kms_key_name": &hcldec.AttrSpec{Name: "kms_key_name", Type: cty.String, Required: false},
+		"raw_key":      &hcldec.AttrSpec{Name: "raw_key", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/hcloud/config.go b/builder/hcloud/config.go
index 3a7d49fb5..73687ba5e 100644
--- a/builder/hcloud/config.go
+++ b/builder/hcloud/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config,imageFilter
+
 package hcloud
 
 import (
diff --git a/builder/hcloud/config.hcl2spec.go b/builder/hcloud/config.hcl2spec.go
new file mode 100644
index 000000000..36ea266ff
--- /dev/null
+++ b/builder/hcloud/config.hcl2spec.go
@@ -0,0 +1,169 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,imageFilter"; DO NOT EDIT.
+package hcloud
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	HCloudToken               *string           `mapstructure:"token" cty:"token"`
+	Endpoint                  *string           `mapstructure:"endpoint" cty:"endpoint"`
+	PollInterval              *string           `mapstructure:"poll_interval" cty:"poll_interval"`
+	ServerName                *string           `mapstructure:"server_name" cty:"server_name"`
+	Location                  *string           `mapstructure:"location" cty:"location"`
+	ServerType                *string           `mapstructure:"server_type" cty:"server_type"`
+	Image                     *string           `mapstructure:"image" cty:"image"`
+	ImageFilter               *FlatimageFilter  `mapstructure:"image_filter" cty:"image_filter"`
+	SnapshotName              *string           `mapstructure:"snapshot_name" cty:"snapshot_name"`
+	SnapshotLabels            map[string]string `mapstructure:"snapshot_labels" cty:"snapshot_labels"`
+	UserData                  *string           `mapstructure:"user_data" cty:"user_data"`
+	UserDataFile              *string           `mapstructure:"user_data_file" cty:"user_data_file"`
+	SSHKeys                   []string          `mapstructure:"ssh_keys" cty:"ssh_keys"`
+	RescueMode                *string           `mapstructure:"rescue" cty:"rescue"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"token":                        &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"endpoint":                     &hcldec.AttrSpec{Name: "endpoint", Type: cty.String, Required: false},
+		"poll_interval":                &hcldec.AttrSpec{Name: "poll_interval", Type: cty.String, Required: false},
+		"server_name":                  &hcldec.AttrSpec{Name: "server_name", Type: cty.String, Required: false},
+		"location":                     &hcldec.AttrSpec{Name: "location", Type: cty.String, Required: false},
+		"server_type":                  &hcldec.AttrSpec{Name: "server_type", Type: cty.String, Required: false},
+		"image":                        &hcldec.AttrSpec{Name: "image", Type: cty.String, Required: false},
+		"image_filter":                 &hcldec.BlockSpec{TypeName: "image_filter", Nested: hcldec.ObjectSpec((*FlatimageFilter)(nil).HCL2Spec())},
+		"snapshot_name":                &hcldec.AttrSpec{Name: "snapshot_name", Type: cty.String, Required: false},
+		"snapshot_labels":              &hcldec.BlockAttrsSpec{TypeName: "snapshot_labels", ElementType: cty.String, Required: false},
+		"user_data":                    &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":               &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"ssh_keys":                     &hcldec.AttrSpec{Name: "ssh_keys", Type: cty.List(cty.String), Required: false},
+		"rescue":                       &hcldec.AttrSpec{Name: "rescue", Type: cty.String, Required: false},
+	}
+	return s
+}
+
+// FlatimageFilter is an auto-generated flat version of imageFilter.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatimageFilter struct {
+	WithSelector []string `mapstructure:"with_selector" cty:"with_selector"`
+	MostRecent   *bool    `mapstructure:"most_recent" cty:"most_recent"`
+}
+
+// FlatMapstructure returns a new FlatimageFilter.
+// FlatimageFilter is an auto-generated flat version of imageFilter.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*imageFilter) FlatMapstructure() interface{} { return new(FlatimageFilter) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatimageFilter.
+// This spec is used by HCL to read the fields of FlatimageFilter.
+func (*FlatimageFilter) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"with_selector": &hcldec.AttrSpec{Name: "with_selector", Type: cty.List(cty.String), Required: false},
+		"most_recent":   &hcldec.AttrSpec{Name: "most_recent", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/hyperone/config.go b/builder/hyperone/config.go
index 4dfa9d573..f9173f7ce 100644
--- a/builder/hyperone/config.go
+++ b/builder/hyperone/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package hyperone
 
diff --git a/builder/hyperone/config.hcl2spec.go b/builder/hyperone/config.hcl2spec.go
new file mode 100644
index 000000000..04daf5778
--- /dev/null
+++ b/builder/hyperone/config.hcl2spec.go
@@ -0,0 +1,185 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package hyperone
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string                `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string                `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool                  `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool                  `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string                `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string      `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string               `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string                `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string                `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string                `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int                   `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string                `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string                `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string                `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string                `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string                `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool                  `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string                `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool                  `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool                  `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int                   `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string                `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int                   `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool                  `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string                `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string                `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string                `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string                `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string                `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int                   `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string                `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string                `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string                `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string                `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string               `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string               `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte                 `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte                 `cty:"ssh_private_key"`
+	WinRMUser                 *string                `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string                `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string                `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int                   `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string                `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool                  `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool                  `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool                  `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	APIURL                    *string                `mapstructure:"api_url" required:"false" cty:"api_url"`
+	Token                     *string                `mapstructure:"token" required:"true" cty:"token"`
+	Project                   *string                `mapstructure:"project" required:"true" cty:"project"`
+	TokenLogin                *string                `mapstructure:"token_login" required:"false" cty:"token_login"`
+	StateTimeout              *string                `mapstructure:"state_timeout" required:"false" cty:"state_timeout"`
+	SourceImage               *string                `mapstructure:"source_image" required:"true" cty:"source_image"`
+	ImageName                 *string                `mapstructure:"image_name" required:"false" cty:"image_name"`
+	ImageDescription          *string                `mapstructure:"image_description" required:"false" cty:"image_description"`
+	ImageTags                 map[string]interface{} `mapstructure:"image_tags" required:"false" cty:"image_tags"`
+	ImageService              *string                `mapstructure:"image_service" required:"false" cty:"image_service"`
+	VmType                    *string                `mapstructure:"vm_type" required:"true" cty:"vm_type"`
+	VmName                    *string                `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+	VmTags                    map[string]interface{} `mapstructure:"vm_tags" required:"false" cty:"vm_tags"`
+	DiskName                  *string                `mapstructure:"disk_name" required:"false" cty:"disk_name"`
+	DiskType                  *string                `mapstructure:"disk_type" required:"false" cty:"disk_type"`
+	DiskSize                  *float32               `mapstructure:"disk_size" required:"true" cty:"disk_size"`
+	Network                   *string                `mapstructure:"network" required:"false" cty:"network"`
+	PrivateIP                 *string                `mapstructure:"private_ip" required:"false" cty:"private_ip"`
+	PublicIP                  *string                `mapstructure:"public_ip" required:"false" cty:"public_ip"`
+	PublicNetAdpService       *string                `mapstructure:"public_netadp_service" required:"false" cty:"public_netadp_service"`
+	ChrootDisk                *bool                  `mapstructure:"chroot_disk" cty:"chroot_disk"`
+	ChrootDiskSize            *float32               `mapstructure:"chroot_disk_size" cty:"chroot_disk_size"`
+	ChrootDiskType            *string                `mapstructure:"chroot_disk_type" cty:"chroot_disk_type"`
+	ChrootMountPath           *string                `mapstructure:"chroot_mount_path" cty:"chroot_mount_path"`
+	ChrootMounts              [][]string             `mapstructure:"chroot_mounts" cty:"chroot_mounts"`
+	ChrootCopyFiles           []string               `mapstructure:"chroot_copy_files" cty:"chroot_copy_files"`
+	ChrootCommandWrapper      *string                `mapstructure:"chroot_command_wrapper" cty:"chroot_command_wrapper"`
+	MountOptions              []string               `mapstructure:"mount_options" cty:"mount_options"`
+	MountPartition            *string                `mapstructure:"mount_partition" cty:"mount_partition"`
+	PreMountCommands          []string               `mapstructure:"pre_mount_commands" cty:"pre_mount_commands"`
+	PostMountCommands         []string               `mapstructure:"post_mount_commands" cty:"post_mount_commands"`
+	SSHKeys                   []string               `mapstructure:"ssh_keys" required:"false" cty:"ssh_keys"`
+	UserData                  *string                `mapstructure:"user_data" required:"false" cty:"user_data"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"api_url":                      &hcldec.AttrSpec{Name: "api_url", Type: cty.String, Required: false},
+		"token":                        &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"project":                      &hcldec.AttrSpec{Name: "project", Type: cty.String, Required: false},
+		"token_login":                  &hcldec.AttrSpec{Name: "token_login", Type: cty.String, Required: false},
+		"state_timeout":                &hcldec.AttrSpec{Name: "state_timeout", Type: cty.String, Required: false},
+		"source_image":                 &hcldec.AttrSpec{Name: "source_image", Type: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_description":            &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"image_tags":                   &hcldec.BlockAttrsSpec{TypeName: "image_tags", ElementType: cty.String, Required: false},
+		"image_service":                &hcldec.AttrSpec{Name: "image_service", Type: cty.String, Required: false},
+		"vm_type":                      &hcldec.AttrSpec{Name: "vm_type", Type: cty.String, Required: false},
+		"vm_name":                      &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"vm_tags":                      &hcldec.BlockAttrsSpec{TypeName: "vm_tags", ElementType: cty.String, Required: false},
+		"disk_name":                    &hcldec.AttrSpec{Name: "disk_name", Type: cty.String, Required: false},
+		"disk_type":                    &hcldec.AttrSpec{Name: "disk_type", Type: cty.String, Required: false},
+		"disk_size":                    &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"network":                      &hcldec.AttrSpec{Name: "network", Type: cty.String, Required: false},
+		"private_ip":                   &hcldec.AttrSpec{Name: "private_ip", Type: cty.String, Required: false},
+		"public_ip":                    &hcldec.AttrSpec{Name: "public_ip", Type: cty.String, Required: false},
+		"public_netadp_service":        &hcldec.AttrSpec{Name: "public_netadp_service", Type: cty.String, Required: false},
+		"chroot_disk":                  &hcldec.AttrSpec{Name: "chroot_disk", Type: cty.Bool, Required: false},
+		"chroot_disk_size":             &hcldec.AttrSpec{Name: "chroot_disk_size", Type: cty.Number, Required: false},
+		"chroot_disk_type":             &hcldec.AttrSpec{Name: "chroot_disk_type", Type: cty.String, Required: false},
+		"chroot_mount_path":            &hcldec.AttrSpec{Name: "chroot_mount_path", Type: cty.String, Required: false},
+		"chroot_mounts":                &hcldec.BlockListSpec{TypeName: "chroot_mounts", Nested: &hcldec.AttrSpec{Name: "chroot_mounts", Type: cty.List(cty.String), Required: false}},
+		"chroot_copy_files":            &hcldec.AttrSpec{Name: "chroot_copy_files", Type: cty.List(cty.String), Required: false},
+		"chroot_command_wrapper":       &hcldec.AttrSpec{Name: "chroot_command_wrapper", Type: cty.String, Required: false},
+		"mount_options":                &hcldec.AttrSpec{Name: "mount_options", Type: cty.List(cty.String), Required: false},
+		"mount_partition":              &hcldec.AttrSpec{Name: "mount_partition", Type: cty.String, Required: false},
+		"pre_mount_commands":           &hcldec.AttrSpec{Name: "pre_mount_commands", Type: cty.List(cty.String), Required: false},
+		"post_mount_commands":          &hcldec.AttrSpec{Name: "post_mount_commands", Type: cty.List(cty.String), Required: false},
+		"ssh_keys":                     &hcldec.AttrSpec{Name: "ssh_keys", Type: cty.List(cty.String), Required: false},
+		"user_data":                    &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/hyperv/common/output_config.go b/builder/hyperv/common/output_config.go
index fbf9cd7ac..3a1538312 100644
--- a/builder/hyperv/common/output_config.go
+++ b/builder/hyperv/common/output_config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type OutputConfig
 
 package common
 
diff --git a/builder/hyperv/common/output_config.hcl2spec.go b/builder/hyperv/common/output_config.hcl2spec.go
new file mode 100644
index 000000000..c3794c70d
--- /dev/null
+++ b/builder/hyperv/common/output_config.hcl2spec.go
@@ -0,0 +1,27 @@
+// Code generated by "mapstructure-to-hcl2 -type OutputConfig"; DO NOT EDIT.
+package common
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatOutputConfig is an auto-generated flat version of OutputConfig.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatOutputConfig struct {
+	OutputDir *string `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+}
+
+// FlatMapstructure returns a new FlatOutputConfig.
+// FlatOutputConfig is an auto-generated flat version of OutputConfig.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*OutputConfig) FlatMapstructure() interface{} { return new(FlatOutputConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatOutputConfig.
+// This spec is used by HCL to read the fields of FlatOutputConfig.
+func (*FlatOutputConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"output_directory": &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/hyperv/iso/builder.go b/builder/hyperv/iso/builder.go
index a364c3226..253560f7a 100644
--- a/builder/hyperv/iso/builder.go
+++ b/builder/hyperv/iso/builder.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package iso
 
diff --git a/builder/hyperv/iso/builder.hcl2spec.go b/builder/hyperv/iso/builder.hcl2spec.go
new file mode 100644
index 000000000..d67ba7ee5
--- /dev/null
+++ b/builder/hyperv/iso/builder.hcl2spec.go
@@ -0,0 +1,215 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package iso
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName                *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType              *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                    *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                    *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError                  *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars                 map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars            []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                        *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin                    *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax                    *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	ISOChecksum                    *string           `mapstructure:"iso_checksum" required:"true" cty:"iso_checksum"`
+	ISOChecksumURL                 *string           `mapstructure:"iso_checksum_url" cty:"iso_checksum_url"`
+	ISOChecksumType                *string           `mapstructure:"iso_checksum_type" cty:"iso_checksum_type"`
+	RawSingleISOUrl                *string           `mapstructure:"iso_url" required:"true" cty:"iso_url"`
+	ISOUrls                        []string          `mapstructure:"iso_urls" cty:"iso_urls"`
+	TargetPath                     *string           `mapstructure:"iso_target_path" cty:"iso_target_path"`
+	TargetExtension                *string           `mapstructure:"iso_target_extension" cty:"iso_target_extension"`
+	FloppyFiles                    []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories              []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel                    *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	RawBootGroupInterval           *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait                    *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand                    []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval              *string           `cty:"boot_group_interval"`
+	OutputDir                      *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	Type                           *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect             *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                        *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                        *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                    *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                    *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName                 *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName        *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys         *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile              *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                         *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                     *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                   *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding      *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts           *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost                 *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort                 *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth            *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername             *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword             *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile       *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod          *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                   *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                   *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername               *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword               *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval           *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout            *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels               []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels                []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                   []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey                  []byte            `cty:"ssh_private_key"`
+	WinRMUser                      *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword                  *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                      *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                      *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                   *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                    *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure                  *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                   *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	ShutdownCommand                *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout             *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	DiskSize                       *uint             `mapstructure:"disk_size" required:"false" cty:"disk_size"`
+	DiskBlockSize                  *uint             `mapstructure:"disk_block_size" required:"false" cty:"disk_block_size"`
+	RamSize                        *uint             `mapstructure:"memory" required:"false" cty:"memory"`
+	SecondaryDvdImages             []string          `mapstructure:"secondary_iso_images" required:"false" cty:"secondary_iso_images"`
+	GuestAdditionsMode             *string           `mapstructure:"guest_additions_mode" required:"false" cty:"guest_additions_mode"`
+	GuestAdditionsPath             *string           `mapstructure:"guest_additions_path" required:"false" cty:"guest_additions_path"`
+	VMName                         *string           `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+	SwitchName                     *string           `mapstructure:"switch_name" required:"false" cty:"switch_name"`
+	SwitchVlanId                   *string           `mapstructure:"switch_vlan_id" required:"false" cty:"switch_vlan_id"`
+	MacAddress                     *string           `mapstructure:"mac_address" required:"false" cty:"mac_address"`
+	VlanId                         *string           `mapstructure:"vlan_id" required:"false" cty:"vlan_id"`
+	Cpu                            *uint             `mapstructure:"cpus" required:"false" cty:"cpus"`
+	Generation                     *uint             `mapstructure:"generation" required:"false" cty:"generation"`
+	EnableMacSpoofing              *bool             `mapstructure:"enable_mac_spoofing" required:"false" cty:"enable_mac_spoofing"`
+	UseLegacyNetworkAdapter        *bool             `mapstructure:"use_legacy_network_adapter" required:"false" cty:"use_legacy_network_adapter"`
+	EnableDynamicMemory            *bool             `mapstructure:"enable_dynamic_memory" required:"false" cty:"enable_dynamic_memory"`
+	EnableSecureBoot               *bool             `mapstructure:"enable_secure_boot" required:"false" cty:"enable_secure_boot"`
+	SecureBootTemplate             *string           `mapstructure:"secure_boot_template" required:"false" cty:"secure_boot_template"`
+	EnableVirtualizationExtensions *bool             `mapstructure:"enable_virtualization_extensions" required:"false" cty:"enable_virtualization_extensions"`
+	TempPath                       *string           `mapstructure:"temp_path" required:"false" cty:"temp_path"`
+	Version                        *string           `mapstructure:"configuration_version" required:"false" cty:"configuration_version"`
+	KeepRegistered                 *bool             `mapstructure:"keep_registered" required:"false" cty:"keep_registered"`
+	AdditionalDiskSize             []uint            `mapstructure:"disk_additional_size" required:"false" cty:"disk_additional_size"`
+	SkipCompaction                 *bool             `mapstructure:"skip_compaction" required:"false" cty:"skip_compaction"`
+	SkipExport                     *bool             `mapstructure:"skip_export" required:"false" cty:"skip_export"`
+	DifferencingDisk               *bool             `mapstructure:"differencing_disk" required:"false" cty:"differencing_disk"`
+	FixedVHD                       *bool             `mapstructure:"use_fixed_vhd_format" required:"false" cty:"use_fixed_vhd_format"`
+	Headless                       *bool             `mapstructure:"headless" required:"false" cty:"headless"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":                &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":              &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                     &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                     &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                  &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":            &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":       &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":                   &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                    &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                    &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"iso_checksum":                     &hcldec.AttrSpec{Name: "iso_checksum", Type: cty.String, Required: false},
+		"iso_checksum_url":                 &hcldec.AttrSpec{Name: "iso_checksum_url", Type: cty.String, Required: false},
+		"iso_checksum_type":                &hcldec.AttrSpec{Name: "iso_checksum_type", Type: cty.String, Required: false},
+		"iso_url":                          &hcldec.AttrSpec{Name: "iso_url", Type: cty.String, Required: false},
+		"iso_urls":                         &hcldec.AttrSpec{Name: "iso_urls", Type: cty.List(cty.String), Required: false},
+		"iso_target_path":                  &hcldec.AttrSpec{Name: "iso_target_path", Type: cty.String, Required: false},
+		"iso_target_extension":             &hcldec.AttrSpec{Name: "iso_target_extension", Type: cty.String, Required: false},
+		"floppy_files":                     &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                      &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                     &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"boot_keygroup_interval":           &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                        &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                     &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":              &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"output_directory":                 &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"communicator":                     &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":          &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                         &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                         &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                     &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                     &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":                 &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":          &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":        &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":             &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                          &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                      &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                   &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":     &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":           &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":                 &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":                 &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":           &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":             &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":             &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":     &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":         &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                   &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                   &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":               &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":               &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":          &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":           &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":               &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":                &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                   &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                  &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                   &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                   &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                       &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                       &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                    &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                    &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                   &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                   &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"shutdown_command":                 &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":                 &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"disk_size":                        &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"disk_block_size":                  &hcldec.AttrSpec{Name: "disk_block_size", Type: cty.Number, Required: false},
+		"memory":                           &hcldec.AttrSpec{Name: "memory", Type: cty.Number, Required: false},
+		"secondary_iso_images":             &hcldec.AttrSpec{Name: "secondary_iso_images", Type: cty.List(cty.String), Required: false},
+		"guest_additions_mode":             &hcldec.AttrSpec{Name: "guest_additions_mode", Type: cty.String, Required: false},
+		"guest_additions_path":             &hcldec.AttrSpec{Name: "guest_additions_path", Type: cty.String, Required: false},
+		"vm_name":                          &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"switch_name":                      &hcldec.AttrSpec{Name: "switch_name", Type: cty.String, Required: false},
+		"switch_vlan_id":                   &hcldec.AttrSpec{Name: "switch_vlan_id", Type: cty.String, Required: false},
+		"mac_address":                      &hcldec.AttrSpec{Name: "mac_address", Type: cty.String, Required: false},
+		"vlan_id":                          &hcldec.AttrSpec{Name: "vlan_id", Type: cty.String, Required: false},
+		"cpus":                             &hcldec.AttrSpec{Name: "cpus", Type: cty.Number, Required: false},
+		"generation":                       &hcldec.AttrSpec{Name: "generation", Type: cty.Number, Required: false},
+		"enable_mac_spoofing":              &hcldec.AttrSpec{Name: "enable_mac_spoofing", Type: cty.Bool, Required: false},
+		"use_legacy_network_adapter":       &hcldec.AttrSpec{Name: "use_legacy_network_adapter", Type: cty.Bool, Required: false},
+		"enable_dynamic_memory":            &hcldec.AttrSpec{Name: "enable_dynamic_memory", Type: cty.Bool, Required: false},
+		"enable_secure_boot":               &hcldec.AttrSpec{Name: "enable_secure_boot", Type: cty.Bool, Required: false},
+		"secure_boot_template":             &hcldec.AttrSpec{Name: "secure_boot_template", Type: cty.String, Required: false},
+		"enable_virtualization_extensions": &hcldec.AttrSpec{Name: "enable_virtualization_extensions", Type: cty.Bool, Required: false},
+		"temp_path":                        &hcldec.AttrSpec{Name: "temp_path", Type: cty.String, Required: false},
+		"configuration_version":            &hcldec.AttrSpec{Name: "configuration_version", Type: cty.String, Required: false},
+		"keep_registered":                  &hcldec.AttrSpec{Name: "keep_registered", Type: cty.Bool, Required: false},
+		"disk_additional_size":             &hcldec.AttrSpec{Name: "disk_additional_size", Type: cty.List(cty.Number), Required: false},
+		"skip_compaction":                  &hcldec.AttrSpec{Name: "skip_compaction", Type: cty.Bool, Required: false},
+		"skip_export":                      &hcldec.AttrSpec{Name: "skip_export", Type: cty.Bool, Required: false},
+		"differencing_disk":                &hcldec.AttrSpec{Name: "differencing_disk", Type: cty.Bool, Required: false},
+		"use_fixed_vhd_format":             &hcldec.AttrSpec{Name: "use_fixed_vhd_format", Type: cty.Bool, Required: false},
+		"headless":                         &hcldec.AttrSpec{Name: "headless", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/hyperv/vmcx/builder.go b/builder/hyperv/vmcx/builder.go
index b95630706..b5e774245 100644
--- a/builder/hyperv/vmcx/builder.go
+++ b/builder/hyperv/vmcx/builder.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package vmcx
 
diff --git a/builder/hyperv/vmcx/builder.hcl2spec.go b/builder/hyperv/vmcx/builder.hcl2spec.go
new file mode 100644
index 000000000..488950078
--- /dev/null
+++ b/builder/hyperv/vmcx/builder.hcl2spec.go
@@ -0,0 +1,215 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package vmcx
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName                *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType              *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                    *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                    *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError                  *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars                 map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars            []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                        *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin                    *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax                    *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	ISOChecksum                    *string           `mapstructure:"iso_checksum" required:"true" cty:"iso_checksum"`
+	ISOChecksumURL                 *string           `mapstructure:"iso_checksum_url" cty:"iso_checksum_url"`
+	ISOChecksumType                *string           `mapstructure:"iso_checksum_type" cty:"iso_checksum_type"`
+	RawSingleISOUrl                *string           `mapstructure:"iso_url" required:"true" cty:"iso_url"`
+	ISOUrls                        []string          `mapstructure:"iso_urls" cty:"iso_urls"`
+	TargetPath                     *string           `mapstructure:"iso_target_path" cty:"iso_target_path"`
+	TargetExtension                *string           `mapstructure:"iso_target_extension" cty:"iso_target_extension"`
+	FloppyFiles                    []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories              []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel                    *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	RawBootGroupInterval           *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait                    *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand                    []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval              *string           `cty:"boot_group_interval"`
+	OutputDir                      *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	Type                           *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect             *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                        *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                        *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                    *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                    *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName                 *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName        *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys         *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile              *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                         *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                     *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                   *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding      *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts           *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost                 *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort                 *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth            *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername             *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword             *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile       *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod          *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                   *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                   *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername               *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword               *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval           *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout            *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels               []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels                []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                   []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey                  []byte            `cty:"ssh_private_key"`
+	WinRMUser                      *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword                  *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                      *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                      *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                   *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                    *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure                  *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                   *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	ShutdownCommand                *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout             *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	RamSize                        *uint             `mapstructure:"memory" required:"false" cty:"memory"`
+	SecondaryDvdImages             []string          `mapstructure:"secondary_iso_images" required:"false" cty:"secondary_iso_images"`
+	GuestAdditionsMode             *string           `mapstructure:"guest_additions_mode" required:"false" cty:"guest_additions_mode"`
+	GuestAdditionsPath             *string           `mapstructure:"guest_additions_path" required:"false" cty:"guest_additions_path"`
+	CloneFromVMCXPath              *string           `mapstructure:"clone_from_vmcx_path" cty:"clone_from_vmcx_path"`
+	CloneFromVMName                *string           `mapstructure:"clone_from_vm_name" cty:"clone_from_vm_name"`
+	CloneFromSnapshotName          *string           `mapstructure:"clone_from_snapshot_name" required:"false" cty:"clone_from_snapshot_name"`
+	CloneAllSnapshots              *bool             `mapstructure:"clone_all_snapshots" required:"false" cty:"clone_all_snapshots"`
+	VMName                         *string           `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+	DifferencingDisk               *bool             `mapstructure:"differencing_disk" required:"false" cty:"differencing_disk"`
+	SwitchName                     *string           `mapstructure:"switch_name" required:"false" cty:"switch_name"`
+	CompareCopy                    *bool             `mapstructure:"copy_in_compare" required:"false" cty:"copy_in_compare"`
+	SwitchVlanId                   *string           `mapstructure:"switch_vlan_id" required:"false" cty:"switch_vlan_id"`
+	MacAddress                     *string           `mapstructure:"mac_address" required:"false" cty:"mac_address"`
+	VlanId                         *string           `mapstructure:"vlan_id" required:"false" cty:"vlan_id"`
+	Cpu                            *uint             `mapstructure:"cpus" required:"false" cty:"cpus"`
+	Generation                     *uint             `mapstructure:"generation" required:"false" cty:"generation"`
+	EnableMacSpoofing              *bool             `mapstructure:"enable_mac_spoofing" required:"false" cty:"enable_mac_spoofing"`
+	EnableDynamicMemory            *bool             `mapstructure:"enable_dynamic_memory" required:"false" cty:"enable_dynamic_memory"`
+	EnableSecureBoot               *bool             `mapstructure:"enable_secure_boot" required:"false" cty:"enable_secure_boot"`
+	SecureBootTemplate             *string           `mapstructure:"secure_boot_template" required:"false" cty:"secure_boot_template"`
+	EnableVirtualizationExtensions *bool             `mapstructure:"enable_virtualization_extensions" required:"false" cty:"enable_virtualization_extensions"`
+	TempPath                       *string           `mapstructure:"temp_path" required:"false" cty:"temp_path"`
+	Version                        *string           `mapstructure:"configuration_version" required:"false" cty:"configuration_version"`
+	KeepRegistered                 *bool             `mapstructure:"keep_registered" required:"false" cty:"keep_registered"`
+	SkipCompaction                 *bool             `mapstructure:"skip_compaction" required:"false" cty:"skip_compaction"`
+	SkipExport                     *bool             `mapstructure:"skip_export" required:"false" cty:"skip_export"`
+	Headless                       *bool             `mapstructure:"headless" required:"false" cty:"headless"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":                &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":              &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                     &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                     &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                  &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":            &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":       &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":                   &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                    &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                    &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"iso_checksum":                     &hcldec.AttrSpec{Name: "iso_checksum", Type: cty.String, Required: false},
+		"iso_checksum_url":                 &hcldec.AttrSpec{Name: "iso_checksum_url", Type: cty.String, Required: false},
+		"iso_checksum_type":                &hcldec.AttrSpec{Name: "iso_checksum_type", Type: cty.String, Required: false},
+		"iso_url":                          &hcldec.AttrSpec{Name: "iso_url", Type: cty.String, Required: false},
+		"iso_urls":                         &hcldec.AttrSpec{Name: "iso_urls", Type: cty.List(cty.String), Required: false},
+		"iso_target_path":                  &hcldec.AttrSpec{Name: "iso_target_path", Type: cty.String, Required: false},
+		"iso_target_extension":             &hcldec.AttrSpec{Name: "iso_target_extension", Type: cty.String, Required: false},
+		"floppy_files":                     &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                      &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                     &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"boot_keygroup_interval":           &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                        &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                     &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":              &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"output_directory":                 &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"communicator":                     &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":          &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                         &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                         &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                     &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                     &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":                 &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":          &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":        &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":             &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                          &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                      &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                   &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":     &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":           &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":                 &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":                 &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":           &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":             &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":             &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":     &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":         &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                   &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                   &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":               &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":               &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":          &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":           &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":               &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":                &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                   &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                  &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                   &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                   &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                       &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                       &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                    &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                    &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                   &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                   &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"shutdown_command":                 &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":                 &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"memory":                           &hcldec.AttrSpec{Name: "memory", Type: cty.Number, Required: false},
+		"secondary_iso_images":             &hcldec.AttrSpec{Name: "secondary_iso_images", Type: cty.List(cty.String), Required: false},
+		"guest_additions_mode":             &hcldec.AttrSpec{Name: "guest_additions_mode", Type: cty.String, Required: false},
+		"guest_additions_path":             &hcldec.AttrSpec{Name: "guest_additions_path", Type: cty.String, Required: false},
+		"clone_from_vmcx_path":             &hcldec.AttrSpec{Name: "clone_from_vmcx_path", Type: cty.String, Required: false},
+		"clone_from_vm_name":               &hcldec.AttrSpec{Name: "clone_from_vm_name", Type: cty.String, Required: false},
+		"clone_from_snapshot_name":         &hcldec.AttrSpec{Name: "clone_from_snapshot_name", Type: cty.String, Required: false},
+		"clone_all_snapshots":              &hcldec.AttrSpec{Name: "clone_all_snapshots", Type: cty.Bool, Required: false},
+		"vm_name":                          &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"differencing_disk":                &hcldec.AttrSpec{Name: "differencing_disk", Type: cty.Bool, Required: false},
+		"switch_name":                      &hcldec.AttrSpec{Name: "switch_name", Type: cty.String, Required: false},
+		"copy_in_compare":                  &hcldec.AttrSpec{Name: "copy_in_compare", Type: cty.Bool, Required: false},
+		"switch_vlan_id":                   &hcldec.AttrSpec{Name: "switch_vlan_id", Type: cty.String, Required: false},
+		"mac_address":                      &hcldec.AttrSpec{Name: "mac_address", Type: cty.String, Required: false},
+		"vlan_id":                          &hcldec.AttrSpec{Name: "vlan_id", Type: cty.String, Required: false},
+		"cpus":                             &hcldec.AttrSpec{Name: "cpus", Type: cty.Number, Required: false},
+		"generation":                       &hcldec.AttrSpec{Name: "generation", Type: cty.Number, Required: false},
+		"enable_mac_spoofing":              &hcldec.AttrSpec{Name: "enable_mac_spoofing", Type: cty.Bool, Required: false},
+		"enable_dynamic_memory":            &hcldec.AttrSpec{Name: "enable_dynamic_memory", Type: cty.Bool, Required: false},
+		"enable_secure_boot":               &hcldec.AttrSpec{Name: "enable_secure_boot", Type: cty.Bool, Required: false},
+		"secure_boot_template":             &hcldec.AttrSpec{Name: "secure_boot_template", Type: cty.String, Required: false},
+		"enable_virtualization_extensions": &hcldec.AttrSpec{Name: "enable_virtualization_extensions", Type: cty.Bool, Required: false},
+		"temp_path":                        &hcldec.AttrSpec{Name: "temp_path", Type: cty.String, Required: false},
+		"configuration_version":            &hcldec.AttrSpec{Name: "configuration_version", Type: cty.String, Required: false},
+		"keep_registered":                  &hcldec.AttrSpec{Name: "keep_registered", Type: cty.Bool, Required: false},
+		"skip_compaction":                  &hcldec.AttrSpec{Name: "skip_compaction", Type: cty.Bool, Required: false},
+		"skip_export":                      &hcldec.AttrSpec{Name: "skip_export", Type: cty.Bool, Required: false},
+		"headless":                         &hcldec.AttrSpec{Name: "headless", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/jdcloud/common.go b/builder/jdcloud/common.go
index d94d9c976..1de7efe22 100644
--- a/builder/jdcloud/common.go
+++ b/builder/jdcloud/common.go
@@ -1,16 +1,19 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package jdcloud
 
 import (
 	"fmt"
+	"log"
+	"strings"
+	"sync"
+	"time"
+
 	"github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/template/interpolate"
 	vm "github.com/jdcloud-api/jdcloud-sdk-go/services/vm/client"
 	vpc "github.com/jdcloud-api/jdcloud-sdk-go/services/vpc/client"
-	"log"
-	"strings"
-	"sync"
-	"time"
 )
 
 const (
diff --git a/builder/jdcloud/common.hcl2spec.go b/builder/jdcloud/common.hcl2spec.go
new file mode 100644
index 000000000..0bc486d27
--- /dev/null
+++ b/builder/jdcloud/common.hcl2spec.go
@@ -0,0 +1,145 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package jdcloud
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	AccessKey                 *string           `mapstructure:"access_key" cty:"access_key"`
+	SecretKey                 *string           `mapstructure:"secret_key" cty:"secret_key"`
+	RegionId                  *string           `mapstructure:"region_id" cty:"region_id"`
+	Az                        *string           `mapstructure:"az" cty:"az"`
+	ImageId                   *string           `mapstructure:"image_id" cty:"image_id"`
+	InstanceName              *string           `mapstructure:"instance_name" cty:"instance_name"`
+	InstanceType              *string           `mapstructure:"instance_type" cty:"instance_type"`
+	ImageName                 *string           `mapstructure:"image_name" cty:"image_name"`
+	SubnetId                  *string           `mapstructure:"subnet_id" cty:"subnet_id"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	InstanceId                *string           `cty:"instance_id"`
+	ArtifactId                *string           `cty:"artifact_id"`
+	PublicIpAddress           *string           `cty:"public_ip_address"`
+	PublicIpId                *string           `cty:"public_ip_id"`
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"access_key":                   &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"secret_key":                   &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"region_id":                    &hcldec.AttrSpec{Name: "region_id", Type: cty.String, Required: false},
+		"az":                           &hcldec.AttrSpec{Name: "az", Type: cty.String, Required: false},
+		"image_id":                     &hcldec.AttrSpec{Name: "image_id", Type: cty.String, Required: false},
+		"instance_name":                &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"instance_type":                &hcldec.AttrSpec{Name: "instance_type", Type: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"subnet_id":                    &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"instance_id":                  &hcldec.AttrSpec{Name: "instance_id", Type: cty.String, Required: false},
+		"artifact_id":                  &hcldec.AttrSpec{Name: "artifact_id", Type: cty.String, Required: false},
+		"public_ip_address":            &hcldec.AttrSpec{Name: "public_ip_address", Type: cty.String, Required: false},
+		"public_ip_id":                 &hcldec.AttrSpec{Name: "public_ip_id", Type: cty.String, Required: false},
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+	}
+	return s
+}
diff --git a/builder/linode/config.go b/builder/linode/config.go
index 079c44639..df6346c9c 100644
--- a/builder/linode/config.go
+++ b/builder/linode/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package linode
 
 import (
diff --git a/builder/linode/config.hcl2spec.go b/builder/linode/config.hcl2spec.go
new file mode 100644
index 000000000..9fc15340e
--- /dev/null
+++ b/builder/linode/config.hcl2spec.go
@@ -0,0 +1,143 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package linode
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	PersonalAccessToken       *string           `mapstructure:"linode_token" cty:"linode_token"`
+	Region                    *string           `mapstructure:"region" cty:"region"`
+	InstanceType              *string           `mapstructure:"instance_type" cty:"instance_type"`
+	Label                     *string           `mapstructure:"instance_label" cty:"instance_label"`
+	Tags                      []string          `mapstructure:"instance_tags" cty:"instance_tags"`
+	Image                     *string           `mapstructure:"image" cty:"image"`
+	SwapSize                  *int              `mapstructure:"swap_size" cty:"swap_size"`
+	RootPass                  *string           `mapstructure:"root_pass" cty:"root_pass"`
+	RootSSHKey                *string           `mapstructure:"root_ssh_key" cty:"root_ssh_key"`
+	ImageLabel                *string           `mapstructure:"image_label" cty:"image_label"`
+	Description               *string           `mapstructure:"image_description" cty:"image_description"`
+	RawStateTimeout           *string           `mapstructure:"state_timeout" cty:"state_timeout"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"linode_token":                 &hcldec.AttrSpec{Name: "linode_token", Type: cty.String, Required: false},
+		"region":                       &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"instance_type":                &hcldec.AttrSpec{Name: "instance_type", Type: cty.String, Required: false},
+		"instance_label":               &hcldec.AttrSpec{Name: "instance_label", Type: cty.String, Required: false},
+		"instance_tags":                &hcldec.AttrSpec{Name: "instance_tags", Type: cty.List(cty.String), Required: false},
+		"image":                        &hcldec.AttrSpec{Name: "image", Type: cty.String, Required: false},
+		"swap_size":                    &hcldec.AttrSpec{Name: "swap_size", Type: cty.Number, Required: false},
+		"root_pass":                    &hcldec.AttrSpec{Name: "root_pass", Type: cty.String, Required: false},
+		"root_ssh_key":                 &hcldec.AttrSpec{Name: "root_ssh_key", Type: cty.String, Required: false},
+		"image_label":                  &hcldec.AttrSpec{Name: "image_label", Type: cty.String, Required: false},
+		"image_description":            &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"state_timeout":                &hcldec.AttrSpec{Name: "state_timeout", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/lxd/config.go b/builder/lxd/config.go
index b127f7aaf..6914392b4 100644
--- a/builder/lxd/config.go
+++ b/builder/lxd/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package lxd
 
diff --git a/builder/lxd/config.hcl2spec.go b/builder/lxd/config.hcl2spec.go
new file mode 100644
index 000000000..61cc74e19
--- /dev/null
+++ b/builder/lxd/config.hcl2spec.go
@@ -0,0 +1,55 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package lxd
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	OutputImage         *string           `mapstructure:"output_image" required:"false" cty:"output_image"`
+	ContainerName       *string           `mapstructure:"container_name" cty:"container_name"`
+	CommandWrapper      *string           `mapstructure:"command_wrapper" required:"false" cty:"command_wrapper"`
+	Image               *string           `mapstructure:"image" required:"true" cty:"image"`
+	Profile             *string           `mapstructure:"profile" cty:"profile"`
+	InitSleep           *string           `mapstructure:"init_sleep" required:"false" cty:"init_sleep"`
+	PublishProperties   map[string]string `mapstructure:"publish_properties" required:"false" cty:"publish_properties"`
+	LaunchConfig        map[string]string `mapstructure:"launch_config" required:"false" cty:"launch_config"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"output_image":               &hcldec.AttrSpec{Name: "output_image", Type: cty.String, Required: false},
+		"container_name":             &hcldec.AttrSpec{Name: "container_name", Type: cty.String, Required: false},
+		"command_wrapper":            &hcldec.AttrSpec{Name: "command_wrapper", Type: cty.String, Required: false},
+		"image":                      &hcldec.AttrSpec{Name: "image", Type: cty.String, Required: false},
+		"profile":                    &hcldec.AttrSpec{Name: "profile", Type: cty.String, Required: false},
+		"init_sleep":                 &hcldec.AttrSpec{Name: "init_sleep", Type: cty.String, Required: false},
+		"publish_properties":         &hcldec.BlockAttrsSpec{TypeName: "publish_properties", ElementType: cty.String, Required: false},
+		"launch_config":              &hcldec.BlockAttrsSpec{TypeName: "launch_config", ElementType: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/ncloud/config.go b/builder/ncloud/config.go
index 15e531db8..b1f7f4416 100644
--- a/builder/ncloud/config.go
+++ b/builder/ncloud/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package ncloud
 
diff --git a/builder/ncloud/config.hcl2spec.go b/builder/ncloud/config.hcl2spec.go
new file mode 100644
index 000000000..f72c02456
--- /dev/null
+++ b/builder/ncloud/config.hcl2spec.go
@@ -0,0 +1,143 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package ncloud
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName                   *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType                 *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                       *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                       *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError                     *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars                    map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars               []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AccessKey                         *string           `mapstructure:"access_key" cty:"access_key"`
+	SecretKey                         *string           `mapstructure:"secret_key" cty:"secret_key"`
+	ServerImageProductCode            *string           `mapstructure:"server_image_product_code" required:"true" cty:"server_image_product_code"`
+	ServerProductCode                 *string           `mapstructure:"server_product_code" required:"true" cty:"server_product_code"`
+	MemberServerImageNo               *string           `mapstructure:"member_server_image_no" required:"false" cty:"member_server_image_no"`
+	ServerImageName                   *string           `mapstructure:"server_image_name" required:"false" cty:"server_image_name"`
+	ServerImageDescription            *string           `mapstructure:"server_image_description" required:"false" cty:"server_image_description"`
+	UserData                          *string           `mapstructure:"user_data" required:"false" cty:"user_data"`
+	UserDataFile                      *string           `mapstructure:"user_data_file" required:"false" cty:"user_data_file"`
+	BlockStorageSize                  *int              `mapstructure:"block_storage_size" required:"false" cty:"block_storage_size"`
+	Region                            *string           `mapstructure:"region" required:"false" cty:"region"`
+	AccessControlGroupConfigurationNo *string           `mapstructure:"access_control_group_configuration_no" required:"false" cty:"access_control_group_configuration_no"`
+	Type                              *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect                *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                           *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                           *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                       *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                       *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName                    *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName           *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys            *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile                 *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                            *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                        *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                      *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding         *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts              *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost                    *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort                    *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth               *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername                *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword                *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile          *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod             *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                      *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                      *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername                  *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword                  *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval              *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout               *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels                  []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels                   []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                      []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey                     []byte            `cty:"ssh_private_key"`
+	WinRMUser                         *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword                     *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                         *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                         *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                      *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                       *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure                     *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                      *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":                     &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":                   &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                          &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                          &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                       &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":                 &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":            &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"access_key":                            &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"secret_key":                            &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"server_image_product_code":             &hcldec.AttrSpec{Name: "server_image_product_code", Type: cty.String, Required: false},
+		"server_product_code":                   &hcldec.AttrSpec{Name: "server_product_code", Type: cty.String, Required: false},
+		"member_server_image_no":                &hcldec.AttrSpec{Name: "member_server_image_no", Type: cty.String, Required: false},
+		"server_image_name":                     &hcldec.AttrSpec{Name: "server_image_name", Type: cty.String, Required: false},
+		"server_image_description":              &hcldec.AttrSpec{Name: "server_image_description", Type: cty.String, Required: false},
+		"user_data":                             &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":                        &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"block_storage_size":                    &hcldec.AttrSpec{Name: "block_storage_size", Type: cty.Number, Required: false},
+		"region":                                &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"access_control_group_configuration_no": &hcldec.AttrSpec{Name: "access_control_group_configuration_no", Type: cty.String, Required: false},
+		"communicator":                          &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":               &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                              &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                              &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                          &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                          &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":                      &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":               &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":             &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":                  &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                               &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                           &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                        &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":          &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":                &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":                      &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":                      &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":                &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":                  &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":                  &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":          &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":              &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                        &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                        &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":                    &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":                    &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":               &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":                &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":                    &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":                     &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                        &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                       &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                        &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                        &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                            &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                            &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                         &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                         &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                        &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                        &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/null/config.go b/builder/null/config.go
index a9d54eeb0..a589b297b 100644
--- a/builder/null/config.go
+++ b/builder/null/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package null
 
 import (
diff --git a/builder/null/config.hcl2spec.go b/builder/null/config.hcl2spec.go
new file mode 100644
index 000000000..cceed507b
--- /dev/null
+++ b/builder/null/config.hcl2spec.go
@@ -0,0 +1,119 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package null
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/oneandone/config.go b/builder/oneandone/config.go
index 24df56fc8..68f2203f3 100644
--- a/builder/oneandone/config.go
+++ b/builder/oneandone/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package oneandone
 
 import (
@@ -23,10 +25,9 @@ type Config struct {
 	SnapshotName   string `mapstructure:"image_name"`
 	DataCenterName string `mapstructure:"data_center_name"`
 	DataCenterId   string
-	Image          string              `mapstructure:"source_image_name"`
-	DiskSize       int                 `mapstructure:"disk_size"`
-	Retries        int                 `mapstructure:"retries"`
-	CommConfig     communicator.Config `mapstructure:",squash"`
+	Image          string `mapstructure:"source_image_name"`
+	DiskSize       int    `mapstructure:"disk_size"`
+	Retries        int    `mapstructure:"retries"`
 	ctx            interpolate.Context
 }
 
diff --git a/builder/oneandone/config.hcl2spec.go b/builder/oneandone/config.hcl2spec.go
new file mode 100644
index 000000000..ebed17e63
--- /dev/null
+++ b/builder/oneandone/config.hcl2spec.go
@@ -0,0 +1,135 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package oneandone
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	Token                     *string           `mapstructure:"token" cty:"token"`
+	Url                       *string           `mapstructure:"url" cty:"url"`
+	SnapshotName              *string           `mapstructure:"image_name" cty:"image_name"`
+	DataCenterName            *string           `mapstructure:"data_center_name" cty:"data_center_name"`
+	DataCenterId              *string           `cty:"data_center_id"`
+	Image                     *string           `mapstructure:"source_image_name" cty:"source_image_name"`
+	DiskSize                  *int              `mapstructure:"disk_size" cty:"disk_size"`
+	Retries                   *int              `mapstructure:"retries" cty:"retries"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"token":                        &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"url":                          &hcldec.AttrSpec{Name: "url", Type: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"data_center_name":             &hcldec.AttrSpec{Name: "data_center_name", Type: cty.String, Required: false},
+		"data_center_id":               &hcldec.AttrSpec{Name: "data_center_id", Type: cty.String, Required: false},
+		"source_image_name":            &hcldec.AttrSpec{Name: "source_image_name", Type: cty.String, Required: false},
+		"disk_size":                    &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"retries":                      &hcldec.AttrSpec{Name: "retries", Type: cty.Number, Required: false},
+	}
+	return s
+}
diff --git a/builder/openstack/builder.go b/builder/openstack/builder.go
index f802e2523..de8e67d83 100644
--- a/builder/openstack/builder.go
+++ b/builder/openstack/builder.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config,ImageFilter,ImageFilterOptions
+
 // The openstack package contains a packer.Builder implementation that
 // builds Images for openstack.
 
diff --git a/builder/openstack/builder.hcl2spec.go b/builder/openstack/builder.hcl2spec.go
new file mode 100644
index 000000000..e44baa3e1
--- /dev/null
+++ b/builder/openstack/builder.hcl2spec.go
@@ -0,0 +1,280 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,ImageFilter,ImageFilterOptions"; DO NOT EDIT.
+package openstack
+
+import (
+	"github.com/gophercloud/gophercloud/openstack/imageservice/v2/images"
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName             *string                `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType           *string                `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                 *bool                  `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                 *bool                  `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError               *string                `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars              map[string]string      `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars         []string               `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Username                    *string                `mapstructure:"username" required:"true" cty:"username"`
+	UserID                      *string                `mapstructure:"user_id" cty:"user_id"`
+	Password                    *string                `mapstructure:"password" required:"true" cty:"password"`
+	IdentityEndpoint            *string                `mapstructure:"identity_endpoint" required:"true" cty:"identity_endpoint"`
+	TenantID                    *string                `mapstructure:"tenant_id" required:"false" cty:"tenant_id"`
+	TenantName                  *string                `mapstructure:"tenant_name" cty:"tenant_name"`
+	DomainID                    *string                `mapstructure:"domain_id" cty:"domain_id"`
+	DomainName                  *string                `mapstructure:"domain_name" required:"false" cty:"domain_name"`
+	Insecure                    *bool                  `mapstructure:"insecure" required:"false" cty:"insecure"`
+	Region                      *string                `mapstructure:"region" required:"false" cty:"region"`
+	EndpointType                *string                `mapstructure:"endpoint_type" required:"false" cty:"endpoint_type"`
+	CACertFile                  *string                `mapstructure:"cacert" required:"false" cty:"cacert"`
+	ClientCertFile              *string                `mapstructure:"cert" required:"false" cty:"cert"`
+	ClientKeyFile               *string                `mapstructure:"key" required:"false" cty:"key"`
+	Token                       *string                `mapstructure:"token" required:"false" cty:"token"`
+	ApplicationCredentialName   *string                `mapstructure:"application_credential_name" required:"false" cty:"application_credential_name"`
+	ApplicationCredentialID     *string                `mapstructure:"application_credential_id" required:"false" cty:"application_credential_id"`
+	ApplicationCredentialSecret *string                `mapstructure:"application_credential_secret" required:"false" cty:"application_credential_secret"`
+	Cloud                       *string                `mapstructure:"cloud" required:"false" cty:"cloud"`
+	ImageName                   *string                `mapstructure:"image_name" required:"true" cty:"image_name"`
+	ImageMetadata               map[string]string      `mapstructure:"metadata" required:"false" cty:"metadata"`
+	ImageVisibility             images.ImageVisibility `mapstructure:"image_visibility" required:"false" cty:"image_visibility"`
+	ImageMembers                []string               `mapstructure:"image_members" required:"false" cty:"image_members"`
+	ImageDiskFormat             *string                `mapstructure:"image_disk_format" required:"false" cty:"image_disk_format"`
+	ImageTags                   []string               `mapstructure:"image_tags" required:"false" cty:"image_tags"`
+	ImageMinDisk                *int                   `mapstructure:"image_min_disk" required:"false" cty:"image_min_disk"`
+	Type                        *string                `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect          *string                `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                     *string                `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                     *int                   `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                 *string                `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                 *string                `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName              *string                `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName     *string                `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys      *bool                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile           *string                `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                      *bool                  `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                  *string                `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                *bool                  `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding   *bool                  `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts        *int                   `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost              *string                `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort              *int                   `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth         *bool                  `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername          *string                `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword          *string                `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile    *string                `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod       *string                `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                *string                `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                *int                   `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername            *string                `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword            *string                `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval        *string                `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout         *string                `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels            []string               `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels             []string               `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                []byte                 `cty:"ssh_public_key"`
+	SSHPrivateKey               []byte                 `cty:"ssh_private_key"`
+	WinRMUser                   *string                `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword               *string                `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                   *string                `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                   *int                   `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                *string                `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                 *bool                  `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure               *bool                  `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                *bool                  `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHInterface                *string                `mapstructure:"ssh_interface" required:"false" cty:"ssh_interface"`
+	SSHIPVersion                *string                `mapstructure:"ssh_ip_version" required:"false" cty:"ssh_ip_version"`
+	SourceImage                 *string                `mapstructure:"source_image" required:"true" cty:"source_image"`
+	SourceImageName             *string                `mapstructure:"source_image_name" required:"true" cty:"source_image_name"`
+	SourceImageFilters          *FlatImageFilter       `mapstructure:"source_image_filter" required:"true" cty:"source_image_filter"`
+	Flavor                      *string                `mapstructure:"flavor" required:"true" cty:"flavor"`
+	AvailabilityZone            *string                `mapstructure:"availability_zone" required:"false" cty:"availability_zone"`
+	RackconnectWait             *bool                  `mapstructure:"rackconnect_wait" required:"false" cty:"rackconnect_wait"`
+	FloatingIPNetwork           *string                `mapstructure:"floating_ip_network" required:"false" cty:"floating_ip_network"`
+	InstanceFloatingIPNet       *string                `mapstructure:"instance_floating_ip_net" required:"false" cty:"instance_floating_ip_net"`
+	FloatingIP                  *string                `mapstructure:"floating_ip" required:"false" cty:"floating_ip"`
+	ReuseIPs                    *bool                  `mapstructure:"reuse_ips" required:"false" cty:"reuse_ips"`
+	SecurityGroups              []string               `mapstructure:"security_groups" required:"false" cty:"security_groups"`
+	Networks                    []string               `mapstructure:"networks" required:"false" cty:"networks"`
+	Ports                       []string               `mapstructure:"ports" required:"false" cty:"ports"`
+	UserData                    *string                `mapstructure:"user_data" required:"false" cty:"user_data"`
+	UserDataFile                *string                `mapstructure:"user_data_file" required:"false" cty:"user_data_file"`
+	InstanceName                *string                `mapstructure:"instance_name" required:"false" cty:"instance_name"`
+	InstanceMetadata            map[string]string      `mapstructure:"instance_metadata" required:"false" cty:"instance_metadata"`
+	ForceDelete                 *bool                  `mapstructure:"force_delete" required:"false" cty:"force_delete"`
+	ConfigDrive                 *bool                  `mapstructure:"config_drive" required:"false" cty:"config_drive"`
+	FloatingIPPool              *string                `mapstructure:"floating_ip_pool" required:"false" cty:"floating_ip_pool"`
+	UseBlockStorageVolume       *bool                  `mapstructure:"use_blockstorage_volume" required:"false" cty:"use_blockstorage_volume"`
+	VolumeName                  *string                `mapstructure:"volume_name" required:"false" cty:"volume_name"`
+	VolumeType                  *string                `mapstructure:"volume_type" required:"false" cty:"volume_type"`
+	VolumeSize                  *int                   `mapstructure:"volume_size" required:"false" cty:"volume_size"`
+	VolumeAvailabilityZone      *string                `mapstructure:"volume_availability_zone" required:"false" cty:"volume_availability_zone"`
+	OpenstackProvider           *string                `mapstructure:"openstack_provider" cty:"openstack_provider"`
+	UseFloatingIp               *bool                  `mapstructure:"use_floating_ip" required:"false" cty:"use_floating_ip"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":             &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":           &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                  &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                  &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":               &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":         &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":    &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"username":                      &hcldec.AttrSpec{Name: "username", Type: cty.String, Required: false},
+		"user_id":                       &hcldec.AttrSpec{Name: "user_id", Type: cty.String, Required: false},
+		"password":                      &hcldec.AttrSpec{Name: "password", Type: cty.String, Required: false},
+		"identity_endpoint":             &hcldec.AttrSpec{Name: "identity_endpoint", Type: cty.String, Required: false},
+		"tenant_id":                     &hcldec.AttrSpec{Name: "tenant_id", Type: cty.String, Required: false},
+		"tenant_name":                   &hcldec.AttrSpec{Name: "tenant_name", Type: cty.String, Required: false},
+		"domain_id":                     &hcldec.AttrSpec{Name: "domain_id", Type: cty.String, Required: false},
+		"domain_name":                   &hcldec.AttrSpec{Name: "domain_name", Type: cty.String, Required: false},
+		"insecure":                      &hcldec.AttrSpec{Name: "insecure", Type: cty.Bool, Required: false},
+		"region":                        &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"endpoint_type":                 &hcldec.AttrSpec{Name: "endpoint_type", Type: cty.String, Required: false},
+		"cacert":                        &hcldec.AttrSpec{Name: "cacert", Type: cty.String, Required: false},
+		"cert":                          &hcldec.AttrSpec{Name: "cert", Type: cty.String, Required: false},
+		"key":                           &hcldec.AttrSpec{Name: "key", Type: cty.String, Required: false},
+		"token":                         &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"application_credential_name":   &hcldec.AttrSpec{Name: "application_credential_name", Type: cty.String, Required: false},
+		"application_credential_id":     &hcldec.AttrSpec{Name: "application_credential_id", Type: cty.String, Required: false},
+		"application_credential_secret": &hcldec.AttrSpec{Name: "application_credential_secret", Type: cty.String, Required: false},
+		"cloud":                         &hcldec.AttrSpec{Name: "cloud", Type: cty.String, Required: false},
+		"image_name":                    &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"metadata":                      &hcldec.BlockAttrsSpec{TypeName: "metadata", ElementType: cty.String, Required: false},
+		"image_visibility":              &hcldec.AttrSpec{Name: "images.ImageVisibility", Type: cty.String, Required: false},
+		"image_members":                 &hcldec.AttrSpec{Name: "image_members", Type: cty.List(cty.String), Required: false},
+		"image_disk_format":             &hcldec.AttrSpec{Name: "image_disk_format", Type: cty.String, Required: false},
+		"image_tags":                    &hcldec.AttrSpec{Name: "image_tags", Type: cty.List(cty.String), Required: false},
+		"image_min_disk":                &hcldec.AttrSpec{Name: "image_min_disk", Type: cty.Number, Required: false},
+		"communicator":                  &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":       &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                      &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                      &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                  &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                  &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":              &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":       &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":     &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":          &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                       &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                   &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":  &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":        &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":              &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":              &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":        &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":          &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":          &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":  &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":      &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":            &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":            &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":       &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":        &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":            &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":             &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":               &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                    &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                    &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                 &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                 &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_interface":                 &hcldec.AttrSpec{Name: "ssh_interface", Type: cty.String, Required: false},
+		"ssh_ip_version":                &hcldec.AttrSpec{Name: "ssh_ip_version", Type: cty.String, Required: false},
+		"source_image":                  &hcldec.AttrSpec{Name: "source_image", Type: cty.String, Required: false},
+		"source_image_name":             &hcldec.AttrSpec{Name: "source_image_name", Type: cty.String, Required: false},
+		"source_image_filter":           &hcldec.BlockSpec{TypeName: "source_image_filter", Nested: hcldec.ObjectSpec((*FlatImageFilter)(nil).HCL2Spec())},
+		"flavor":                        &hcldec.AttrSpec{Name: "flavor", Type: cty.String, Required: false},
+		"availability_zone":             &hcldec.AttrSpec{Name: "availability_zone", Type: cty.String, Required: false},
+		"rackconnect_wait":              &hcldec.AttrSpec{Name: "rackconnect_wait", Type: cty.Bool, Required: false},
+		"floating_ip_network":           &hcldec.AttrSpec{Name: "floating_ip_network", Type: cty.String, Required: false},
+		"instance_floating_ip_net":      &hcldec.AttrSpec{Name: "instance_floating_ip_net", Type: cty.String, Required: false},
+		"floating_ip":                   &hcldec.AttrSpec{Name: "floating_ip", Type: cty.String, Required: false},
+		"reuse_ips":                     &hcldec.AttrSpec{Name: "reuse_ips", Type: cty.Bool, Required: false},
+		"security_groups":               &hcldec.AttrSpec{Name: "security_groups", Type: cty.List(cty.String), Required: false},
+		"networks":                      &hcldec.AttrSpec{Name: "networks", Type: cty.List(cty.String), Required: false},
+		"ports":                         &hcldec.AttrSpec{Name: "ports", Type: cty.List(cty.String), Required: false},
+		"user_data":                     &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":                &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"instance_name":                 &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"instance_metadata":             &hcldec.BlockAttrsSpec{TypeName: "instance_metadata", ElementType: cty.String, Required: false},
+		"force_delete":                  &hcldec.AttrSpec{Name: "force_delete", Type: cty.Bool, Required: false},
+		"config_drive":                  &hcldec.AttrSpec{Name: "config_drive", Type: cty.Bool, Required: false},
+		"floating_ip_pool":              &hcldec.AttrSpec{Name: "floating_ip_pool", Type: cty.String, Required: false},
+		"use_blockstorage_volume":       &hcldec.AttrSpec{Name: "use_blockstorage_volume", Type: cty.Bool, Required: false},
+		"volume_name":                   &hcldec.AttrSpec{Name: "volume_name", Type: cty.String, Required: false},
+		"volume_type":                   &hcldec.AttrSpec{Name: "volume_type", Type: cty.String, Required: false},
+		"volume_size":                   &hcldec.AttrSpec{Name: "volume_size", Type: cty.Number, Required: false},
+		"volume_availability_zone":      &hcldec.AttrSpec{Name: "volume_availability_zone", Type: cty.String, Required: false},
+		"openstack_provider":            &hcldec.AttrSpec{Name: "openstack_provider", Type: cty.String, Required: false},
+		"use_floating_ip":               &hcldec.AttrSpec{Name: "use_floating_ip", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatImageFilter is an auto-generated flat version of ImageFilter.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatImageFilter struct {
+	Filters    *FlatImageFilterOptions `mapstructure:"filters" required:"false" cty:"filters"`
+	MostRecent *bool                   `mapstructure:"most_recent" required:"false" cty:"most_recent"`
+}
+
+// FlatMapstructure returns a new FlatImageFilter.
+// FlatImageFilter is an auto-generated flat version of ImageFilter.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*ImageFilter) FlatMapstructure() interface{} { return new(FlatImageFilter) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatImageFilter.
+// This spec is used by HCL to read the fields of FlatImageFilter.
+func (*FlatImageFilter) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"filters":     &hcldec.BlockSpec{TypeName: "filters", Nested: hcldec.ObjectSpec((*FlatImageFilterOptions)(nil).HCL2Spec())},
+		"most_recent": &hcldec.AttrSpec{Name: "most_recent", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatImageFilterOptions is an auto-generated flat version of ImageFilterOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatImageFilterOptions struct {
+	Name       *string           `mapstructure:"name" cty:"name"`
+	Owner      *string           `mapstructure:"owner" cty:"owner"`
+	Tags       []string          `mapstructure:"tags" cty:"tags"`
+	Visibility *string           `mapstructure:"visibility" cty:"visibility"`
+	Properties map[string]string `mapstructure:"properties" cty:"properties"`
+}
+
+// FlatMapstructure returns a new FlatImageFilterOptions.
+// FlatImageFilterOptions is an auto-generated flat version of ImageFilterOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*ImageFilterOptions) FlatMapstructure() interface{} { return new(FlatImageFilterOptions) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatImageFilterOptions.
+// This spec is used by HCL to read the fields of FlatImageFilterOptions.
+func (*FlatImageFilterOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"name":       &hcldec.AttrSpec{Name: "name", Type: cty.String, Required: false},
+		"owner":      &hcldec.AttrSpec{Name: "owner", Type: cty.String, Required: false},
+		"tags":       &hcldec.AttrSpec{Name: "tags", Type: cty.List(cty.String), Required: false},
+		"visibility": &hcldec.AttrSpec{Name: "visibility", Type: cty.String, Required: false},
+		"properties": &hcldec.BlockAttrsSpec{TypeName: "properties", ElementType: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/oracle/classic/config.go b/builder/oracle/classic/config.go
index 7809b5259..4fc1ddb15 100644
--- a/builder/oracle/classic/config.go
+++ b/builder/oracle/classic/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package classic
 
 import (
diff --git a/builder/oracle/classic/config.hcl2spec.go b/builder/oracle/classic/config.hcl2spec.go
new file mode 100644
index 000000000..a65bc849e
--- /dev/null
+++ b/builder/oracle/classic/config.hcl2spec.go
@@ -0,0 +1,160 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package classic
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/hashicorp/packer/helper/communicator"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string                  `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string                  `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool                    `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool                    `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string                  `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string        `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string                 `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	PersistentVolumeSize      *int                     `mapstructure:"persistent_volume_size" cty:"persistent_volume_size"`
+	BuilderUploadImageCommand *string                  `mapstructure:"builder_upload_image_command" cty:"builder_upload_image_command"`
+	BuilderShape              *string                  `mapstructure:"builder_shape" cty:"builder_shape"`
+	BuilderImageList          *string                  `mapstructure:"builder_image_list" cty:"builder_image_list"`
+	BuilderImageListEntry     *int                     `mapstructure:"builder_image_list_entry" cty:"builder_image_list_entry"`
+	BuilderComm               *communicator.FlatConfig `mapstructure:"builder_communicator" cty:"builder_communicator"`
+	Type                      *string                  `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string                  `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string                  `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int                     `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string                  `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string                  `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string                  `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string                  `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool                    `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string                  `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool                    `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string                  `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool                    `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool                    `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int                     `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string                  `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int                     `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool                    `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string                  `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string                  `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string                  `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string                  `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string                  `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int                     `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string                  `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string                  `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string                  `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string                  `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string                 `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string                 `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte                   `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte                   `cty:"ssh_private_key"`
+	WinRMUser                 *string                  `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string                  `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string                  `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int                     `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string                  `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool                    `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool                    `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool                    `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	Username                  *string                  `mapstructure:"username" cty:"username"`
+	Password                  *string                  `mapstructure:"password" cty:"password"`
+	IdentityDomain            *string                  `mapstructure:"identity_domain" cty:"identity_domain"`
+	APIEndpoint               *string                  `mapstructure:"api_endpoint" cty:"api_endpoint"`
+	ImageName                 *string                  `mapstructure:"image_name" cty:"image_name"`
+	Shape                     *string                  `mapstructure:"shape" cty:"shape"`
+	SourceImageList           *string                  `mapstructure:"source_image_list" cty:"source_image_list"`
+	SourceImageListEntry      *int                     `mapstructure:"source_image_list_entry" cty:"source_image_list_entry"`
+	SnapshotTimeout           *string                  `mapstructure:"snapshot_timeout" cty:"snapshot_timeout"`
+	DestImageList             *string                  `mapstructure:"dest_image_list" cty:"dest_image_list"`
+	Attributes                *string                  `mapstructure:"attributes" cty:"attributes"`
+	AttributesFile            *string                  `mapstructure:"attributes_file" cty:"attributes_file"`
+	DestImageListDescription  *string                  `mapstructure:"image_description" cty:"image_description"`
+	SSHSourceList             *string                  `mapstructure:"ssh_source_list" cty:"ssh_source_list"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"persistent_volume_size":       &hcldec.AttrSpec{Name: "persistent_volume_size", Type: cty.Number, Required: false},
+		"builder_upload_image_command": &hcldec.AttrSpec{Name: "builder_upload_image_command", Type: cty.String, Required: false},
+		"builder_shape":                &hcldec.AttrSpec{Name: "builder_shape", Type: cty.String, Required: false},
+		"builder_image_list":           &hcldec.AttrSpec{Name: "builder_image_list", Type: cty.String, Required: false},
+		"builder_image_list_entry":     &hcldec.AttrSpec{Name: "builder_image_list_entry", Type: cty.Number, Required: false},
+		"builder_communicator":         &hcldec.BlockSpec{TypeName: "builder_communicator", Nested: hcldec.ObjectSpec((*communicator.FlatConfig)(nil).HCL2Spec())},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"username":                     &hcldec.AttrSpec{Name: "username", Type: cty.String, Required: false},
+		"password":                     &hcldec.AttrSpec{Name: "password", Type: cty.String, Required: false},
+		"identity_domain":              &hcldec.AttrSpec{Name: "identity_domain", Type: cty.String, Required: false},
+		"api_endpoint":                 &hcldec.AttrSpec{Name: "api_endpoint", Type: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"shape":                        &hcldec.AttrSpec{Name: "shape", Type: cty.String, Required: false},
+		"source_image_list":            &hcldec.AttrSpec{Name: "source_image_list", Type: cty.String, Required: false},
+		"source_image_list_entry":      &hcldec.AttrSpec{Name: "source_image_list_entry", Type: cty.Number, Required: false},
+		"snapshot_timeout":             &hcldec.AttrSpec{Name: "snapshot_timeout", Type: cty.String, Required: false},
+		"dest_image_list":              &hcldec.AttrSpec{Name: "dest_image_list", Type: cty.String, Required: false},
+		"attributes":                   &hcldec.AttrSpec{Name: "attributes", Type: cty.String, Required: false},
+		"attributes_file":              &hcldec.AttrSpec{Name: "attributes_file", Type: cty.String, Required: false},
+		"image_description":            &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"ssh_source_list":              &hcldec.AttrSpec{Name: "ssh_source_list", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/oracle/oci/config.go b/builder/oracle/oci/config.go
index acb3b1573..2d11cb05a 100644
--- a/builder/oracle/oci/config.go
+++ b/builder/oracle/oci/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package oci
 
 import (
diff --git a/builder/oracle/oci/config.hcl2spec.go b/builder/oracle/oci/config.hcl2spec.go
new file mode 100644
index 000000000..78980b963
--- /dev/null
+++ b/builder/oracle/oci/config.hcl2spec.go
@@ -0,0 +1,161 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package oci
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string                           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string                           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool                             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool                             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string                           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string                 `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string                          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string                           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string                           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string                           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int                              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string                           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string                           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string                           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string                           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool                             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string                           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool                             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string                           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool                             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool                             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int                              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string                           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int                              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool                             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string                           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string                           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string                           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string                           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string                           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int                              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string                           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string                           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string                           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string                           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string                          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string                          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte                            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte                            `cty:"ssh_private_key"`
+	WinRMUser                 *string                           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string                           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string                           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int                              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string                           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool                             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool                             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool                             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	AccessCfgFile             *string                           `mapstructure:"access_cfg_file" cty:"access_cfg_file"`
+	AccessCfgFileAccount      *string                           `mapstructure:"access_cfg_file_account" cty:"access_cfg_file_account"`
+	UserID                    *string                           `mapstructure:"user_ocid" cty:"user_ocid"`
+	TenancyID                 *string                           `mapstructure:"tenancy_ocid" cty:"tenancy_ocid"`
+	Region                    *string                           `mapstructure:"region" cty:"region"`
+	Fingerprint               *string                           `mapstructure:"fingerprint" cty:"fingerprint"`
+	KeyFile                   *string                           `mapstructure:"key_file" cty:"key_file"`
+	PassPhrase                *string                           `mapstructure:"pass_phrase" cty:"pass_phrase"`
+	UsePrivateIP              *bool                             `mapstructure:"use_private_ip" cty:"use_private_ip"`
+	AvailabilityDomain        *string                           `mapstructure:"availability_domain" cty:"availability_domain"`
+	CompartmentID             *string                           `mapstructure:"compartment_ocid" cty:"compartment_ocid"`
+	BaseImageID               *string                           `mapstructure:"base_image_ocid" cty:"base_image_ocid"`
+	Shape                     *string                           `mapstructure:"shape" cty:"shape"`
+	ImageName                 *string                           `mapstructure:"image_name" cty:"image_name"`
+	InstanceName              *string                           `mapstructure:"instance_name" cty:"instance_name"`
+	Metadata                  map[string]string                 `mapstructure:"metadata" cty:"metadata"`
+	UserData                  *string                           `mapstructure:"user_data" cty:"user_data"`
+	UserDataFile              *string                           `mapstructure:"user_data_file" cty:"user_data_file"`
+	SubnetID                  *string                           `mapstructure:"subnet_ocid" cty:"subnet_ocid"`
+	Tags                      map[string]string                 `mapstructure:"tags" cty:"tags"`
+	DefinedTags               map[string]map[string]interface{} `mapstructure:"defined_tags" cty:"defined_tags"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"access_cfg_file":              &hcldec.AttrSpec{Name: "access_cfg_file", Type: cty.String, Required: false},
+		"access_cfg_file_account":      &hcldec.AttrSpec{Name: "access_cfg_file_account", Type: cty.String, Required: false},
+		"user_ocid":                    &hcldec.AttrSpec{Name: "user_ocid", Type: cty.String, Required: false},
+		"tenancy_ocid":                 &hcldec.AttrSpec{Name: "tenancy_ocid", Type: cty.String, Required: false},
+		"region":                       &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"fingerprint":                  &hcldec.AttrSpec{Name: "fingerprint", Type: cty.String, Required: false},
+		"key_file":                     &hcldec.AttrSpec{Name: "key_file", Type: cty.String, Required: false},
+		"pass_phrase":                  &hcldec.AttrSpec{Name: "pass_phrase", Type: cty.String, Required: false},
+		"use_private_ip":               &hcldec.AttrSpec{Name: "use_private_ip", Type: cty.Bool, Required: false},
+		"availability_domain":          &hcldec.AttrSpec{Name: "availability_domain", Type: cty.String, Required: false},
+		"compartment_ocid":             &hcldec.AttrSpec{Name: "compartment_ocid", Type: cty.String, Required: false},
+		"base_image_ocid":              &hcldec.AttrSpec{Name: "base_image_ocid", Type: cty.String, Required: false},
+		"shape":                        &hcldec.AttrSpec{Name: "shape", Type: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"instance_name":                &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"metadata":                     &hcldec.BlockAttrsSpec{TypeName: "metadata", ElementType: cty.String, Required: false},
+		"user_data":                    &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":               &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"subnet_ocid":                  &hcldec.AttrSpec{Name: "subnet_ocid", Type: cty.String, Required: false},
+		"tags":                         &hcldec.BlockAttrsSpec{TypeName: "tags", ElementType: cty.String, Required: false},
+		"defined_tags":                 &hcldec.BlockAttrsSpec{TypeName: "defined_tags", ElementType: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/osc/bsu/builder.go b/builder/osc/bsu/builder.go
index 798371723..ab4280417 100644
--- a/builder/osc/bsu/builder.go
+++ b/builder/osc/bsu/builder.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // Package bsu contains a packer.Builder implementation that
 // builds OMIs for Outscale OAPI.
 //
diff --git a/builder/osc/bsu/builder.hcl2spec.go b/builder/osc/bsu/builder.hcl2spec.go
new file mode 100644
index 000000000..8bc75d0f7
--- /dev/null
+++ b/builder/osc/bsu/builder.hcl2spec.go
@@ -0,0 +1,226 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package bsu
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/hashicorp/packer/builder/osc/common"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName             *string                                `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType           *string                                `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                 *bool                                  `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                 *bool                                  `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError               *string                                `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars              map[string]string                      `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars         []string                               `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AccessKey                   *string                                `mapstructure:"access_key" cty:"access_key"`
+	CustomEndpointOAPI          *string                                `mapstructure:"custom_endpoint_oapi" cty:"custom_endpoint_oapi"`
+	InsecureSkipTLSVerify       *bool                                  `mapstructure:"insecure_skip_tls_verify" cty:"insecure_skip_tls_verify"`
+	MFACode                     *string                                `mapstructure:"mfa_code" cty:"mfa_code"`
+	ProfileName                 *string                                `mapstructure:"profile" cty:"profile"`
+	RawRegion                   *string                                `mapstructure:"region" cty:"region"`
+	SecretKey                   *string                                `mapstructure:"secret_key" cty:"secret_key"`
+	SkipValidation              *bool                                  `mapstructure:"skip_region_validation" cty:"skip_region_validation"`
+	SkipMetadataApiCheck        *bool                                  `mapstructure:"skip_metadata_api_check" cty:"skip_metadata_api_check"`
+	Token                       *string                                `mapstructure:"token" cty:"token"`
+	OMIName                     *string                                `mapstructure:"omi_name" cty:"omi_name"`
+	OMIDescription              *string                                `mapstructure:"omi_description" cty:"omi_description"`
+	OMIVirtType                 *string                                `mapstructure:"omi_virtualization_type" cty:"omi_virtualization_type"`
+	OMIAccountIDs               []string                               `mapstructure:"omi_account_ids" cty:"omi_account_ids"`
+	OMIGroups                   []string                               `mapstructure:"omi_groups" cty:"omi_groups"`
+	OMIProductCodes             []string                               `mapstructure:"omi_product_codes" cty:"omi_product_codes"`
+	OMIRegions                  []string                               `mapstructure:"omi_regions" cty:"omi_regions"`
+	OMITags                     common.TagMap                          `mapstructure:"tags" cty:"tags"`
+	OMIForceDeregister          *bool                                  `mapstructure:"force_deregister" cty:"force_deregister"`
+	OMIForceDeleteSnapshot      *bool                                  `mapstructure:"force_delete_snapshot" cty:"force_delete_snapshot"`
+	SnapshotTags                common.TagMap                          `mapstructure:"snapshot_tags" cty:"snapshot_tags"`
+	SnapshotAccountIDs          []string                               `mapstructure:"snapshot_account_ids" cty:"snapshot_account_ids"`
+	SnapshotGroups              []string                               `mapstructure:"snapshot_groups" cty:"snapshot_groups"`
+	OMIMappings                 []common.FlatBlockDevice               `mapstructure:"omi_block_device_mappings" cty:"omi_block_device_mappings"`
+	LaunchMappings              []common.FlatBlockDevice               `mapstructure:"launch_block_device_mappings" cty:"launch_block_device_mappings"`
+	AssociatePublicIpAddress    *bool                                  `mapstructure:"associate_public_ip_address" cty:"associate_public_ip_address"`
+	Subregion                   *string                                `mapstructure:"subregion_name" cty:"subregion_name"`
+	BlockDurationMinutes        *int64                                 `mapstructure:"block_duration_minutes" cty:"block_duration_minutes"`
+	DisableStopVm               *bool                                  `mapstructure:"disable_stop_vm" cty:"disable_stop_vm"`
+	BsuOptimized                *bool                                  `mapstructure:"bsu_optimized" cty:"bsu_optimized"`
+	EnableT2Unlimited           *bool                                  `mapstructure:"enable_t2_unlimited" cty:"enable_t2_unlimited"`
+	IamVmProfile                *string                                `mapstructure:"iam_vm_profile" cty:"iam_vm_profile"`
+	VmInitiatedShutdownBehavior *string                                `mapstructure:"shutdown_behavior" cty:"shutdown_behavior"`
+	VmType                      *string                                `mapstructure:"vm_type" cty:"vm_type"`
+	SecurityGroupFilter         *common.FlatSecurityGroupFilterOptions `mapstructure:"security_group_filter" cty:"security_group_filter"`
+	RunTags                     map[string]string                      `mapstructure:"run_tags" cty:"run_tags"`
+	SecurityGroupId             *string                                `mapstructure:"security_group_id" cty:"security_group_id"`
+	SecurityGroupIds            []string                               `mapstructure:"security_group_ids" cty:"security_group_ids"`
+	SourceOmi                   *string                                `mapstructure:"source_omi" cty:"source_omi"`
+	SourceOmiFilter             *common.FlatOmiFilterOptions           `mapstructure:"source_omi_filter" cty:"source_omi_filter"`
+	SpotPrice                   *string                                `mapstructure:"spot_price" cty:"spot_price"`
+	SpotPriceAutoProduct        *string                                `mapstructure:"spot_price_auto_product" cty:"spot_price_auto_product"`
+	SpotTags                    map[string]string                      `mapstructure:"spot_tags" cty:"spot_tags"`
+	SubnetFilter                *common.FlatSubnetFilterOptions        `mapstructure:"subnet_filter" cty:"subnet_filter"`
+	SubnetId                    *string                                `mapstructure:"subnet_id" cty:"subnet_id"`
+	TemporaryKeyPairName        *string                                `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	TemporarySGSourceCidr       *string                                `mapstructure:"temporary_security_group_source_cidr" cty:"temporary_security_group_source_cidr"`
+	UserData                    *string                                `mapstructure:"user_data" cty:"user_data"`
+	UserDataFile                *string                                `mapstructure:"user_data_file" cty:"user_data_file"`
+	NetFilter                   *common.FlatNetFilterOptions           `mapstructure:"net_filter" cty:"net_filter"`
+	NetId                       *string                                `mapstructure:"net_id" cty:"net_id"`
+	WindowsPasswordTimeout      *string                                `mapstructure:"windows_password_timeout" cty:"windows_password_timeout"`
+	Type                        *string                                `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect          *string                                `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                     *string                                `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                     *int                                   `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                 *string                                `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                 *string                                `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName              *string                                `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHClearAuthorizedKeys      *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile           *string                                `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                      *bool                                  `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                  *string                                `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                *bool                                  `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding   *bool                                  `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts        *int                                   `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost              *string                                `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort              *int                                   `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth         *bool                                  `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername          *string                                `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword          *string                                `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile    *string                                `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod       *string                                `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                *string                                `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                *int                                   `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername            *string                                `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword            *string                                `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval        *string                                `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout         *string                                `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels            []string                               `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels             []string                               `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                []byte                                 `cty:"ssh_public_key"`
+	SSHPrivateKey               []byte                                 `cty:"ssh_private_key"`
+	WinRMUser                   *string                                `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword               *string                                `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                   *string                                `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                   *int                                   `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                *string                                `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                 *bool                                  `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure               *bool                                  `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                *bool                                  `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHInterface                *string                                `mapstructure:"ssh_interface" cty:"ssh_interface"`
+	VolumeRunTags               common.TagMap                          `mapstructure:"run_volume_tags" cty:"run_volume_tags"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":                    &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":                  &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                         &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                         &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                      &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":                &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":           &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"access_key":                           &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"custom_endpoint_oapi":                 &hcldec.AttrSpec{Name: "custom_endpoint_oapi", Type: cty.String, Required: false},
+		"insecure_skip_tls_verify":             &hcldec.AttrSpec{Name: "insecure_skip_tls_verify", Type: cty.Bool, Required: false},
+		"mfa_code":                             &hcldec.AttrSpec{Name: "mfa_code", Type: cty.String, Required: false},
+		"profile":                              &hcldec.AttrSpec{Name: "profile", Type: cty.String, Required: false},
+		"region":                               &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"secret_key":                           &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"skip_region_validation":               &hcldec.AttrSpec{Name: "skip_region_validation", Type: cty.Bool, Required: false},
+		"skip_metadata_api_check":              &hcldec.AttrSpec{Name: "skip_metadata_api_check", Type: cty.Bool, Required: false},
+		"token":                                &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"omi_name":                             &hcldec.AttrSpec{Name: "omi_name", Type: cty.String, Required: false},
+		"omi_description":                      &hcldec.AttrSpec{Name: "omi_description", Type: cty.String, Required: false},
+		"omi_virtualization_type":              &hcldec.AttrSpec{Name: "omi_virtualization_type", Type: cty.String, Required: false},
+		"omi_account_ids":                      &hcldec.AttrSpec{Name: "omi_account_ids", Type: cty.List(cty.String), Required: false},
+		"omi_groups":                           &hcldec.AttrSpec{Name: "omi_groups", Type: cty.List(cty.String), Required: false},
+		"omi_product_codes":                    &hcldec.AttrSpec{Name: "omi_product_codes", Type: cty.List(cty.String), Required: false},
+		"omi_regions":                          &hcldec.AttrSpec{Name: "omi_regions", Type: cty.List(cty.String), Required: false},
+		"tags":                                 &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+		"force_deregister":                     &hcldec.AttrSpec{Name: "force_deregister", Type: cty.Bool, Required: false},
+		"force_delete_snapshot":                &hcldec.AttrSpec{Name: "force_delete_snapshot", Type: cty.Bool, Required: false},
+		"snapshot_tags":                        &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+		"snapshot_account_ids":                 &hcldec.AttrSpec{Name: "snapshot_account_ids", Type: cty.List(cty.String), Required: false},
+		"snapshot_groups":                      &hcldec.AttrSpec{Name: "snapshot_groups", Type: cty.List(cty.String), Required: false},
+		"omi_block_device_mappings":            &hcldec.BlockListSpec{TypeName: "omi_block_device_mappings", Nested: &hcldec.BlockSpec{TypeName: "omi_block_device_mappings", Nested: hcldec.ObjectSpec((*common.FlatBlockDevice)(nil).HCL2Spec())}},
+		"launch_block_device_mappings":         &hcldec.BlockListSpec{TypeName: "launch_block_device_mappings", Nested: &hcldec.BlockSpec{TypeName: "launch_block_device_mappings", Nested: hcldec.ObjectSpec((*common.FlatBlockDevice)(nil).HCL2Spec())}},
+		"associate_public_ip_address":          &hcldec.AttrSpec{Name: "associate_public_ip_address", Type: cty.Bool, Required: false},
+		"subregion_name":                       &hcldec.AttrSpec{Name: "subregion_name", Type: cty.String, Required: false},
+		"block_duration_minutes":               &hcldec.AttrSpec{Name: "block_duration_minutes", Type: cty.Number, Required: false},
+		"disable_stop_vm":                      &hcldec.AttrSpec{Name: "disable_stop_vm", Type: cty.Bool, Required: false},
+		"bsu_optimized":                        &hcldec.AttrSpec{Name: "bsu_optimized", Type: cty.Bool, Required: false},
+		"enable_t2_unlimited":                  &hcldec.AttrSpec{Name: "enable_t2_unlimited", Type: cty.Bool, Required: false},
+		"iam_vm_profile":                       &hcldec.AttrSpec{Name: "iam_vm_profile", Type: cty.String, Required: false},
+		"shutdown_behavior":                    &hcldec.AttrSpec{Name: "shutdown_behavior", Type: cty.String, Required: false},
+		"vm_type":                              &hcldec.AttrSpec{Name: "vm_type", Type: cty.String, Required: false},
+		"security_group_filter":                &hcldec.BlockSpec{TypeName: "security_group_filter", Nested: hcldec.ObjectSpec((*common.FlatSecurityGroupFilterOptions)(nil).HCL2Spec())},
+		"run_tags":                             &hcldec.BlockAttrsSpec{TypeName: "run_tags", ElementType: cty.String, Required: false},
+		"security_group_id":                    &hcldec.AttrSpec{Name: "security_group_id", Type: cty.String, Required: false},
+		"security_group_ids":                   &hcldec.AttrSpec{Name: "security_group_ids", Type: cty.List(cty.String), Required: false},
+		"source_omi":                           &hcldec.AttrSpec{Name: "source_omi", Type: cty.String, Required: false},
+		"source_omi_filter":                    &hcldec.BlockSpec{TypeName: "source_omi_filter", Nested: hcldec.ObjectSpec((*common.FlatOmiFilterOptions)(nil).HCL2Spec())},
+		"spot_price":                           &hcldec.AttrSpec{Name: "spot_price", Type: cty.String, Required: false},
+		"spot_price_auto_product":              &hcldec.AttrSpec{Name: "spot_price_auto_product", Type: cty.String, Required: false},
+		"spot_tags":                            &hcldec.BlockAttrsSpec{TypeName: "spot_tags", ElementType: cty.String, Required: false},
+		"subnet_filter":                        &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
+		"subnet_id":                            &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
+		"temporary_key_pair_name":              &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"temporary_security_group_source_cidr": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidr", Type: cty.String, Required: false},
+		"user_data":                            &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":                       &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"net_filter":                           &hcldec.BlockSpec{TypeName: "net_filter", Nested: hcldec.ObjectSpec((*common.FlatNetFilterOptions)(nil).HCL2Spec())},
+		"net_id":                               &hcldec.AttrSpec{Name: "net_id", Type: cty.String, Required: false},
+		"windows_password_timeout":             &hcldec.AttrSpec{Name: "windows_password_timeout", Type: cty.String, Required: false},
+		"communicator":                         &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":              &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                             &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                             &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                         &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                         &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":                     &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":            &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":                 &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                              &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                          &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                       &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":         &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":               &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":                     &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":                     &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":               &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":                 &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":                 &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":         &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":             &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                       &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                       &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":                   &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":                   &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":              &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":               &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":                   &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":                    &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                       &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                      &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                       &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                       &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                           &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                           &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                        &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                        &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                       &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                       &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_interface":                        &hcldec.AttrSpec{Name: "ssh_interface", Type: cty.String, Required: false},
+		"run_volume_tags":                      &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/osc/bsuvolume/builder.go b/builder/osc/bsuvolume/builder.go
index 96d5531d3..e0b5a8fa7 100644
--- a/builder/osc/bsuvolume/builder.go
+++ b/builder/osc/bsuvolume/builder.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config,BlockDevice
+
 // The ebsvolume package contains a packer.Builder implementation that
 // builds EBS volumes for Outscale using an ephemeral instance,
 package bsuvolume
diff --git a/builder/osc/bsuvolume/builder.hcl2spec.go b/builder/osc/bsuvolume/builder.hcl2spec.go
new file mode 100644
index 000000000..70789c634
--- /dev/null
+++ b/builder/osc/bsuvolume/builder.hcl2spec.go
@@ -0,0 +1,232 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,BlockDevice"; DO NOT EDIT.
+package bsuvolume
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/hashicorp/packer/builder/osc/common"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatBlockDevice is an auto-generated flat version of BlockDevice.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatBlockDevice struct {
+	DeleteOnVmDeletion *bool         `mapstructure:"delete_on_vm_deletion" cty:"delete_on_vm_deletion"`
+	DeviceName         *string       `mapstructure:"device_name" cty:"device_name"`
+	IOPS               *int64        `mapstructure:"iops" cty:"iops"`
+	NoDevice           *bool         `mapstructure:"no_device" cty:"no_device"`
+	SnapshotId         *string       `mapstructure:"snapshot_id" cty:"snapshot_id"`
+	VirtualName        *string       `mapstructure:"virtual_name" cty:"virtual_name"`
+	VolumeType         *string       `mapstructure:"volume_type" cty:"volume_type"`
+	VolumeSize         *int64        `mapstructure:"volume_size" cty:"volume_size"`
+	Tags               common.TagMap `mapstructure:"tags" cty:"tags"`
+}
+
+// FlatMapstructure returns a new FlatBlockDevice.
+// FlatBlockDevice is an auto-generated flat version of BlockDevice.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*BlockDevice) FlatMapstructure() interface{} { return new(FlatBlockDevice) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatBlockDevice.
+// This spec is used by HCL to read the fields of FlatBlockDevice.
+func (*FlatBlockDevice) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"delete_on_vm_deletion": &hcldec.AttrSpec{Name: "delete_on_vm_deletion", Type: cty.Bool, Required: false},
+		"device_name":           &hcldec.AttrSpec{Name: "device_name", Type: cty.String, Required: false},
+		"iops":                  &hcldec.AttrSpec{Name: "iops", Type: cty.Number, Required: false},
+		"no_device":             &hcldec.AttrSpec{Name: "no_device", Type: cty.Bool, Required: false},
+		"snapshot_id":           &hcldec.AttrSpec{Name: "snapshot_id", Type: cty.String, Required: false},
+		"virtual_name":          &hcldec.AttrSpec{Name: "virtual_name", Type: cty.String, Required: false},
+		"volume_type":           &hcldec.AttrSpec{Name: "volume_type", Type: cty.String, Required: false},
+		"volume_size":           &hcldec.AttrSpec{Name: "volume_size", Type: cty.Number, Required: false},
+		"tags":                  &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+	}
+	return s
+}
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName             *string                                `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType           *string                                `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                 *bool                                  `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                 *bool                                  `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError               *string                                `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars              map[string]string                      `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars         []string                               `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AccessKey                   *string                                `mapstructure:"access_key" cty:"access_key"`
+	CustomEndpointOAPI          *string                                `mapstructure:"custom_endpoint_oapi" cty:"custom_endpoint_oapi"`
+	InsecureSkipTLSVerify       *bool                                  `mapstructure:"insecure_skip_tls_verify" cty:"insecure_skip_tls_verify"`
+	MFACode                     *string                                `mapstructure:"mfa_code" cty:"mfa_code"`
+	ProfileName                 *string                                `mapstructure:"profile" cty:"profile"`
+	RawRegion                   *string                                `mapstructure:"region" cty:"region"`
+	SecretKey                   *string                                `mapstructure:"secret_key" cty:"secret_key"`
+	SkipValidation              *bool                                  `mapstructure:"skip_region_validation" cty:"skip_region_validation"`
+	SkipMetadataApiCheck        *bool                                  `mapstructure:"skip_metadata_api_check" cty:"skip_metadata_api_check"`
+	Token                       *string                                `mapstructure:"token" cty:"token"`
+	AssociatePublicIpAddress    *bool                                  `mapstructure:"associate_public_ip_address" cty:"associate_public_ip_address"`
+	Subregion                   *string                                `mapstructure:"subregion_name" cty:"subregion_name"`
+	BlockDurationMinutes        *int64                                 `mapstructure:"block_duration_minutes" cty:"block_duration_minutes"`
+	DisableStopVm               *bool                                  `mapstructure:"disable_stop_vm" cty:"disable_stop_vm"`
+	BsuOptimized                *bool                                  `mapstructure:"bsu_optimized" cty:"bsu_optimized"`
+	EnableT2Unlimited           *bool                                  `mapstructure:"enable_t2_unlimited" cty:"enable_t2_unlimited"`
+	IamVmProfile                *string                                `mapstructure:"iam_vm_profile" cty:"iam_vm_profile"`
+	VmInitiatedShutdownBehavior *string                                `mapstructure:"shutdown_behavior" cty:"shutdown_behavior"`
+	VmType                      *string                                `mapstructure:"vm_type" cty:"vm_type"`
+	SecurityGroupFilter         *common.FlatSecurityGroupFilterOptions `mapstructure:"security_group_filter" cty:"security_group_filter"`
+	RunTags                     map[string]string                      `mapstructure:"run_tags" cty:"run_tags"`
+	SecurityGroupId             *string                                `mapstructure:"security_group_id" cty:"security_group_id"`
+	SecurityGroupIds            []string                               `mapstructure:"security_group_ids" cty:"security_group_ids"`
+	SourceOmi                   *string                                `mapstructure:"source_omi" cty:"source_omi"`
+	SourceOmiFilter             *common.FlatOmiFilterOptions           `mapstructure:"source_omi_filter" cty:"source_omi_filter"`
+	SpotPrice                   *string                                `mapstructure:"spot_price" cty:"spot_price"`
+	SpotPriceAutoProduct        *string                                `mapstructure:"spot_price_auto_product" cty:"spot_price_auto_product"`
+	SpotTags                    map[string]string                      `mapstructure:"spot_tags" cty:"spot_tags"`
+	SubnetFilter                *common.FlatSubnetFilterOptions        `mapstructure:"subnet_filter" cty:"subnet_filter"`
+	SubnetId                    *string                                `mapstructure:"subnet_id" cty:"subnet_id"`
+	TemporaryKeyPairName        *string                                `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	TemporarySGSourceCidr       *string                                `mapstructure:"temporary_security_group_source_cidr" cty:"temporary_security_group_source_cidr"`
+	UserData                    *string                                `mapstructure:"user_data" cty:"user_data"`
+	UserDataFile                *string                                `mapstructure:"user_data_file" cty:"user_data_file"`
+	NetFilter                   *common.FlatNetFilterOptions           `mapstructure:"net_filter" cty:"net_filter"`
+	NetId                       *string                                `mapstructure:"net_id" cty:"net_id"`
+	WindowsPasswordTimeout      *string                                `mapstructure:"windows_password_timeout" cty:"windows_password_timeout"`
+	Type                        *string                                `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect          *string                                `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                     *string                                `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                     *int                                   `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                 *string                                `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                 *string                                `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName              *string                                `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHClearAuthorizedKeys      *bool                                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile           *string                                `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                      *bool                                  `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                  *string                                `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                *bool                                  `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding   *bool                                  `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts        *int                                   `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost              *string                                `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort              *int                                   `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth         *bool                                  `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername          *string                                `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword          *string                                `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile    *string                                `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod       *string                                `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                *string                                `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                *int                                   `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername            *string                                `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword            *string                                `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval        *string                                `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout         *string                                `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels            []string                               `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels             []string                               `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                []byte                                 `cty:"ssh_public_key"`
+	SSHPrivateKey               []byte                                 `cty:"ssh_private_key"`
+	WinRMUser                   *string                                `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword               *string                                `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                   *string                                `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                   *int                                   `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                *string                                `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                 *bool                                  `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure               *bool                                  `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                *bool                                  `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHInterface                *string                                `mapstructure:"ssh_interface" cty:"ssh_interface"`
+	VolumeMappings              []FlatBlockDevice                      `mapstructure:"bsu_volumes" cty:"bsu_volumes"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":                    &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":                  &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                         &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                         &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                      &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":                &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":           &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"access_key":                           &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"custom_endpoint_oapi":                 &hcldec.AttrSpec{Name: "custom_endpoint_oapi", Type: cty.String, Required: false},
+		"insecure_skip_tls_verify":             &hcldec.AttrSpec{Name: "insecure_skip_tls_verify", Type: cty.Bool, Required: false},
+		"mfa_code":                             &hcldec.AttrSpec{Name: "mfa_code", Type: cty.String, Required: false},
+		"profile":                              &hcldec.AttrSpec{Name: "profile", Type: cty.String, Required: false},
+		"region":                               &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"secret_key":                           &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"skip_region_validation":               &hcldec.AttrSpec{Name: "skip_region_validation", Type: cty.Bool, Required: false},
+		"skip_metadata_api_check":              &hcldec.AttrSpec{Name: "skip_metadata_api_check", Type: cty.Bool, Required: false},
+		"token":                                &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"associate_public_ip_address":          &hcldec.AttrSpec{Name: "associate_public_ip_address", Type: cty.Bool, Required: false},
+		"subregion_name":                       &hcldec.AttrSpec{Name: "subregion_name", Type: cty.String, Required: false},
+		"block_duration_minutes":               &hcldec.AttrSpec{Name: "block_duration_minutes", Type: cty.Number, Required: false},
+		"disable_stop_vm":                      &hcldec.AttrSpec{Name: "disable_stop_vm", Type: cty.Bool, Required: false},
+		"bsu_optimized":                        &hcldec.AttrSpec{Name: "bsu_optimized", Type: cty.Bool, Required: false},
+		"enable_t2_unlimited":                  &hcldec.AttrSpec{Name: "enable_t2_unlimited", Type: cty.Bool, Required: false},
+		"iam_vm_profile":                       &hcldec.AttrSpec{Name: "iam_vm_profile", Type: cty.String, Required: false},
+		"shutdown_behavior":                    &hcldec.AttrSpec{Name: "shutdown_behavior", Type: cty.String, Required: false},
+		"vm_type":                              &hcldec.AttrSpec{Name: "vm_type", Type: cty.String, Required: false},
+		"security_group_filter":                &hcldec.BlockSpec{TypeName: "security_group_filter", Nested: hcldec.ObjectSpec((*common.FlatSecurityGroupFilterOptions)(nil).HCL2Spec())},
+		"run_tags":                             &hcldec.BlockAttrsSpec{TypeName: "run_tags", ElementType: cty.String, Required: false},
+		"security_group_id":                    &hcldec.AttrSpec{Name: "security_group_id", Type: cty.String, Required: false},
+		"security_group_ids":                   &hcldec.AttrSpec{Name: "security_group_ids", Type: cty.List(cty.String), Required: false},
+		"source_omi":                           &hcldec.AttrSpec{Name: "source_omi", Type: cty.String, Required: false},
+		"source_omi_filter":                    &hcldec.BlockSpec{TypeName: "source_omi_filter", Nested: hcldec.ObjectSpec((*common.FlatOmiFilterOptions)(nil).HCL2Spec())},
+		"spot_price":                           &hcldec.AttrSpec{Name: "spot_price", Type: cty.String, Required: false},
+		"spot_price_auto_product":              &hcldec.AttrSpec{Name: "spot_price_auto_product", Type: cty.String, Required: false},
+		"spot_tags":                            &hcldec.BlockAttrsSpec{TypeName: "spot_tags", ElementType: cty.String, Required: false},
+		"subnet_filter":                        &hcldec.BlockSpec{TypeName: "subnet_filter", Nested: hcldec.ObjectSpec((*common.FlatSubnetFilterOptions)(nil).HCL2Spec())},
+		"subnet_id":                            &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
+		"temporary_key_pair_name":              &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"temporary_security_group_source_cidr": &hcldec.AttrSpec{Name: "temporary_security_group_source_cidr", Type: cty.String, Required: false},
+		"user_data":                            &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":                       &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"net_filter":                           &hcldec.BlockSpec{TypeName: "net_filter", Nested: hcldec.ObjectSpec((*common.FlatNetFilterOptions)(nil).HCL2Spec())},
+		"net_id":                               &hcldec.AttrSpec{Name: "net_id", Type: cty.String, Required: false},
+		"windows_password_timeout":             &hcldec.AttrSpec{Name: "windows_password_timeout", Type: cty.String, Required: false},
+		"communicator":                         &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":              &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                             &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                             &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                         &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                         &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":                     &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":            &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":                 &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                              &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                          &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                       &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":         &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":               &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":                     &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":                     &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":               &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":                 &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":                 &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":         &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":             &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                       &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                       &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":                   &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":                   &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":              &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":               &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":                   &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":                    &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                       &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                      &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                       &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                       &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                           &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                           &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                        &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                        &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                       &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                       &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_interface":                        &hcldec.AttrSpec{Name: "ssh_interface", Type: cty.String, Required: false},
+		"bsu_volumes":                          &hcldec.BlockListSpec{TypeName: "bsu_volumes", Nested: &hcldec.BlockSpec{TypeName: "bsu_volumes", Nested: hcldec.ObjectSpec((*FlatBlockDevice)(nil).HCL2Spec())}},
+	}
+	return s
+}
diff --git a/builder/osc/chroot/builder.go b/builder/osc/chroot/builder.go
index ab52eba43..e6813d263 100644
--- a/builder/osc/chroot/builder.go
+++ b/builder/osc/chroot/builder.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // Package chroot is able to create an Outscale OMI without requiring
 // the launch of a new instance for every build. It does this by attaching
 // and mounting the root volume of another OMI and chrooting into that
diff --git a/builder/osc/chroot/builder.hcl2spec.go b/builder/osc/chroot/builder.hcl2spec.go
new file mode 100644
index 000000000..0404b12c1
--- /dev/null
+++ b/builder/osc/chroot/builder.hcl2spec.go
@@ -0,0 +1,122 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package chroot
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/hashicorp/packer/builder/osc/common"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName         *string                      `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType       *string                      `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug             *bool                        `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce             *bool                        `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError           *string                      `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars          map[string]string            `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars     []string                     `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	OMIMappings             []common.FlatBlockDevice     `mapstructure:"omi_block_device_mappings" cty:"omi_block_device_mappings"`
+	OMIName                 *string                      `mapstructure:"omi_name" cty:"omi_name"`
+	OMIDescription          *string                      `mapstructure:"omi_description" cty:"omi_description"`
+	OMIVirtType             *string                      `mapstructure:"omi_virtualization_type" cty:"omi_virtualization_type"`
+	OMIAccountIDs           []string                     `mapstructure:"omi_account_ids" cty:"omi_account_ids"`
+	OMIGroups               []string                     `mapstructure:"omi_groups" cty:"omi_groups"`
+	OMIProductCodes         []string                     `mapstructure:"omi_product_codes" cty:"omi_product_codes"`
+	OMIRegions              []string                     `mapstructure:"omi_regions" cty:"omi_regions"`
+	OMISkipRegionValidation *bool                        `mapstructure:"skip_region_validation" cty:"skip_region_validation"`
+	OMITags                 common.TagMap                `mapstructure:"tags" cty:"tags"`
+	OMIForceDeregister      *bool                        `mapstructure:"force_deregister" cty:"force_deregister"`
+	OMIForceDeleteSnapshot  *bool                        `mapstructure:"force_delete_snapshot" cty:"force_delete_snapshot"`
+	SnapshotTags            common.TagMap                `mapstructure:"snapshot_tags" cty:"snapshot_tags"`
+	SnapshotAccountIDs      []string                     `mapstructure:"snapshot_account_ids" cty:"snapshot_account_ids"`
+	SnapshotGroups          []string                     `mapstructure:"snapshot_groups" cty:"snapshot_groups"`
+	AccessKey               *string                      `mapstructure:"access_key" cty:"access_key"`
+	CustomEndpointOAPI      *string                      `mapstructure:"custom_endpoint_oapi" cty:"custom_endpoint_oapi"`
+	InsecureSkipTLSVerify   *bool                        `mapstructure:"insecure_skip_tls_verify" cty:"insecure_skip_tls_verify"`
+	MFACode                 *string                      `mapstructure:"mfa_code" cty:"mfa_code"`
+	ProfileName             *string                      `mapstructure:"profile" cty:"profile"`
+	RawRegion               *string                      `mapstructure:"region" cty:"region"`
+	SecretKey               *string                      `mapstructure:"secret_key" cty:"secret_key"`
+	SkipMetadataApiCheck    *bool                        `mapstructure:"skip_metadata_api_check" cty:"skip_metadata_api_check"`
+	Token                   *string                      `mapstructure:"token" cty:"token"`
+	ChrootMounts            [][]string                   `mapstructure:"chroot_mounts" cty:"chroot_mounts"`
+	CommandWrapper          *string                      `mapstructure:"command_wrapper" cty:"command_wrapper"`
+	CopyFiles               []string                     `mapstructure:"copy_files" cty:"copy_files"`
+	DevicePath              *string                      `mapstructure:"device_path" cty:"device_path"`
+	NVMEDevicePath          *string                      `mapstructure:"nvme_device_path" cty:"nvme_device_path"`
+	FromScratch             *bool                        `mapstructure:"from_scratch" cty:"from_scratch"`
+	MountOptions            []string                     `mapstructure:"mount_options" cty:"mount_options"`
+	MountPartition          *string                      `mapstructure:"mount_partition" cty:"mount_partition"`
+	MountPath               *string                      `mapstructure:"mount_path" cty:"mount_path"`
+	PostMountCommands       []string                     `mapstructure:"post_mount_commands" cty:"post_mount_commands"`
+	PreMountCommands        []string                     `mapstructure:"pre_mount_commands" cty:"pre_mount_commands"`
+	RootDeviceName          *string                      `mapstructure:"root_device_name" cty:"root_device_name"`
+	RootVolumeSize          *int64                       `mapstructure:"root_volume_size" cty:"root_volume_size"`
+	RootVolumeType          *string                      `mapstructure:"root_volume_type" cty:"root_volume_type"`
+	SourceOMI               *string                      `mapstructure:"source_omi" cty:"source_omi"`
+	SourceOMIFilter         *common.FlatOmiFilterOptions `mapstructure:"source_omi_filter" cty:"source_omi_filter"`
+	RootVolumeTags          common.TagMap                `mapstructure:"root_volume_tags" cty:"root_volume_tags"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"omi_block_device_mappings":  &hcldec.BlockListSpec{TypeName: "omi_block_device_mappings", Nested: &hcldec.BlockSpec{TypeName: "omi_block_device_mappings", Nested: hcldec.ObjectSpec((*common.FlatBlockDevice)(nil).HCL2Spec())}},
+		"omi_name":                   &hcldec.AttrSpec{Name: "omi_name", Type: cty.String, Required: false},
+		"omi_description":            &hcldec.AttrSpec{Name: "omi_description", Type: cty.String, Required: false},
+		"omi_virtualization_type":    &hcldec.AttrSpec{Name: "omi_virtualization_type", Type: cty.String, Required: false},
+		"omi_account_ids":            &hcldec.AttrSpec{Name: "omi_account_ids", Type: cty.List(cty.String), Required: false},
+		"omi_groups":                 &hcldec.AttrSpec{Name: "omi_groups", Type: cty.List(cty.String), Required: false},
+		"omi_product_codes":          &hcldec.AttrSpec{Name: "omi_product_codes", Type: cty.List(cty.String), Required: false},
+		"omi_regions":                &hcldec.AttrSpec{Name: "omi_regions", Type: cty.List(cty.String), Required: false},
+		"skip_region_validation":     &hcldec.AttrSpec{Name: "skip_region_validation", Type: cty.Bool, Required: false},
+		"tags":                       &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+		"force_deregister":           &hcldec.AttrSpec{Name: "force_deregister", Type: cty.Bool, Required: false},
+		"force_delete_snapshot":      &hcldec.AttrSpec{Name: "force_delete_snapshot", Type: cty.Bool, Required: false},
+		"snapshot_tags":              &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+		"snapshot_account_ids":       &hcldec.AttrSpec{Name: "snapshot_account_ids", Type: cty.List(cty.String), Required: false},
+		"snapshot_groups":            &hcldec.AttrSpec{Name: "snapshot_groups", Type: cty.List(cty.String), Required: false},
+		"access_key":                 &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"custom_endpoint_oapi":       &hcldec.AttrSpec{Name: "custom_endpoint_oapi", Type: cty.String, Required: false},
+		"insecure_skip_tls_verify":   &hcldec.AttrSpec{Name: "insecure_skip_tls_verify", Type: cty.Bool, Required: false},
+		"mfa_code":                   &hcldec.AttrSpec{Name: "mfa_code", Type: cty.String, Required: false},
+		"profile":                    &hcldec.AttrSpec{Name: "profile", Type: cty.String, Required: false},
+		"region":                     &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"secret_key":                 &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"skip_metadata_api_check":    &hcldec.AttrSpec{Name: "skip_metadata_api_check", Type: cty.Bool, Required: false},
+		"token":                      &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"chroot_mounts":              &hcldec.BlockListSpec{TypeName: "chroot_mounts", Nested: &hcldec.AttrSpec{Name: "chroot_mounts", Type: cty.List(cty.String), Required: false}},
+		"command_wrapper":            &hcldec.AttrSpec{Name: "command_wrapper", Type: cty.String, Required: false},
+		"copy_files":                 &hcldec.AttrSpec{Name: "copy_files", Type: cty.List(cty.String), Required: false},
+		"device_path":                &hcldec.AttrSpec{Name: "device_path", Type: cty.String, Required: false},
+		"nvme_device_path":           &hcldec.AttrSpec{Name: "nvme_device_path", Type: cty.String, Required: false},
+		"from_scratch":               &hcldec.AttrSpec{Name: "from_scratch", Type: cty.Bool, Required: false},
+		"mount_options":              &hcldec.AttrSpec{Name: "mount_options", Type: cty.List(cty.String), Required: false},
+		"mount_partition":            &hcldec.AttrSpec{Name: "mount_partition", Type: cty.String, Required: false},
+		"mount_path":                 &hcldec.AttrSpec{Name: "mount_path", Type: cty.String, Required: false},
+		"post_mount_commands":        &hcldec.AttrSpec{Name: "post_mount_commands", Type: cty.List(cty.String), Required: false},
+		"pre_mount_commands":         &hcldec.AttrSpec{Name: "pre_mount_commands", Type: cty.List(cty.String), Required: false},
+		"root_device_name":           &hcldec.AttrSpec{Name: "root_device_name", Type: cty.String, Required: false},
+		"root_volume_size":           &hcldec.AttrSpec{Name: "root_volume_size", Type: cty.Number, Required: false},
+		"root_volume_type":           &hcldec.AttrSpec{Name: "root_volume_type", Type: cty.String, Required: false},
+		"source_omi":                 &hcldec.AttrSpec{Name: "source_omi", Type: cty.String, Required: false},
+		"source_omi_filter":          &hcldec.BlockSpec{TypeName: "source_omi_filter", Nested: hcldec.ObjectSpec((*common.FlatOmiFilterOptions)(nil).HCL2Spec())},
+		"root_volume_tags":           &hcldec.BlockAttrsSpec{TypeName: "common.TagMap", ElementType: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/osc/common/run_config.go b/builder/osc/common/run_config.go
index 1bff1772a..55683caa2 100644
--- a/builder/osc/common/run_config.go
+++ b/builder/osc/common/run_config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type SecurityGroupFilterOptions,OmiFilterOptions,SubnetFilterOptions,NetFilterOptions,BlockDevice
+
 package common
 
 import (
diff --git a/builder/osc/common/run_config.hcl2spec.go b/builder/osc/common/run_config.hcl2spec.go
new file mode 100644
index 000000000..53edc1f9f
--- /dev/null
+++ b/builder/osc/common/run_config.hcl2spec.go
@@ -0,0 +1,131 @@
+// Code generated by "mapstructure-to-hcl2 -type SecurityGroupFilterOptions,OmiFilterOptions,SubnetFilterOptions,NetFilterOptions,BlockDevice"; DO NOT EDIT.
+package common
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatBlockDevice is an auto-generated flat version of BlockDevice.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatBlockDevice struct {
+	DeleteOnVmDeletion *bool   `mapstructure:"delete_on_vm_deletion" cty:"delete_on_vm_deletion"`
+	DeviceName         *string `mapstructure:"device_name" cty:"device_name"`
+	IOPS               *int64  `mapstructure:"iops" cty:"iops"`
+	NoDevice           *bool   `mapstructure:"no_device" cty:"no_device"`
+	SnapshotId         *string `mapstructure:"snapshot_id" cty:"snapshot_id"`
+	VirtualName        *string `mapstructure:"virtual_name" cty:"virtual_name"`
+	VolumeType         *string `mapstructure:"volume_type" cty:"volume_type"`
+	VolumeSize         *int64  `mapstructure:"volume_size" cty:"volume_size"`
+}
+
+// FlatMapstructure returns a new FlatBlockDevice.
+// FlatBlockDevice is an auto-generated flat version of BlockDevice.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*BlockDevice) FlatMapstructure() interface{} { return new(FlatBlockDevice) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatBlockDevice.
+// This spec is used by HCL to read the fields of FlatBlockDevice.
+func (*FlatBlockDevice) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"delete_on_vm_deletion": &hcldec.AttrSpec{Name: "delete_on_vm_deletion", Type: cty.Bool, Required: false},
+		"device_name":           &hcldec.AttrSpec{Name: "device_name", Type: cty.String, Required: false},
+		"iops":                  &hcldec.AttrSpec{Name: "iops", Type: cty.Number, Required: false},
+		"no_device":             &hcldec.AttrSpec{Name: "no_device", Type: cty.Bool, Required: false},
+		"snapshot_id":           &hcldec.AttrSpec{Name: "snapshot_id", Type: cty.String, Required: false},
+		"virtual_name":          &hcldec.AttrSpec{Name: "virtual_name", Type: cty.String, Required: false},
+		"volume_type":           &hcldec.AttrSpec{Name: "volume_type", Type: cty.String, Required: false},
+		"volume_size":           &hcldec.AttrSpec{Name: "volume_size", Type: cty.Number, Required: false},
+	}
+	return s
+}
+
+// FlatNetFilterOptions is an auto-generated flat version of NetFilterOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatNetFilterOptions struct {
+	Filters map[string]string `cty:"filters"`
+}
+
+// FlatMapstructure returns a new FlatNetFilterOptions.
+// FlatNetFilterOptions is an auto-generated flat version of NetFilterOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*NetFilterOptions) FlatMapstructure() interface{} { return new(FlatNetFilterOptions) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatNetFilterOptions.
+// This spec is used by HCL to read the fields of FlatNetFilterOptions.
+func (*FlatNetFilterOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"filters": &hcldec.BlockAttrsSpec{TypeName: "filters", ElementType: cty.String, Required: false},
+	}
+	return s
+}
+
+// FlatOmiFilterOptions is an auto-generated flat version of OmiFilterOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatOmiFilterOptions struct {
+	Filters    map[string]string `cty:"filters"`
+	Owners     []string          `cty:"owners"`
+	MostRecent *bool             `mapstructure:"most_recent" cty:"most_recent"`
+}
+
+// FlatMapstructure returns a new FlatOmiFilterOptions.
+// FlatOmiFilterOptions is an auto-generated flat version of OmiFilterOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*OmiFilterOptions) FlatMapstructure() interface{} { return new(FlatOmiFilterOptions) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatOmiFilterOptions.
+// This spec is used by HCL to read the fields of FlatOmiFilterOptions.
+func (*FlatOmiFilterOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"filters":     &hcldec.BlockAttrsSpec{TypeName: "filters", ElementType: cty.String, Required: false},
+		"owners":      &hcldec.AttrSpec{Name: "owners", Type: cty.List(cty.String), Required: false},
+		"most_recent": &hcldec.AttrSpec{Name: "most_recent", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatSecurityGroupFilterOptions is an auto-generated flat version of SecurityGroupFilterOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatSecurityGroupFilterOptions struct {
+	Filters map[string]string `cty:"filters"`
+}
+
+// FlatMapstructure returns a new FlatSecurityGroupFilterOptions.
+// FlatSecurityGroupFilterOptions is an auto-generated flat version of SecurityGroupFilterOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*SecurityGroupFilterOptions) FlatMapstructure() interface{} {
+	return new(FlatSecurityGroupFilterOptions)
+}
+
+// HCL2Spec returns the hcldec.Spec of a FlatSecurityGroupFilterOptions.
+// This spec is used by HCL to read the fields of FlatSecurityGroupFilterOptions.
+func (*FlatSecurityGroupFilterOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"filters": &hcldec.BlockAttrsSpec{TypeName: "filters", ElementType: cty.String, Required: false},
+	}
+	return s
+}
+
+// FlatSubnetFilterOptions is an auto-generated flat version of SubnetFilterOptions.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatSubnetFilterOptions struct {
+	Filters  map[string]string `cty:"filters"`
+	MostFree *bool             `mapstructure:"most_free" cty:"most_free"`
+	Random   *bool             `mapstructure:"random" cty:"random"`
+}
+
+// FlatMapstructure returns a new FlatSubnetFilterOptions.
+// FlatSubnetFilterOptions is an auto-generated flat version of SubnetFilterOptions.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*SubnetFilterOptions) FlatMapstructure() interface{} { return new(FlatSubnetFilterOptions) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatSubnetFilterOptions.
+// This spec is used by HCL to read the fields of FlatSubnetFilterOptions.
+func (*FlatSubnetFilterOptions) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"filters":   &hcldec.BlockAttrsSpec{TypeName: "filters", ElementType: cty.String, Required: false},
+		"most_free": &hcldec.AttrSpec{Name: "most_free", Type: cty.Bool, Required: false},
+		"random":    &hcldec.AttrSpec{Name: "random", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/parallels/iso/builder.go b/builder/parallels/iso/builder.go
index 568aca2e9..b7ea4788f 100644
--- a/builder/parallels/iso/builder.go
+++ b/builder/parallels/iso/builder.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package iso
 
diff --git a/builder/parallels/iso/builder.hcl2spec.go b/builder/parallels/iso/builder.hcl2spec.go
new file mode 100644
index 000000000..73f4aefe5
--- /dev/null
+++ b/builder/parallels/iso/builder.hcl2spec.go
@@ -0,0 +1,195 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package iso
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	ISOChecksum               *string           `mapstructure:"iso_checksum" required:"true" cty:"iso_checksum"`
+	ISOChecksumURL            *string           `mapstructure:"iso_checksum_url" cty:"iso_checksum_url"`
+	ISOChecksumType           *string           `mapstructure:"iso_checksum_type" cty:"iso_checksum_type"`
+	RawSingleISOUrl           *string           `mapstructure:"iso_url" required:"true" cty:"iso_url"`
+	ISOUrls                   []string          `mapstructure:"iso_urls" cty:"iso_urls"`
+	TargetPath                *string           `mapstructure:"iso_target_path" cty:"iso_target_path"`
+	TargetExtension           *string           `mapstructure:"iso_target_extension" cty:"iso_target_extension"`
+	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories         []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel               *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	OutputDir                 *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	CpuCount                  *int              `mapstructure:"cpus" required:"false" cty:"cpus"`
+	MemorySize                *int              `mapstructure:"memory" required:"false" cty:"memory"`
+	Sound                     *bool             `mapstructure:"sound" required:"false" cty:"sound"`
+	USB                       *bool             `mapstructure:"usb" required:"false" cty:"usb"`
+	Prlctl                    [][]string        `mapstructure:"prlctl" required:"false" cty:"prlctl"`
+	PrlctlPost                [][]string        `mapstructure:"prlctl_post" required:"false" cty:"prlctl_post"`
+	PrlctlVersionFile         *string           `mapstructure:"prlctl_version_file" required:"false" cty:"prlctl_version_file"`
+	ShutdownCommand           *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout        *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHWaitTimeout            *string           `mapstructure:"ssh_wait_timeout" cty:"ssh_wait_timeout"`
+	ParallelsToolsFlavor      *string           `mapstructure:"parallels_tools_flavor" required:"true" cty:"parallels_tools_flavor"`
+	ParallelsToolsGuestPath   *string           `mapstructure:"parallels_tools_guest_path" required:"false" cty:"parallels_tools_guest_path"`
+	ParallelsToolsMode        *string           `mapstructure:"parallels_tools_mode" required:"false" cty:"parallels_tools_mode"`
+	DiskSize                  *uint             `mapstructure:"disk_size" required:"false" cty:"disk_size"`
+	DiskType                  *string           `mapstructure:"disk_type" required:"false" cty:"disk_type"`
+	GuestOSType               *string           `mapstructure:"guest_os_type" required:"false" cty:"guest_os_type"`
+	HardDriveInterface        *string           `mapstructure:"hard_drive_interface" required:"false" cty:"hard_drive_interface"`
+	HostInterfaces            []string          `mapstructure:"host_interfaces" required:"false" cty:"host_interfaces"`
+	SkipCompaction            *bool             `mapstructure:"skip_compaction" required:"false" cty:"skip_compaction"`
+	VMName                    *string           `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":               &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"iso_checksum":                 &hcldec.AttrSpec{Name: "iso_checksum", Type: cty.String, Required: false},
+		"iso_checksum_url":             &hcldec.AttrSpec{Name: "iso_checksum_url", Type: cty.String, Required: false},
+		"iso_checksum_type":            &hcldec.AttrSpec{Name: "iso_checksum_type", Type: cty.String, Required: false},
+		"iso_url":                      &hcldec.AttrSpec{Name: "iso_url", Type: cty.String, Required: false},
+		"iso_urls":                     &hcldec.AttrSpec{Name: "iso_urls", Type: cty.List(cty.String), Required: false},
+		"iso_target_path":              &hcldec.AttrSpec{Name: "iso_target_path", Type: cty.String, Required: false},
+		"iso_target_extension":         &hcldec.AttrSpec{Name: "iso_target_extension", Type: cty.String, Required: false},
+		"floppy_files":                 &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                  &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                 &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"boot_keygroup_interval":       &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                    &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                 &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":          &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"output_directory":             &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"cpus":                         &hcldec.AttrSpec{Name: "cpus", Type: cty.Number, Required: false},
+		"memory":                       &hcldec.AttrSpec{Name: "memory", Type: cty.Number, Required: false},
+		"sound":                        &hcldec.AttrSpec{Name: "sound", Type: cty.Bool, Required: false},
+		"usb":                          &hcldec.AttrSpec{Name: "usb", Type: cty.Bool, Required: false},
+		"prlctl":                       &hcldec.BlockListSpec{TypeName: "prlctl", Nested: &hcldec.AttrSpec{Name: "prlctl", Type: cty.List(cty.String), Required: false}},
+		"prlctl_post":                  &hcldec.BlockListSpec{TypeName: "prlctl_post", Nested: &hcldec.AttrSpec{Name: "prlctl_post", Type: cty.List(cty.String), Required: false}},
+		"prlctl_version_file":          &hcldec.AttrSpec{Name: "prlctl_version_file", Type: cty.String, Required: false},
+		"shutdown_command":             &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":             &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_wait_timeout":             &hcldec.AttrSpec{Name: "ssh_wait_timeout", Type: cty.String, Required: false},
+		"parallels_tools_flavor":       &hcldec.AttrSpec{Name: "parallels_tools_flavor", Type: cty.String, Required: false},
+		"parallels_tools_guest_path":   &hcldec.AttrSpec{Name: "parallels_tools_guest_path", Type: cty.String, Required: false},
+		"parallels_tools_mode":         &hcldec.AttrSpec{Name: "parallels_tools_mode", Type: cty.String, Required: false},
+		"disk_size":                    &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"disk_type":                    &hcldec.AttrSpec{Name: "disk_type", Type: cty.String, Required: false},
+		"guest_os_type":                &hcldec.AttrSpec{Name: "guest_os_type", Type: cty.String, Required: false},
+		"hard_drive_interface":         &hcldec.AttrSpec{Name: "hard_drive_interface", Type: cty.String, Required: false},
+		"host_interfaces":              &hcldec.AttrSpec{Name: "host_interfaces", Type: cty.List(cty.String), Required: false},
+		"skip_compaction":              &hcldec.AttrSpec{Name: "skip_compaction", Type: cty.Bool, Required: false},
+		"vm_name":                      &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/parallels/pvm/config.go b/builder/parallels/pvm/config.go
index aa1fe3e45..3fffe7b98 100644
--- a/builder/parallels/pvm/config.go
+++ b/builder/parallels/pvm/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package pvm
 
diff --git a/builder/parallels/pvm/config.hcl2spec.go b/builder/parallels/pvm/config.hcl2spec.go
new file mode 100644
index 000000000..b0a1f90a4
--- /dev/null
+++ b/builder/parallels/pvm/config.hcl2spec.go
@@ -0,0 +1,161 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package pvm
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories         []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel               *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	OutputDir                 *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	Prlctl                    [][]string        `mapstructure:"prlctl" required:"false" cty:"prlctl"`
+	PrlctlPost                [][]string        `mapstructure:"prlctl_post" required:"false" cty:"prlctl_post"`
+	PrlctlVersionFile         *string           `mapstructure:"prlctl_version_file" required:"false" cty:"prlctl_version_file"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHWaitTimeout            *string           `mapstructure:"ssh_wait_timeout" cty:"ssh_wait_timeout"`
+	ShutdownCommand           *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout        *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	ParallelsToolsFlavor      *string           `mapstructure:"parallels_tools_flavor" required:"true" cty:"parallels_tools_flavor"`
+	ParallelsToolsGuestPath   *string           `mapstructure:"parallels_tools_guest_path" required:"false" cty:"parallels_tools_guest_path"`
+	ParallelsToolsMode        *string           `mapstructure:"parallels_tools_mode" required:"false" cty:"parallels_tools_mode"`
+	SourcePath                *string           `mapstructure:"source_path" required:"true" cty:"source_path"`
+	SkipCompaction            *bool             `mapstructure:"skip_compaction" required:"false" cty:"skip_compaction"`
+	VMName                    *string           `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+	ReassignMAC               *bool             `mapstructure:"reassign_mac" required:"false" cty:"reassign_mac"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"floppy_files":                 &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                  &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                 &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"output_directory":             &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"prlctl":                       &hcldec.BlockListSpec{TypeName: "prlctl", Nested: &hcldec.AttrSpec{Name: "prlctl", Type: cty.List(cty.String), Required: false}},
+		"prlctl_post":                  &hcldec.BlockListSpec{TypeName: "prlctl_post", Nested: &hcldec.AttrSpec{Name: "prlctl_post", Type: cty.List(cty.String), Required: false}},
+		"prlctl_version_file":          &hcldec.AttrSpec{Name: "prlctl_version_file", Type: cty.String, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_wait_timeout":             &hcldec.AttrSpec{Name: "ssh_wait_timeout", Type: cty.String, Required: false},
+		"shutdown_command":             &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":             &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"boot_keygroup_interval":       &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                    &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                 &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":          &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"parallels_tools_flavor":       &hcldec.AttrSpec{Name: "parallels_tools_flavor", Type: cty.String, Required: false},
+		"parallels_tools_guest_path":   &hcldec.AttrSpec{Name: "parallels_tools_guest_path", Type: cty.String, Required: false},
+		"parallels_tools_mode":         &hcldec.AttrSpec{Name: "parallels_tools_mode", Type: cty.String, Required: false},
+		"source_path":                  &hcldec.AttrSpec{Name: "source_path", Type: cty.String, Required: false},
+		"skip_compaction":              &hcldec.AttrSpec{Name: "skip_compaction", Type: cty.Bool, Required: false},
+		"vm_name":                      &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"reassign_mac":                 &hcldec.AttrSpec{Name: "reassign_mac", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/profitbricks/config.go b/builder/profitbricks/config.go
index 4cf4c9d32..f3d366c60 100644
--- a/builder/profitbricks/config.go
+++ b/builder/profitbricks/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package profitbricks
 
 import (
diff --git a/builder/profitbricks/config.hcl2spec.go b/builder/profitbricks/config.hcl2spec.go
new file mode 100644
index 000000000..c0867c500
--- /dev/null
+++ b/builder/profitbricks/config.hcl2spec.go
@@ -0,0 +1,143 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package profitbricks
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	PBUsername                *string           `mapstructure:"username" cty:"username"`
+	PBPassword                *string           `mapstructure:"password" cty:"password"`
+	PBUrl                     *string           `mapstructure:"url" cty:"url"`
+	Region                    *string           `mapstructure:"location" cty:"location"`
+	Image                     *string           `mapstructure:"image" cty:"image"`
+	SSHKey                    *string           `cty:"ssh_key"`
+	SnapshotName              *string           `mapstructure:"snapshot_name" cty:"snapshot_name"`
+	DiskSize                  *int              `mapstructure:"disk_size" cty:"disk_size"`
+	DiskType                  *string           `mapstructure:"disk_type" cty:"disk_type"`
+	Cores                     *int              `mapstructure:"cores" cty:"cores"`
+	Ram                       *int              `mapstructure:"ram" cty:"ram"`
+	Retries                   *int              `mapstructure:"retries" cty:"retries"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"username":                     &hcldec.AttrSpec{Name: "username", Type: cty.String, Required: false},
+		"password":                     &hcldec.AttrSpec{Name: "password", Type: cty.String, Required: false},
+		"url":                          &hcldec.AttrSpec{Name: "url", Type: cty.String, Required: false},
+		"location":                     &hcldec.AttrSpec{Name: "location", Type: cty.String, Required: false},
+		"image":                        &hcldec.AttrSpec{Name: "image", Type: cty.String, Required: false},
+		"ssh_key":                      &hcldec.AttrSpec{Name: "ssh_key", Type: cty.String, Required: false},
+		"snapshot_name":                &hcldec.AttrSpec{Name: "snapshot_name", Type: cty.String, Required: false},
+		"disk_size":                    &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"disk_type":                    &hcldec.AttrSpec{Name: "disk_type", Type: cty.String, Required: false},
+		"cores":                        &hcldec.AttrSpec{Name: "cores", Type: cty.Number, Required: false},
+		"ram":                          &hcldec.AttrSpec{Name: "ram", Type: cty.Number, Required: false},
+		"retries":                      &hcldec.AttrSpec{Name: "retries", Type: cty.Number, Required: false},
+	}
+	return s
+}
diff --git a/builder/proxmox/config.go b/builder/proxmox/config.go
index 5d0a9f1eb..d4deead65 100644
--- a/builder/proxmox/config.go
+++ b/builder/proxmox/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config,nicConfig,diskConfig
+
 package proxmox
 
 import (
diff --git a/builder/proxmox/config.hcl2spec.go b/builder/proxmox/config.hcl2spec.go
new file mode 100644
index 000000000..a8cc2c0f0
--- /dev/null
+++ b/builder/proxmox/config.hcl2spec.go
@@ -0,0 +1,233 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,nicConfig,diskConfig"; DO NOT EDIT.
+package proxmox
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	RawBootKeyInterval        *string           `mapstructure:"boot_key_interval" cty:"boot_key_interval"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	ProxmoxURLRaw             *string           `mapstructure:"proxmox_url" cty:"proxmox_url"`
+	SkipCertValidation        *bool             `mapstructure:"insecure_skip_tls_verify" cty:"insecure_skip_tls_verify"`
+	Username                  *string           `mapstructure:"username" cty:"username"`
+	Password                  *string           `mapstructure:"password" cty:"password"`
+	Node                      *string           `mapstructure:"node" cty:"node"`
+	Pool                      *string           `mapstructure:"pool" cty:"pool"`
+	VMName                    *string           `mapstructure:"vm_name" cty:"vm_name"`
+	VMID                      *int              `mapstructure:"vm_id" cty:"vm_id"`
+	Memory                    *int              `mapstructure:"memory" cty:"memory"`
+	Cores                     *int              `mapstructure:"cores" cty:"cores"`
+	CPUType                   *string           `mapstructure:"cpu_type" cty:"cpu_type"`
+	Sockets                   *int              `mapstructure:"sockets" cty:"sockets"`
+	OS                        *string           `mapstructure:"os" cty:"os"`
+	NICs                      []FlatnicConfig   `mapstructure:"network_adapters" cty:"network_adapters"`
+	Disks                     []FlatdiskConfig  `mapstructure:"disks" cty:"disks"`
+	ISOFile                   *string           `mapstructure:"iso_file" cty:"iso_file"`
+	Agent                     *bool             `mapstructure:"qemu_agent" cty:"qemu_agent"`
+	SCSIController            *string           `mapstructure:"scsi_controller" cty:"scsi_controller"`
+	TemplateName              *string           `mapstructure:"template_name" cty:"template_name"`
+	TemplateDescription       *string           `mapstructure:"template_description" cty:"template_description"`
+	UnmountISO                *bool             `mapstructure:"unmount_iso" cty:"unmount_iso"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":               &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"boot_keygroup_interval":       &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                    &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                 &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":          &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"boot_key_interval":            &hcldec.AttrSpec{Name: "boot_key_interval", Type: cty.String, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"proxmox_url":                  &hcldec.AttrSpec{Name: "proxmox_url", Type: cty.String, Required: false},
+		"insecure_skip_tls_verify":     &hcldec.AttrSpec{Name: "insecure_skip_tls_verify", Type: cty.Bool, Required: false},
+		"username":                     &hcldec.AttrSpec{Name: "username", Type: cty.String, Required: false},
+		"password":                     &hcldec.AttrSpec{Name: "password", Type: cty.String, Required: false},
+		"node":                         &hcldec.AttrSpec{Name: "node", Type: cty.String, Required: false},
+		"pool":                         &hcldec.AttrSpec{Name: "pool", Type: cty.String, Required: false},
+		"vm_name":                      &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"vm_id":                        &hcldec.AttrSpec{Name: "vm_id", Type: cty.Number, Required: false},
+		"memory":                       &hcldec.AttrSpec{Name: "memory", Type: cty.Number, Required: false},
+		"cores":                        &hcldec.AttrSpec{Name: "cores", Type: cty.Number, Required: false},
+		"cpu_type":                     &hcldec.AttrSpec{Name: "cpu_type", Type: cty.String, Required: false},
+		"sockets":                      &hcldec.AttrSpec{Name: "sockets", Type: cty.Number, Required: false},
+		"os":                           &hcldec.AttrSpec{Name: "os", Type: cty.String, Required: false},
+		"network_adapters":             &hcldec.BlockListSpec{TypeName: "network_adapters", Nested: &hcldec.BlockSpec{TypeName: "network_adapters", Nested: hcldec.ObjectSpec((*FlatnicConfig)(nil).HCL2Spec())}},
+		"disks":                        &hcldec.BlockListSpec{TypeName: "disks", Nested: &hcldec.BlockSpec{TypeName: "disks", Nested: hcldec.ObjectSpec((*FlatdiskConfig)(nil).HCL2Spec())}},
+		"iso_file":                     &hcldec.AttrSpec{Name: "iso_file", Type: cty.String, Required: false},
+		"qemu_agent":                   &hcldec.AttrSpec{Name: "qemu_agent", Type: cty.Bool, Required: false},
+		"scsi_controller":              &hcldec.AttrSpec{Name: "scsi_controller", Type: cty.String, Required: false},
+		"template_name":                &hcldec.AttrSpec{Name: "template_name", Type: cty.String, Required: false},
+		"template_description":         &hcldec.AttrSpec{Name: "template_description", Type: cty.String, Required: false},
+		"unmount_iso":                  &hcldec.AttrSpec{Name: "unmount_iso", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatdiskConfig is an auto-generated flat version of diskConfig.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatdiskConfig struct {
+	Type            *string `mapstructure:"type" cty:"type"`
+	StoragePool     *string `mapstructure:"storage_pool" cty:"storage_pool"`
+	StoragePoolType *string `mapstructure:"storage_pool_type" cty:"storage_pool_type"`
+	Size            *string `mapstructure:"disk_size" cty:"disk_size"`
+	CacheMode       *string `mapstructure:"cache_mode" cty:"cache_mode"`
+	DiskFormat      *string `mapstructure:"format" cty:"format"`
+}
+
+// FlatMapstructure returns a new FlatdiskConfig.
+// FlatdiskConfig is an auto-generated flat version of diskConfig.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*diskConfig) FlatMapstructure() interface{} { return new(FlatdiskConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatdiskConfig.
+// This spec is used by HCL to read the fields of FlatdiskConfig.
+func (*FlatdiskConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"type":              &hcldec.AttrSpec{Name: "type", Type: cty.String, Required: false},
+		"storage_pool":      &hcldec.AttrSpec{Name: "storage_pool", Type: cty.String, Required: false},
+		"storage_pool_type": &hcldec.AttrSpec{Name: "storage_pool_type", Type: cty.String, Required: false},
+		"disk_size":         &hcldec.AttrSpec{Name: "disk_size", Type: cty.String, Required: false},
+		"cache_mode":        &hcldec.AttrSpec{Name: "cache_mode", Type: cty.String, Required: false},
+		"format":            &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+	}
+	return s
+}
+
+// FlatnicConfig is an auto-generated flat version of nicConfig.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatnicConfig struct {
+	Model      *string `mapstructure:"model" cty:"model"`
+	MACAddress *string `mapstructure:"mac_address" cty:"mac_address"`
+	Bridge     *string `mapstructure:"bridge" cty:"bridge"`
+	VLANTag    *string `mapstructure:"vlan_tag" cty:"vlan_tag"`
+}
+
+// FlatMapstructure returns a new FlatnicConfig.
+// FlatnicConfig is an auto-generated flat version of nicConfig.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*nicConfig) FlatMapstructure() interface{} { return new(FlatnicConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatnicConfig.
+// This spec is used by HCL to read the fields of FlatnicConfig.
+func (*FlatnicConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"model":       &hcldec.AttrSpec{Name: "model", Type: cty.String, Required: false},
+		"mac_address": &hcldec.AttrSpec{Name: "mac_address", Type: cty.String, Required: false},
+		"bridge":      &hcldec.AttrSpec{Name: "bridge", Type: cty.String, Required: false},
+		"vlan_tag":    &hcldec.AttrSpec{Name: "vlan_tag", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/qemu/builder.go b/builder/qemu/builder.go
index a277e1d45..989e4e277 100644
--- a/builder/qemu/builder.go
+++ b/builder/qemu/builder.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package qemu
 
diff --git a/builder/qemu/builder.hcl2spec.go b/builder/qemu/builder.hcl2spec.go
new file mode 100644
index 000000000..4675ba834
--- /dev/null
+++ b/builder/qemu/builder.hcl2spec.go
@@ -0,0 +1,227 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package qemu
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	ISOChecksum               *string           `mapstructure:"iso_checksum" required:"true" cty:"iso_checksum"`
+	ISOChecksumURL            *string           `mapstructure:"iso_checksum_url" cty:"iso_checksum_url"`
+	ISOChecksumType           *string           `mapstructure:"iso_checksum_type" cty:"iso_checksum_type"`
+	RawSingleISOUrl           *string           `mapstructure:"iso_url" required:"true" cty:"iso_url"`
+	ISOUrls                   []string          `mapstructure:"iso_urls" cty:"iso_urls"`
+	TargetPath                *string           `mapstructure:"iso_target_path" cty:"iso_target_path"`
+	TargetExtension           *string           `mapstructure:"iso_target_extension" cty:"iso_target_extension"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	DisableVNC                *bool             `mapstructure:"disable_vnc" cty:"disable_vnc"`
+	RawBootKeyInterval        *string           `mapstructure:"boot_key_interval" cty:"boot_key_interval"`
+	ShutdownCommand           *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout        *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories         []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel               *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	ISOSkipCache              *bool             `mapstructure:"iso_skip_cache" required:"false" cty:"iso_skip_cache"`
+	Accelerator               *string           `mapstructure:"accelerator" required:"false" cty:"accelerator"`
+	AdditionalDiskSize        []string          `mapstructure:"disk_additional_size" required:"false" cty:"disk_additional_size"`
+	CpuCount                  *int              `mapstructure:"cpus" required:"false" cty:"cpus"`
+	DiskInterface             *string           `mapstructure:"disk_interface" required:"false" cty:"disk_interface"`
+	DiskSize                  *uint             `mapstructure:"disk_size" required:"false" cty:"disk_size"`
+	DiskCache                 *string           `mapstructure:"disk_cache" required:"false" cty:"disk_cache"`
+	DiskDiscard               *string           `mapstructure:"disk_discard" required:"false" cty:"disk_discard"`
+	DetectZeroes              *string           `mapstructure:"disk_detect_zeroes" required:"false" cty:"disk_detect_zeroes"`
+	SkipCompaction            *bool             `mapstructure:"skip_compaction" required:"false" cty:"skip_compaction"`
+	DiskCompression           *bool             `mapstructure:"disk_compression" required:"false" cty:"disk_compression"`
+	Format                    *string           `mapstructure:"format" required:"false" cty:"format"`
+	Headless                  *bool             `mapstructure:"headless" required:"false" cty:"headless"`
+	DiskImage                 *bool             `mapstructure:"disk_image" required:"false" cty:"disk_image"`
+	UseBackingFile            *bool             `mapstructure:"use_backing_file" required:"false" cty:"use_backing_file"`
+	MachineType               *string           `mapstructure:"machine_type" required:"false" cty:"machine_type"`
+	MemorySize                *int              `mapstructure:"memory" required:"false" cty:"memory"`
+	NetDevice                 *string           `mapstructure:"net_device" required:"false" cty:"net_device"`
+	OutputDir                 *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	QemuArgs                  [][]string        `mapstructure:"qemuargs" required:"false" cty:"qemuargs"`
+	QemuBinary                *string           `mapstructure:"qemu_binary" required:"false" cty:"qemu_binary"`
+	QMPEnable                 *bool             `mapstructure:"qmp_enable" required:"false" cty:"qmp_enable"`
+	QMPSocketPath             *string           `mapstructure:"qmp_socket_path" required:"false" cty:"qmp_socket_path"`
+	SSHHostPortMin            *int              `mapstructure:"ssh_host_port_min" required:"false" cty:"ssh_host_port_min"`
+	SSHHostPortMax            *int              `mapstructure:"ssh_host_port_max" required:"false" cty:"ssh_host_port_max"`
+	UseDefaultDisplay         *bool             `mapstructure:"use_default_display" required:"false" cty:"use_default_display"`
+	VNCBindAddress            *string           `mapstructure:"vnc_bind_address" required:"false" cty:"vnc_bind_address"`
+	VNCUsePassword            *bool             `mapstructure:"vnc_use_password" required:"false" cty:"vnc_use_password"`
+	VNCPortMin                *int              `mapstructure:"vnc_port_min" required:"false" cty:"vnc_port_min"`
+	VNCPortMax                *int              `mapstructure:"vnc_port_max" cty:"vnc_port_max"`
+	VMName                    *string           `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+	SSHWaitTimeout            *string           `mapstructure:"ssh_wait_timeout" required:"false" cty:"ssh_wait_timeout"`
+	RunOnce                   *bool             `mapstructure:"run_once" cty:"run_once"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":               &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"iso_checksum":                 &hcldec.AttrSpec{Name: "iso_checksum", Type: cty.String, Required: false},
+		"iso_checksum_url":             &hcldec.AttrSpec{Name: "iso_checksum_url", Type: cty.String, Required: false},
+		"iso_checksum_type":            &hcldec.AttrSpec{Name: "iso_checksum_type", Type: cty.String, Required: false},
+		"iso_url":                      &hcldec.AttrSpec{Name: "iso_url", Type: cty.String, Required: false},
+		"iso_urls":                     &hcldec.AttrSpec{Name: "iso_urls", Type: cty.List(cty.String), Required: false},
+		"iso_target_path":              &hcldec.AttrSpec{Name: "iso_target_path", Type: cty.String, Required: false},
+		"iso_target_extension":         &hcldec.AttrSpec{Name: "iso_target_extension", Type: cty.String, Required: false},
+		"boot_keygroup_interval":       &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                    &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                 &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":          &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"disable_vnc":                  &hcldec.AttrSpec{Name: "disable_vnc", Type: cty.Bool, Required: false},
+		"boot_key_interval":            &hcldec.AttrSpec{Name: "boot_key_interval", Type: cty.String, Required: false},
+		"shutdown_command":             &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":             &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"floppy_files":                 &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                  &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                 &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"iso_skip_cache":               &hcldec.AttrSpec{Name: "iso_skip_cache", Type: cty.Bool, Required: false},
+		"accelerator":                  &hcldec.AttrSpec{Name: "accelerator", Type: cty.String, Required: false},
+		"disk_additional_size":         &hcldec.AttrSpec{Name: "disk_additional_size", Type: cty.List(cty.String), Required: false},
+		"cpus":                         &hcldec.AttrSpec{Name: "cpus", Type: cty.Number, Required: false},
+		"disk_interface":               &hcldec.AttrSpec{Name: "disk_interface", Type: cty.String, Required: false},
+		"disk_size":                    &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"disk_cache":                   &hcldec.AttrSpec{Name: "disk_cache", Type: cty.String, Required: false},
+		"disk_discard":                 &hcldec.AttrSpec{Name: "disk_discard", Type: cty.String, Required: false},
+		"disk_detect_zeroes":           &hcldec.AttrSpec{Name: "disk_detect_zeroes", Type: cty.String, Required: false},
+		"skip_compaction":              &hcldec.AttrSpec{Name: "skip_compaction", Type: cty.Bool, Required: false},
+		"disk_compression":             &hcldec.AttrSpec{Name: "disk_compression", Type: cty.Bool, Required: false},
+		"format":                       &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+		"headless":                     &hcldec.AttrSpec{Name: "headless", Type: cty.Bool, Required: false},
+		"disk_image":                   &hcldec.AttrSpec{Name: "disk_image", Type: cty.Bool, Required: false},
+		"use_backing_file":             &hcldec.AttrSpec{Name: "use_backing_file", Type: cty.Bool, Required: false},
+		"machine_type":                 &hcldec.AttrSpec{Name: "machine_type", Type: cty.String, Required: false},
+		"memory":                       &hcldec.AttrSpec{Name: "memory", Type: cty.Number, Required: false},
+		"net_device":                   &hcldec.AttrSpec{Name: "net_device", Type: cty.String, Required: false},
+		"output_directory":             &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"qemuargs":                     &hcldec.BlockListSpec{TypeName: "qemuargs", Nested: &hcldec.AttrSpec{Name: "qemuargs", Type: cty.List(cty.String), Required: false}},
+		"qemu_binary":                  &hcldec.AttrSpec{Name: "qemu_binary", Type: cty.String, Required: false},
+		"qmp_enable":                   &hcldec.AttrSpec{Name: "qmp_enable", Type: cty.Bool, Required: false},
+		"qmp_socket_path":              &hcldec.AttrSpec{Name: "qmp_socket_path", Type: cty.String, Required: false},
+		"ssh_host_port_min":            &hcldec.AttrSpec{Name: "ssh_host_port_min", Type: cty.Number, Required: false},
+		"ssh_host_port_max":            &hcldec.AttrSpec{Name: "ssh_host_port_max", Type: cty.Number, Required: false},
+		"use_default_display":          &hcldec.AttrSpec{Name: "use_default_display", Type: cty.Bool, Required: false},
+		"vnc_bind_address":             &hcldec.AttrSpec{Name: "vnc_bind_address", Type: cty.String, Required: false},
+		"vnc_use_password":             &hcldec.AttrSpec{Name: "vnc_use_password", Type: cty.Bool, Required: false},
+		"vnc_port_min":                 &hcldec.AttrSpec{Name: "vnc_port_min", Type: cty.Number, Required: false},
+		"vnc_port_max":                 &hcldec.AttrSpec{Name: "vnc_port_max", Type: cty.Number, Required: false},
+		"vm_name":                      &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"ssh_wait_timeout":             &hcldec.AttrSpec{Name: "ssh_wait_timeout", Type: cty.String, Required: false},
+		"run_once":                     &hcldec.AttrSpec{Name: "run_once", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/scaleway/config.go b/builder/scaleway/config.go
index 7a78092db..6fd862974 100644
--- a/builder/scaleway/config.go
+++ b/builder/scaleway/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package scaleway
 
diff --git a/builder/scaleway/config.hcl2spec.go b/builder/scaleway/config.hcl2spec.go
new file mode 100644
index 000000000..7d91dba08
--- /dev/null
+++ b/builder/scaleway/config.hcl2spec.go
@@ -0,0 +1,143 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package scaleway
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	Token                     *string           `mapstructure:"api_token" required:"true" cty:"api_token"`
+	Organization              *string           `mapstructure:"organization_id" required:"true" cty:"organization_id"`
+	Region                    *string           `mapstructure:"region" required:"true" cty:"region"`
+	Image                     *string           `mapstructure:"image" required:"true" cty:"image"`
+	CommercialType            *string           `mapstructure:"commercial_type" required:"true" cty:"commercial_type"`
+	SnapshotName              *string           `mapstructure:"snapshot_name" required:"false" cty:"snapshot_name"`
+	ImageName                 *string           `mapstructure:"image_name" required:"false" cty:"image_name"`
+	ServerName                *string           `mapstructure:"server_name" required:"false" cty:"server_name"`
+	Bootscript                *string           `mapstructure:"bootscript" required:"false" cty:"bootscript"`
+	BootType                  *string           `mapstructure:"boottype" required:"false" cty:"boottype"`
+	RemoveVolume              *bool             `mapstructure:"remove_volume" cty:"remove_volume"`
+	UserAgent                 *string           `cty:"user_agent"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"api_token":                    &hcldec.AttrSpec{Name: "api_token", Type: cty.String, Required: false},
+		"organization_id":              &hcldec.AttrSpec{Name: "organization_id", Type: cty.String, Required: false},
+		"region":                       &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"image":                        &hcldec.AttrSpec{Name: "image", Type: cty.String, Required: false},
+		"commercial_type":              &hcldec.AttrSpec{Name: "commercial_type", Type: cty.String, Required: false},
+		"snapshot_name":                &hcldec.AttrSpec{Name: "snapshot_name", Type: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"server_name":                  &hcldec.AttrSpec{Name: "server_name", Type: cty.String, Required: false},
+		"bootscript":                   &hcldec.AttrSpec{Name: "bootscript", Type: cty.String, Required: false},
+		"boottype":                     &hcldec.AttrSpec{Name: "boottype", Type: cty.String, Required: false},
+		"remove_volume":                &hcldec.AttrSpec{Name: "remove_volume", Type: cty.Bool, Required: false},
+		"user_agent":                   &hcldec.AttrSpec{Name: "user_agent", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/tencentcloud/cvm/builder.go b/builder/tencentcloud/cvm/builder.go
index 9b05846b3..f6f80aab7 100644
--- a/builder/tencentcloud/cvm/builder.go
+++ b/builder/tencentcloud/cvm/builder.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package cvm
 
 import (
diff --git a/builder/tencentcloud/cvm/builder.hcl2spec.go b/builder/tencentcloud/cvm/builder.hcl2spec.go
new file mode 100644
index 000000000..4b3c3914b
--- /dev/null
+++ b/builder/tencentcloud/cvm/builder.hcl2spec.go
@@ -0,0 +1,191 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package cvm
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string                    `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string                    `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool                      `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool                      `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string                    `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string          `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string                   `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	SecretId                  *string                    `mapstructure:"secret_id" required:"true" cty:"secret_id"`
+	SecretKey                 *string                    `mapstructure:"secret_key" required:"true" cty:"secret_key"`
+	Region                    *string                    `mapstructure:"region" required:"true" cty:"region"`
+	Zone                      *string                    `mapstructure:"zone" required:"true" cty:"zone"`
+	SkipValidation            *bool                      `mapstructure:"skip_region_validation" required:"false" cty:"skip_region_validation"`
+	ImageName                 *string                    `mapstructure:"image_name" required:"true" cty:"image_name"`
+	ImageDescription          *string                    `mapstructure:"image_description" required:"false" cty:"image_description"`
+	Reboot                    *bool                      `mapstructure:"reboot" required:"false" cty:"reboot"`
+	ForcePoweroff             *bool                      `mapstructure:"force_poweroff" required:"false" cty:"force_poweroff"`
+	Sysprep                   *bool                      `mapstructure:"sysprep" required:"false" cty:"sysprep"`
+	ImageForceDelete          *bool                      `mapstructure:"image_force_delete" cty:"image_force_delete"`
+	ImageCopyRegions          []string                   `mapstructure:"image_copy_regions" required:"false" cty:"image_copy_regions"`
+	ImageShareAccounts        []string                   `mapstructure:"image_share_accounts" required:"false" cty:"image_share_accounts"`
+	AssociatePublicIpAddress  *bool                      `mapstructure:"associate_public_ip_address" required:"false" cty:"associate_public_ip_address"`
+	SourceImageId             *string                    `mapstructure:"source_image_id" required:"true" cty:"source_image_id"`
+	InstanceType              *string                    `mapstructure:"instance_type" required:"true" cty:"instance_type"`
+	InstanceName              *string                    `mapstructure:"instance_name" required:"false" cty:"instance_name"`
+	DiskType                  *string                    `mapstructure:"disk_type" required:"false" cty:"disk_type"`
+	DiskSize                  *int64                     `mapstructure:"disk_size" required:"false" cty:"disk_size"`
+	DataDisks                 []FlattencentCloudDataDisk `mapstructure:"data_disks" cty:"data_disks"`
+	VpcId                     *string                    `mapstructure:"vpc_id" required:"false" cty:"vpc_id"`
+	VpcName                   *string                    `mapstructure:"vpc_name" required:"false" cty:"vpc_name"`
+	VpcIp                     *string                    `mapstructure:"vpc_ip" cty:"vpc_ip"`
+	SubnetId                  *string                    `mapstructure:"subnet_id" required:"false" cty:"subnet_id"`
+	SubnetName                *string                    `mapstructure:"subnet_name" required:"false" cty:"subnet_name"`
+	CidrBlock                 *string                    `mapstructure:"cidr_block" required:"false" cty:"cidr_block"`
+	SubnectCidrBlock          *string                    `mapstructure:"subnect_cidr_block" required:"false" cty:"subnect_cidr_block"`
+	InternetChargeType        *string                    `mapstructure:"internet_charge_type" cty:"internet_charge_type"`
+	InternetMaxBandwidthOut   *int64                     `mapstructure:"internet_max_bandwidth_out" required:"false" cty:"internet_max_bandwidth_out"`
+	SecurityGroupId           *string                    `mapstructure:"security_group_id" required:"false" cty:"security_group_id"`
+	SecurityGroupName         *string                    `mapstructure:"security_group_name" required:"false" cty:"security_group_name"`
+	UserData                  *string                    `mapstructure:"user_data" required:"false" cty:"user_data"`
+	UserDataFile              *string                    `mapstructure:"user_data_file" required:"false" cty:"user_data_file"`
+	HostName                  *string                    `mapstructure:"host_name" required:"false" cty:"host_name"`
+	RunTags                   map[string]string          `mapstructure:"run_tags" required:"false" cty:"run_tags"`
+	Type                      *string                    `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string                    `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string                    `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int                       `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string                    `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string                    `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string                    `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string                    `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool                      `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string                    `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool                      `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string                    `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool                      `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool                      `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int                       `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string                    `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int                       `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool                      `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string                    `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string                    `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string                    `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string                    `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string                    `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int                       `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string                    `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string                    `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string                    `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string                    `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string                   `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string                   `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte                     `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte                     `cty:"ssh_private_key"`
+	WinRMUser                 *string                    `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string                    `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string                    `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int                       `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string                    `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool                      `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool                      `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool                      `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHPrivateIp              *bool                      `mapstructure:"ssh_private_ip" cty:"ssh_private_ip"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"secret_id":                    &hcldec.AttrSpec{Name: "secret_id", Type: cty.String, Required: false},
+		"secret_key":                   &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"region":                       &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"zone":                         &hcldec.AttrSpec{Name: "zone", Type: cty.String, Required: false},
+		"skip_region_validation":       &hcldec.AttrSpec{Name: "skip_region_validation", Type: cty.Bool, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_description":            &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"reboot":                       &hcldec.AttrSpec{Name: "reboot", Type: cty.Bool, Required: false},
+		"force_poweroff":               &hcldec.AttrSpec{Name: "force_poweroff", Type: cty.Bool, Required: false},
+		"sysprep":                      &hcldec.AttrSpec{Name: "sysprep", Type: cty.Bool, Required: false},
+		"image_force_delete":           &hcldec.AttrSpec{Name: "image_force_delete", Type: cty.Bool, Required: false},
+		"image_copy_regions":           &hcldec.AttrSpec{Name: "image_copy_regions", Type: cty.List(cty.String), Required: false},
+		"image_share_accounts":         &hcldec.AttrSpec{Name: "image_share_accounts", Type: cty.List(cty.String), Required: false},
+		"associate_public_ip_address":  &hcldec.AttrSpec{Name: "associate_public_ip_address", Type: cty.Bool, Required: false},
+		"source_image_id":              &hcldec.AttrSpec{Name: "source_image_id", Type: cty.String, Required: false},
+		"instance_type":                &hcldec.AttrSpec{Name: "instance_type", Type: cty.String, Required: false},
+		"instance_name":                &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"disk_type":                    &hcldec.AttrSpec{Name: "disk_type", Type: cty.String, Required: false},
+		"disk_size":                    &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"data_disks":                   &hcldec.BlockListSpec{TypeName: "data_disks", Nested: &hcldec.BlockSpec{TypeName: "data_disks", Nested: hcldec.ObjectSpec((*FlattencentCloudDataDisk)(nil).HCL2Spec())}},
+		"vpc_id":                       &hcldec.AttrSpec{Name: "vpc_id", Type: cty.String, Required: false},
+		"vpc_name":                     &hcldec.AttrSpec{Name: "vpc_name", Type: cty.String, Required: false},
+		"vpc_ip":                       &hcldec.AttrSpec{Name: "vpc_ip", Type: cty.String, Required: false},
+		"subnet_id":                    &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
+		"subnet_name":                  &hcldec.AttrSpec{Name: "subnet_name", Type: cty.String, Required: false},
+		"cidr_block":                   &hcldec.AttrSpec{Name: "cidr_block", Type: cty.String, Required: false},
+		"subnect_cidr_block":           &hcldec.AttrSpec{Name: "subnect_cidr_block", Type: cty.String, Required: false},
+		"internet_charge_type":         &hcldec.AttrSpec{Name: "internet_charge_type", Type: cty.String, Required: false},
+		"internet_max_bandwidth_out":   &hcldec.AttrSpec{Name: "internet_max_bandwidth_out", Type: cty.Number, Required: false},
+		"security_group_id":            &hcldec.AttrSpec{Name: "security_group_id", Type: cty.String, Required: false},
+		"security_group_name":          &hcldec.AttrSpec{Name: "security_group_name", Type: cty.String, Required: false},
+		"user_data":                    &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":               &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"host_name":                    &hcldec.AttrSpec{Name: "host_name", Type: cty.String, Required: false},
+		"run_tags":                     &hcldec.BlockAttrsSpec{TypeName: "run_tags", ElementType: cty.String, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_private_ip":               &hcldec.AttrSpec{Name: "ssh_private_ip", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/tencentcloud/cvm/run_config.go b/builder/tencentcloud/cvm/run_config.go
index 2e4bc3cfe..a061740a7 100644
--- a/builder/tencentcloud/cvm/run_config.go
+++ b/builder/tencentcloud/cvm/run_config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type tencentCloudDataDisk
 
 package cvm
 
diff --git a/builder/tencentcloud/cvm/run_config.hcl2spec.go b/builder/tencentcloud/cvm/run_config.hcl2spec.go
new file mode 100644
index 000000000..ea01fe69e
--- /dev/null
+++ b/builder/tencentcloud/cvm/run_config.hcl2spec.go
@@ -0,0 +1,31 @@
+// Code generated by "mapstructure-to-hcl2 -type tencentCloudDataDisk"; DO NOT EDIT.
+package cvm
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlattencentCloudDataDisk is an auto-generated flat version of tencentCloudDataDisk.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlattencentCloudDataDisk struct {
+	DiskType   *string `mapstructure:"disk_type" cty:"disk_type"`
+	DiskSize   *int64  `mapstructure:"disk_size" cty:"disk_size"`
+	SnapshotId *string `mapstructure:"disk_snapshot_id" cty:"disk_snapshot_id"`
+}
+
+// FlatMapstructure returns a new FlattencentCloudDataDisk.
+// FlattencentCloudDataDisk is an auto-generated flat version of tencentCloudDataDisk.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*tencentCloudDataDisk) FlatMapstructure() interface{} { return new(FlattencentCloudDataDisk) }
+
+// HCL2Spec returns the hcldec.Spec of a FlattencentCloudDataDisk.
+// This spec is used by HCL to read the fields of FlattencentCloudDataDisk.
+func (*FlattencentCloudDataDisk) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"disk_type":        &hcldec.AttrSpec{Name: "disk_type", Type: cty.String, Required: false},
+		"disk_size":        &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"disk_snapshot_id": &hcldec.AttrSpec{Name: "disk_snapshot_id", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/triton/config.go b/builder/triton/config.go
index 9a08508b5..e01fce6dc 100644
--- a/builder/triton/config.go
+++ b/builder/triton/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package triton
 
 import (
diff --git a/builder/triton/config.hcl2spec.go b/builder/triton/config.hcl2spec.go
new file mode 100644
index 000000000..b6ee44651
--- /dev/null
+++ b/builder/triton/config.hcl2spec.go
@@ -0,0 +1,161 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package triton
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string                 `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string                 `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool                   `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool                   `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string                 `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string       `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string                `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Endpoint                  *string                 `mapstructure:"triton_url" required:"false" cty:"triton_url"`
+	Account                   *string                 `mapstructure:"triton_account" required:"true" cty:"triton_account"`
+	Username                  *string                 `mapstructure:"triton_user" required:"false" cty:"triton_user"`
+	KeyID                     *string                 `mapstructure:"triton_key_id" required:"true" cty:"triton_key_id"`
+	KeyMaterial               *string                 `mapstructure:"triton_key_material" required:"false" cty:"triton_key_material"`
+	InsecureSkipTLSVerify     *bool                   `mapstructure:"insecure_skip_tls_verify" required:"false" cty:"insecure_skip_tls_verify"`
+	MachineName               *string                 `mapstructure:"source_machine_name" required:"false" cty:"source_machine_name"`
+	MachinePackage            *string                 `mapstructure:"source_machine_package" required:"true" cty:"source_machine_package"`
+	MachineImage              *string                 `mapstructure:"source_machine_image" required:"true" cty:"source_machine_image"`
+	MachineNetworks           []string                `mapstructure:"source_machine_networks" required:"false" cty:"source_machine_networks"`
+	MachineMetadata           map[string]string       `mapstructure:"source_machine_metadata" required:"false" cty:"source_machine_metadata"`
+	MachineTags               map[string]string       `mapstructure:"source_machine_tags" required:"false" cty:"source_machine_tags"`
+	MachineFirewallEnabled    *bool                   `mapstructure:"source_machine_firewall_enabled" required:"false" cty:"source_machine_firewall_enabled"`
+	MachineImageFilters       *FlatMachineImageFilter `mapstructure:"source_machine_image_filter" required:"false" cty:"source_machine_image_filter"`
+	ImageName                 *string                 `mapstructure:"image_name" required:"true" cty:"image_name"`
+	ImageVersion              *string                 `mapstructure:"image_version" required:"true" cty:"image_version"`
+	ImageDescription          *string                 `mapstructure:"image_description" required:"false" cty:"image_description"`
+	ImageHomepage             *string                 `mapstructure:"image_homepage" required:"false" cty:"image_homepage"`
+	ImageEULA                 *string                 `mapstructure:"image_eula_url" required:"false" cty:"image_eula_url"`
+	ImageACL                  []string                `mapstructure:"image_acls" required:"false" cty:"image_acls"`
+	ImageTags                 map[string]string       `mapstructure:"image_tags" required:"false" cty:"image_tags"`
+	Type                      *string                 `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string                 `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string                 `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int                    `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string                 `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string                 `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string                 `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string                 `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool                   `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string                 `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool                   `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string                 `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool                   `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool                   `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int                    `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string                 `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int                    `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool                   `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string                 `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string                 `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string                 `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string                 `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string                 `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int                    `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string                 `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string                 `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string                 `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string                 `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string                `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string                `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte                  `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte                  `cty:"ssh_private_key"`
+	WinRMUser                 *string                 `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string                 `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string                 `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int                    `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string                 `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool                   `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool                   `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool                   `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":               &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":             &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                    &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                    &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                 &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":           &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":      &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"triton_url":                      &hcldec.AttrSpec{Name: "triton_url", Type: cty.String, Required: false},
+		"triton_account":                  &hcldec.AttrSpec{Name: "triton_account", Type: cty.String, Required: false},
+		"triton_user":                     &hcldec.AttrSpec{Name: "triton_user", Type: cty.String, Required: false},
+		"triton_key_id":                   &hcldec.AttrSpec{Name: "triton_key_id", Type: cty.String, Required: false},
+		"triton_key_material":             &hcldec.AttrSpec{Name: "triton_key_material", Type: cty.String, Required: false},
+		"insecure_skip_tls_verify":        &hcldec.AttrSpec{Name: "insecure_skip_tls_verify", Type: cty.Bool, Required: false},
+		"source_machine_name":             &hcldec.AttrSpec{Name: "source_machine_name", Type: cty.String, Required: false},
+		"source_machine_package":          &hcldec.AttrSpec{Name: "source_machine_package", Type: cty.String, Required: false},
+		"source_machine_image":            &hcldec.AttrSpec{Name: "source_machine_image", Type: cty.String, Required: false},
+		"source_machine_networks":         &hcldec.AttrSpec{Name: "source_machine_networks", Type: cty.List(cty.String), Required: false},
+		"source_machine_metadata":         &hcldec.BlockAttrsSpec{TypeName: "source_machine_metadata", ElementType: cty.String, Required: false},
+		"source_machine_tags":             &hcldec.BlockAttrsSpec{TypeName: "source_machine_tags", ElementType: cty.String, Required: false},
+		"source_machine_firewall_enabled": &hcldec.AttrSpec{Name: "source_machine_firewall_enabled", Type: cty.Bool, Required: false},
+		"source_machine_image_filter":     &hcldec.BlockSpec{TypeName: "source_machine_image_filter", Nested: hcldec.ObjectSpec((*FlatMachineImageFilter)(nil).HCL2Spec())},
+		"image_name":                      &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_version":                   &hcldec.AttrSpec{Name: "image_version", Type: cty.String, Required: false},
+		"image_description":               &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"image_homepage":                  &hcldec.AttrSpec{Name: "image_homepage", Type: cty.String, Required: false},
+		"image_eula_url":                  &hcldec.AttrSpec{Name: "image_eula_url", Type: cty.String, Required: false},
+		"image_acls":                      &hcldec.AttrSpec{Name: "image_acls", Type: cty.List(cty.String), Required: false},
+		"image_tags":                      &hcldec.BlockAttrsSpec{TypeName: "image_tags", ElementType: cty.String, Required: false},
+		"communicator":                    &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":         &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                        &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                        &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                    &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                    &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":                &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":         &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":       &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":            &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                         &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                     &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                  &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":    &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":          &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":                &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":                &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":          &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":            &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":            &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":    &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":        &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                  &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                  &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":              &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":              &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":         &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":          &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":              &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":               &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                  &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                 &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                  &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                  &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                      &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                      &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                   &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                   &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                  &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                  &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/triton/source_machine_config.go b/builder/triton/source_machine_config.go
index a31688ec5..906b5c38f 100644
--- a/builder/triton/source_machine_config.go
+++ b/builder/triton/source_machine_config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type MachineImageFilter
 
 package triton
 
diff --git a/builder/triton/source_machine_config.hcl2spec.go b/builder/triton/source_machine_config.hcl2spec.go
new file mode 100644
index 000000000..7dfed2c69
--- /dev/null
+++ b/builder/triton/source_machine_config.hcl2spec.go
@@ -0,0 +1,41 @@
+// Code generated by "mapstructure-to-hcl2 -type MachineImageFilter"; DO NOT EDIT.
+package triton
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatMachineImageFilter is an auto-generated flat version of MachineImageFilter.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatMachineImageFilter struct {
+	MostRecent *bool   `mapstructure:"most_recent" cty:"most_recent"`
+	Name       *string `cty:"name"`
+	OS         *string `cty:"os"`
+	Version    *string `cty:"version"`
+	Public     *bool   `cty:"public"`
+	State      *string `cty:"state"`
+	Owner      *string `cty:"owner"`
+	Type       *string `cty:"type"`
+}
+
+// FlatMapstructure returns a new FlatMachineImageFilter.
+// FlatMachineImageFilter is an auto-generated flat version of MachineImageFilter.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*MachineImageFilter) FlatMapstructure() interface{} { return new(FlatMachineImageFilter) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatMachineImageFilter.
+// This spec is used by HCL to read the fields of FlatMachineImageFilter.
+func (*FlatMachineImageFilter) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"most_recent": &hcldec.AttrSpec{Name: "most_recent", Type: cty.Bool, Required: false},
+		"name":        &hcldec.AttrSpec{Name: "name", Type: cty.String, Required: false},
+		"os":          &hcldec.AttrSpec{Name: "os", Type: cty.String, Required: false},
+		"version":     &hcldec.AttrSpec{Name: "version", Type: cty.String, Required: false},
+		"public":      &hcldec.AttrSpec{Name: "public", Type: cty.Bool, Required: false},
+		"state":       &hcldec.AttrSpec{Name: "state", Type: cty.String, Required: false},
+		"owner":       &hcldec.AttrSpec{Name: "owner", Type: cty.String, Required: false},
+		"type":        &hcldec.AttrSpec{Name: "type", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/ucloud/uhost/builder.go b/builder/ucloud/uhost/builder.go
index 3ec4393bb..1c606494f 100644
--- a/builder/ucloud/uhost/builder.go
+++ b/builder/ucloud/uhost/builder.go
@@ -1,9 +1,12 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // The ucloud-uhost contains a packer.Builder implementation that
 // builds uhost images for UCloud UHost instance.
 package uhost
 
 import (
 	"context"
+
 	"github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/helper/config"
diff --git a/builder/ucloud/uhost/builder.hcl2spec.go b/builder/ucloud/uhost/builder.hcl2spec.go
new file mode 100644
index 000000000..fc405781d
--- /dev/null
+++ b/builder/ucloud/uhost/builder.hcl2spec.go
@@ -0,0 +1,153 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package uhost
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string                `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string                `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool                  `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool                  `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string                `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string      `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string               `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	PublicKey                 *string                `mapstructure:"public_key" cty:"public_key"`
+	PrivateKey                *string                `mapstructure:"private_key" cty:"private_key"`
+	Region                    *string                `mapstructure:"region" cty:"region"`
+	ProjectId                 *string                `mapstructure:"project_id" cty:"project_id"`
+	BaseUrl                   *string                `mapstructure:"base_url" cty:"base_url"`
+	ImageName                 *string                `mapstructure:"image_name" cty:"image_name"`
+	ImageDescription          *string                `mapstructure:"image_description" cty:"image_description"`
+	ImageDestinations         []FlatImageDestination `mapstructure:"image_copy_to_mappings" cty:"image_copy_to_mappings"`
+	Zone                      *string                `mapstructure:"availability_zone" cty:"availability_zone"`
+	SourceImageId             *string                `mapstructure:"source_image_id" cty:"source_image_id"`
+	InstanceType              *string                `mapstructure:"instance_type" cty:"instance_type"`
+	InstanceName              *string                `mapstructure:"instance_name" cty:"instance_name"`
+	BootDiskType              *string                `mapstructure:"boot_disk_type" cty:"boot_disk_type"`
+	VPCId                     *string                `mapstructure:"vpc_id" cty:"vpc_id"`
+	SubnetId                  *string                `mapstructure:"subnet_id" cty:"subnet_id"`
+	SecurityGroupId           *string                `mapstructure:"security_group_id" cty:"security_group_id"`
+	Type                      *string                `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string                `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string                `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int                   `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string                `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string                `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string                `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string                `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool                  `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string                `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool                  `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string                `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool                  `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool                  `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int                   `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string                `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int                   `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool                  `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string                `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string                `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string                `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string                `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string                `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int                   `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string                `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string                `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string                `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string                `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string               `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string               `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte                 `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte                 `cty:"ssh_private_key"`
+	WinRMUser                 *string                `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string                `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string                `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int                   `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string                `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool                  `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool                  `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool                  `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	UseSSHPrivateIp           *bool                  `mapstructure:"use_ssh_private_ip" cty:"use_ssh_private_ip"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"public_key":                   &hcldec.AttrSpec{Name: "public_key", Type: cty.String, Required: false},
+		"private_key":                  &hcldec.AttrSpec{Name: "private_key", Type: cty.String, Required: false},
+		"region":                       &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"project_id":                   &hcldec.AttrSpec{Name: "project_id", Type: cty.String, Required: false},
+		"base_url":                     &hcldec.AttrSpec{Name: "base_url", Type: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_description":            &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"image_copy_to_mappings":       &hcldec.BlockListSpec{TypeName: "image_copy_to_mappings", Nested: &hcldec.BlockSpec{TypeName: "image_copy_to_mappings", Nested: hcldec.ObjectSpec((*FlatImageDestination)(nil).HCL2Spec())}},
+		"availability_zone":            &hcldec.AttrSpec{Name: "availability_zone", Type: cty.String, Required: false},
+		"source_image_id":              &hcldec.AttrSpec{Name: "source_image_id", Type: cty.String, Required: false},
+		"instance_type":                &hcldec.AttrSpec{Name: "instance_type", Type: cty.String, Required: false},
+		"instance_name":                &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"boot_disk_type":               &hcldec.AttrSpec{Name: "boot_disk_type", Type: cty.String, Required: false},
+		"vpc_id":                       &hcldec.AttrSpec{Name: "vpc_id", Type: cty.String, Required: false},
+		"subnet_id":                    &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
+		"security_group_id":            &hcldec.AttrSpec{Name: "security_group_id", Type: cty.String, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"use_ssh_private_ip":           &hcldec.AttrSpec{Name: "use_ssh_private_ip", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/ucloud/uhost/image_config.go b/builder/ucloud/uhost/image_config.go
index 85fe43822..7a9ada8ce 100644
--- a/builder/ucloud/uhost/image_config.go
+++ b/builder/ucloud/uhost/image_config.go
@@ -1,9 +1,12 @@
+//go:generate mapstructure-to-hcl2 -type ImageDestination
+
 package uhost
 
 import (
 	"fmt"
-	"github.com/hashicorp/packer/template/interpolate"
 	"regexp"
+
+	"github.com/hashicorp/packer/template/interpolate"
 )
 
 type ImageDestination struct {
diff --git a/builder/ucloud/uhost/image_config.hcl2spec.go b/builder/ucloud/uhost/image_config.hcl2spec.go
new file mode 100644
index 000000000..ae0b07ed8
--- /dev/null
+++ b/builder/ucloud/uhost/image_config.hcl2spec.go
@@ -0,0 +1,33 @@
+// Code generated by "mapstructure-to-hcl2 -type ImageDestination"; DO NOT EDIT.
+package uhost
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatImageDestination is an auto-generated flat version of ImageDestination.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatImageDestination struct {
+	ProjectId   *string `mapstructure:"project_id" cty:"project_id"`
+	Region      *string `mapstructure:"region" cty:"region"`
+	Name        *string `mapstructure:"name" cty:"name"`
+	Description *string `mapstructure:"description" cty:"description"`
+}
+
+// FlatMapstructure returns a new FlatImageDestination.
+// FlatImageDestination is an auto-generated flat version of ImageDestination.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*ImageDestination) FlatMapstructure() interface{} { return new(FlatImageDestination) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatImageDestination.
+// This spec is used by HCL to read the fields of FlatImageDestination.
+func (*FlatImageDestination) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"project_id":  &hcldec.AttrSpec{Name: "project_id", Type: cty.String, Required: false},
+		"region":      &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"name":        &hcldec.AttrSpec{Name: "name", Type: cty.String, Required: false},
+		"description": &hcldec.AttrSpec{Name: "description", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/ucloud/uhost/run_config.go b/builder/ucloud/uhost/run_config.go
index cf8f1b0c3..6464e2ea8 100644
--- a/builder/ucloud/uhost/run_config.go
+++ b/builder/ucloud/uhost/run_config.go
@@ -2,10 +2,11 @@ package uhost
 
 import (
 	"fmt"
+	"regexp"
+
 	"github.com/hashicorp/packer/common/uuid"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/template/interpolate"
-	"regexp"
 )
 
 type RunConfig struct {
diff --git a/builder/vagrant/builder.go b/builder/vagrant/builder.go
index 72d8ac490..309356102 100644
--- a/builder/vagrant/builder.go
+++ b/builder/vagrant/builder.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package vagrant
 
diff --git a/builder/vagrant/builder.hcl2spec.go b/builder/vagrant/builder.hcl2spec.go
new file mode 100644
index 000000000..ed1c45fb5
--- /dev/null
+++ b/builder/vagrant/builder.hcl2spec.go
@@ -0,0 +1,197 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package vagrant
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	ISOChecksum               *string           `mapstructure:"iso_checksum" required:"true" cty:"iso_checksum"`
+	ISOChecksumURL            *string           `mapstructure:"iso_checksum_url" cty:"iso_checksum_url"`
+	ISOChecksumType           *string           `mapstructure:"iso_checksum_type" cty:"iso_checksum_type"`
+	RawSingleISOUrl           *string           `mapstructure:"iso_url" required:"true" cty:"iso_url"`
+	ISOUrls                   []string          `mapstructure:"iso_urls" cty:"iso_urls"`
+	TargetPath                *string           `mapstructure:"iso_target_path" cty:"iso_target_path"`
+	TargetExtension           *string           `mapstructure:"iso_target_extension" cty:"iso_target_extension"`
+	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories         []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel               *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	OutputDir                 *string           `mapstructure:"output_dir" required:"false" cty:"output_dir"`
+	SourceBox                 *string           `mapstructure:"source_path" required:"true" cty:"source_path"`
+	GlobalID                  *string           `mapstructure:"global_id" required:"true" cty:"global_id"`
+	Checksum                  *string           `mapstructure:"checksum" required:"false" cty:"checksum"`
+	ChecksumType              *string           `mapstructure:"checksum_type" required:"false" cty:"checksum_type"`
+	BoxName                   *string           `mapstructure:"box_name" required:"false" cty:"box_name"`
+	Provider                  *string           `mapstructure:"provider" required:"false" cty:"provider"`
+	VagrantfileTpl            *string           `mapstructure:"vagrantfile_template" cty:"vagrantfile_template"`
+	TeardownMethod            *string           `mapstructure:"teardown_method" required:"false" cty:"teardown_method"`
+	BoxVersion                *string           `mapstructure:"box_version" required:"false" cty:"box_version"`
+	Template                  *string           `mapstructure:"template" required:"false" cty:"template"`
+	SyncedFolder              *string           `mapstructure:"synced_folder" cty:"synced_folder"`
+	SkipAdd                   *bool             `mapstructure:"skip_add" required:"false" cty:"skip_add"`
+	AddCACert                 *string           `mapstructure:"add_cacert" required:"false" cty:"add_cacert"`
+	AddCAPath                 *string           `mapstructure:"add_capath" required:"false" cty:"add_capath"`
+	AddCert                   *string           `mapstructure:"add_cert" required:"false" cty:"add_cert"`
+	AddClean                  *bool             `mapstructure:"add_clean" required:"false" cty:"add_clean"`
+	AddForce                  *bool             `mapstructure:"add_force" required:"false" cty:"add_force"`
+	AddInsecure               *bool             `mapstructure:"add_insecure" required:"false" cty:"add_insecure"`
+	SkipPackage               *bool             `mapstructure:"skip_package" required:"false" cty:"skip_package"`
+	OutputVagrantfile         *string           `mapstructure:"output_vagrantfile" cty:"output_vagrantfile"`
+	PackageInclude            []string          `mapstructure:"package_include" cty:"package_include"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":               &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"iso_checksum":                 &hcldec.AttrSpec{Name: "iso_checksum", Type: cty.String, Required: false},
+		"iso_checksum_url":             &hcldec.AttrSpec{Name: "iso_checksum_url", Type: cty.String, Required: false},
+		"iso_checksum_type":            &hcldec.AttrSpec{Name: "iso_checksum_type", Type: cty.String, Required: false},
+		"iso_url":                      &hcldec.AttrSpec{Name: "iso_url", Type: cty.String, Required: false},
+		"iso_urls":                     &hcldec.AttrSpec{Name: "iso_urls", Type: cty.List(cty.String), Required: false},
+		"iso_target_path":              &hcldec.AttrSpec{Name: "iso_target_path", Type: cty.String, Required: false},
+		"iso_target_extension":         &hcldec.AttrSpec{Name: "iso_target_extension", Type: cty.String, Required: false},
+		"floppy_files":                 &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                  &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                 &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"boot_keygroup_interval":       &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                    &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                 &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":          &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"output_dir":                   &hcldec.AttrSpec{Name: "output_dir", Type: cty.String, Required: false},
+		"source_path":                  &hcldec.AttrSpec{Name: "source_path", Type: cty.String, Required: false},
+		"global_id":                    &hcldec.AttrSpec{Name: "global_id", Type: cty.String, Required: false},
+		"checksum":                     &hcldec.AttrSpec{Name: "checksum", Type: cty.String, Required: false},
+		"checksum_type":                &hcldec.AttrSpec{Name: "checksum_type", Type: cty.String, Required: false},
+		"box_name":                     &hcldec.AttrSpec{Name: "box_name", Type: cty.String, Required: false},
+		"provider":                     &hcldec.AttrSpec{Name: "provider", Type: cty.String, Required: false},
+		"vagrantfile_template":         &hcldec.AttrSpec{Name: "vagrantfile_template", Type: cty.String, Required: false},
+		"teardown_method":              &hcldec.AttrSpec{Name: "teardown_method", Type: cty.String, Required: false},
+		"box_version":                  &hcldec.AttrSpec{Name: "box_version", Type: cty.String, Required: false},
+		"template":                     &hcldec.AttrSpec{Name: "template", Type: cty.String, Required: false},
+		"synced_folder":                &hcldec.AttrSpec{Name: "synced_folder", Type: cty.String, Required: false},
+		"skip_add":                     &hcldec.AttrSpec{Name: "skip_add", Type: cty.Bool, Required: false},
+		"add_cacert":                   &hcldec.AttrSpec{Name: "add_cacert", Type: cty.String, Required: false},
+		"add_capath":                   &hcldec.AttrSpec{Name: "add_capath", Type: cty.String, Required: false},
+		"add_cert":                     &hcldec.AttrSpec{Name: "add_cert", Type: cty.String, Required: false},
+		"add_clean":                    &hcldec.AttrSpec{Name: "add_clean", Type: cty.Bool, Required: false},
+		"add_force":                    &hcldec.AttrSpec{Name: "add_force", Type: cty.Bool, Required: false},
+		"add_insecure":                 &hcldec.AttrSpec{Name: "add_insecure", Type: cty.Bool, Required: false},
+		"skip_package":                 &hcldec.AttrSpec{Name: "skip_package", Type: cty.Bool, Required: false},
+		"output_vagrantfile":           &hcldec.AttrSpec{Name: "output_vagrantfile", Type: cty.String, Required: false},
+		"package_include":              &hcldec.AttrSpec{Name: "package_include", Type: cty.List(cty.String), Required: false},
+	}
+	return s
+}
diff --git a/builder/virtualbox/iso/builder.go b/builder/virtualbox/iso/builder.go
index e3b6ba75d..5ff62c54e 100644
--- a/builder/virtualbox/iso/builder.go
+++ b/builder/virtualbox/iso/builder.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package iso
 
diff --git a/builder/virtualbox/iso/builder.hcl2spec.go b/builder/virtualbox/iso/builder.hcl2spec.go
new file mode 100644
index 000000000..af6d5027f
--- /dev/null
+++ b/builder/virtualbox/iso/builder.hcl2spec.go
@@ -0,0 +1,227 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package iso
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	ISOChecksum               *string           `mapstructure:"iso_checksum" required:"true" cty:"iso_checksum"`
+	ISOChecksumURL            *string           `mapstructure:"iso_checksum_url" cty:"iso_checksum_url"`
+	ISOChecksumType           *string           `mapstructure:"iso_checksum_type" cty:"iso_checksum_type"`
+	RawSingleISOUrl           *string           `mapstructure:"iso_url" required:"true" cty:"iso_url"`
+	ISOUrls                   []string          `mapstructure:"iso_urls" cty:"iso_urls"`
+	TargetPath                *string           `mapstructure:"iso_target_path" cty:"iso_target_path"`
+	TargetExtension           *string           `mapstructure:"iso_target_extension" cty:"iso_target_extension"`
+	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories         []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel               *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	Format                    *string           `mapstructure:"format" required:"false" cty:"format"`
+	ExportOpts                []string          `mapstructure:"export_opts" required:"false" cty:"export_opts"`
+	OutputDir                 *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	Headless                  *bool             `mapstructure:"headless" required:"false" cty:"headless"`
+	VRDPBindAddress           *string           `mapstructure:"vrdp_bind_address" required:"false" cty:"vrdp_bind_address"`
+	VRDPPortMin               *int              `mapstructure:"vrdp_port_min" required:"false" cty:"vrdp_port_min"`
+	VRDPPortMax               *int              `mapstructure:"vrdp_port_max" cty:"vrdp_port_max"`
+	ShutdownCommand           *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout        *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	RawPostShutdownDelay      *string           `mapstructure:"post_shutdown_delay" required:"false" cty:"post_shutdown_delay"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHHostPortMin            *int              `mapstructure:"ssh_host_port_min" required:"false" cty:"ssh_host_port_min"`
+	SSHHostPortMax            *int              `mapstructure:"ssh_host_port_max" cty:"ssh_host_port_max"`
+	SSHSkipNatMapping         *bool             `mapstructure:"ssh_skip_nat_mapping" required:"false" cty:"ssh_skip_nat_mapping"`
+	SSHWaitTimeout            *string           `mapstructure:"ssh_wait_timeout" cty:"ssh_wait_timeout"`
+	CpuCount                  *int              `mapstructure:"cpus" required:"false" cty:"cpus"`
+	MemorySize                *int              `mapstructure:"memory" required:"false" cty:"memory"`
+	Sound                     *string           `mapstructure:"sound" required:"false" cty:"sound"`
+	USB                       *bool             `mapstructure:"usb" required:"false" cty:"usb"`
+	VBoxManage                [][]string        `mapstructure:"vboxmanage" required:"false" cty:"vboxmanage"`
+	VBoxManagePost            [][]string        `mapstructure:"vboxmanage_post" required:"false" cty:"vboxmanage_post"`
+	VBoxVersionFile           *string           `mapstructure:"virtualbox_version_file" required:"false" cty:"virtualbox_version_file"`
+	BundleISO                 *bool             `mapstructure:"bundle_iso" required:"false" cty:"bundle_iso"`
+	GuestAdditionsMode        *string           `mapstructure:"guest_additions_mode" required:"false" cty:"guest_additions_mode"`
+	DiskSize                  *uint             `mapstructure:"disk_size" required:"false" cty:"disk_size"`
+	GuestAdditionsPath        *string           `mapstructure:"guest_additions_path" required:"false" cty:"guest_additions_path"`
+	GuestAdditionsSHA256      *string           `mapstructure:"guest_additions_sha256" required:"false" cty:"guest_additions_sha256"`
+	GuestAdditionsURL         *string           `mapstructure:"guest_additions_url" required:"false" cty:"guest_additions_url"`
+	GuestAdditionsInterface   *string           `mapstructure:"guest_additions_interface" required:"false" cty:"guest_additions_interface"`
+	GuestOSType               *string           `mapstructure:"guest_os_type" required:"false" cty:"guest_os_type"`
+	HardDriveDiscard          *bool             `mapstructure:"hard_drive_discard" required:"false" cty:"hard_drive_discard"`
+	HardDriveInterface        *string           `mapstructure:"hard_drive_interface" required:"false" cty:"hard_drive_interface"`
+	SATAPortCount             *int              `mapstructure:"sata_port_count" required:"false" cty:"sata_port_count"`
+	HardDriveNonrotational    *bool             `mapstructure:"hard_drive_nonrotational" required:"false" cty:"hard_drive_nonrotational"`
+	ISOInterface              *string           `mapstructure:"iso_interface" required:"false" cty:"iso_interface"`
+	KeepRegistered            *bool             `mapstructure:"keep_registered" required:"false" cty:"keep_registered"`
+	SkipExport                *bool             `mapstructure:"skip_export" required:"false" cty:"skip_export"`
+	VMName                    *string           `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":               &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"iso_checksum":                 &hcldec.AttrSpec{Name: "iso_checksum", Type: cty.String, Required: false},
+		"iso_checksum_url":             &hcldec.AttrSpec{Name: "iso_checksum_url", Type: cty.String, Required: false},
+		"iso_checksum_type":            &hcldec.AttrSpec{Name: "iso_checksum_type", Type: cty.String, Required: false},
+		"iso_url":                      &hcldec.AttrSpec{Name: "iso_url", Type: cty.String, Required: false},
+		"iso_urls":                     &hcldec.AttrSpec{Name: "iso_urls", Type: cty.List(cty.String), Required: false},
+		"iso_target_path":              &hcldec.AttrSpec{Name: "iso_target_path", Type: cty.String, Required: false},
+		"iso_target_extension":         &hcldec.AttrSpec{Name: "iso_target_extension", Type: cty.String, Required: false},
+		"floppy_files":                 &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                  &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                 &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"boot_keygroup_interval":       &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                    &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                 &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":          &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"format":                       &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+		"export_opts":                  &hcldec.AttrSpec{Name: "export_opts", Type: cty.List(cty.String), Required: false},
+		"output_directory":             &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"headless":                     &hcldec.AttrSpec{Name: "headless", Type: cty.Bool, Required: false},
+		"vrdp_bind_address":            &hcldec.AttrSpec{Name: "vrdp_bind_address", Type: cty.String, Required: false},
+		"vrdp_port_min":                &hcldec.AttrSpec{Name: "vrdp_port_min", Type: cty.Number, Required: false},
+		"vrdp_port_max":                &hcldec.AttrSpec{Name: "vrdp_port_max", Type: cty.Number, Required: false},
+		"shutdown_command":             &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":             &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"post_shutdown_delay":          &hcldec.AttrSpec{Name: "post_shutdown_delay", Type: cty.String, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_host_port_min":            &hcldec.AttrSpec{Name: "ssh_host_port_min", Type: cty.Number, Required: false},
+		"ssh_host_port_max":            &hcldec.AttrSpec{Name: "ssh_host_port_max", Type: cty.Number, Required: false},
+		"ssh_skip_nat_mapping":         &hcldec.AttrSpec{Name: "ssh_skip_nat_mapping", Type: cty.Bool, Required: false},
+		"ssh_wait_timeout":             &hcldec.AttrSpec{Name: "ssh_wait_timeout", Type: cty.String, Required: false},
+		"cpus":                         &hcldec.AttrSpec{Name: "cpus", Type: cty.Number, Required: false},
+		"memory":                       &hcldec.AttrSpec{Name: "memory", Type: cty.Number, Required: false},
+		"sound":                        &hcldec.AttrSpec{Name: "sound", Type: cty.String, Required: false},
+		"usb":                          &hcldec.AttrSpec{Name: "usb", Type: cty.Bool, Required: false},
+		"vboxmanage":                   &hcldec.BlockListSpec{TypeName: "vboxmanage", Nested: &hcldec.AttrSpec{Name: "vboxmanage", Type: cty.List(cty.String), Required: false}},
+		"vboxmanage_post":              &hcldec.BlockListSpec{TypeName: "vboxmanage_post", Nested: &hcldec.AttrSpec{Name: "vboxmanage_post", Type: cty.List(cty.String), Required: false}},
+		"virtualbox_version_file":      &hcldec.AttrSpec{Name: "virtualbox_version_file", Type: cty.String, Required: false},
+		"bundle_iso":                   &hcldec.AttrSpec{Name: "bundle_iso", Type: cty.Bool, Required: false},
+		"guest_additions_mode":         &hcldec.AttrSpec{Name: "guest_additions_mode", Type: cty.String, Required: false},
+		"disk_size":                    &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"guest_additions_path":         &hcldec.AttrSpec{Name: "guest_additions_path", Type: cty.String, Required: false},
+		"guest_additions_sha256":       &hcldec.AttrSpec{Name: "guest_additions_sha256", Type: cty.String, Required: false},
+		"guest_additions_url":          &hcldec.AttrSpec{Name: "guest_additions_url", Type: cty.String, Required: false},
+		"guest_additions_interface":    &hcldec.AttrSpec{Name: "guest_additions_interface", Type: cty.String, Required: false},
+		"guest_os_type":                &hcldec.AttrSpec{Name: "guest_os_type", Type: cty.String, Required: false},
+		"hard_drive_discard":           &hcldec.AttrSpec{Name: "hard_drive_discard", Type: cty.Bool, Required: false},
+		"hard_drive_interface":         &hcldec.AttrSpec{Name: "hard_drive_interface", Type: cty.String, Required: false},
+		"sata_port_count":              &hcldec.AttrSpec{Name: "sata_port_count", Type: cty.Number, Required: false},
+		"hard_drive_nonrotational":     &hcldec.AttrSpec{Name: "hard_drive_nonrotational", Type: cty.Bool, Required: false},
+		"iso_interface":                &hcldec.AttrSpec{Name: "iso_interface", Type: cty.String, Required: false},
+		"keep_registered":              &hcldec.AttrSpec{Name: "keep_registered", Type: cty.Bool, Required: false},
+		"skip_export":                  &hcldec.AttrSpec{Name: "skip_export", Type: cty.Bool, Required: false},
+		"vm_name":                      &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/virtualbox/ovf/config.go b/builder/virtualbox/ovf/config.go
index b33607732..10999f463 100644
--- a/builder/virtualbox/ovf/config.go
+++ b/builder/virtualbox/ovf/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package ovf
 
diff --git a/builder/virtualbox/ovf/config.hcl2spec.go b/builder/virtualbox/ovf/config.hcl2spec.go
new file mode 100644
index 000000000..ba709eba1
--- /dev/null
+++ b/builder/virtualbox/ovf/config.hcl2spec.go
@@ -0,0 +1,201 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package ovf
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories         []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel               *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	Format                    *string           `mapstructure:"format" required:"false" cty:"format"`
+	ExportOpts                []string          `mapstructure:"export_opts" required:"false" cty:"export_opts"`
+	OutputDir                 *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	Headless                  *bool             `mapstructure:"headless" required:"false" cty:"headless"`
+	VRDPBindAddress           *string           `mapstructure:"vrdp_bind_address" required:"false" cty:"vrdp_bind_address"`
+	VRDPPortMin               *int              `mapstructure:"vrdp_port_min" required:"false" cty:"vrdp_port_min"`
+	VRDPPortMax               *int              `mapstructure:"vrdp_port_max" cty:"vrdp_port_max"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHHostPortMin            *int              `mapstructure:"ssh_host_port_min" required:"false" cty:"ssh_host_port_min"`
+	SSHHostPortMax            *int              `mapstructure:"ssh_host_port_max" cty:"ssh_host_port_max"`
+	SSHSkipNatMapping         *bool             `mapstructure:"ssh_skip_nat_mapping" required:"false" cty:"ssh_skip_nat_mapping"`
+	SSHWaitTimeout            *string           `mapstructure:"ssh_wait_timeout" cty:"ssh_wait_timeout"`
+	ShutdownCommand           *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout        *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	RawPostShutdownDelay      *string           `mapstructure:"post_shutdown_delay" required:"false" cty:"post_shutdown_delay"`
+	VBoxManage                [][]string        `mapstructure:"vboxmanage" required:"false" cty:"vboxmanage"`
+	VBoxManagePost            [][]string        `mapstructure:"vboxmanage_post" required:"false" cty:"vboxmanage_post"`
+	VBoxVersionFile           *string           `mapstructure:"virtualbox_version_file" required:"false" cty:"virtualbox_version_file"`
+	GuestAdditionsMode        *string           `mapstructure:"guest_additions_mode" required:"false" cty:"guest_additions_mode"`
+	Checksum                  *string           `mapstructure:"checksum" required:"true" cty:"checksum"`
+	ChecksumType              *string           `mapstructure:"checksum_type" required:"false" cty:"checksum_type"`
+	GuestAdditionsPath        *string           `mapstructure:"guest_additions_path" required:"false" cty:"guest_additions_path"`
+	GuestAdditionsInterface   *string           `mapstructure:"guest_additions_interface" required:"false" cty:"guest_additions_interface"`
+	GuestAdditionsSHA256      *string           `mapstructure:"guest_additions_sha256" required:"false" cty:"guest_additions_sha256"`
+	GuestAdditionsURL         *string           `mapstructure:"guest_additions_url" required:"false" cty:"guest_additions_url"`
+	ImportFlags               []string          `mapstructure:"import_flags" required:"false" cty:"import_flags"`
+	ImportOpts                *string           `mapstructure:"import_opts" required:"false" cty:"import_opts"`
+	SourcePath                *string           `mapstructure:"source_path" required:"true" cty:"source_path"`
+	TargetPath                *string           `mapstructure:"target_path" required:"false" cty:"target_path"`
+	VMName                    *string           `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+	KeepRegistered            *bool             `mapstructure:"keep_registered" required:"false" cty:"keep_registered"`
+	SkipExport                *bool             `mapstructure:"skip_export" required:"false" cty:"skip_export"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":               &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"floppy_files":                 &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                  &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                 &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"boot_keygroup_interval":       &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                    &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                 &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":          &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"format":                       &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+		"export_opts":                  &hcldec.AttrSpec{Name: "export_opts", Type: cty.List(cty.String), Required: false},
+		"output_directory":             &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"headless":                     &hcldec.AttrSpec{Name: "headless", Type: cty.Bool, Required: false},
+		"vrdp_bind_address":            &hcldec.AttrSpec{Name: "vrdp_bind_address", Type: cty.String, Required: false},
+		"vrdp_port_min":                &hcldec.AttrSpec{Name: "vrdp_port_min", Type: cty.Number, Required: false},
+		"vrdp_port_max":                &hcldec.AttrSpec{Name: "vrdp_port_max", Type: cty.Number, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_host_port_min":            &hcldec.AttrSpec{Name: "ssh_host_port_min", Type: cty.Number, Required: false},
+		"ssh_host_port_max":            &hcldec.AttrSpec{Name: "ssh_host_port_max", Type: cty.Number, Required: false},
+		"ssh_skip_nat_mapping":         &hcldec.AttrSpec{Name: "ssh_skip_nat_mapping", Type: cty.Bool, Required: false},
+		"ssh_wait_timeout":             &hcldec.AttrSpec{Name: "ssh_wait_timeout", Type: cty.String, Required: false},
+		"shutdown_command":             &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":             &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"post_shutdown_delay":          &hcldec.AttrSpec{Name: "post_shutdown_delay", Type: cty.String, Required: false},
+		"vboxmanage":                   &hcldec.BlockListSpec{TypeName: "vboxmanage", Nested: &hcldec.AttrSpec{Name: "vboxmanage", Type: cty.List(cty.String), Required: false}},
+		"vboxmanage_post":              &hcldec.BlockListSpec{TypeName: "vboxmanage_post", Nested: &hcldec.AttrSpec{Name: "vboxmanage_post", Type: cty.List(cty.String), Required: false}},
+		"virtualbox_version_file":      &hcldec.AttrSpec{Name: "virtualbox_version_file", Type: cty.String, Required: false},
+		"guest_additions_mode":         &hcldec.AttrSpec{Name: "guest_additions_mode", Type: cty.String, Required: false},
+		"checksum":                     &hcldec.AttrSpec{Name: "checksum", Type: cty.String, Required: false},
+		"checksum_type":                &hcldec.AttrSpec{Name: "checksum_type", Type: cty.String, Required: false},
+		"guest_additions_path":         &hcldec.AttrSpec{Name: "guest_additions_path", Type: cty.String, Required: false},
+		"guest_additions_interface":    &hcldec.AttrSpec{Name: "guest_additions_interface", Type: cty.String, Required: false},
+		"guest_additions_sha256":       &hcldec.AttrSpec{Name: "guest_additions_sha256", Type: cty.String, Required: false},
+		"guest_additions_url":          &hcldec.AttrSpec{Name: "guest_additions_url", Type: cty.String, Required: false},
+		"import_flags":                 &hcldec.AttrSpec{Name: "import_flags", Type: cty.List(cty.String), Required: false},
+		"import_opts":                  &hcldec.AttrSpec{Name: "import_opts", Type: cty.String, Required: false},
+		"source_path":                  &hcldec.AttrSpec{Name: "source_path", Type: cty.String, Required: false},
+		"target_path":                  &hcldec.AttrSpec{Name: "target_path", Type: cty.String, Required: false},
+		"vm_name":                      &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"keep_registered":              &hcldec.AttrSpec{Name: "keep_registered", Type: cty.Bool, Required: false},
+		"skip_export":                  &hcldec.AttrSpec{Name: "skip_export", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/virtualbox/vm/config.go b/builder/virtualbox/vm/config.go
index b244739c7..e43d44283 100644
--- a/builder/virtualbox/vm/config.go
+++ b/builder/virtualbox/vm/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package vm
 
 import (
diff --git a/builder/virtualbox/vm/config.hcl2spec.go b/builder/virtualbox/vm/config.hcl2spec.go
new file mode 100644
index 000000000..0214aac6a
--- /dev/null
+++ b/builder/virtualbox/vm/config.hcl2spec.go
@@ -0,0 +1,193 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package vm
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories         []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel               *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	Format                    *string           `mapstructure:"format" required:"false" cty:"format"`
+	ExportOpts                []string          `mapstructure:"export_opts" required:"false" cty:"export_opts"`
+	OutputDir                 *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	Headless                  *bool             `mapstructure:"headless" required:"false" cty:"headless"`
+	VRDPBindAddress           *string           `mapstructure:"vrdp_bind_address" required:"false" cty:"vrdp_bind_address"`
+	VRDPPortMin               *int              `mapstructure:"vrdp_port_min" required:"false" cty:"vrdp_port_min"`
+	VRDPPortMax               *int              `mapstructure:"vrdp_port_max" cty:"vrdp_port_max"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHHostPortMin            *int              `mapstructure:"ssh_host_port_min" required:"false" cty:"ssh_host_port_min"`
+	SSHHostPortMax            *int              `mapstructure:"ssh_host_port_max" cty:"ssh_host_port_max"`
+	SSHSkipNatMapping         *bool             `mapstructure:"ssh_skip_nat_mapping" required:"false" cty:"ssh_skip_nat_mapping"`
+	SSHWaitTimeout            *string           `mapstructure:"ssh_wait_timeout" cty:"ssh_wait_timeout"`
+	ShutdownCommand           *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout        *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	RawPostShutdownDelay      *string           `mapstructure:"post_shutdown_delay" required:"false" cty:"post_shutdown_delay"`
+	VBoxManage                [][]string        `mapstructure:"vboxmanage" required:"false" cty:"vboxmanage"`
+	VBoxManagePost            [][]string        `mapstructure:"vboxmanage_post" required:"false" cty:"vboxmanage_post"`
+	VBoxVersionFile           *string           `mapstructure:"virtualbox_version_file" required:"false" cty:"virtualbox_version_file"`
+	GuestAdditionsMode        *string           `mapstructure:"guest_additions_mode" cty:"guest_additions_mode"`
+	GuestAdditionsPath        *string           `mapstructure:"guest_additions_path" cty:"guest_additions_path"`
+	GuestAdditionsSHA256      *string           `mapstructure:"guest_additions_sha256" cty:"guest_additions_sha256"`
+	GuestAdditionsURL         *string           `mapstructure:"guest_additions_url" cty:"guest_additions_url"`
+	VMName                    *string           `mapstructure:"vm_name" cty:"vm_name"`
+	AttachSnapshot            *string           `mapstructure:"attach_snapshot" cty:"attach_snapshot"`
+	TargetSnapshot            *string           `mapstructure:"target_snapshot" cty:"target_snapshot"`
+	DeleteTargetSnapshot      *bool             `mapstructure:"force_delete_snapshot" cty:"force_delete_snapshot"`
+	KeepRegistered            *bool             `mapstructure:"keep_registered" cty:"keep_registered"`
+	SkipExport                *bool             `mapstructure:"skip_export" cty:"skip_export"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":               &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"floppy_files":                 &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                  &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                 &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"boot_keygroup_interval":       &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                    &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                 &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":          &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"format":                       &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+		"export_opts":                  &hcldec.AttrSpec{Name: "export_opts", Type: cty.List(cty.String), Required: false},
+		"output_directory":             &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"headless":                     &hcldec.AttrSpec{Name: "headless", Type: cty.Bool, Required: false},
+		"vrdp_bind_address":            &hcldec.AttrSpec{Name: "vrdp_bind_address", Type: cty.String, Required: false},
+		"vrdp_port_min":                &hcldec.AttrSpec{Name: "vrdp_port_min", Type: cty.Number, Required: false},
+		"vrdp_port_max":                &hcldec.AttrSpec{Name: "vrdp_port_max", Type: cty.Number, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_host_port_min":            &hcldec.AttrSpec{Name: "ssh_host_port_min", Type: cty.Number, Required: false},
+		"ssh_host_port_max":            &hcldec.AttrSpec{Name: "ssh_host_port_max", Type: cty.Number, Required: false},
+		"ssh_skip_nat_mapping":         &hcldec.AttrSpec{Name: "ssh_skip_nat_mapping", Type: cty.Bool, Required: false},
+		"ssh_wait_timeout":             &hcldec.AttrSpec{Name: "ssh_wait_timeout", Type: cty.String, Required: false},
+		"shutdown_command":             &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":             &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"post_shutdown_delay":          &hcldec.AttrSpec{Name: "post_shutdown_delay", Type: cty.String, Required: false},
+		"vboxmanage":                   &hcldec.BlockListSpec{TypeName: "vboxmanage", Nested: &hcldec.AttrSpec{Name: "vboxmanage", Type: cty.List(cty.String), Required: false}},
+		"vboxmanage_post":              &hcldec.BlockListSpec{TypeName: "vboxmanage_post", Nested: &hcldec.AttrSpec{Name: "vboxmanage_post", Type: cty.List(cty.String), Required: false}},
+		"virtualbox_version_file":      &hcldec.AttrSpec{Name: "virtualbox_version_file", Type: cty.String, Required: false},
+		"guest_additions_mode":         &hcldec.AttrSpec{Name: "guest_additions_mode", Type: cty.String, Required: false},
+		"guest_additions_path":         &hcldec.AttrSpec{Name: "guest_additions_path", Type: cty.String, Required: false},
+		"guest_additions_sha256":       &hcldec.AttrSpec{Name: "guest_additions_sha256", Type: cty.String, Required: false},
+		"guest_additions_url":          &hcldec.AttrSpec{Name: "guest_additions_url", Type: cty.String, Required: false},
+		"vm_name":                      &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"attach_snapshot":              &hcldec.AttrSpec{Name: "attach_snapshot", Type: cty.String, Required: false},
+		"target_snapshot":              &hcldec.AttrSpec{Name: "target_snapshot", Type: cty.String, Required: false},
+		"force_delete_snapshot":        &hcldec.AttrSpec{Name: "force_delete_snapshot", Type: cty.Bool, Required: false},
+		"keep_registered":              &hcldec.AttrSpec{Name: "keep_registered", Type: cty.Bool, Required: false},
+		"skip_export":                  &hcldec.AttrSpec{Name: "skip_export", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/builder/vmware/common/export_config.go b/builder/vmware/common/export_config.go
index 1ae85d759..225d140fa 100644
--- a/builder/vmware/common/export_config.go
+++ b/builder/vmware/common/export_config.go
@@ -1,5 +1,6 @@
 //go:generate struct-markdown
 
+
 package common
 
 import (
diff --git a/builder/vmware/common/hw_config.go b/builder/vmware/common/hw_config.go
index 114227ab3..ba288f57c 100644
--- a/builder/vmware/common/hw_config.go
+++ b/builder/vmware/common/hw_config.go
@@ -1,5 +1,6 @@
 //go:generate struct-markdown
 
+
 package common
 
 import (
diff --git a/builder/vmware/common/output_config.go b/builder/vmware/common/output_config.go
index e99919dcb..acc81fa1f 100644
--- a/builder/vmware/common/output_config.go
+++ b/builder/vmware/common/output_config.go
@@ -1,5 +1,6 @@
 //go:generate struct-markdown
 
+
 package common
 
 import (
diff --git a/builder/vmware/common/ssh_config.go b/builder/vmware/common/ssh_config.go
index 8c59cdedc..6b0072b5e 100644
--- a/builder/vmware/common/ssh_config.go
+++ b/builder/vmware/common/ssh_config.go
@@ -1,5 +1,6 @@
 //go:generate struct-markdown
 
+
 package common
 
 import (
diff --git a/builder/vmware/common/tools_config.go b/builder/vmware/common/tools_config.go
index 4830ff30c..3c76ee2a0 100644
--- a/builder/vmware/common/tools_config.go
+++ b/builder/vmware/common/tools_config.go
@@ -1,5 +1,6 @@
 //go:generate struct-markdown
 
+
 package common
 
 import (
diff --git a/builder/vmware/iso/config.go b/builder/vmware/iso/config.go
index 8e3c5034d..44d577058 100644
--- a/builder/vmware/iso/config.go
+++ b/builder/vmware/iso/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package iso
 
diff --git a/builder/vmware/iso/config.hcl2spec.go b/builder/vmware/iso/config.hcl2spec.go
new file mode 100644
index 000000000..9a5da2aae
--- /dev/null
+++ b/builder/vmware/iso/config.hcl2spec.go
@@ -0,0 +1,261 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package iso
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	ISOChecksum               *string           `mapstructure:"iso_checksum" required:"true" cty:"iso_checksum"`
+	ISOChecksumURL            *string           `mapstructure:"iso_checksum_url" cty:"iso_checksum_url"`
+	ISOChecksumType           *string           `mapstructure:"iso_checksum_type" cty:"iso_checksum_type"`
+	RawSingleISOUrl           *string           `mapstructure:"iso_url" required:"true" cty:"iso_url"`
+	ISOUrls                   []string          `mapstructure:"iso_urls" cty:"iso_urls"`
+	TargetPath                *string           `mapstructure:"iso_target_path" cty:"iso_target_path"`
+	TargetExtension           *string           `mapstructure:"iso_target_extension" cty:"iso_target_extension"`
+	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories         []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel               *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	DisableVNC                *bool             `mapstructure:"disable_vnc" cty:"disable_vnc"`
+	RawBootKeyInterval        *string           `mapstructure:"boot_key_interval" cty:"boot_key_interval"`
+	FusionAppPath             *string           `mapstructure:"fusion_app_path" required:"false" cty:"fusion_app_path"`
+	RemoteType                *string           `mapstructure:"remote_type" required:"false" cty:"remote_type"`
+	RemoteDatastore           *string           `mapstructure:"remote_datastore" required:"false" cty:"remote_datastore"`
+	RemoteCacheDatastore      *string           `mapstructure:"remote_cache_datastore" required:"false" cty:"remote_cache_datastore"`
+	RemoteCacheDirectory      *string           `mapstructure:"remote_cache_directory" required:"false" cty:"remote_cache_directory"`
+	RemoteHost                *string           `mapstructure:"remote_host" required:"false" cty:"remote_host"`
+	RemotePort                *int              `mapstructure:"remote_port" required:"false" cty:"remote_port"`
+	RemoteUser                *string           `mapstructure:"remote_username" required:"false" cty:"remote_username"`
+	RemotePassword            *string           `mapstructure:"remote_password" required:"false" cty:"remote_password"`
+	RemotePrivateKey          *string           `mapstructure:"remote_private_key_file" required:"false" cty:"remote_private_key_file"`
+	SkipValidateCredentials   *bool             `mapstructure:"skip_validate_credentials" required:"false" cty:"skip_validate_credentials"`
+	CpuCount                  *int              `mapstructure:"cpus" required:"false" cty:"cpus"`
+	MemorySize                *int              `mapstructure:"memory" required:"false" cty:"memory"`
+	CoreCount                 *int              `mapstructure:"cores" required:"false" cty:"cores"`
+	Network                   *string           `mapstructure:"network" required:"false" cty:"network"`
+	NetworkAdapterType        *string           `mapstructure:"network_adapter_type" required:"false" cty:"network_adapter_type"`
+	Sound                     *bool             `mapstructure:"sound" required:"false" cty:"sound"`
+	USB                       *bool             `mapstructure:"usb" required:"false" cty:"usb"`
+	Serial                    *string           `mapstructure:"serial" required:"false" cty:"serial"`
+	Parallel                  *string           `mapstructure:"parallel" required:"false" cty:"parallel"`
+	OutputDir                 *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	Headless                  *bool             `mapstructure:"headless" required:"false" cty:"headless"`
+	VNCBindAddress            *string           `mapstructure:"vnc_bind_address" required:"false" cty:"vnc_bind_address"`
+	VNCPortMin                *int              `mapstructure:"vnc_port_min" required:"false" cty:"vnc_port_min"`
+	VNCPortMax                *int              `mapstructure:"vnc_port_max" cty:"vnc_port_max"`
+	VNCDisablePassword        *bool             `mapstructure:"vnc_disable_password" required:"false" cty:"vnc_disable_password"`
+	ShutdownCommand           *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout        *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHSkipRequestPty         *bool             `mapstructure:"ssh_skip_request_pty" cty:"ssh_skip_request_pty"`
+	SSHWaitTimeout            *string           `mapstructure:"ssh_wait_timeout" cty:"ssh_wait_timeout"`
+	ToolsUploadFlavor         *string           `mapstructure:"tools_upload_flavor" required:"false" cty:"tools_upload_flavor"`
+	ToolsUploadPath           *string           `mapstructure:"tools_upload_path" required:"false" cty:"tools_upload_path"`
+	VMXData                   map[string]string `mapstructure:"vmx_data" required:"false" cty:"vmx_data"`
+	VMXDataPost               map[string]string `mapstructure:"vmx_data_post" required:"false" cty:"vmx_data_post"`
+	VMXRemoveEthernet         *bool             `mapstructure:"vmx_remove_ethernet_interfaces" required:"false" cty:"vmx_remove_ethernet_interfaces"`
+	VMXDisplayName            *string           `mapstructure:"display_name" required:"false" cty:"display_name"`
+	Format                    *string           `mapstructure:"format" required:"false" cty:"format"`
+	OVFToolOptions            []string          `mapstructure:"ovftool_options" required:"false" cty:"ovftool_options"`
+	SkipExport                *bool             `mapstructure:"skip_export" required:"false" cty:"skip_export"`
+	KeepRegistered            *bool             `mapstructure:"keep_registered" required:"false" cty:"keep_registered"`
+	SkipCompaction            *bool             `mapstructure:"skip_compaction" required:"false" cty:"skip_compaction"`
+	AdditionalDiskSize        []uint            `mapstructure:"disk_additional_size" required:"false" cty:"disk_additional_size"`
+	DiskAdapterType           *string           `mapstructure:"disk_adapter_type" required:"false" cty:"disk_adapter_type"`
+	DiskName                  *string           `mapstructure:"vmdk_name" required:"false" cty:"vmdk_name"`
+	DiskSize                  *uint             `mapstructure:"disk_size" required:"false" cty:"disk_size"`
+	DiskTypeId                *string           `mapstructure:"disk_type_id" required:"false" cty:"disk_type_id"`
+	CdromAdapterType          *string           `mapstructure:"cdrom_adapter_type" required:"false" cty:"cdrom_adapter_type"`
+	GuestOSType               *string           `mapstructure:"guest_os_type" required:"false" cty:"guest_os_type"`
+	Version                   *string           `mapstructure:"version" required:"false" cty:"version"`
+	VMName                    *string           `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+	VMXDiskTemplatePath       *string           `mapstructure:"vmx_disk_template_path" cty:"vmx_disk_template_path"`
+	VMXTemplatePath           *string           `mapstructure:"vmx_template_path" required:"false" cty:"vmx_template_path"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":              &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":            &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                   &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                   &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":          &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":     &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":                 &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                  &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                  &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"iso_checksum":                   &hcldec.AttrSpec{Name: "iso_checksum", Type: cty.String, Required: false},
+		"iso_checksum_url":               &hcldec.AttrSpec{Name: "iso_checksum_url", Type: cty.String, Required: false},
+		"iso_checksum_type":              &hcldec.AttrSpec{Name: "iso_checksum_type", Type: cty.String, Required: false},
+		"iso_url":                        &hcldec.AttrSpec{Name: "iso_url", Type: cty.String, Required: false},
+		"iso_urls":                       &hcldec.AttrSpec{Name: "iso_urls", Type: cty.List(cty.String), Required: false},
+		"iso_target_path":                &hcldec.AttrSpec{Name: "iso_target_path", Type: cty.String, Required: false},
+		"iso_target_extension":           &hcldec.AttrSpec{Name: "iso_target_extension", Type: cty.String, Required: false},
+		"floppy_files":                   &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                    &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                   &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"boot_keygroup_interval":         &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                      &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                   &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":            &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"disable_vnc":                    &hcldec.AttrSpec{Name: "disable_vnc", Type: cty.Bool, Required: false},
+		"boot_key_interval":              &hcldec.AttrSpec{Name: "boot_key_interval", Type: cty.String, Required: false},
+		"fusion_app_path":                &hcldec.AttrSpec{Name: "fusion_app_path", Type: cty.String, Required: false},
+		"remote_type":                    &hcldec.AttrSpec{Name: "remote_type", Type: cty.String, Required: false},
+		"remote_datastore":               &hcldec.AttrSpec{Name: "remote_datastore", Type: cty.String, Required: false},
+		"remote_cache_datastore":         &hcldec.AttrSpec{Name: "remote_cache_datastore", Type: cty.String, Required: false},
+		"remote_cache_directory":         &hcldec.AttrSpec{Name: "remote_cache_directory", Type: cty.String, Required: false},
+		"remote_host":                    &hcldec.AttrSpec{Name: "remote_host", Type: cty.String, Required: false},
+		"remote_port":                    &hcldec.AttrSpec{Name: "remote_port", Type: cty.Number, Required: false},
+		"remote_username":                &hcldec.AttrSpec{Name: "remote_username", Type: cty.String, Required: false},
+		"remote_password":                &hcldec.AttrSpec{Name: "remote_password", Type: cty.String, Required: false},
+		"remote_private_key_file":        &hcldec.AttrSpec{Name: "remote_private_key_file", Type: cty.String, Required: false},
+		"skip_validate_credentials":      &hcldec.AttrSpec{Name: "skip_validate_credentials", Type: cty.Bool, Required: false},
+		"cpus":                           &hcldec.AttrSpec{Name: "cpus", Type: cty.Number, Required: false},
+		"memory":                         &hcldec.AttrSpec{Name: "memory", Type: cty.Number, Required: false},
+		"cores":                          &hcldec.AttrSpec{Name: "cores", Type: cty.Number, Required: false},
+		"network":                        &hcldec.AttrSpec{Name: "network", Type: cty.String, Required: false},
+		"network_adapter_type":           &hcldec.AttrSpec{Name: "network_adapter_type", Type: cty.String, Required: false},
+		"sound":                          &hcldec.AttrSpec{Name: "sound", Type: cty.Bool, Required: false},
+		"usb":                            &hcldec.AttrSpec{Name: "usb", Type: cty.Bool, Required: false},
+		"serial":                         &hcldec.AttrSpec{Name: "serial", Type: cty.String, Required: false},
+		"parallel":                       &hcldec.AttrSpec{Name: "parallel", Type: cty.String, Required: false},
+		"output_directory":               &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"headless":                       &hcldec.AttrSpec{Name: "headless", Type: cty.Bool, Required: false},
+		"vnc_bind_address":               &hcldec.AttrSpec{Name: "vnc_bind_address", Type: cty.String, Required: false},
+		"vnc_port_min":                   &hcldec.AttrSpec{Name: "vnc_port_min", Type: cty.Number, Required: false},
+		"vnc_port_max":                   &hcldec.AttrSpec{Name: "vnc_port_max", Type: cty.Number, Required: false},
+		"vnc_disable_password":           &hcldec.AttrSpec{Name: "vnc_disable_password", Type: cty.Bool, Required: false},
+		"shutdown_command":               &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":               &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"communicator":                   &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":        &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                       &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                       &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                   &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                   &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":               &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":        &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":      &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":           &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                        &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                    &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                 &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":   &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":         &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":               &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":               &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":         &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":           &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":           &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":   &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":       &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                 &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                 &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":             &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":             &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":        &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":         &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":             &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":              &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                 &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                 &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                 &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                     &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                     &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                  &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                  &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                 &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                 &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_skip_request_pty":           &hcldec.AttrSpec{Name: "ssh_skip_request_pty", Type: cty.Bool, Required: false},
+		"ssh_wait_timeout":               &hcldec.AttrSpec{Name: "ssh_wait_timeout", Type: cty.String, Required: false},
+		"tools_upload_flavor":            &hcldec.AttrSpec{Name: "tools_upload_flavor", Type: cty.String, Required: false},
+		"tools_upload_path":              &hcldec.AttrSpec{Name: "tools_upload_path", Type: cty.String, Required: false},
+		"vmx_data":                       &hcldec.BlockAttrsSpec{TypeName: "vmx_data", ElementType: cty.String, Required: false},
+		"vmx_data_post":                  &hcldec.BlockAttrsSpec{TypeName: "vmx_data_post", ElementType: cty.String, Required: false},
+		"vmx_remove_ethernet_interfaces": &hcldec.AttrSpec{Name: "vmx_remove_ethernet_interfaces", Type: cty.Bool, Required: false},
+		"display_name":                   &hcldec.AttrSpec{Name: "display_name", Type: cty.String, Required: false},
+		"format":                         &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+		"ovftool_options":                &hcldec.AttrSpec{Name: "ovftool_options", Type: cty.List(cty.String), Required: false},
+		"skip_export":                    &hcldec.AttrSpec{Name: "skip_export", Type: cty.Bool, Required: false},
+		"keep_registered":                &hcldec.AttrSpec{Name: "keep_registered", Type: cty.Bool, Required: false},
+		"skip_compaction":                &hcldec.AttrSpec{Name: "skip_compaction", Type: cty.Bool, Required: false},
+		"disk_additional_size":           &hcldec.AttrSpec{Name: "disk_additional_size", Type: cty.List(cty.Number), Required: false},
+		"disk_adapter_type":              &hcldec.AttrSpec{Name: "disk_adapter_type", Type: cty.String, Required: false},
+		"vmdk_name":                      &hcldec.AttrSpec{Name: "vmdk_name", Type: cty.String, Required: false},
+		"disk_size":                      &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"disk_type_id":                   &hcldec.AttrSpec{Name: "disk_type_id", Type: cty.String, Required: false},
+		"cdrom_adapter_type":             &hcldec.AttrSpec{Name: "cdrom_adapter_type", Type: cty.String, Required: false},
+		"guest_os_type":                  &hcldec.AttrSpec{Name: "guest_os_type", Type: cty.String, Required: false},
+		"version":                        &hcldec.AttrSpec{Name: "version", Type: cty.String, Required: false},
+		"vm_name":                        &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"vmx_disk_template_path":         &hcldec.AttrSpec{Name: "vmx_disk_template_path", Type: cty.String, Required: false},
+		"vmx_template_path":              &hcldec.AttrSpec{Name: "vmx_template_path", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/vmware/vmx/config.go b/builder/vmware/vmx/config.go
index f28e98115..7e5d8d1f0 100644
--- a/builder/vmware/vmx/config.go
+++ b/builder/vmware/vmx/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
 
 package vmx
 
diff --git a/builder/vmware/vmx/config.hcl2spec.go b/builder/vmware/vmx/config.hcl2spec.go
new file mode 100644
index 000000000..432837e07
--- /dev/null
+++ b/builder/vmware/vmx/config.hcl2spec.go
@@ -0,0 +1,213 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package vmx
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	HTTPDir                   *string           `mapstructure:"http_directory" cty:"http_directory"`
+	HTTPPortMin               *int              `mapstructure:"http_port_min" cty:"http_port_min"`
+	HTTPPortMax               *int              `mapstructure:"http_port_max" cty:"http_port_max"`
+	FloppyFiles               []string          `mapstructure:"floppy_files" cty:"floppy_files"`
+	FloppyDirectories         []string          `mapstructure:"floppy_dirs" cty:"floppy_dirs"`
+	FloppyLabel               *string           `mapstructure:"floppy_label" cty:"floppy_label"`
+	RawBootGroupInterval      *string           `mapstructure:"boot_keygroup_interval" cty:"boot_keygroup_interval"`
+	RawBootWait               *string           `mapstructure:"boot_wait" cty:"boot_wait"`
+	BootCommand               []string          `mapstructure:"boot_command" cty:"boot_command"`
+	BootGroupInterval         *string           `cty:"boot_group_interval"`
+	DisableVNC                *bool             `mapstructure:"disable_vnc" cty:"disable_vnc"`
+	RawBootKeyInterval        *string           `mapstructure:"boot_key_interval" cty:"boot_key_interval"`
+	FusionAppPath             *string           `mapstructure:"fusion_app_path" required:"false" cty:"fusion_app_path"`
+	RemoteType                *string           `mapstructure:"remote_type" required:"false" cty:"remote_type"`
+	RemoteDatastore           *string           `mapstructure:"remote_datastore" required:"false" cty:"remote_datastore"`
+	RemoteCacheDatastore      *string           `mapstructure:"remote_cache_datastore" required:"false" cty:"remote_cache_datastore"`
+	RemoteCacheDirectory      *string           `mapstructure:"remote_cache_directory" required:"false" cty:"remote_cache_directory"`
+	RemoteHost                *string           `mapstructure:"remote_host" required:"false" cty:"remote_host"`
+	RemotePort                *int              `mapstructure:"remote_port" required:"false" cty:"remote_port"`
+	RemoteUser                *string           `mapstructure:"remote_username" required:"false" cty:"remote_username"`
+	RemotePassword            *string           `mapstructure:"remote_password" required:"false" cty:"remote_password"`
+	RemotePrivateKey          *string           `mapstructure:"remote_private_key_file" required:"false" cty:"remote_private_key_file"`
+	SkipValidateCredentials   *bool             `mapstructure:"skip_validate_credentials" required:"false" cty:"skip_validate_credentials"`
+	OutputDir                 *string           `mapstructure:"output_directory" required:"false" cty:"output_directory"`
+	Headless                  *bool             `mapstructure:"headless" required:"false" cty:"headless"`
+	VNCBindAddress            *string           `mapstructure:"vnc_bind_address" required:"false" cty:"vnc_bind_address"`
+	VNCPortMin                *int              `mapstructure:"vnc_port_min" required:"false" cty:"vnc_port_min"`
+	VNCPortMax                *int              `mapstructure:"vnc_port_max" cty:"vnc_port_max"`
+	VNCDisablePassword        *bool             `mapstructure:"vnc_disable_password" required:"false" cty:"vnc_disable_password"`
+	ShutdownCommand           *string           `mapstructure:"shutdown_command" required:"false" cty:"shutdown_command"`
+	RawShutdownTimeout        *string           `mapstructure:"shutdown_timeout" required:"false" cty:"shutdown_timeout"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHSkipRequestPty         *bool             `mapstructure:"ssh_skip_request_pty" cty:"ssh_skip_request_pty"`
+	SSHWaitTimeout            *string           `mapstructure:"ssh_wait_timeout" cty:"ssh_wait_timeout"`
+	ToolsUploadFlavor         *string           `mapstructure:"tools_upload_flavor" required:"false" cty:"tools_upload_flavor"`
+	ToolsUploadPath           *string           `mapstructure:"tools_upload_path" required:"false" cty:"tools_upload_path"`
+	VMXData                   map[string]string `mapstructure:"vmx_data" required:"false" cty:"vmx_data"`
+	VMXDataPost               map[string]string `mapstructure:"vmx_data_post" required:"false" cty:"vmx_data_post"`
+	VMXRemoveEthernet         *bool             `mapstructure:"vmx_remove_ethernet_interfaces" required:"false" cty:"vmx_remove_ethernet_interfaces"`
+	VMXDisplayName            *string           `mapstructure:"display_name" required:"false" cty:"display_name"`
+	Format                    *string           `mapstructure:"format" required:"false" cty:"format"`
+	OVFToolOptions            []string          `mapstructure:"ovftool_options" required:"false" cty:"ovftool_options"`
+	SkipExport                *bool             `mapstructure:"skip_export" required:"false" cty:"skip_export"`
+	KeepRegistered            *bool             `mapstructure:"keep_registered" required:"false" cty:"keep_registered"`
+	SkipCompaction            *bool             `mapstructure:"skip_compaction" required:"false" cty:"skip_compaction"`
+	Linked                    *bool             `mapstructure:"linked" required:"false" cty:"linked"`
+	SourcePath                *string           `mapstructure:"source_path" required:"true" cty:"source_path"`
+	VMName                    *string           `mapstructure:"vm_name" required:"false" cty:"vm_name"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":              &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":            &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                   &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                   &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":          &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":     &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"http_directory":                 &hcldec.AttrSpec{Name: "http_directory", Type: cty.String, Required: false},
+		"http_port_min":                  &hcldec.AttrSpec{Name: "http_port_min", Type: cty.Number, Required: false},
+		"http_port_max":                  &hcldec.AttrSpec{Name: "http_port_max", Type: cty.Number, Required: false},
+		"floppy_files":                   &hcldec.AttrSpec{Name: "floppy_files", Type: cty.List(cty.String), Required: false},
+		"floppy_dirs":                    &hcldec.AttrSpec{Name: "floppy_dirs", Type: cty.List(cty.String), Required: false},
+		"floppy_label":                   &hcldec.AttrSpec{Name: "floppy_label", Type: cty.String, Required: false},
+		"boot_keygroup_interval":         &hcldec.AttrSpec{Name: "boot_keygroup_interval", Type: cty.String, Required: false},
+		"boot_wait":                      &hcldec.AttrSpec{Name: "boot_wait", Type: cty.String, Required: false},
+		"boot_command":                   &hcldec.AttrSpec{Name: "boot_command", Type: cty.List(cty.String), Required: false},
+		"boot_group_interval":            &hcldec.AttrSpec{Name: "boot_group_interval", Type: cty.String, Required: false},
+		"disable_vnc":                    &hcldec.AttrSpec{Name: "disable_vnc", Type: cty.Bool, Required: false},
+		"boot_key_interval":              &hcldec.AttrSpec{Name: "boot_key_interval", Type: cty.String, Required: false},
+		"fusion_app_path":                &hcldec.AttrSpec{Name: "fusion_app_path", Type: cty.String, Required: false},
+		"remote_type":                    &hcldec.AttrSpec{Name: "remote_type", Type: cty.String, Required: false},
+		"remote_datastore":               &hcldec.AttrSpec{Name: "remote_datastore", Type: cty.String, Required: false},
+		"remote_cache_datastore":         &hcldec.AttrSpec{Name: "remote_cache_datastore", Type: cty.String, Required: false},
+		"remote_cache_directory":         &hcldec.AttrSpec{Name: "remote_cache_directory", Type: cty.String, Required: false},
+		"remote_host":                    &hcldec.AttrSpec{Name: "remote_host", Type: cty.String, Required: false},
+		"remote_port":                    &hcldec.AttrSpec{Name: "remote_port", Type: cty.Number, Required: false},
+		"remote_username":                &hcldec.AttrSpec{Name: "remote_username", Type: cty.String, Required: false},
+		"remote_password":                &hcldec.AttrSpec{Name: "remote_password", Type: cty.String, Required: false},
+		"remote_private_key_file":        &hcldec.AttrSpec{Name: "remote_private_key_file", Type: cty.String, Required: false},
+		"skip_validate_credentials":      &hcldec.AttrSpec{Name: "skip_validate_credentials", Type: cty.Bool, Required: false},
+		"output_directory":               &hcldec.AttrSpec{Name: "output_directory", Type: cty.String, Required: false},
+		"headless":                       &hcldec.AttrSpec{Name: "headless", Type: cty.Bool, Required: false},
+		"vnc_bind_address":               &hcldec.AttrSpec{Name: "vnc_bind_address", Type: cty.String, Required: false},
+		"vnc_port_min":                   &hcldec.AttrSpec{Name: "vnc_port_min", Type: cty.Number, Required: false},
+		"vnc_port_max":                   &hcldec.AttrSpec{Name: "vnc_port_max", Type: cty.Number, Required: false},
+		"vnc_disable_password":           &hcldec.AttrSpec{Name: "vnc_disable_password", Type: cty.Bool, Required: false},
+		"shutdown_command":               &hcldec.AttrSpec{Name: "shutdown_command", Type: cty.String, Required: false},
+		"shutdown_timeout":               &hcldec.AttrSpec{Name: "shutdown_timeout", Type: cty.String, Required: false},
+		"communicator":                   &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":        &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                       &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                       &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                   &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                   &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":               &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":        &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":      &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":           &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                        &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                    &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":                 &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding":   &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":         &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":               &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":               &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":         &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":           &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":           &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file":   &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":       &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":                 &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":                 &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":             &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":             &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":        &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":         &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":             &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":              &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":                 &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":                &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":                 &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":                 &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                     &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                     &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                  &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                  &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":                 &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":                 &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_skip_request_pty":           &hcldec.AttrSpec{Name: "ssh_skip_request_pty", Type: cty.Bool, Required: false},
+		"ssh_wait_timeout":               &hcldec.AttrSpec{Name: "ssh_wait_timeout", Type: cty.String, Required: false},
+		"tools_upload_flavor":            &hcldec.AttrSpec{Name: "tools_upload_flavor", Type: cty.String, Required: false},
+		"tools_upload_path":              &hcldec.AttrSpec{Name: "tools_upload_path", Type: cty.String, Required: false},
+		"vmx_data":                       &hcldec.BlockAttrsSpec{TypeName: "vmx_data", ElementType: cty.String, Required: false},
+		"vmx_data_post":                  &hcldec.BlockAttrsSpec{TypeName: "vmx_data_post", ElementType: cty.String, Required: false},
+		"vmx_remove_ethernet_interfaces": &hcldec.AttrSpec{Name: "vmx_remove_ethernet_interfaces", Type: cty.Bool, Required: false},
+		"display_name":                   &hcldec.AttrSpec{Name: "display_name", Type: cty.String, Required: false},
+		"format":                         &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+		"ovftool_options":                &hcldec.AttrSpec{Name: "ovftool_options", Type: cty.List(cty.String), Required: false},
+		"skip_export":                    &hcldec.AttrSpec{Name: "skip_export", Type: cty.Bool, Required: false},
+		"keep_registered":                &hcldec.AttrSpec{Name: "keep_registered", Type: cty.Bool, Required: false},
+		"skip_compaction":                &hcldec.AttrSpec{Name: "skip_compaction", Type: cty.Bool, Required: false},
+		"linked":                         &hcldec.AttrSpec{Name: "linked", Type: cty.Bool, Required: false},
+		"source_path":                    &hcldec.AttrSpec{Name: "source_path", Type: cty.String, Required: false},
+		"vm_name":                        &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/builder/yandex/config.go b/builder/yandex/config.go
index 39d29e761..2319203e1 100644
--- a/builder/yandex/config.go
+++ b/builder/yandex/config.go
@@ -1,4 +1,6 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config
+
 package yandex
 
 import (
diff --git a/builder/yandex/config.hcl2spec.go b/builder/yandex/config.hcl2spec.go
new file mode 100644
index 000000000..69f6695d7
--- /dev/null
+++ b/builder/yandex/config.hcl2spec.go
@@ -0,0 +1,185 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package yandex
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName           *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType         *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug               *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce               *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError             *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars            map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars       []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Type                      *string           `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string           `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string           `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int              `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string           `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string           `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string           `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string           `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool             `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string           `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool             `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string           `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool             `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool             `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int              `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string           `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int              `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool             `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string           `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string           `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string           `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string           `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string           `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int              `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string           `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string           `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string           `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string           `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string          `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string          `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte            `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte            `cty:"ssh_private_key"`
+	WinRMUser                 *string           `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string           `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string           `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int              `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string           `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool             `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool             `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool             `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	Endpoint                  *string           `mapstructure:"endpoint" required:"false" cty:"endpoint"`
+	FolderID                  *string           `mapstructure:"folder_id" required:"true" cty:"folder_id"`
+	ServiceAccountKeyFile     *string           `mapstructure:"service_account_key_file" required:"false" cty:"service_account_key_file"`
+	Token                     *string           `mapstructure:"token" required:"true" cty:"token"`
+	DiskName                  *string           `mapstructure:"disk_name" required:"false" cty:"disk_name"`
+	DiskSizeGb                *int              `mapstructure:"disk_size_gb" required:"false" cty:"disk_size_gb"`
+	DiskType                  *string           `mapstructure:"disk_type" required:"false" cty:"disk_type"`
+	ImageDescription          *string           `mapstructure:"image_description" required:"false" cty:"image_description"`
+	ImageFamily               *string           `mapstructure:"image_family" required:"false" cty:"image_family"`
+	ImageLabels               map[string]string `mapstructure:"image_labels" required:"false" cty:"image_labels"`
+	ImageName                 *string           `mapstructure:"image_name" required:"false" cty:"image_name"`
+	ImageProductIDs           []string          `mapstructure:"image_product_ids" required:"false" cty:"image_product_ids"`
+	InstanceCores             *int              `mapstructure:"instance_cores" required:"false" cty:"instance_cores"`
+	InstanceGpus              *int              `mapstructure:"instance_gpus" cty:"instance_gpus"`
+	InstanceMemory            *int              `mapstructure:"instance_mem_gb" required:"false" cty:"instance_mem_gb"`
+	InstanceName              *string           `mapstructure:"instance_name" required:"false" cty:"instance_name"`
+	Labels                    map[string]string `mapstructure:"labels" required:"false" cty:"labels"`
+	PlatformID                *string           `mapstructure:"platform_id" required:"false" cty:"platform_id"`
+	MaxRetries                *int              `mapstructure:"max_retries" cty:"max_retries"`
+	Metadata                  map[string]string `mapstructure:"metadata" required:"false" cty:"metadata"`
+	MetadataFromFile          map[string]string `mapstructure:"metadata_from_file" cty:"metadata_from_file"`
+	Preemptible               *bool             `mapstructure:"preemptible" cty:"preemptible"`
+	SerialLogFile             *string           `mapstructure:"serial_log_file" required:"false" cty:"serial_log_file"`
+	SourceImageFamily         *string           `mapstructure:"source_image_family" required:"true" cty:"source_image_family"`
+	SourceImageFolderID       *string           `mapstructure:"source_image_folder_id" required:"false" cty:"source_image_folder_id"`
+	SourceImageID             *string           `mapstructure:"source_image_id" required:"false" cty:"source_image_id"`
+	SourceImageName           *string           `mapstructure:"source_image_name" cty:"source_image_name"`
+	SubnetID                  *string           `mapstructure:"subnet_id" required:"false" cty:"subnet_id"`
+	UseIPv4Nat                *bool             `mapstructure:"use_ipv4_nat" required:"false" cty:"use_ipv4_nat"`
+	UseIPv6                   *bool             `mapstructure:"use_ipv6" required:"false" cty:"use_ipv6"`
+	UseInternalIP             *bool             `mapstructure:"use_internal_ip" required:"false" cty:"use_internal_ip"`
+	Zone                      *string           `mapstructure:"zone" required:"false" cty:"zone"`
+	StateTimeout              *string           `mapstructure:"state_timeout" required:"false" cty:"state_timeout"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"endpoint":                     &hcldec.AttrSpec{Name: "endpoint", Type: cty.String, Required: false},
+		"folder_id":                    &hcldec.AttrSpec{Name: "folder_id", Type: cty.String, Required: false},
+		"service_account_key_file":     &hcldec.AttrSpec{Name: "service_account_key_file", Type: cty.String, Required: false},
+		"token":                        &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"disk_name":                    &hcldec.AttrSpec{Name: "disk_name", Type: cty.String, Required: false},
+		"disk_size_gb":                 &hcldec.AttrSpec{Name: "disk_size_gb", Type: cty.Number, Required: false},
+		"disk_type":                    &hcldec.AttrSpec{Name: "disk_type", Type: cty.String, Required: false},
+		"image_description":            &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"image_family":                 &hcldec.AttrSpec{Name: "image_family", Type: cty.String, Required: false},
+		"image_labels":                 &hcldec.BlockAttrsSpec{TypeName: "image_labels", ElementType: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_product_ids":            &hcldec.AttrSpec{Name: "image_product_ids", Type: cty.List(cty.String), Required: false},
+		"instance_cores":               &hcldec.AttrSpec{Name: "instance_cores", Type: cty.Number, Required: false},
+		"instance_gpus":                &hcldec.AttrSpec{Name: "instance_gpus", Type: cty.Number, Required: false},
+		"instance_mem_gb":              &hcldec.AttrSpec{Name: "instance_mem_gb", Type: cty.Number, Required: false},
+		"instance_name":                &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"labels":                       &hcldec.BlockAttrsSpec{TypeName: "labels", ElementType: cty.String, Required: false},
+		"platform_id":                  &hcldec.AttrSpec{Name: "platform_id", Type: cty.String, Required: false},
+		"max_retries":                  &hcldec.AttrSpec{Name: "max_retries", Type: cty.Number, Required: false},
+		"metadata":                     &hcldec.BlockAttrsSpec{TypeName: "metadata", ElementType: cty.String, Required: false},
+		"metadata_from_file":           &hcldec.BlockAttrsSpec{TypeName: "metadata_from_file", ElementType: cty.String, Required: false},
+		"preemptible":                  &hcldec.AttrSpec{Name: "preemptible", Type: cty.Bool, Required: false},
+		"serial_log_file":              &hcldec.AttrSpec{Name: "serial_log_file", Type: cty.String, Required: false},
+		"source_image_family":          &hcldec.AttrSpec{Name: "source_image_family", Type: cty.String, Required: false},
+		"source_image_folder_id":       &hcldec.AttrSpec{Name: "source_image_folder_id", Type: cty.String, Required: false},
+		"source_image_id":              &hcldec.AttrSpec{Name: "source_image_id", Type: cty.String, Required: false},
+		"source_image_name":            &hcldec.AttrSpec{Name: "source_image_name", Type: cty.String, Required: false},
+		"subnet_id":                    &hcldec.AttrSpec{Name: "subnet_id", Type: cty.String, Required: false},
+		"use_ipv4_nat":                 &hcldec.AttrSpec{Name: "use_ipv4_nat", Type: cty.Bool, Required: false},
+		"use_ipv6":                     &hcldec.AttrSpec{Name: "use_ipv6", Type: cty.Bool, Required: false},
+		"use_internal_ip":              &hcldec.AttrSpec{Name: "use_internal_ip", Type: cty.Bool, Required: false},
+		"zone":                         &hcldec.AttrSpec{Name: "zone", Type: cty.String, Required: false},
+		"state_timeout":                &hcldec.AttrSpec{Name: "state_timeout", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/cmd/hcl2-schema/hcl2-schema.go b/cmd/hcl2-schema/hcl2-schema.go
new file mode 100644
index 000000000..7628e6185
--- /dev/null
+++ b/cmd/hcl2-schema/hcl2-schema.go
@@ -0,0 +1,313 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"regexp"
+	"strings"
+	"text/template"
+
+	"github.com/fatih/structtag"
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+var (
+	typeNames  = flag.String("type", "", "comma-separated list of type names; must be set")
+	output     = flag.String("output", "", "output file name; default srcdir/<type>_hcl2.go")
+	trimprefix = flag.String("trimprefix", "", "trim the `prefix` from the generated constant names")
+)
+
+// Usage is a replacement usage function for the flags package.
+func Usage() {
+	fmt.Fprintf(os.Stderr, "Usage of hcl2-schema:\n")
+	fmt.Fprintf(os.Stderr, "\thcl2-schema [flags] -type T [directory]\n")
+	fmt.Fprintf(os.Stderr, "\thcl2-schema [flags] -type T files... # Must be a single package\n")
+	fmt.Fprintf(os.Stderr, "Flags:\n")
+	flag.PrintDefaults()
+}
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("hcl2-schema: ")
+	flag.Usage = Usage
+	flag.Parse()
+	if len(*typeNames) == 0 {
+		flag.Usage()
+		os.Exit(2)
+	}
+	types := strings.Split(*typeNames, ",")
+
+	// We accept either one directory or a list of files. Which do we have?
+	args := flag.Args()
+	if len(args) == 0 {
+		// Default: process whole package in current directory.
+		args = []string{os.Getenv("GOFILE")}
+	}
+	fname := args[0]
+	outputPath := fname[:len(fname)-2] + "hcl2spec.go"
+
+	b, err := ioutil.ReadFile(fname)
+	if err != nil {
+		fmt.Printf("ReadFile: %+v", err)
+		os.Exit(1)
+	}
+
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, fname, b, parser.ParseComments)
+	if err != nil {
+		fmt.Printf("ParseFile: %+v", err)
+		os.Exit(1)
+	}
+	output := Output{
+		Args:    strings.Join(os.Args[1:], " "),
+		Package: f.Name.String(),
+	}
+
+	res := []StructDef{}
+
+	for _, t := range types {
+		for _, decl := range f.Decls {
+			typeDecl, ok := decl.(*ast.GenDecl)
+			if !ok {
+				continue
+			}
+			typeSpec, ok := typeDecl.Specs[0].(*ast.TypeSpec)
+			if !ok {
+				continue
+			}
+			structDecl, ok := typeSpec.Type.(*ast.StructType)
+			if !ok {
+				continue
+			}
+			if typeSpec.Name.String() != t {
+				continue
+			}
+			sd := StructDef{StructName: t}
+			fields := structDecl.Fields.List
+			for _, field := range fields {
+
+				fieldType := string(b[field.Type.Pos()-1 : field.Type.End()-1])
+				fieldName := fieldType[strings.Index(fieldType, ".")+1:]
+				if len(field.Names) > 0 {
+					fieldName = field.Names[0].Name
+				}
+
+				if ast.IsExported(fieldName) {
+					continue
+				}
+				if strings.Contains(fieldType, "func") {
+					continue
+				}
+				fd := FieldDef{Name: fieldName}
+
+				squash := false
+				accessor := ToSnakeCase(fieldName)
+				if field.Tag != nil {
+					tag := field.Tag.Value[1:]
+					tag = tag[:len(tag)-1]
+					tags, err := structtag.Parse(tag)
+					if err != nil {
+						log.Fatalf("structtag.Parse(%s): err: %v", field.Tag.Value, err)
+					}
+					if hsg, err := tags.Get("hcl2-schema-generator"); err == nil {
+						if len(hsg.Options) > 0 && hsg.Options[0] == "direct" {
+							fieldType = "direct"
+						}
+						if hsg.Name != "" {
+							accessor = hsg.Name
+						}
+					} else if mstr, err := tags.Get("mapstructure"); err == nil {
+						if len(mstr.Options) > 0 && mstr.Options[0] == "squash" {
+							squash = true
+						}
+						if mstr.Name != "" {
+							accessor = mstr.Name
+						}
+					}
+				}
+
+				switch fieldType {
+				case "direct":
+					fd.Spec = `(&` + sd.StructName + `{}).` + fieldName + `.HCL2Spec()`
+				case "[]string", "[]*string":
+					fd.Spec = fmt.Sprintf("%#v", &hcldec.AttrSpec{
+						Name:     accessor,
+						Type:     cty.List(cty.String),
+						Required: false,
+					})
+				case "[]int", "[]uint", "[]int32", "[]int64":
+					fd.Spec = fmt.Sprintf("%#v", &hcldec.AttrSpec{
+						Name:     accessor,
+						Type:     cty.List(cty.Number),
+						Required: false,
+					})
+				case "[]byte", "string", "*string", "time.Duration", "*url.URL":
+					fd.Spec = fmt.Sprintf("%#v", &hcldec.AttrSpec{
+						Name:     accessor,
+						Type:     cty.String,
+						Required: false,
+					})
+				case "uint", "*int", "int", "int32", "int64", "float", "float32", "float64":
+					fd.Spec = fmt.Sprintf("%#v", &hcldec.AttrSpec{
+						Name:     accessor,
+						Type:     cty.Number,
+						Required: false,
+					})
+				case "bool", "config.Trilean":
+					fd.Spec = fmt.Sprintf("%#v", &hcldec.AttrSpec{
+						Name:     accessor,
+						Type:     cty.Bool,
+						Required: false,
+					})
+				case "osccommon.TagMap", "awscommon.TagMap", "TagMap",
+					"map[string]*string", "map[*string]*string", "map[string]string":
+					fd.Spec = fmt.Sprintf("%#v", &hcldec.BlockAttrsSpec{
+						TypeName:    accessor,
+						ElementType: cty.String,
+						Required:    false,
+					})
+				case "[][]string":
+					// TODO(azr): implement those
+					continue
+				case "communicator.Config":
+					// this one is manually set
+					continue
+				case "map[string]interface{}", "map[string]map[string]interface{}":
+					// probably never going to be supported
+					continue
+				case "common.PackerConfig":
+					// this one is deprecated ?
+					continue
+				default: // nested structures
+					if squash {
+						sd.Squashed = append(sd.Squashed, fieldName)
+					} else if strings.HasPrefix(fieldType, "[]") {
+						sd.NestedList = append(sd.NestedList, NestedFieldDef{
+							FieldName: fieldName,
+							TypeName:  fieldType,
+							Accessor:  accessor,
+						})
+					} else {
+						sd.Nested = append(sd.Nested, NestedFieldDef{
+							FieldName: fieldName,
+							TypeName:  fieldType,
+							Accessor:  accessor,
+						})
+					}
+					continue
+				}
+
+				output.ImportCty = true
+				sd.Fields = append(sd.Fields, fd)
+			}
+			res = append(res, sd)
+		}
+	}
+
+	output.StructDefs = res
+
+	result := bytes.NewBuffer(nil)
+
+	err = structDocsTemplate.Execute(result, output)
+	if err != nil {
+		log.Fatalf("err templating: %v", err)
+	}
+
+	formattedBytes, err := format.Source(result.Bytes())
+	if err != nil {
+		log.Printf("formatting err: %v", err)
+		formattedBytes = result.Bytes()
+	}
+
+	outputFile, err := os.Create(outputPath)
+	if err != nil {
+		log.Fatalf("err: %v", err)
+	}
+	defer outputFile.Close()
+
+	_, err = io.Copy(outputFile, bytes.NewBuffer(formattedBytes))
+	if err != nil {
+		log.Fatalf("err: %v", err)
+	}
+}
+
+type Output struct {
+	Args       string
+	Package    string
+	StructDefs []StructDef
+	ImportCty  bool
+}
+
+type FieldDef struct {
+	Name string
+	Spec string
+}
+type NestedFieldDef struct {
+	TypeName  string
+	FieldName string
+	Accessor  string
+}
+
+type StructDef struct {
+	StructName string
+	Fields     []FieldDef
+	Nested     []NestedFieldDef
+	NestedList []NestedFieldDef
+	Squashed   []string
+}
+
+var structDocsTemplate = template.Must(template.New("structDocsTemplate").
+	Funcs(template.FuncMap{
+		// "indent": indent,
+	}).
+	Parse(`// Code generated by "hcl2-schema {{ .Args }}"; DO NOT EDIT.\n
+
+package {{ .Package }}
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+{{- if .ImportCty }}
+	"github.com/zclconf/go-cty/cty"
+{{end -}}
+)
+{{ range .StructDefs }}
+{{ $StructName := .StructName}}
+func (*{{ .StructName }}) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		{{- range .Fields}}
+		"{{ .Name }}": {{ .Spec }},
+		{{- end }}
+		{{- range .Nested}}
+		"{{ .Accessor }}": &hcldec.BlockObjectSpec{TypeName: "{{ .TypeName }}", LabelNames: []string(nil), Nested: hcldec.ObjectSpec((&{{ $StructName }}{}).{{ .FieldName }}.HCL2Spec())},
+		{{- end }}
+		{{- range .NestedList }}
+		"{{ .Accessor }}": &hcldec.BlockListSpec{TypeName: "{{ .TypeName }}", Nested: hcldec.ObjectSpec((&{{ $StructName }}{}).{{ .FieldName }}[0].HCL2Spec()) },
+		{{- end}}
+	}
+	{{- range .Squashed }}
+	for k,v := range (&{{ $StructName }}{}).{{ . }}.HCL2Spec() {
+		s[k] = v
+	}
+	{{- end}}
+	return s
+}
+{{end}}`))
+
+var matchFirstCap = regexp.MustCompile("(.)([A-Z][a-z]+)")
+var matchAllCap = regexp.MustCompile("([a-z0-9])([A-Z])")
+
+func ToSnakeCase(str string) string {
+	snake := matchFirstCap.ReplaceAllString(str, "${1}_${2}")
+	snake = matchAllCap.ReplaceAllString(snake, "${1}_${2}")
+	return strings.ToLower(snake)
+}
diff --git a/common/shell-local/config.go b/common/shell-local/config.go
index d7b97db6a..6acda345a 100644
--- a/common/shell-local/config.go
+++ b/common/shell-local/config.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package shell_local
 
 import (
diff --git a/common/shell-local/config.hcl2spec.go b/common/shell-local/config.hcl2spec.go
new file mode 100644
index 000000000..353530f6b
--- /dev/null
+++ b/common/shell-local/config.hcl2spec.go
@@ -0,0 +1,61 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package shell_local
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Command             *string           `cty:"command"`
+	Inline              []string          `cty:"inline"`
+	InlineShebang       *string           `mapstructure:"inline_shebang" cty:"inline_shebang"`
+	OnlyOn              []string          `mapstructure:"only_on" cty:"only_on"`
+	TempfileExtension   *string           `mapstructure:"tempfile_extension" cty:"tempfile_extension"`
+	Script              *string           `cty:"script"`
+	Scripts             []string          `cty:"scripts"`
+	Vars                []string          `mapstructure:"environment_vars" cty:"environment_vars"`
+	EnvVarFormat        *string           `mapstructure:"env_var_format" cty:"env_var_format"`
+	ExecuteCommand      []string          `mapstructure:"execute_command" cty:"execute_command"`
+	UseLinuxPathing     *bool             `mapstructure:"use_linux_pathing" cty:"use_linux_pathing"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"command":                    &hcldec.AttrSpec{Name: "command", Type: cty.String, Required: false},
+		"inline":                     &hcldec.AttrSpec{Name: "inline", Type: cty.List(cty.String), Required: false},
+		"inline_shebang":             &hcldec.AttrSpec{Name: "inline_shebang", Type: cty.String, Required: false},
+		"only_on":                    &hcldec.AttrSpec{Name: "only_on", Type: cty.List(cty.String), Required: false},
+		"tempfile_extension":         &hcldec.AttrSpec{Name: "tempfile_extension", Type: cty.String, Required: false},
+		"script":                     &hcldec.AttrSpec{Name: "script", Type: cty.String, Required: false},
+		"scripts":                    &hcldec.AttrSpec{Name: "scripts", Type: cty.List(cty.String), Required: false},
+		"environment_vars":           &hcldec.AttrSpec{Name: "environment_vars", Type: cty.List(cty.String), Required: false},
+		"env_var_format":             &hcldec.AttrSpec{Name: "env_var_format", Type: cty.String, Required: false},
+		"execute_command":            &hcldec.AttrSpec{Name: "execute_command", Type: cty.List(cty.String), Required: false},
+		"use_linux_pathing":          &hcldec.AttrSpec{Name: "use_linux_pathing", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/helper/communicator/config.go b/helper/communicator/config.go
index a1a52c056..20207d1c6 100644
--- a/helper/communicator/config.go
+++ b/helper/communicator/config.go
@@ -1,4 +1,5 @@
 //go:generate struct-markdown
+//go:generate mapstructure-to-hcl2 -type Config,SSH,WinRM
 
 package communicator
 
diff --git a/helper/communicator/config.hcl2spec.go b/helper/communicator/config.hcl2spec.go
new file mode 100644
index 000000000..bf726f3cd
--- /dev/null
+++ b/helper/communicator/config.hcl2spec.go
@@ -0,0 +1,217 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,SSH,WinRM"; DO NOT EDIT.
+package communicator
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	Type                      *string  `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect        *string  `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                   *string  `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int     `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string  `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string  `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string  `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string  `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool    `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string  `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool    `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string  `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool    `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool    `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int     `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string  `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int     `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool    `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string  `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string  `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string  `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string  `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string  `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int     `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string  `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string  `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string  `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string  `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte   `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte   `cty:"ssh_private_key"`
+	WinRMUser                 *string  `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword             *string  `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                 *string  `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                 *int     `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout              *string  `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL               *bool    `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure             *bool    `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM              *bool    `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatSSH is an auto-generated flat version of SSH.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatSSH struct {
+	SSHHost                   *string  `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                   *int     `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername               *string  `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword               *string  `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName            *string  `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName   *string  `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys    *bool    `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile         *string  `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                    *bool    `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                *string  `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth              *bool    `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding *bool    `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts      *int     `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost            *string  `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort            *int     `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth       *bool    `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername        *string  `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword        *string  `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile  *string  `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod     *string  `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost              *string  `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort              *int     `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername          *string  `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword          *string  `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval      *string  `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout       *string  `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels          []string `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels           []string `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey              []byte   `cty:"ssh_public_key"`
+	SSHPrivateKey             []byte   `cty:"ssh_private_key"`
+}
+
+// FlatMapstructure returns a new FlatSSH.
+// FlatSSH is an auto-generated flat version of SSH.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*SSH) FlatMapstructure() interface{} { return new(FlatSSH) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatSSH.
+// This spec is used by HCL to read the fields of FlatSSH.
+func (*FlatSSH) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+	}
+	return s
+}
+
+// FlatWinRM is an auto-generated flat version of WinRM.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatWinRM struct {
+	WinRMUser     *string `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword *string `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost     *string `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort     *int    `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout  *string `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL   *bool   `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure *bool   `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM  *bool   `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+}
+
+// FlatMapstructure returns a new FlatWinRM.
+// FlatWinRM is an auto-generated flat version of WinRM.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*WinRM) FlatMapstructure() interface{} { return new(FlatWinRM) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatWinRM.
+// This spec is used by HCL to read the fields of FlatWinRM.
+func (*FlatWinRM) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"winrm_username": &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password": &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":     &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":     &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":  &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":  &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure": &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm": &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/alicloud-import/post-processor.go b/post-processor/alicloud-import/post-processor.go
index a05f1aa2f..42882c6df 100644
--- a/post-processor/alicloud-import/post-processor.go
+++ b/post-processor/alicloud-import/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package alicloudimport
 
 import (
@@ -15,7 +17,6 @@ import (
 	"github.com/aliyun/alibaba-cloud-sdk-go/services/ram"
 	"github.com/aliyun/aliyun-oss-go-sdk/oss"
 	packerecs "github.com/hashicorp/packer/builder/alicloud/ecs"
-	"github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/packer"
 	"github.com/hashicorp/packer/template/interpolate"
@@ -53,8 +54,7 @@ const (
 
 // Configuration of this post processor
 type Config struct {
-	common.PackerConfig `mapstructure:",squash"`
-	packerecs.Config    `mapstructure:",squash"`
+	packerecs.Config `mapstructure:",squash"`
 
 	// Variables specific to this post processor
 	OSSBucket                       string            `mapstructure:"oss_bucket_name"`
diff --git a/post-processor/alicloud-import/post-processor.hcl2spec.go b/post-processor/alicloud-import/post-processor.hcl2spec.go
new file mode 100644
index 000000000..aeeed2435
--- /dev/null
+++ b/post-processor/alicloud-import/post-processor.hcl2spec.go
@@ -0,0 +1,220 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package alicloudimport
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/hashicorp/packer/builder/alicloud/ecs"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName                   *string                      `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType                 *string                      `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                       *bool                        `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                       *bool                        `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError                     *string                      `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars                    map[string]string            `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars               []string                     `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AlicloudAccessKey                 *string                      `mapstructure:"access_key" required:"true" cty:"access_key"`
+	AlicloudSecretKey                 *string                      `mapstructure:"secret_key" required:"true" cty:"secret_key"`
+	AlicloudRegion                    *string                      `mapstructure:"region" required:"true" cty:"region"`
+	AlicloudSkipValidation            *bool                        `mapstructure:"skip_region_validation" required:"false" cty:"skip_region_validation"`
+	SecurityToken                     *string                      `mapstructure:"security_token" required:"false" cty:"security_token"`
+	AlicloudImageName                 *string                      `mapstructure:"image_name" required:"true" cty:"image_name"`
+	AlicloudImageVersion              *string                      `mapstructure:"image_version" required:"false" cty:"image_version"`
+	AlicloudImageDescription          *string                      `mapstructure:"image_description" required:"false" cty:"image_description"`
+	AlicloudImageShareAccounts        []string                     `mapstructure:"image_share_account" required:"false" cty:"image_share_account"`
+	AlicloudImageUNShareAccounts      []string                     `mapstructure:"image_unshare_account" cty:"image_unshare_account"`
+	AlicloudImageDestinationRegions   []string                     `mapstructure:"image_copy_regions" required:"false" cty:"image_copy_regions"`
+	AlicloudImageDestinationNames     []string                     `mapstructure:"image_copy_names" required:"false" cty:"image_copy_names"`
+	ImageEncrypted                    *bool                        `mapstructure:"image_encrypted" required:"false" cty:"image_encrypted"`
+	AlicloudImageForceDelete          *bool                        `mapstructure:"image_force_delete" required:"false" cty:"image_force_delete"`
+	AlicloudImageForceDeleteSnapshots *bool                        `mapstructure:"image_force_delete_snapshots" required:"false" cty:"image_force_delete_snapshots"`
+	AlicloudImageForceDeleteInstances *bool                        `mapstructure:"image_force_delete_instances" cty:"image_force_delete_instances"`
+	AlicloudImageIgnoreDataDisks      *bool                        `mapstructure:"image_ignore_data_disks" required:"false" cty:"image_ignore_data_disks"`
+	AlicloudImageTags                 map[string]string            `mapstructure:"tags" required:"false" cty:"tags"`
+	ECSSystemDiskMapping              *ecs.FlatAlicloudDiskDevice  `mapstructure:"system_disk_mapping" required:"false" cty:"system_disk_mapping"`
+	ECSImagesDiskMappings             []ecs.FlatAlicloudDiskDevice `mapstructure:"image_disk_mappings" required:"false" cty:"image_disk_mappings"`
+	AssociatePublicIpAddress          *bool                        `mapstructure:"associate_public_ip_address" cty:"associate_public_ip_address"`
+	ZoneId                            *string                      `mapstructure:"zone_id" required:"false" cty:"zone_id"`
+	IOOptimized                       *bool                        `mapstructure:"io_optimized" required:"false" cty:"io_optimized"`
+	InstanceType                      *string                      `mapstructure:"instance_type" required:"true" cty:"instance_type"`
+	Description                       *string                      `mapstructure:"description" cty:"description"`
+	AlicloudSourceImage               *string                      `mapstructure:"source_image" required:"true" cty:"source_image"`
+	ForceStopInstance                 *bool                        `mapstructure:"force_stop_instance" required:"false" cty:"force_stop_instance"`
+	DisableStopInstance               *bool                        `mapstructure:"disable_stop_instance" required:"false" cty:"disable_stop_instance"`
+	SecurityGroupId                   *string                      `mapstructure:"security_group_id" required:"false" cty:"security_group_id"`
+	SecurityGroupName                 *string                      `mapstructure:"security_group_name" required:"false" cty:"security_group_name"`
+	UserData                          *string                      `mapstructure:"user_data" required:"false" cty:"user_data"`
+	UserDataFile                      *string                      `mapstructure:"user_data_file" required:"false" cty:"user_data_file"`
+	VpcId                             *string                      `mapstructure:"vpc_id" required:"false" cty:"vpc_id"`
+	VpcName                           *string                      `mapstructure:"vpc_name" required:"false" cty:"vpc_name"`
+	CidrBlock                         *string                      `mapstructure:"vpc_cidr_block" required:"false" cty:"vpc_cidr_block"`
+	VSwitchId                         *string                      `mapstructure:"vswitch_id" required:"false" cty:"vswitch_id"`
+	VSwitchName                       *string                      `mapstructure:"vswitch_name" required:"false" cty:"vswitch_name"`
+	InstanceName                      *string                      `mapstructure:"instance_name" required:"false" cty:"instance_name"`
+	InternetChargeType                *string                      `mapstructure:"internet_charge_type" required:"false" cty:"internet_charge_type"`
+	InternetMaxBandwidthOut           *int                         `mapstructure:"internet_max_bandwidth_out" required:"false" cty:"internet_max_bandwidth_out"`
+	WaitSnapshotReadyTimeout          *int                         `mapstructure:"wait_snapshot_ready_timeout" required:"false" cty:"wait_snapshot_ready_timeout"`
+	Type                              *string                      `mapstructure:"communicator" cty:"communicator"`
+	PauseBeforeConnect                *string                      `mapstructure:"pause_before_connecting" cty:"pause_before_connecting"`
+	SSHHost                           *string                      `mapstructure:"ssh_host" cty:"ssh_host"`
+	SSHPort                           *int                         `mapstructure:"ssh_port" cty:"ssh_port"`
+	SSHUsername                       *string                      `mapstructure:"ssh_username" cty:"ssh_username"`
+	SSHPassword                       *string                      `mapstructure:"ssh_password" cty:"ssh_password"`
+	SSHKeyPairName                    *string                      `mapstructure:"ssh_keypair_name" cty:"ssh_keypair_name"`
+	SSHTemporaryKeyPairName           *string                      `mapstructure:"temporary_key_pair_name" cty:"temporary_key_pair_name"`
+	SSHClearAuthorizedKeys            *bool                        `mapstructure:"ssh_clear_authorized_keys" cty:"ssh_clear_authorized_keys"`
+	SSHPrivateKeyFile                 *string                      `mapstructure:"ssh_private_key_file" cty:"ssh_private_key_file"`
+	SSHPty                            *bool                        `mapstructure:"ssh_pty" cty:"ssh_pty"`
+	SSHTimeout                        *string                      `mapstructure:"ssh_timeout" cty:"ssh_timeout"`
+	SSHAgentAuth                      *bool                        `mapstructure:"ssh_agent_auth" cty:"ssh_agent_auth"`
+	SSHDisableAgentForwarding         *bool                        `mapstructure:"ssh_disable_agent_forwarding" cty:"ssh_disable_agent_forwarding"`
+	SSHHandshakeAttempts              *int                         `mapstructure:"ssh_handshake_attempts" cty:"ssh_handshake_attempts"`
+	SSHBastionHost                    *string                      `mapstructure:"ssh_bastion_host" cty:"ssh_bastion_host"`
+	SSHBastionPort                    *int                         `mapstructure:"ssh_bastion_port" cty:"ssh_bastion_port"`
+	SSHBastionAgentAuth               *bool                        `mapstructure:"ssh_bastion_agent_auth" cty:"ssh_bastion_agent_auth"`
+	SSHBastionUsername                *string                      `mapstructure:"ssh_bastion_username" cty:"ssh_bastion_username"`
+	SSHBastionPassword                *string                      `mapstructure:"ssh_bastion_password" cty:"ssh_bastion_password"`
+	SSHBastionPrivateKeyFile          *string                      `mapstructure:"ssh_bastion_private_key_file" cty:"ssh_bastion_private_key_file"`
+	SSHFileTransferMethod             *string                      `mapstructure:"ssh_file_transfer_method" cty:"ssh_file_transfer_method"`
+	SSHProxyHost                      *string                      `mapstructure:"ssh_proxy_host" cty:"ssh_proxy_host"`
+	SSHProxyPort                      *int                         `mapstructure:"ssh_proxy_port" cty:"ssh_proxy_port"`
+	SSHProxyUsername                  *string                      `mapstructure:"ssh_proxy_username" cty:"ssh_proxy_username"`
+	SSHProxyPassword                  *string                      `mapstructure:"ssh_proxy_password" cty:"ssh_proxy_password"`
+	SSHKeepAliveInterval              *string                      `mapstructure:"ssh_keep_alive_interval" cty:"ssh_keep_alive_interval"`
+	SSHReadWriteTimeout               *string                      `mapstructure:"ssh_read_write_timeout" cty:"ssh_read_write_timeout"`
+	SSHRemoteTunnels                  []string                     `mapstructure:"ssh_remote_tunnels" cty:"ssh_remote_tunnels"`
+	SSHLocalTunnels                   []string                     `mapstructure:"ssh_local_tunnels" cty:"ssh_local_tunnels"`
+	SSHPublicKey                      []byte                       `cty:"ssh_public_key"`
+	SSHPrivateKey                     []byte                       `cty:"ssh_private_key"`
+	WinRMUser                         *string                      `mapstructure:"winrm_username" cty:"winrm_username"`
+	WinRMPassword                     *string                      `mapstructure:"winrm_password" cty:"winrm_password"`
+	WinRMHost                         *string                      `mapstructure:"winrm_host" cty:"winrm_host"`
+	WinRMPort                         *int                         `mapstructure:"winrm_port" cty:"winrm_port"`
+	WinRMTimeout                      *string                      `mapstructure:"winrm_timeout" cty:"winrm_timeout"`
+	WinRMUseSSL                       *bool                        `mapstructure:"winrm_use_ssl" cty:"winrm_use_ssl"`
+	WinRMInsecure                     *bool                        `mapstructure:"winrm_insecure" cty:"winrm_insecure"`
+	WinRMUseNTLM                      *bool                        `mapstructure:"winrm_use_ntlm" cty:"winrm_use_ntlm"`
+	SSHPrivateIp                      *bool                        `mapstructure:"ssh_private_ip" required:"false" cty:"ssh_private_ip"`
+	OSSBucket                         *string                      `mapstructure:"oss_bucket_name" cty:"oss_bucket_name"`
+	OSSKey                            *string                      `mapstructure:"oss_key_name" cty:"oss_key_name"`
+	SkipClean                         *bool                        `mapstructure:"skip_clean" cty:"skip_clean"`
+	OSType                            *string                      `mapstructure:"image_os_type" cty:"image_os_type"`
+	Platform                          *string                      `mapstructure:"image_platform" cty:"image_platform"`
+	Architecture                      *string                      `mapstructure:"image_architecture" cty:"image_architecture"`
+	Size                              *string                      `mapstructure:"image_system_size" cty:"image_system_size"`
+	Format                            *string                      `mapstructure:"format" cty:"format"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":            &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":          &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                 &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                 &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":              &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":        &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":   &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"access_key":                   &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"secret_key":                   &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"region":                       &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"skip_region_validation":       &hcldec.AttrSpec{Name: "skip_region_validation", Type: cty.Bool, Required: false},
+		"security_token":               &hcldec.AttrSpec{Name: "security_token", Type: cty.String, Required: false},
+		"image_name":                   &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_version":                &hcldec.AttrSpec{Name: "image_version", Type: cty.String, Required: false},
+		"image_description":            &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"image_share_account":          &hcldec.AttrSpec{Name: "image_share_account", Type: cty.List(cty.String), Required: false},
+		"image_unshare_account":        &hcldec.AttrSpec{Name: "image_unshare_account", Type: cty.List(cty.String), Required: false},
+		"image_copy_regions":           &hcldec.AttrSpec{Name: "image_copy_regions", Type: cty.List(cty.String), Required: false},
+		"image_copy_names":             &hcldec.AttrSpec{Name: "image_copy_names", Type: cty.List(cty.String), Required: false},
+		"image_encrypted":              &hcldec.AttrSpec{Name: "image_encrypted", Type: cty.Bool, Required: false},
+		"image_force_delete":           &hcldec.AttrSpec{Name: "image_force_delete", Type: cty.Bool, Required: false},
+		"image_force_delete_snapshots": &hcldec.AttrSpec{Name: "image_force_delete_snapshots", Type: cty.Bool, Required: false},
+		"image_force_delete_instances": &hcldec.AttrSpec{Name: "image_force_delete_instances", Type: cty.Bool, Required: false},
+		"image_ignore_data_disks":      &hcldec.AttrSpec{Name: "image_ignore_data_disks", Type: cty.Bool, Required: false},
+		"tags":                         &hcldec.BlockAttrsSpec{TypeName: "tags", ElementType: cty.String, Required: false},
+		"system_disk_mapping":          &hcldec.BlockSpec{TypeName: "system_disk_mapping", Nested: hcldec.ObjectSpec((*ecs.FlatAlicloudDiskDevice)(nil).HCL2Spec())},
+		"image_disk_mappings":          &hcldec.BlockListSpec{TypeName: "image_disk_mappings", Nested: &hcldec.BlockSpec{TypeName: "image_disk_mappings", Nested: hcldec.ObjectSpec((*ecs.FlatAlicloudDiskDevice)(nil).HCL2Spec())}},
+		"associate_public_ip_address":  &hcldec.AttrSpec{Name: "associate_public_ip_address", Type: cty.Bool, Required: false},
+		"zone_id":                      &hcldec.AttrSpec{Name: "zone_id", Type: cty.String, Required: false},
+		"io_optimized":                 &hcldec.AttrSpec{Name: "io_optimized", Type: cty.Bool, Required: false},
+		"instance_type":                &hcldec.AttrSpec{Name: "instance_type", Type: cty.String, Required: false},
+		"description":                  &hcldec.AttrSpec{Name: "description", Type: cty.String, Required: false},
+		"source_image":                 &hcldec.AttrSpec{Name: "source_image", Type: cty.String, Required: false},
+		"force_stop_instance":          &hcldec.AttrSpec{Name: "force_stop_instance", Type: cty.Bool, Required: false},
+		"disable_stop_instance":        &hcldec.AttrSpec{Name: "disable_stop_instance", Type: cty.Bool, Required: false},
+		"security_group_id":            &hcldec.AttrSpec{Name: "security_group_id", Type: cty.String, Required: false},
+		"security_group_name":          &hcldec.AttrSpec{Name: "security_group_name", Type: cty.String, Required: false},
+		"user_data":                    &hcldec.AttrSpec{Name: "user_data", Type: cty.String, Required: false},
+		"user_data_file":               &hcldec.AttrSpec{Name: "user_data_file", Type: cty.String, Required: false},
+		"vpc_id":                       &hcldec.AttrSpec{Name: "vpc_id", Type: cty.String, Required: false},
+		"vpc_name":                     &hcldec.AttrSpec{Name: "vpc_name", Type: cty.String, Required: false},
+		"vpc_cidr_block":               &hcldec.AttrSpec{Name: "vpc_cidr_block", Type: cty.String, Required: false},
+		"vswitch_id":                   &hcldec.AttrSpec{Name: "vswitch_id", Type: cty.String, Required: false},
+		"vswitch_name":                 &hcldec.AttrSpec{Name: "vswitch_name", Type: cty.String, Required: false},
+		"instance_name":                &hcldec.AttrSpec{Name: "instance_name", Type: cty.String, Required: false},
+		"internet_charge_type":         &hcldec.AttrSpec{Name: "internet_charge_type", Type: cty.String, Required: false},
+		"internet_max_bandwidth_out":   &hcldec.AttrSpec{Name: "internet_max_bandwidth_out", Type: cty.Number, Required: false},
+		"wait_snapshot_ready_timeout":  &hcldec.AttrSpec{Name: "wait_snapshot_ready_timeout", Type: cty.Number, Required: false},
+		"communicator":                 &hcldec.AttrSpec{Name: "communicator", Type: cty.String, Required: false},
+		"pause_before_connecting":      &hcldec.AttrSpec{Name: "pause_before_connecting", Type: cty.String, Required: false},
+		"ssh_host":                     &hcldec.AttrSpec{Name: "ssh_host", Type: cty.String, Required: false},
+		"ssh_port":                     &hcldec.AttrSpec{Name: "ssh_port", Type: cty.Number, Required: false},
+		"ssh_username":                 &hcldec.AttrSpec{Name: "ssh_username", Type: cty.String, Required: false},
+		"ssh_password":                 &hcldec.AttrSpec{Name: "ssh_password", Type: cty.String, Required: false},
+		"ssh_keypair_name":             &hcldec.AttrSpec{Name: "ssh_keypair_name", Type: cty.String, Required: false},
+		"temporary_key_pair_name":      &hcldec.AttrSpec{Name: "temporary_key_pair_name", Type: cty.String, Required: false},
+		"ssh_clear_authorized_keys":    &hcldec.AttrSpec{Name: "ssh_clear_authorized_keys", Type: cty.Bool, Required: false},
+		"ssh_private_key_file":         &hcldec.AttrSpec{Name: "ssh_private_key_file", Type: cty.String, Required: false},
+		"ssh_pty":                      &hcldec.AttrSpec{Name: "ssh_pty", Type: cty.Bool, Required: false},
+		"ssh_timeout":                  &hcldec.AttrSpec{Name: "ssh_timeout", Type: cty.String, Required: false},
+		"ssh_agent_auth":               &hcldec.AttrSpec{Name: "ssh_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_disable_agent_forwarding": &hcldec.AttrSpec{Name: "ssh_disable_agent_forwarding", Type: cty.Bool, Required: false},
+		"ssh_handshake_attempts":       &hcldec.AttrSpec{Name: "ssh_handshake_attempts", Type: cty.Number, Required: false},
+		"ssh_bastion_host":             &hcldec.AttrSpec{Name: "ssh_bastion_host", Type: cty.String, Required: false},
+		"ssh_bastion_port":             &hcldec.AttrSpec{Name: "ssh_bastion_port", Type: cty.Number, Required: false},
+		"ssh_bastion_agent_auth":       &hcldec.AttrSpec{Name: "ssh_bastion_agent_auth", Type: cty.Bool, Required: false},
+		"ssh_bastion_username":         &hcldec.AttrSpec{Name: "ssh_bastion_username", Type: cty.String, Required: false},
+		"ssh_bastion_password":         &hcldec.AttrSpec{Name: "ssh_bastion_password", Type: cty.String, Required: false},
+		"ssh_bastion_private_key_file": &hcldec.AttrSpec{Name: "ssh_bastion_private_key_file", Type: cty.String, Required: false},
+		"ssh_file_transfer_method":     &hcldec.AttrSpec{Name: "ssh_file_transfer_method", Type: cty.String, Required: false},
+		"ssh_proxy_host":               &hcldec.AttrSpec{Name: "ssh_proxy_host", Type: cty.String, Required: false},
+		"ssh_proxy_port":               &hcldec.AttrSpec{Name: "ssh_proxy_port", Type: cty.Number, Required: false},
+		"ssh_proxy_username":           &hcldec.AttrSpec{Name: "ssh_proxy_username", Type: cty.String, Required: false},
+		"ssh_proxy_password":           &hcldec.AttrSpec{Name: "ssh_proxy_password", Type: cty.String, Required: false},
+		"ssh_keep_alive_interval":      &hcldec.AttrSpec{Name: "ssh_keep_alive_interval", Type: cty.String, Required: false},
+		"ssh_read_write_timeout":       &hcldec.AttrSpec{Name: "ssh_read_write_timeout", Type: cty.String, Required: false},
+		"ssh_remote_tunnels":           &hcldec.AttrSpec{Name: "ssh_remote_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_local_tunnels":            &hcldec.AttrSpec{Name: "ssh_local_tunnels", Type: cty.List(cty.String), Required: false},
+		"ssh_public_key":               &hcldec.AttrSpec{Name: "ssh_public_key", Type: cty.List(cty.Number), Required: false},
+		"ssh_private_key":              &hcldec.AttrSpec{Name: "ssh_private_key", Type: cty.List(cty.Number), Required: false},
+		"winrm_username":               &hcldec.AttrSpec{Name: "winrm_username", Type: cty.String, Required: false},
+		"winrm_password":               &hcldec.AttrSpec{Name: "winrm_password", Type: cty.String, Required: false},
+		"winrm_host":                   &hcldec.AttrSpec{Name: "winrm_host", Type: cty.String, Required: false},
+		"winrm_port":                   &hcldec.AttrSpec{Name: "winrm_port", Type: cty.Number, Required: false},
+		"winrm_timeout":                &hcldec.AttrSpec{Name: "winrm_timeout", Type: cty.String, Required: false},
+		"winrm_use_ssl":                &hcldec.AttrSpec{Name: "winrm_use_ssl", Type: cty.Bool, Required: false},
+		"winrm_insecure":               &hcldec.AttrSpec{Name: "winrm_insecure", Type: cty.Bool, Required: false},
+		"winrm_use_ntlm":               &hcldec.AttrSpec{Name: "winrm_use_ntlm", Type: cty.Bool, Required: false},
+		"ssh_private_ip":               &hcldec.AttrSpec{Name: "ssh_private_ip", Type: cty.Bool, Required: false},
+		"oss_bucket_name":              &hcldec.AttrSpec{Name: "oss_bucket_name", Type: cty.String, Required: false},
+		"oss_key_name":                 &hcldec.AttrSpec{Name: "oss_key_name", Type: cty.String, Required: false},
+		"skip_clean":                   &hcldec.AttrSpec{Name: "skip_clean", Type: cty.Bool, Required: false},
+		"image_os_type":                &hcldec.AttrSpec{Name: "image_os_type", Type: cty.String, Required: false},
+		"image_platform":               &hcldec.AttrSpec{Name: "image_platform", Type: cty.String, Required: false},
+		"image_architecture":           &hcldec.AttrSpec{Name: "image_architecture", Type: cty.String, Required: false},
+		"image_system_size":            &hcldec.AttrSpec{Name: "image_system_size", Type: cty.String, Required: false},
+		"format":                       &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/amazon-import/post-processor.go b/post-processor/amazon-import/post-processor.go
index 17302effc..d4e995181 100644
--- a/post-processor/amazon-import/post-processor.go
+++ b/post-processor/amazon-import/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package amazonimport
 
 import (
diff --git a/post-processor/amazon-import/post-processor.hcl2spec.go b/post-processor/amazon-import/post-processor.hcl2spec.go
new file mode 100644
index 000000000..ef2134711
--- /dev/null
+++ b/post-processor/amazon-import/post-processor.hcl2spec.go
@@ -0,0 +1,94 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package amazonimport
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/hashicorp/packer/builder/amazon/common"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName       *string                           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType     *string                           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug           *bool                             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce           *bool                             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError         *string                           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars        map[string]string                 `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars   []string                          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AccessKey             *string                           `mapstructure:"access_key" required:"true" cty:"access_key"`
+	CustomEndpointEc2     *string                           `mapstructure:"custom_endpoint_ec2" required:"false" cty:"custom_endpoint_ec2"`
+	DecodeAuthZMessages   *bool                             `mapstructure:"decode_authorization_messages" required:"false" cty:"decode_authorization_messages"`
+	InsecureSkipTLSVerify *bool                             `mapstructure:"insecure_skip_tls_verify" required:"false" cty:"insecure_skip_tls_verify"`
+	MFACode               *string                           `mapstructure:"mfa_code" required:"false" cty:"mfa_code"`
+	ProfileName           *string                           `mapstructure:"profile" required:"false" cty:"profile"`
+	RawRegion             *string                           `mapstructure:"region" required:"true" cty:"region"`
+	SecretKey             *string                           `mapstructure:"secret_key" required:"true" cty:"secret_key"`
+	SkipValidation        *bool                             `mapstructure:"skip_region_validation" required:"false" cty:"skip_region_validation"`
+	SkipMetadataApiCheck  *bool                             `mapstructure:"skip_metadata_api_check" cty:"skip_metadata_api_check"`
+	Token                 *string                           `mapstructure:"token" required:"false" cty:"token"`
+	VaultAWSEngine        *common.FlatVaultAWSEngineOptions `mapstructure:"vault_aws_engine" required:"false" cty:"vault_aws_engine"`
+	S3Bucket              *string                           `mapstructure:"s3_bucket_name" cty:"s3_bucket_name"`
+	S3Key                 *string                           `mapstructure:"s3_key_name" cty:"s3_key_name"`
+	S3Encryption          *string                           `mapstructure:"s3_encryption" cty:"s3_encryption"`
+	S3EncryptionKey       *string                           `mapstructure:"s3_encryption_key" cty:"s3_encryption_key"`
+	SkipClean             *bool                             `mapstructure:"skip_clean" cty:"skip_clean"`
+	Tags                  map[string]string                 `mapstructure:"tags" cty:"tags"`
+	Name                  *string                           `mapstructure:"ami_name" cty:"ami_name"`
+	Description           *string                           `mapstructure:"ami_description" cty:"ami_description"`
+	Users                 []string                          `mapstructure:"ami_users" cty:"ami_users"`
+	Groups                []string                          `mapstructure:"ami_groups" cty:"ami_groups"`
+	Encrypt               *bool                             `mapstructure:"ami_encrypt" cty:"ami_encrypt"`
+	KMSKey                *string                           `mapstructure:"ami_kms_key" cty:"ami_kms_key"`
+	LicenseType           *string                           `mapstructure:"license_type" cty:"license_type"`
+	RoleName              *string                           `mapstructure:"role_name" cty:"role_name"`
+	Format                *string                           `mapstructure:"format" cty:"format"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":             &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":           &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                  &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                  &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":               &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":         &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":    &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"access_key":                    &hcldec.AttrSpec{Name: "access_key", Type: cty.String, Required: false},
+		"custom_endpoint_ec2":           &hcldec.AttrSpec{Name: "custom_endpoint_ec2", Type: cty.String, Required: false},
+		"decode_authorization_messages": &hcldec.AttrSpec{Name: "decode_authorization_messages", Type: cty.Bool, Required: false},
+		"insecure_skip_tls_verify":      &hcldec.AttrSpec{Name: "insecure_skip_tls_verify", Type: cty.Bool, Required: false},
+		"mfa_code":                      &hcldec.AttrSpec{Name: "mfa_code", Type: cty.String, Required: false},
+		"profile":                       &hcldec.AttrSpec{Name: "profile", Type: cty.String, Required: false},
+		"region":                        &hcldec.AttrSpec{Name: "region", Type: cty.String, Required: false},
+		"secret_key":                    &hcldec.AttrSpec{Name: "secret_key", Type: cty.String, Required: false},
+		"skip_region_validation":        &hcldec.AttrSpec{Name: "skip_region_validation", Type: cty.Bool, Required: false},
+		"skip_metadata_api_check":       &hcldec.AttrSpec{Name: "skip_metadata_api_check", Type: cty.Bool, Required: false},
+		"token":                         &hcldec.AttrSpec{Name: "token", Type: cty.String, Required: false},
+		"vault_aws_engine":              &hcldec.BlockSpec{TypeName: "vault_aws_engine", Nested: hcldec.ObjectSpec((*common.FlatVaultAWSEngineOptions)(nil).HCL2Spec())},
+		"s3_bucket_name":                &hcldec.AttrSpec{Name: "s3_bucket_name", Type: cty.String, Required: false},
+		"s3_key_name":                   &hcldec.AttrSpec{Name: "s3_key_name", Type: cty.String, Required: false},
+		"s3_encryption":                 &hcldec.AttrSpec{Name: "s3_encryption", Type: cty.String, Required: false},
+		"s3_encryption_key":             &hcldec.AttrSpec{Name: "s3_encryption_key", Type: cty.String, Required: false},
+		"skip_clean":                    &hcldec.AttrSpec{Name: "skip_clean", Type: cty.Bool, Required: false},
+		"tags":                          &hcldec.BlockAttrsSpec{TypeName: "tags", ElementType: cty.String, Required: false},
+		"ami_name":                      &hcldec.AttrSpec{Name: "ami_name", Type: cty.String, Required: false},
+		"ami_description":               &hcldec.AttrSpec{Name: "ami_description", Type: cty.String, Required: false},
+		"ami_users":                     &hcldec.AttrSpec{Name: "ami_users", Type: cty.List(cty.String), Required: false},
+		"ami_groups":                    &hcldec.AttrSpec{Name: "ami_groups", Type: cty.List(cty.String), Required: false},
+		"ami_encrypt":                   &hcldec.AttrSpec{Name: "ami_encrypt", Type: cty.Bool, Required: false},
+		"ami_kms_key":                   &hcldec.AttrSpec{Name: "ami_kms_key", Type: cty.String, Required: false},
+		"license_type":                  &hcldec.AttrSpec{Name: "license_type", Type: cty.String, Required: false},
+		"role_name":                     &hcldec.AttrSpec{Name: "role_name", Type: cty.String, Required: false},
+		"format":                        &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/artifice/post-processor.go b/post-processor/artifice/post-processor.go
index c0714946e..fafa915e7 100644
--- a/post-processor/artifice/post-processor.go
+++ b/post-processor/artifice/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package artifice
 
 import (
diff --git a/post-processor/artifice/post-processor.hcl2spec.go b/post-processor/artifice/post-processor.hcl2spec.go
new file mode 100644
index 000000000..c81b3eefe
--- /dev/null
+++ b/post-processor/artifice/post-processor.hcl2spec.go
@@ -0,0 +1,43 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package artifice
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Files               []string          `mapstructure:"files" cty:"files"`
+	Keep                *bool             `mapstructure:"keep_input_artifact" cty:"keep_input_artifact"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"files":                      &hcldec.AttrSpec{Name: "files", Type: cty.List(cty.String), Required: false},
+		"keep_input_artifact":        &hcldec.AttrSpec{Name: "keep_input_artifact", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/checksum/post-processor.go b/post-processor/checksum/post-processor.go
index 79d1863be..9b3cec76f 100644
--- a/post-processor/checksum/post-processor.go
+++ b/post-processor/checksum/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package checksum
 
 import (
diff --git a/post-processor/checksum/post-processor.hcl2spec.go b/post-processor/checksum/post-processor.hcl2spec.go
new file mode 100644
index 000000000..1efec6c80
--- /dev/null
+++ b/post-processor/checksum/post-processor.hcl2spec.go
@@ -0,0 +1,45 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package checksum
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Keep                *bool             `mapstructure:"keep_input_artifact" cty:"keep_input_artifact"`
+	ChecksumTypes       []string          `mapstructure:"checksum_types" cty:"checksum_types"`
+	OutputPath          *string           `mapstructure:"output" cty:"output"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"keep_input_artifact":        &hcldec.AttrSpec{Name: "keep_input_artifact", Type: cty.Bool, Required: false},
+		"checksum_types":             &hcldec.AttrSpec{Name: "checksum_types", Type: cty.List(cty.String), Required: false},
+		"output":                     &hcldec.AttrSpec{Name: "output", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/compress/post-processor.go b/post-processor/compress/post-processor.go
index be60e9897..7432b373e 100644
--- a/post-processor/compress/post-processor.go
+++ b/post-processor/compress/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package compress
 
 import (
diff --git a/post-processor/compress/post-processor.hcl2spec.go b/post-processor/compress/post-processor.hcl2spec.go
new file mode 100644
index 000000000..4e8db0497
--- /dev/null
+++ b/post-processor/compress/post-processor.hcl2spec.go
@@ -0,0 +1,49 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package compress
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	OutputPath          *string           `mapstructure:"output" cty:"output"`
+	Format              *string           `mapstructure:"format" cty:"format"`
+	CompressionLevel    *int              `mapstructure:"compression_level" cty:"compression_level"`
+	Archive             *string           `cty:"archive"`
+	Algorithm           *string           `cty:"algorithm"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"output":                     &hcldec.AttrSpec{Name: "output", Type: cty.String, Required: false},
+		"format":                     &hcldec.AttrSpec{Name: "format", Type: cty.String, Required: false},
+		"compression_level":          &hcldec.AttrSpec{Name: "compression_level", Type: cty.Number, Required: false},
+		"archive":                    &hcldec.AttrSpec{Name: "archive", Type: cty.String, Required: false},
+		"algorithm":                  &hcldec.AttrSpec{Name: "algorithm", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/digitalocean-import/post-processor.go b/post-processor/digitalocean-import/post-processor.go
index 80e1d13a8..0588a3566 100644
--- a/post-processor/digitalocean-import/post-processor.go
+++ b/post-processor/digitalocean-import/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package digitaloceanimport
 
 import (
diff --git a/post-processor/digitalocean-import/post-processor.hcl2spec.go b/post-processor/digitalocean-import/post-processor.hcl2spec.go
new file mode 100644
index 000000000..00e764e83
--- /dev/null
+++ b/post-processor/digitalocean-import/post-processor.hcl2spec.go
@@ -0,0 +1,65 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package digitaloceanimport
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	APIToken            *string           `mapstructure:"api_token" cty:"api_token"`
+	SpacesKey           *string           `mapstructure:"spaces_key" cty:"spaces_key"`
+	SpacesSecret        *string           `mapstructure:"spaces_secret" cty:"spaces_secret"`
+	SpacesRegion        *string           `mapstructure:"spaces_region" cty:"spaces_region"`
+	SpaceName           *string           `mapstructure:"space_name" cty:"space_name"`
+	ObjectName          *string           `mapstructure:"space_object_name" cty:"space_object_name"`
+	SkipClean           *bool             `mapstructure:"skip_clean" cty:"skip_clean"`
+	Tags                []string          `mapstructure:"image_tags" cty:"image_tags"`
+	Name                *string           `mapstructure:"image_name" cty:"image_name"`
+	Description         *string           `mapstructure:"image_description" cty:"image_description"`
+	Distribution        *string           `mapstructure:"image_distribution" cty:"image_distribution"`
+	ImageRegions        []string          `mapstructure:"image_regions" cty:"image_regions"`
+	Timeout             *string           `mapstructure:"timeout" cty:"timeout"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"api_token":                  &hcldec.AttrSpec{Name: "api_token", Type: cty.String, Required: false},
+		"spaces_key":                 &hcldec.AttrSpec{Name: "spaces_key", Type: cty.String, Required: false},
+		"spaces_secret":              &hcldec.AttrSpec{Name: "spaces_secret", Type: cty.String, Required: false},
+		"spaces_region":              &hcldec.AttrSpec{Name: "spaces_region", Type: cty.String, Required: false},
+		"space_name":                 &hcldec.AttrSpec{Name: "space_name", Type: cty.String, Required: false},
+		"space_object_name":          &hcldec.AttrSpec{Name: "space_object_name", Type: cty.String, Required: false},
+		"skip_clean":                 &hcldec.AttrSpec{Name: "skip_clean", Type: cty.Bool, Required: false},
+		"image_tags":                 &hcldec.AttrSpec{Name: "image_tags", Type: cty.List(cty.String), Required: false},
+		"image_name":                 &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"image_description":          &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"image_distribution":         &hcldec.AttrSpec{Name: "image_distribution", Type: cty.String, Required: false},
+		"image_regions":              &hcldec.AttrSpec{Name: "image_regions", Type: cty.List(cty.String), Required: false},
+		"timeout":                    &hcldec.AttrSpec{Name: "timeout", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/docker-import/post-processor.go b/post-processor/docker-import/post-processor.go
index bf1e44f54..fc0309a3c 100644
--- a/post-processor/docker-import/post-processor.go
+++ b/post-processor/docker-import/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package dockerimport
 
 import (
diff --git a/post-processor/docker-import/post-processor.hcl2spec.go b/post-processor/docker-import/post-processor.hcl2spec.go
new file mode 100644
index 000000000..80a0ff36c
--- /dev/null
+++ b/post-processor/docker-import/post-processor.hcl2spec.go
@@ -0,0 +1,45 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package dockerimport
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Repository          *string           `mapstructure:"repository" cty:"repository"`
+	Tag                 *string           `mapstructure:"tag" cty:"tag"`
+	Changes             []string          `mapstructure:"changes" cty:"changes"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"repository":                 &hcldec.AttrSpec{Name: "repository", Type: cty.String, Required: false},
+		"tag":                        &hcldec.AttrSpec{Name: "tag", Type: cty.String, Required: false},
+		"changes":                    &hcldec.AttrSpec{Name: "changes", Type: cty.List(cty.String), Required: false},
+	}
+	return s
+}
diff --git a/post-processor/docker-push/post-processor.go b/post-processor/docker-push/post-processor.go
index 3af640335..cd0b950e1 100644
--- a/post-processor/docker-push/post-processor.go
+++ b/post-processor/docker-push/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package dockerpush
 
 import (
diff --git a/post-processor/docker-push/post-processor.hcl2spec.go b/post-processor/docker-push/post-processor.hcl2spec.go
new file mode 100644
index 000000000..096aebdda
--- /dev/null
+++ b/post-processor/docker-push/post-processor.hcl2spec.go
@@ -0,0 +1,57 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package dockerpush
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Login               *bool             `cty:"login"`
+	LoginUsername       *string           `mapstructure:"login_username" cty:"login_username"`
+	LoginPassword       *string           `mapstructure:"login_password" cty:"login_password"`
+	LoginServer         *string           `mapstructure:"login_server" cty:"login_server"`
+	EcrLogin            *bool             `mapstructure:"ecr_login" cty:"ecr_login"`
+	AccessKey           *string           `mapstructure:"aws_access_key" required:"false" cty:"aws_access_key"`
+	SecretKey           *string           `mapstructure:"aws_secret_key" required:"false" cty:"aws_secret_key"`
+	Token               *string           `mapstructure:"aws_token" required:"false" cty:"aws_token"`
+	Profile             *string           `mapstructure:"aws_profile" required:"false" cty:"aws_profile"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"login":                      &hcldec.AttrSpec{Name: "login", Type: cty.Bool, Required: false},
+		"login_username":             &hcldec.AttrSpec{Name: "login_username", Type: cty.String, Required: false},
+		"login_password":             &hcldec.AttrSpec{Name: "login_password", Type: cty.String, Required: false},
+		"login_server":               &hcldec.AttrSpec{Name: "login_server", Type: cty.String, Required: false},
+		"ecr_login":                  &hcldec.AttrSpec{Name: "ecr_login", Type: cty.Bool, Required: false},
+		"aws_access_key":             &hcldec.AttrSpec{Name: "aws_access_key", Type: cty.String, Required: false},
+		"aws_secret_key":             &hcldec.AttrSpec{Name: "aws_secret_key", Type: cty.String, Required: false},
+		"aws_token":                  &hcldec.AttrSpec{Name: "aws_token", Type: cty.String, Required: false},
+		"aws_profile":                &hcldec.AttrSpec{Name: "aws_profile", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/docker-save/post-processor.go b/post-processor/docker-save/post-processor.go
index fa935dde3..26198142c 100644
--- a/post-processor/docker-save/post-processor.go
+++ b/post-processor/docker-save/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package dockersave
 
 import (
diff --git a/post-processor/docker-save/post-processor.hcl2spec.go b/post-processor/docker-save/post-processor.hcl2spec.go
new file mode 100644
index 000000000..e7c71ed51
--- /dev/null
+++ b/post-processor/docker-save/post-processor.hcl2spec.go
@@ -0,0 +1,41 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package dockersave
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Path                *string           `mapstructure:"path" cty:"path"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"path":                       &hcldec.AttrSpec{Name: "path", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/docker-tag/post-processor.go b/post-processor/docker-tag/post-processor.go
index 20729ad5e..1712efbda 100644
--- a/post-processor/docker-tag/post-processor.go
+++ b/post-processor/docker-tag/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package dockertag
 
 import (
diff --git a/post-processor/docker-tag/post-processor.hcl2spec.go b/post-processor/docker-tag/post-processor.hcl2spec.go
new file mode 100644
index 000000000..3df25724b
--- /dev/null
+++ b/post-processor/docker-tag/post-processor.hcl2spec.go
@@ -0,0 +1,45 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package dockertag
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Repository          *string           `mapstructure:"repository" cty:"repository"`
+	Tag                 *string           `mapstructure:"tag" cty:"tag"`
+	Force               *bool             `cty:"force"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"repository":                 &hcldec.AttrSpec{Name: "repository", Type: cty.String, Required: false},
+		"tag":                        &hcldec.AttrSpec{Name: "tag", Type: cty.String, Required: false},
+		"force":                      &hcldec.AttrSpec{Name: "force", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/exoscale-import/post-processor.go b/post-processor/exoscale-import/post-processor.go
index b3afee7ac..3e8cc261a 100644
--- a/post-processor/exoscale-import/post-processor.go
+++ b/post-processor/exoscale-import/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package exoscaleimport
 
 import (
diff --git a/post-processor/exoscale-import/post-processor.hcl2spec.go b/post-processor/exoscale-import/post-processor.hcl2spec.go
new file mode 100644
index 000000000..3dbd4740d
--- /dev/null
+++ b/post-processor/exoscale-import/post-processor.hcl2spec.go
@@ -0,0 +1,63 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package exoscaleimport
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName         *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType       *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug             *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce             *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError           *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars          map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars     []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	SkipClean               *bool             `mapstructure:"skip_clean" cty:"skip_clean"`
+	SOSEndpoint             *string           `mapstructure:"sos_endpoint" cty:"sos_endpoint"`
+	APIEndpoint             *string           `mapstructure:"api_endpoint" cty:"api_endpoint"`
+	APIKey                  *string           `mapstructure:"api_key" cty:"api_key"`
+	APISecret               *string           `mapstructure:"api_secret" cty:"api_secret"`
+	ImageBucket             *string           `mapstructure:"image_bucket" cty:"image_bucket"`
+	TemplateZone            *string           `mapstructure:"template_zone" cty:"template_zone"`
+	TemplateName            *string           `mapstructure:"template_name" cty:"template_name"`
+	TemplateDescription     *string           `mapstructure:"template_description" cty:"template_description"`
+	TemplateUsername        *string           `mapstructure:"template_username" cty:"template_username"`
+	TemplateDisablePassword *bool             `mapstructure:"template_disable_password" cty:"template_disable_password"`
+	TemplateDisableSSHKey   *bool             `mapstructure:"template_disable_sshkey" cty:"template_disable_sshkey"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"skip_clean":                 &hcldec.AttrSpec{Name: "skip_clean", Type: cty.Bool, Required: false},
+		"sos_endpoint":               &hcldec.AttrSpec{Name: "sos_endpoint", Type: cty.String, Required: false},
+		"api_endpoint":               &hcldec.AttrSpec{Name: "api_endpoint", Type: cty.String, Required: false},
+		"api_key":                    &hcldec.AttrSpec{Name: "api_key", Type: cty.String, Required: false},
+		"api_secret":                 &hcldec.AttrSpec{Name: "api_secret", Type: cty.String, Required: false},
+		"image_bucket":               &hcldec.AttrSpec{Name: "image_bucket", Type: cty.String, Required: false},
+		"template_zone":              &hcldec.AttrSpec{Name: "template_zone", Type: cty.String, Required: false},
+		"template_name":              &hcldec.AttrSpec{Name: "template_name", Type: cty.String, Required: false},
+		"template_description":       &hcldec.AttrSpec{Name: "template_description", Type: cty.String, Required: false},
+		"template_username":          &hcldec.AttrSpec{Name: "template_username", Type: cty.String, Required: false},
+		"template_disable_password":  &hcldec.AttrSpec{Name: "template_disable_password", Type: cty.Bool, Required: false},
+		"template_disable_sshkey":    &hcldec.AttrSpec{Name: "template_disable_sshkey", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/googlecompute-export/post-processor.go b/post-processor/googlecompute-export/post-processor.go
index 640a512c6..eff848bdf 100644
--- a/post-processor/googlecompute-export/post-processor.go
+++ b/post-processor/googlecompute-export/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package googlecomputeexport
 
 import (
diff --git a/post-processor/googlecompute-export/post-processor.hcl2spec.go b/post-processor/googlecompute-export/post-processor.hcl2spec.go
new file mode 100644
index 000000000..336f372e2
--- /dev/null
+++ b/post-processor/googlecompute-export/post-processor.hcl2spec.go
@@ -0,0 +1,57 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package googlecomputeexport
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AccountFile         *string           `mapstructure:"account_file" cty:"account_file"`
+	DiskSizeGb          *int64            `mapstructure:"disk_size" cty:"disk_size"`
+	DiskType            *string           `mapstructure:"disk_type" cty:"disk_type"`
+	MachineType         *string           `mapstructure:"machine_type" cty:"machine_type"`
+	Network             *string           `mapstructure:"network" cty:"network"`
+	Paths               []string          `mapstructure:"paths" cty:"paths"`
+	Subnetwork          *string           `mapstructure:"subnetwork" cty:"subnetwork"`
+	VaultGCPOauthEngine *string           `mapstructure:"vault_gcp_oauth_engine" cty:"vault_gcp_oauth_engine"`
+	Zone                *string           `mapstructure:"zone" cty:"zone"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"account_file":               &hcldec.AttrSpec{Name: "account_file", Type: cty.String, Required: false},
+		"disk_size":                  &hcldec.AttrSpec{Name: "disk_size", Type: cty.Number, Required: false},
+		"disk_type":                  &hcldec.AttrSpec{Name: "disk_type", Type: cty.String, Required: false},
+		"machine_type":               &hcldec.AttrSpec{Name: "machine_type", Type: cty.String, Required: false},
+		"network":                    &hcldec.AttrSpec{Name: "network", Type: cty.String, Required: false},
+		"paths":                      &hcldec.AttrSpec{Name: "paths", Type: cty.List(cty.String), Required: false},
+		"subnetwork":                 &hcldec.AttrSpec{Name: "subnetwork", Type: cty.String, Required: false},
+		"vault_gcp_oauth_engine":     &hcldec.AttrSpec{Name: "vault_gcp_oauth_engine", Type: cty.String, Required: false},
+		"zone":                       &hcldec.AttrSpec{Name: "zone", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/googlecompute-import/post-processor.go b/post-processor/googlecompute-import/post-processor.go
index 07741e680..fd949fef3 100644
--- a/post-processor/googlecompute-import/post-processor.go
+++ b/post-processor/googlecompute-import/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package googlecomputeimport
 
 import (
diff --git a/post-processor/googlecompute-import/post-processor.hcl2spec.go b/post-processor/googlecompute-import/post-processor.hcl2spec.go
new file mode 100644
index 000000000..39d10924a
--- /dev/null
+++ b/post-processor/googlecompute-import/post-processor.hcl2spec.go
@@ -0,0 +1,61 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package googlecomputeimport
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName      *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType    *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug          *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce          *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError        *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars       map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars  []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	AccountFile          *string           `mapstructure:"account_file" cty:"account_file"`
+	ProjectId            *string           `mapstructure:"project_id" cty:"project_id"`
+	Bucket               *string           `mapstructure:"bucket" cty:"bucket"`
+	GCSObjectName        *string           `mapstructure:"gcs_object_name" cty:"gcs_object_name"`
+	ImageDescription     *string           `mapstructure:"image_description" cty:"image_description"`
+	ImageFamily          *string           `mapstructure:"image_family" cty:"image_family"`
+	ImageGuestOsFeatures []string          `mapstructure:"image_guest_os_features" cty:"image_guest_os_features"`
+	ImageLabels          map[string]string `mapstructure:"image_labels" cty:"image_labels"`
+	ImageName            *string           `mapstructure:"image_name" cty:"image_name"`
+	SkipClean            *bool             `mapstructure:"skip_clean" cty:"skip_clean"`
+	VaultGCPOauthEngine  *string           `mapstructure:"vault_gcp_oauth_engine" cty:"vault_gcp_oauth_engine"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"account_file":               &hcldec.AttrSpec{Name: "account_file", Type: cty.String, Required: false},
+		"project_id":                 &hcldec.AttrSpec{Name: "project_id", Type: cty.String, Required: false},
+		"bucket":                     &hcldec.AttrSpec{Name: "bucket", Type: cty.String, Required: false},
+		"gcs_object_name":            &hcldec.AttrSpec{Name: "gcs_object_name", Type: cty.String, Required: false},
+		"image_description":          &hcldec.AttrSpec{Name: "image_description", Type: cty.String, Required: false},
+		"image_family":               &hcldec.AttrSpec{Name: "image_family", Type: cty.String, Required: false},
+		"image_guest_os_features":    &hcldec.AttrSpec{Name: "image_guest_os_features", Type: cty.List(cty.String), Required: false},
+		"image_labels":               &hcldec.BlockAttrsSpec{TypeName: "image_labels", ElementType: cty.String, Required: false},
+		"image_name":                 &hcldec.AttrSpec{Name: "image_name", Type: cty.String, Required: false},
+		"skip_clean":                 &hcldec.AttrSpec{Name: "skip_clean", Type: cty.Bool, Required: false},
+		"vault_gcp_oauth_engine":     &hcldec.AttrSpec{Name: "vault_gcp_oauth_engine", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/manifest/post-processor.go b/post-processor/manifest/post-processor.go
index 41e1dda10..d10919d28 100644
--- a/post-processor/manifest/post-processor.go
+++ b/post-processor/manifest/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package manifest
 
 import (
diff --git a/post-processor/manifest/post-processor.hcl2spec.go b/post-processor/manifest/post-processor.hcl2spec.go
new file mode 100644
index 000000000..a7e831e30
--- /dev/null
+++ b/post-processor/manifest/post-processor.hcl2spec.go
@@ -0,0 +1,45 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package manifest
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	OutputPath          *string           `mapstructure:"output" cty:"output"`
+	StripPath           *bool             `mapstructure:"strip_path" cty:"strip_path"`
+	CustomData          map[string]string `mapstructure:"custom_data" cty:"custom_data"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"output":                     &hcldec.AttrSpec{Name: "output", Type: cty.String, Required: false},
+		"strip_path":                 &hcldec.AttrSpec{Name: "strip_path", Type: cty.Bool, Required: false},
+		"custom_data":                &hcldec.BlockAttrsSpec{TypeName: "custom_data", ElementType: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/vagrant-cloud/post-processor.go b/post-processor/vagrant-cloud/post-processor.go
index 528416f32..9401b8374 100644
--- a/post-processor/vagrant-cloud/post-processor.go
+++ b/post-processor/vagrant-cloud/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // vagrant_cloud implements the packer.PostProcessor interface and adds a
 // post-processor that uploads artifacts from the vagrant post-processor
 // and vagrant builder to Vagrant Cloud (vagrantcloud.com) or manages
diff --git a/post-processor/vagrant-cloud/post-processor.hcl2spec.go b/post-processor/vagrant-cloud/post-processor.hcl2spec.go
new file mode 100644
index 000000000..a8216aeff
--- /dev/null
+++ b/post-processor/vagrant-cloud/post-processor.hcl2spec.go
@@ -0,0 +1,55 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package vagrantcloud
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName       *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType     *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug           *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce           *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError         *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars        map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars   []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Tag                   *string           `mapstructure:"box_tag" cty:"box_tag"`
+	Version               *string           `mapstructure:"version" cty:"version"`
+	VersionDescription    *string           `mapstructure:"version_description" cty:"version_description"`
+	NoRelease             *bool             `mapstructure:"no_release" cty:"no_release"`
+	AccessToken           *string           `mapstructure:"access_token" cty:"access_token"`
+	VagrantCloudUrl       *string           `mapstructure:"vagrant_cloud_url" cty:"vagrant_cloud_url"`
+	InsecureSkipTLSVerify *bool             `mapstructure:"insecure_skip_tls_verify" cty:"insecure_skip_tls_verify"`
+	BoxDownloadUrl        *string           `mapstructure:"box_download_url" cty:"box_download_url"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"box_tag":                    &hcldec.AttrSpec{Name: "box_tag", Type: cty.String, Required: false},
+		"version":                    &hcldec.AttrSpec{Name: "version", Type: cty.String, Required: false},
+		"version_description":        &hcldec.AttrSpec{Name: "version_description", Type: cty.String, Required: false},
+		"no_release":                 &hcldec.AttrSpec{Name: "no_release", Type: cty.Bool, Required: false},
+		"access_token":               &hcldec.AttrSpec{Name: "access_token", Type: cty.String, Required: false},
+		"vagrant_cloud_url":          &hcldec.AttrSpec{Name: "vagrant_cloud_url", Type: cty.String, Required: false},
+		"insecure_skip_tls_verify":   &hcldec.AttrSpec{Name: "insecure_skip_tls_verify", Type: cty.Bool, Required: false},
+		"box_download_url":           &hcldec.AttrSpec{Name: "box_download_url", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/vagrant/post-processor.go b/post-processor/vagrant/post-processor.go
index 90197c316..0a4527026 100644
--- a/post-processor/vagrant/post-processor.go
+++ b/post-processor/vagrant/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // vagrant implements the packer.PostProcessor interface and adds a
 // post-processor that turns artifacts of known builders into Vagrant
 // boxes.
diff --git a/post-processor/vagrant/post-processor.hcl2spec.go b/post-processor/vagrant/post-processor.hcl2spec.go
new file mode 100644
index 000000000..541c4d493
--- /dev/null
+++ b/post-processor/vagrant/post-processor.hcl2spec.go
@@ -0,0 +1,51 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package vagrant
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName              *string                `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType            *string                `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                  *bool                  `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                  *bool                  `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError                *string                `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars               map[string]string      `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars          []string               `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	CompressionLevel             *int                   `mapstructure:"compression_level" cty:"compression_level"`
+	Include                      []string               `mapstructure:"include" cty:"include"`
+	OutputPath                   *string                `mapstructure:"output" cty:"output"`
+	Override                     map[string]interface{} `cty:"override"`
+	VagrantfileTemplate          *string                `mapstructure:"vagrantfile_template" cty:"vagrantfile_template"`
+	VagrantfileTemplateGenerated *bool                  `mapstructure:"vagrantfile_template_generated" cty:"vagrantfile_template_generated"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":              &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":            &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                   &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                   &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":          &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":     &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"compression_level":              &hcldec.AttrSpec{Name: "compression_level", Type: cty.Number, Required: false},
+		"include":                        &hcldec.AttrSpec{Name: "include", Type: cty.List(cty.String), Required: false},
+		"output":                         &hcldec.AttrSpec{Name: "output", Type: cty.String, Required: false},
+		"override":                       &hcldec.BlockAttrsSpec{TypeName: "override", ElementType: cty.String, Required: false},
+		"vagrantfile_template":           &hcldec.AttrSpec{Name: "vagrantfile_template", Type: cty.String, Required: false},
+		"vagrantfile_template_generated": &hcldec.AttrSpec{Name: "vagrantfile_template_generated", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/vsphere-template/post-processor.go b/post-processor/vsphere-template/post-processor.go
index 85e562665..ca4b8393c 100644
--- a/post-processor/vsphere-template/post-processor.go
+++ b/post-processor/vsphere-template/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package vsphere_template
 
 import (
diff --git a/post-processor/vsphere-template/post-processor.hcl2spec.go b/post-processor/vsphere-template/post-processor.hcl2spec.go
new file mode 100644
index 000000000..0ec10a50b
--- /dev/null
+++ b/post-processor/vsphere-template/post-processor.hcl2spec.go
@@ -0,0 +1,57 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package vsphere_template
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Host                *string           `mapstructure:"host" cty:"host"`
+	Insecure            *bool             `mapstructure:"insecure" cty:"insecure"`
+	Username            *string           `mapstructure:"username" cty:"username"`
+	Password            *string           `mapstructure:"password" cty:"password"`
+	Datacenter          *string           `mapstructure:"datacenter" cty:"datacenter"`
+	Folder              *string           `mapstructure:"folder" cty:"folder"`
+	SnapshotEnable      *bool             `mapstructure:"snapshot_enable" cty:"snapshot_enable"`
+	SnapshotName        *string           `mapstructure:"snapshot_name" cty:"snapshot_name"`
+	SnapshotDescription *string           `mapstructure:"snapshot_description" cty:"snapshot_description"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"host":                       &hcldec.AttrSpec{Name: "host", Type: cty.String, Required: false},
+		"insecure":                   &hcldec.AttrSpec{Name: "insecure", Type: cty.Bool, Required: false},
+		"username":                   &hcldec.AttrSpec{Name: "username", Type: cty.String, Required: false},
+		"password":                   &hcldec.AttrSpec{Name: "password", Type: cty.String, Required: false},
+		"datacenter":                 &hcldec.AttrSpec{Name: "datacenter", Type: cty.String, Required: false},
+		"folder":                     &hcldec.AttrSpec{Name: "folder", Type: cty.String, Required: false},
+		"snapshot_enable":            &hcldec.AttrSpec{Name: "snapshot_enable", Type: cty.Bool, Required: false},
+		"snapshot_name":              &hcldec.AttrSpec{Name: "snapshot_name", Type: cty.String, Required: false},
+		"snapshot_description":       &hcldec.AttrSpec{Name: "snapshot_description", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/post-processor/vsphere/post-processor.go b/post-processor/vsphere/post-processor.go
index 05607e87c..c4da09a8e 100644
--- a/post-processor/vsphere/post-processor.go
+++ b/post-processor/vsphere/post-processor.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package vsphere
 
 import (
diff --git a/post-processor/vsphere/post-processor.hcl2spec.go b/post-processor/vsphere/post-processor.hcl2spec.go
new file mode 100644
index 000000000..ecf70776a
--- /dev/null
+++ b/post-processor/vsphere/post-processor.hcl2spec.go
@@ -0,0 +1,69 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package vsphere
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Cluster             *string           `mapstructure:"cluster" cty:"cluster"`
+	Datacenter          *string           `mapstructure:"datacenter" cty:"datacenter"`
+	Datastore           *string           `mapstructure:"datastore" cty:"datastore"`
+	DiskMode            *string           `mapstructure:"disk_mode" cty:"disk_mode"`
+	Host                *string           `mapstructure:"host" cty:"host"`
+	ESXiHost            *string           `mapstructure:"esxi_host" cty:"esxi_host"`
+	Insecure            *bool             `mapstructure:"insecure" cty:"insecure"`
+	Options             []string          `mapstructure:"options" cty:"options"`
+	Overwrite           *bool             `mapstructure:"overwrite" cty:"overwrite"`
+	Password            *string           `mapstructure:"password" cty:"password"`
+	ResourcePool        *string           `mapstructure:"resource_pool" cty:"resource_pool"`
+	Username            *string           `mapstructure:"username" cty:"username"`
+	VMFolder            *string           `mapstructure:"vm_folder" cty:"vm_folder"`
+	VMName              *string           `mapstructure:"vm_name" cty:"vm_name"`
+	VMNetwork           *string           `mapstructure:"vm_network" cty:"vm_network"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"cluster":                    &hcldec.AttrSpec{Name: "cluster", Type: cty.String, Required: false},
+		"datacenter":                 &hcldec.AttrSpec{Name: "datacenter", Type: cty.String, Required: false},
+		"datastore":                  &hcldec.AttrSpec{Name: "datastore", Type: cty.String, Required: false},
+		"disk_mode":                  &hcldec.AttrSpec{Name: "disk_mode", Type: cty.String, Required: false},
+		"host":                       &hcldec.AttrSpec{Name: "host", Type: cty.String, Required: false},
+		"esxi_host":                  &hcldec.AttrSpec{Name: "esxi_host", Type: cty.String, Required: false},
+		"insecure":                   &hcldec.AttrSpec{Name: "insecure", Type: cty.Bool, Required: false},
+		"options":                    &hcldec.AttrSpec{Name: "options", Type: cty.List(cty.String), Required: false},
+		"overwrite":                  &hcldec.AttrSpec{Name: "overwrite", Type: cty.Bool, Required: false},
+		"password":                   &hcldec.AttrSpec{Name: "password", Type: cty.String, Required: false},
+		"resource_pool":              &hcldec.AttrSpec{Name: "resource_pool", Type: cty.String, Required: false},
+		"username":                   &hcldec.AttrSpec{Name: "username", Type: cty.String, Required: false},
+		"vm_folder":                  &hcldec.AttrSpec{Name: "vm_folder", Type: cty.String, Required: false},
+		"vm_name":                    &hcldec.AttrSpec{Name: "vm_name", Type: cty.String, Required: false},
+		"vm_network":                 &hcldec.AttrSpec{Name: "vm_network", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/ansible-local/provisioner.go b/provisioner/ansible-local/provisioner.go
index d98d44673..c3c6a6e37 100644
--- a/provisioner/ansible-local/provisioner.go
+++ b/provisioner/ansible-local/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package ansiblelocal
 
 import (
diff --git a/provisioner/ansible-local/provisioner.hcl2spec.go b/provisioner/ansible-local/provisioner.hcl2spec.go
new file mode 100644
index 000000000..0362930e6
--- /dev/null
+++ b/provisioner/ansible-local/provisioner.hcl2spec.go
@@ -0,0 +1,69 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package ansiblelocal
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Command             *string           `cty:"command"`
+	ExtraArguments      []string          `mapstructure:"extra_arguments" cty:"extra_arguments"`
+	GroupVars           *string           `mapstructure:"group_vars" cty:"group_vars"`
+	HostVars            *string           `mapstructure:"host_vars" cty:"host_vars"`
+	PlaybookDir         *string           `mapstructure:"playbook_dir" cty:"playbook_dir"`
+	PlaybookFile        *string           `mapstructure:"playbook_file" cty:"playbook_file"`
+	PlaybookFiles       []string          `mapstructure:"playbook_files" cty:"playbook_files"`
+	PlaybookPaths       []string          `mapstructure:"playbook_paths" cty:"playbook_paths"`
+	RolePaths           []string          `mapstructure:"role_paths" cty:"role_paths"`
+	StagingDir          *string           `mapstructure:"staging_directory" cty:"staging_directory"`
+	CleanStagingDir     *bool             `mapstructure:"clean_staging_directory" cty:"clean_staging_directory"`
+	InventoryFile       *string           `mapstructure:"inventory_file" cty:"inventory_file"`
+	InventoryGroups     []string          `mapstructure:"inventory_groups" cty:"inventory_groups"`
+	GalaxyFile          *string           `mapstructure:"galaxy_file" cty:"galaxy_file"`
+	GalaxyCommand       *string           `cty:"galaxy_command"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"command":                    &hcldec.AttrSpec{Name: "command", Type: cty.String, Required: false},
+		"extra_arguments":            &hcldec.AttrSpec{Name: "extra_arguments", Type: cty.List(cty.String), Required: false},
+		"group_vars":                 &hcldec.AttrSpec{Name: "group_vars", Type: cty.String, Required: false},
+		"host_vars":                  &hcldec.AttrSpec{Name: "host_vars", Type: cty.String, Required: false},
+		"playbook_dir":               &hcldec.AttrSpec{Name: "playbook_dir", Type: cty.String, Required: false},
+		"playbook_file":              &hcldec.AttrSpec{Name: "playbook_file", Type: cty.String, Required: false},
+		"playbook_files":             &hcldec.AttrSpec{Name: "playbook_files", Type: cty.List(cty.String), Required: false},
+		"playbook_paths":             &hcldec.AttrSpec{Name: "playbook_paths", Type: cty.List(cty.String), Required: false},
+		"role_paths":                 &hcldec.AttrSpec{Name: "role_paths", Type: cty.List(cty.String), Required: false},
+		"staging_directory":          &hcldec.AttrSpec{Name: "staging_directory", Type: cty.String, Required: false},
+		"clean_staging_directory":    &hcldec.AttrSpec{Name: "clean_staging_directory", Type: cty.Bool, Required: false},
+		"inventory_file":             &hcldec.AttrSpec{Name: "inventory_file", Type: cty.String, Required: false},
+		"inventory_groups":           &hcldec.AttrSpec{Name: "inventory_groups", Type: cty.List(cty.String), Required: false},
+		"galaxy_file":                &hcldec.AttrSpec{Name: "galaxy_file", Type: cty.String, Required: false},
+		"galaxy_command":             &hcldec.AttrSpec{Name: "galaxy_command", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/ansible/provisioner.go b/provisioner/ansible/provisioner.go
index f129d8c79..6de5bba5f 100644
--- a/provisioner/ansible/provisioner.go
+++ b/provisioner/ansible/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package ansible
 
 import (
diff --git a/provisioner/ansible/provisioner.hcl2spec.go b/provisioner/ansible/provisioner.hcl2spec.go
new file mode 100644
index 000000000..1e659cece
--- /dev/null
+++ b/provisioner/ansible/provisioner.hcl2spec.go
@@ -0,0 +1,79 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package ansible
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName      *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType    *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug          *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce          *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError        *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars       map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars  []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Command              *string           `cty:"command"`
+	ExtraArguments       []string          `mapstructure:"extra_arguments" cty:"extra_arguments"`
+	AnsibleEnvVars       []string          `mapstructure:"ansible_env_vars" cty:"ansible_env_vars"`
+	PlaybookFile         *string           `mapstructure:"playbook_file" cty:"playbook_file"`
+	Groups               []string          `mapstructure:"groups" cty:"groups"`
+	EmptyGroups          []string          `mapstructure:"empty_groups" cty:"empty_groups"`
+	HostAlias            *string           `mapstructure:"host_alias" cty:"host_alias"`
+	User                 *string           `mapstructure:"user" cty:"user"`
+	LocalPort            *int              `mapstructure:"local_port" cty:"local_port"`
+	SSHHostKeyFile       *string           `mapstructure:"ssh_host_key_file" cty:"ssh_host_key_file"`
+	SSHAuthorizedKeyFile *string           `mapstructure:"ssh_authorized_key_file" cty:"ssh_authorized_key_file"`
+	SFTPCmd              *string           `mapstructure:"sftp_command" cty:"sftp_command"`
+	SkipVersionCheck     *bool             `mapstructure:"skip_version_check" cty:"skip_version_check"`
+	UseSFTP              *bool             `mapstructure:"use_sftp" cty:"use_sftp"`
+	InventoryDirectory   *string           `mapstructure:"inventory_directory" cty:"inventory_directory"`
+	InventoryFile        *string           `mapstructure:"inventory_file" cty:"inventory_file"`
+	GalaxyFile           *string           `mapstructure:"galaxy_file" cty:"galaxy_file"`
+	GalaxyCommand        *string           `mapstructure:"galaxy_command" cty:"galaxy_command"`
+	GalaxyForceInstall   *bool             `mapstructure:"galaxy_force_install" cty:"galaxy_force_install"`
+	RolesPath            *string           `mapstructure:"roles_path" cty:"roles_path"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"command":                    &hcldec.AttrSpec{Name: "command", Type: cty.String, Required: false},
+		"extra_arguments":            &hcldec.AttrSpec{Name: "extra_arguments", Type: cty.List(cty.String), Required: false},
+		"ansible_env_vars":           &hcldec.AttrSpec{Name: "ansible_env_vars", Type: cty.List(cty.String), Required: false},
+		"playbook_file":              &hcldec.AttrSpec{Name: "playbook_file", Type: cty.String, Required: false},
+		"groups":                     &hcldec.AttrSpec{Name: "groups", Type: cty.List(cty.String), Required: false},
+		"empty_groups":               &hcldec.AttrSpec{Name: "empty_groups", Type: cty.List(cty.String), Required: false},
+		"host_alias":                 &hcldec.AttrSpec{Name: "host_alias", Type: cty.String, Required: false},
+		"user":                       &hcldec.AttrSpec{Name: "user", Type: cty.String, Required: false},
+		"local_port":                 &hcldec.AttrSpec{Name: "local_port", Type: cty.Number, Required: false},
+		"ssh_host_key_file":          &hcldec.AttrSpec{Name: "ssh_host_key_file", Type: cty.String, Required: false},
+		"ssh_authorized_key_file":    &hcldec.AttrSpec{Name: "ssh_authorized_key_file", Type: cty.String, Required: false},
+		"sftp_command":               &hcldec.AttrSpec{Name: "sftp_command", Type: cty.String, Required: false},
+		"skip_version_check":         &hcldec.AttrSpec{Name: "skip_version_check", Type: cty.Bool, Required: false},
+		"use_sftp":                   &hcldec.AttrSpec{Name: "use_sftp", Type: cty.Bool, Required: false},
+		"inventory_directory":        &hcldec.AttrSpec{Name: "inventory_directory", Type: cty.String, Required: false},
+		"inventory_file":             &hcldec.AttrSpec{Name: "inventory_file", Type: cty.String, Required: false},
+		"galaxy_file":                &hcldec.AttrSpec{Name: "galaxy_file", Type: cty.String, Required: false},
+		"galaxy_command":             &hcldec.AttrSpec{Name: "galaxy_command", Type: cty.String, Required: false},
+		"galaxy_force_install":       &hcldec.AttrSpec{Name: "galaxy_force_install", Type: cty.Bool, Required: false},
+		"roles_path":                 &hcldec.AttrSpec{Name: "roles_path", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/breakpoint/provisioner.go b/provisioner/breakpoint/provisioner.go
index b6c6f4504..8ff752065 100644
--- a/provisioner/breakpoint/provisioner.go
+++ b/provisioner/breakpoint/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package breakpoint
 
 import (
diff --git a/provisioner/breakpoint/provisioner.hcl2spec.go b/provisioner/breakpoint/provisioner.hcl2spec.go
new file mode 100644
index 000000000..d22e893ae
--- /dev/null
+++ b/provisioner/breakpoint/provisioner.hcl2spec.go
@@ -0,0 +1,43 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package breakpoint
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Note                *string           `mapstructure:"note" cty:"note"`
+	Disable             *bool             `mapstructure:"disable" cty:"disable"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"note":                       &hcldec.AttrSpec{Name: "note", Type: cty.String, Required: false},
+		"disable":                    &hcldec.AttrSpec{Name: "disable", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/chef-client/provisioner.go b/provisioner/chef-client/provisioner.go
index c08cff859..6ca75e402 100644
--- a/provisioner/chef-client/provisioner.go
+++ b/provisioner/chef-client/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // This package implements a provisioner for Packer that uses
 // Chef to provision the remote machine, specifically with chef-client (that is,
 // with a Chef server).
diff --git a/provisioner/chef-client/provisioner.hcl2spec.go b/provisioner/chef-client/provisioner.hcl2spec.go
new file mode 100644
index 000000000..fcc0dac58
--- /dev/null
+++ b/provisioner/chef-client/provisioner.hcl2spec.go
@@ -0,0 +1,93 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package chefclient
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName            *string                `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType          *string                `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                *bool                  `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                *bool                  `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError              *string                `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars             map[string]string      `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars        []string               `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Json                       map[string]interface{} `cty:"json"`
+	ChefEnvironment            *string                `mapstructure:"chef_environment" cty:"chef_environment"`
+	ChefLicense                *string                `mapstructure:"chef_license" cty:"chef_license"`
+	ClientKey                  *string                `mapstructure:"client_key" cty:"client_key"`
+	ConfigTemplate             *string                `mapstructure:"config_template" cty:"config_template"`
+	ElevatedUser               *string                `mapstructure:"elevated_user" cty:"elevated_user"`
+	ElevatedPassword           *string                `mapstructure:"elevated_password" cty:"elevated_password"`
+	EncryptedDataBagSecretPath *string                `mapstructure:"encrypted_data_bag_secret_path" cty:"encrypted_data_bag_secret_path"`
+	ExecuteCommand             *string                `mapstructure:"execute_command" cty:"execute_command"`
+	GuestOSType                *string                `mapstructure:"guest_os_type" cty:"guest_os_type"`
+	InstallCommand             *string                `mapstructure:"install_command" cty:"install_command"`
+	KnifeCommand               *string                `mapstructure:"knife_command" cty:"knife_command"`
+	NodeName                   *string                `mapstructure:"node_name" cty:"node_name"`
+	PolicyGroup                *string                `mapstructure:"policy_group" cty:"policy_group"`
+	PolicyName                 *string                `mapstructure:"policy_name" cty:"policy_name"`
+	PreventSudo                *bool                  `mapstructure:"prevent_sudo" cty:"prevent_sudo"`
+	RunList                    []string               `mapstructure:"run_list" cty:"run_list"`
+	ServerUrl                  *string                `mapstructure:"server_url" cty:"server_url"`
+	SkipCleanClient            *bool                  `mapstructure:"skip_clean_client" cty:"skip_clean_client"`
+	SkipCleanNode              *bool                  `mapstructure:"skip_clean_node" cty:"skip_clean_node"`
+	SkipCleanStagingDirectory  *bool                  `mapstructure:"skip_clean_staging_directory" cty:"skip_clean_staging_directory"`
+	SkipInstall                *bool                  `mapstructure:"skip_install" cty:"skip_install"`
+	SslVerifyMode              *string                `mapstructure:"ssl_verify_mode" cty:"ssl_verify_mode"`
+	TrustedCertsDir            *string                `mapstructure:"trusted_certs_dir" cty:"trusted_certs_dir"`
+	StagingDir                 *string                `mapstructure:"staging_directory" cty:"staging_directory"`
+	ValidationClientName       *string                `mapstructure:"validation_client_name" cty:"validation_client_name"`
+	ValidationKeyPath          *string                `mapstructure:"validation_key_path" cty:"validation_key_path"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":              &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":            &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                   &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                   &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":          &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":     &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"json":                           &hcldec.BlockAttrsSpec{TypeName: "json", ElementType: cty.String, Required: false},
+		"chef_environment":               &hcldec.AttrSpec{Name: "chef_environment", Type: cty.String, Required: false},
+		"chef_license":                   &hcldec.AttrSpec{Name: "chef_license", Type: cty.String, Required: false},
+		"client_key":                     &hcldec.AttrSpec{Name: "client_key", Type: cty.String, Required: false},
+		"config_template":                &hcldec.AttrSpec{Name: "config_template", Type: cty.String, Required: false},
+		"elevated_user":                  &hcldec.AttrSpec{Name: "elevated_user", Type: cty.String, Required: false},
+		"elevated_password":              &hcldec.AttrSpec{Name: "elevated_password", Type: cty.String, Required: false},
+		"encrypted_data_bag_secret_path": &hcldec.AttrSpec{Name: "encrypted_data_bag_secret_path", Type: cty.String, Required: false},
+		"execute_command":                &hcldec.AttrSpec{Name: "execute_command", Type: cty.String, Required: false},
+		"guest_os_type":                  &hcldec.AttrSpec{Name: "guest_os_type", Type: cty.String, Required: false},
+		"install_command":                &hcldec.AttrSpec{Name: "install_command", Type: cty.String, Required: false},
+		"knife_command":                  &hcldec.AttrSpec{Name: "knife_command", Type: cty.String, Required: false},
+		"node_name":                      &hcldec.AttrSpec{Name: "node_name", Type: cty.String, Required: false},
+		"policy_group":                   &hcldec.AttrSpec{Name: "policy_group", Type: cty.String, Required: false},
+		"policy_name":                    &hcldec.AttrSpec{Name: "policy_name", Type: cty.String, Required: false},
+		"prevent_sudo":                   &hcldec.AttrSpec{Name: "prevent_sudo", Type: cty.Bool, Required: false},
+		"run_list":                       &hcldec.AttrSpec{Name: "run_list", Type: cty.List(cty.String), Required: false},
+		"server_url":                     &hcldec.AttrSpec{Name: "server_url", Type: cty.String, Required: false},
+		"skip_clean_client":              &hcldec.AttrSpec{Name: "skip_clean_client", Type: cty.Bool, Required: false},
+		"skip_clean_node":                &hcldec.AttrSpec{Name: "skip_clean_node", Type: cty.Bool, Required: false},
+		"skip_clean_staging_directory":   &hcldec.AttrSpec{Name: "skip_clean_staging_directory", Type: cty.Bool, Required: false},
+		"skip_install":                   &hcldec.AttrSpec{Name: "skip_install", Type: cty.Bool, Required: false},
+		"ssl_verify_mode":                &hcldec.AttrSpec{Name: "ssl_verify_mode", Type: cty.String, Required: false},
+		"trusted_certs_dir":              &hcldec.AttrSpec{Name: "trusted_certs_dir", Type: cty.String, Required: false},
+		"staging_directory":              &hcldec.AttrSpec{Name: "staging_directory", Type: cty.String, Required: false},
+		"validation_client_name":         &hcldec.AttrSpec{Name: "validation_client_name", Type: cty.String, Required: false},
+		"validation_key_path":            &hcldec.AttrSpec{Name: "validation_key_path", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/chef-solo/provisioner.go b/provisioner/chef-solo/provisioner.go
index a28632466..39d59b36b 100644
--- a/provisioner/chef-solo/provisioner.go
+++ b/provisioner/chef-solo/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // This package implements a provisioner for Packer that uses
 // Chef to provision the remote machine, specifically with chef-solo (that is,
 // without a Chef server).
diff --git a/provisioner/chef-solo/provisioner.hcl2spec.go b/provisioner/chef-solo/provisioner.hcl2spec.go
new file mode 100644
index 000000000..df801aa29
--- /dev/null
+++ b/provisioner/chef-solo/provisioner.hcl2spec.go
@@ -0,0 +1,75 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package chefsolo
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName            *string                `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType          *string                `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug                *bool                  `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce                *bool                  `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError              *string                `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars             map[string]string      `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars        []string               `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	ChefEnvironment            *string                `mapstructure:"chef_environment" cty:"chef_environment"`
+	ChefLicense                *string                `mapstructure:"chef_license" cty:"chef_license"`
+	ConfigTemplate             *string                `mapstructure:"config_template" cty:"config_template"`
+	CookbookPaths              []string               `mapstructure:"cookbook_paths" cty:"cookbook_paths"`
+	RolesPath                  *string                `mapstructure:"roles_path" cty:"roles_path"`
+	DataBagsPath               *string                `mapstructure:"data_bags_path" cty:"data_bags_path"`
+	EncryptedDataBagSecretPath *string                `mapstructure:"encrypted_data_bag_secret_path" cty:"encrypted_data_bag_secret_path"`
+	EnvironmentsPath           *string                `mapstructure:"environments_path" cty:"environments_path"`
+	ExecuteCommand             *string                `mapstructure:"execute_command" cty:"execute_command"`
+	InstallCommand             *string                `mapstructure:"install_command" cty:"install_command"`
+	RemoteCookbookPaths        []string               `mapstructure:"remote_cookbook_paths" cty:"remote_cookbook_paths"`
+	Json                       map[string]interface{} `cty:"json"`
+	PreventSudo                *bool                  `mapstructure:"prevent_sudo" cty:"prevent_sudo"`
+	RunList                    []string               `mapstructure:"run_list" cty:"run_list"`
+	SkipInstall                *bool                  `mapstructure:"skip_install" cty:"skip_install"`
+	StagingDir                 *string                `mapstructure:"staging_directory" cty:"staging_directory"`
+	GuestOSType                *string                `mapstructure:"guest_os_type" cty:"guest_os_type"`
+	Version                    *string                `mapstructure:"version" cty:"version"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":              &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":            &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":                   &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":                   &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":                &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":          &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables":     &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"chef_environment":               &hcldec.AttrSpec{Name: "chef_environment", Type: cty.String, Required: false},
+		"chef_license":                   &hcldec.AttrSpec{Name: "chef_license", Type: cty.String, Required: false},
+		"config_template":                &hcldec.AttrSpec{Name: "config_template", Type: cty.String, Required: false},
+		"cookbook_paths":                 &hcldec.AttrSpec{Name: "cookbook_paths", Type: cty.List(cty.String), Required: false},
+		"roles_path":                     &hcldec.AttrSpec{Name: "roles_path", Type: cty.String, Required: false},
+		"data_bags_path":                 &hcldec.AttrSpec{Name: "data_bags_path", Type: cty.String, Required: false},
+		"encrypted_data_bag_secret_path": &hcldec.AttrSpec{Name: "encrypted_data_bag_secret_path", Type: cty.String, Required: false},
+		"environments_path":              &hcldec.AttrSpec{Name: "environments_path", Type: cty.String, Required: false},
+		"execute_command":                &hcldec.AttrSpec{Name: "execute_command", Type: cty.String, Required: false},
+		"install_command":                &hcldec.AttrSpec{Name: "install_command", Type: cty.String, Required: false},
+		"remote_cookbook_paths":          &hcldec.AttrSpec{Name: "remote_cookbook_paths", Type: cty.List(cty.String), Required: false},
+		"json":                           &hcldec.BlockAttrsSpec{TypeName: "json", ElementType: cty.String, Required: false},
+		"prevent_sudo":                   &hcldec.AttrSpec{Name: "prevent_sudo", Type: cty.Bool, Required: false},
+		"run_list":                       &hcldec.AttrSpec{Name: "run_list", Type: cty.List(cty.String), Required: false},
+		"skip_install":                   &hcldec.AttrSpec{Name: "skip_install", Type: cty.Bool, Required: false},
+		"staging_directory":              &hcldec.AttrSpec{Name: "staging_directory", Type: cty.String, Required: false},
+		"guest_os_type":                  &hcldec.AttrSpec{Name: "guest_os_type", Type: cty.String, Required: false},
+		"version":                        &hcldec.AttrSpec{Name: "version", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/converge/provisioner.go b/provisioner/converge/provisioner.go
index a7ea6f6a9..c0c5cbeb4 100644
--- a/provisioner/converge/provisioner.go
+++ b/provisioner/converge/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config,ModuleDir
+
 // This package implements a provisioner for Packer that executes
 // Converge to provision a remote machine
 
diff --git a/provisioner/converge/provisioner.hcl2spec.go b/provisioner/converge/provisioner.hcl2spec.go
new file mode 100644
index 000000000..1594f8f14
--- /dev/null
+++ b/provisioner/converge/provisioner.hcl2spec.go
@@ -0,0 +1,83 @@
+// Code generated by "mapstructure-to-hcl2 -type Config,ModuleDir"; DO NOT EDIT.
+package converge
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName      *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType    *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug          *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce          *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError        *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars       map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars  []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Bootstrap            *bool             `mapstructure:"bootstrap" cty:"bootstrap"`
+	Version              *string           `mapstructure:"version" cty:"version"`
+	BootstrapCommand     *string           `mapstructure:"bootstrap_command" cty:"bootstrap_command"`
+	PreventBootstrapSudo *bool             `mapstructure:"prevent_bootstrap_sudo" cty:"prevent_bootstrap_sudo"`
+	ModuleDirs           []FlatModuleDir   `mapstructure:"module_dirs" cty:"module_dirs"`
+	Module               *string           `mapstructure:"module" cty:"module"`
+	WorkingDirectory     *string           `mapstructure:"working_directory" cty:"working_directory"`
+	Params               map[string]string `mapstructure:"params" cty:"params"`
+	ExecuteCommand       *string           `mapstructure:"execute_command" cty:"execute_command"`
+	PreventSudo          *bool             `mapstructure:"prevent_sudo" cty:"prevent_sudo"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"bootstrap":                  &hcldec.AttrSpec{Name: "bootstrap", Type: cty.Bool, Required: false},
+		"version":                    &hcldec.AttrSpec{Name: "version", Type: cty.String, Required: false},
+		"bootstrap_command":          &hcldec.AttrSpec{Name: "bootstrap_command", Type: cty.String, Required: false},
+		"prevent_bootstrap_sudo":     &hcldec.AttrSpec{Name: "prevent_bootstrap_sudo", Type: cty.Bool, Required: false},
+		"module_dirs":                &hcldec.BlockListSpec{TypeName: "module_dirs", Nested: &hcldec.BlockSpec{TypeName: "module_dirs", Nested: hcldec.ObjectSpec((*FlatModuleDir)(nil).HCL2Spec())}},
+		"module":                     &hcldec.AttrSpec{Name: "module", Type: cty.String, Required: false},
+		"working_directory":          &hcldec.AttrSpec{Name: "working_directory", Type: cty.String, Required: false},
+		"params":                     &hcldec.BlockAttrsSpec{TypeName: "params", ElementType: cty.String, Required: false},
+		"execute_command":            &hcldec.AttrSpec{Name: "execute_command", Type: cty.String, Required: false},
+		"prevent_sudo":               &hcldec.AttrSpec{Name: "prevent_sudo", Type: cty.Bool, Required: false},
+	}
+	return s
+}
+
+// FlatModuleDir is an auto-generated flat version of ModuleDir.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatModuleDir struct {
+	Source      *string  `mapstructure:"source" cty:"source"`
+	Destination *string  `mapstructure:"destination" cty:"destination"`
+	Exclude     []string `mapstructure:"exclude" cty:"exclude"`
+}
+
+// FlatMapstructure returns a new FlatModuleDir.
+// FlatModuleDir is an auto-generated flat version of ModuleDir.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*ModuleDir) FlatMapstructure() interface{} { return new(FlatModuleDir) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatModuleDir.
+// This spec is used by HCL to read the fields of FlatModuleDir.
+func (*FlatModuleDir) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"source":      &hcldec.AttrSpec{Name: "source", Type: cty.String, Required: false},
+		"destination": &hcldec.AttrSpec{Name: "destination", Type: cty.String, Required: false},
+		"exclude":     &hcldec.AttrSpec{Name: "exclude", Type: cty.List(cty.String), Required: false},
+	}
+	return s
+}
diff --git a/provisioner/file/provisioner.go b/provisioner/file/provisioner.go
index 04358f98d..9fc73b950 100644
--- a/provisioner/file/provisioner.go
+++ b/provisioner/file/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package file
 
 import (
diff --git a/provisioner/file/provisioner.hcl2spec.go b/provisioner/file/provisioner.hcl2spec.go
new file mode 100644
index 000000000..7a7c90d78
--- /dev/null
+++ b/provisioner/file/provisioner.hcl2spec.go
@@ -0,0 +1,49 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package file
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Source              *string           `cty:"source"`
+	Sources             []string          `cty:"sources"`
+	Destination         *string           `cty:"destination"`
+	Direction           *string           `cty:"direction"`
+	Generated           *bool             `cty:"generated"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"source":                     &hcldec.AttrSpec{Name: "source", Type: cty.String, Required: false},
+		"sources":                    &hcldec.AttrSpec{Name: "sources", Type: cty.List(cty.String), Required: false},
+		"destination":                &hcldec.AttrSpec{Name: "destination", Type: cty.String, Required: false},
+		"direction":                  &hcldec.AttrSpec{Name: "direction", Type: cty.String, Required: false},
+		"generated":                  &hcldec.AttrSpec{Name: "generated", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/inspec/provisioner.go b/provisioner/inspec/provisioner.go
index f9d52d36c..0b7d047aa 100644
--- a/provisioner/inspec/provisioner.go
+++ b/provisioner/inspec/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package inspec
 
 import (
diff --git a/provisioner/inspec/provisioner.hcl2spec.go b/provisioner/inspec/provisioner.hcl2spec.go
new file mode 100644
index 000000000..cc6411db5
--- /dev/null
+++ b/provisioner/inspec/provisioner.hcl2spec.go
@@ -0,0 +1,65 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package inspec
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName      *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType    *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug          *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce          *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError        *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars       map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars  []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Command              *string           `cty:"command"`
+	SubCommand           *string           `cty:"sub_command"`
+	ExtraArguments       []string          `mapstructure:"extra_arguments" cty:"extra_arguments"`
+	InspecEnvVars        []string          `mapstructure:"inspec_env_vars" cty:"inspec_env_vars"`
+	Profile              *string           `mapstructure:"profile" cty:"profile"`
+	AttributesDirectory  *string           `mapstructure:"attributes_directory" cty:"attributes_directory"`
+	AttributesFiles      []string          `mapstructure:"attributes" cty:"attributes"`
+	Backend              *string           `mapstructure:"backend" cty:"backend"`
+	User                 *string           `mapstructure:"user" cty:"user"`
+	Host                 *string           `mapstructure:"host" cty:"host"`
+	LocalPort            *int              `mapstructure:"local_port" cty:"local_port"`
+	SSHHostKeyFile       *string           `mapstructure:"ssh_host_key_file" cty:"ssh_host_key_file"`
+	SSHAuthorizedKeyFile *string           `mapstructure:"ssh_authorized_key_file" cty:"ssh_authorized_key_file"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"command":                    &hcldec.AttrSpec{Name: "command", Type: cty.String, Required: false},
+		"sub_command":                &hcldec.AttrSpec{Name: "sub_command", Type: cty.String, Required: false},
+		"extra_arguments":            &hcldec.AttrSpec{Name: "extra_arguments", Type: cty.List(cty.String), Required: false},
+		"inspec_env_vars":            &hcldec.AttrSpec{Name: "inspec_env_vars", Type: cty.List(cty.String), Required: false},
+		"profile":                    &hcldec.AttrSpec{Name: "profile", Type: cty.String, Required: false},
+		"attributes_directory":       &hcldec.AttrSpec{Name: "attributes_directory", Type: cty.String, Required: false},
+		"attributes":                 &hcldec.AttrSpec{Name: "attributes", Type: cty.List(cty.String), Required: false},
+		"backend":                    &hcldec.AttrSpec{Name: "backend", Type: cty.String, Required: false},
+		"user":                       &hcldec.AttrSpec{Name: "user", Type: cty.String, Required: false},
+		"host":                       &hcldec.AttrSpec{Name: "host", Type: cty.String, Required: false},
+		"local_port":                 &hcldec.AttrSpec{Name: "local_port", Type: cty.Number, Required: false},
+		"ssh_host_key_file":          &hcldec.AttrSpec{Name: "ssh_host_key_file", Type: cty.String, Required: false},
+		"ssh_authorized_key_file":    &hcldec.AttrSpec{Name: "ssh_authorized_key_file", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/powershell/provisioner.go b/provisioner/powershell/provisioner.go
index 53903ceb9..e541a782b 100644
--- a/provisioner/powershell/provisioner.go
+++ b/provisioner/powershell/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // This package implements a provisioner for Packer that executes powershell
 // scripts within the remote machine.
 package powershell
diff --git a/provisioner/powershell/provisioner.hcl2spec.go b/provisioner/powershell/provisioner.hcl2spec.go
new file mode 100644
index 000000000..42f2e39ef
--- /dev/null
+++ b/provisioner/powershell/provisioner.hcl2spec.go
@@ -0,0 +1,71 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package powershell
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName        *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType      *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug            *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce            *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError          *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars         map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars    []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Binary                 *bool             `cty:"binary"`
+	ExecuteCommand         *string           `mapstructure:"execute_command" cty:"execute_command"`
+	Inline                 []string          `cty:"inline"`
+	RemotePath             *string           `mapstructure:"remote_path" cty:"remote_path"`
+	Script                 *string           `cty:"script"`
+	Scripts                []string          `cty:"scripts"`
+	ValidExitCodes         []int             `mapstructure:"valid_exit_codes" cty:"valid_exit_codes"`
+	Vars                   []string          `mapstructure:"environment_vars" cty:"environment_vars"`
+	RemoteEnvVarPath       *string           `mapstructure:"remote_env_var_path" cty:"remote_env_var_path"`
+	ElevatedExecuteCommand *string           `mapstructure:"elevated_execute_command" cty:"elevated_execute_command"`
+	StartRetryTimeout      *string           `mapstructure:"start_retry_timeout" cty:"start_retry_timeout"`
+	EnvVarFormat           *string           `cty:"env_var_format"`
+	ElevatedEnvVarFormat   *string           `mapstructure:"elevated_env_var_format" cty:"elevated_env_var_format"`
+	ElevatedUser           *string           `mapstructure:"elevated_user" cty:"elevated_user"`
+	ElevatedPassword       *string           `mapstructure:"elevated_password" cty:"elevated_password"`
+	ExecutionPolicy        *string           `mapstructure:"execution_policy" cty:"execution_policy"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"binary":                     &hcldec.AttrSpec{Name: "binary", Type: cty.Bool, Required: false},
+		"execute_command":            &hcldec.AttrSpec{Name: "execute_command", Type: cty.String, Required: false},
+		"inline":                     &hcldec.AttrSpec{Name: "inline", Type: cty.List(cty.String), Required: false},
+		"remote_path":                &hcldec.AttrSpec{Name: "remote_path", Type: cty.String, Required: false},
+		"script":                     &hcldec.AttrSpec{Name: "script", Type: cty.String, Required: false},
+		"scripts":                    &hcldec.AttrSpec{Name: "scripts", Type: cty.List(cty.String), Required: false},
+		"valid_exit_codes":           &hcldec.AttrSpec{Name: "valid_exit_codes", Type: cty.List(cty.Number), Required: false},
+		"environment_vars":           &hcldec.AttrSpec{Name: "environment_vars", Type: cty.List(cty.String), Required: false},
+		"remote_env_var_path":        &hcldec.AttrSpec{Name: "remote_env_var_path", Type: cty.String, Required: false},
+		"elevated_execute_command":   &hcldec.AttrSpec{Name: "elevated_execute_command", Type: cty.String, Required: false},
+		"start_retry_timeout":        &hcldec.AttrSpec{Name: "start_retry_timeout", Type: cty.String, Required: false},
+		"env_var_format":             &hcldec.AttrSpec{Name: "env_var_format", Type: cty.String, Required: false},
+		"elevated_env_var_format":    &hcldec.AttrSpec{Name: "elevated_env_var_format", Type: cty.String, Required: false},
+		"elevated_user":              &hcldec.AttrSpec{Name: "elevated_user", Type: cty.String, Required: false},
+		"elevated_password":          &hcldec.AttrSpec{Name: "elevated_password", Type: cty.String, Required: false},
+		"execution_policy":           &hcldec.AttrSpec{Name: "execution_policy", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/puppet-masterless/provisioner.go b/provisioner/puppet-masterless/provisioner.go
index 2dc0cc81c..d66e54baa 100644
--- a/provisioner/puppet-masterless/provisioner.go
+++ b/provisioner/puppet-masterless/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // Package puppetmasterless implements a provisioner for Packer that executes
 // Puppet on the remote machine, configured to apply a local manifest
 // versus connecting to a Puppet master.
diff --git a/provisioner/puppet-masterless/provisioner.hcl2spec.go b/provisioner/puppet-masterless/provisioner.hcl2spec.go
new file mode 100644
index 000000000..d0deb5920
--- /dev/null
+++ b/provisioner/puppet-masterless/provisioner.hcl2spec.go
@@ -0,0 +1,71 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package puppetmasterless
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	CleanStagingDir     *bool             `mapstructure:"clean_staging_directory" cty:"clean_staging_directory"`
+	GuestOSType         *string           `mapstructure:"guest_os_type" cty:"guest_os_type"`
+	ExecuteCommand      *string           `mapstructure:"execute_command" cty:"execute_command"`
+	ExtraArguments      []string          `mapstructure:"extra_arguments" cty:"extra_arguments"`
+	Facter              map[string]string `cty:"facter"`
+	HieraConfigPath     *string           `mapstructure:"hiera_config_path" cty:"hiera_config_path"`
+	IgnoreExitCodes     *bool             `mapstructure:"ignore_exit_codes" cty:"ignore_exit_codes"`
+	ModulePaths         []string          `mapstructure:"module_paths" cty:"module_paths"`
+	ManifestFile        *string           `mapstructure:"manifest_file" cty:"manifest_file"`
+	ManifestDir         *string           `mapstructure:"manifest_dir" cty:"manifest_dir"`
+	PreventSudo         *bool             `mapstructure:"prevent_sudo" cty:"prevent_sudo"`
+	PuppetBinDir        *string           `mapstructure:"puppet_bin_dir" cty:"puppet_bin_dir"`
+	StagingDir          *string           `mapstructure:"staging_directory" cty:"staging_directory"`
+	WorkingDir          *string           `mapstructure:"working_directory" cty:"working_directory"`
+	ElevatedUser        *string           `mapstructure:"elevated_user" cty:"elevated_user"`
+	ElevatedPassword    *string           `mapstructure:"elevated_password" cty:"elevated_password"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"clean_staging_directory":    &hcldec.AttrSpec{Name: "clean_staging_directory", Type: cty.Bool, Required: false},
+		"guest_os_type":              &hcldec.AttrSpec{Name: "guest_os_type", Type: cty.String, Required: false},
+		"execute_command":            &hcldec.AttrSpec{Name: "execute_command", Type: cty.String, Required: false},
+		"extra_arguments":            &hcldec.AttrSpec{Name: "extra_arguments", Type: cty.List(cty.String), Required: false},
+		"facter":                     &hcldec.BlockAttrsSpec{TypeName: "facter", ElementType: cty.String, Required: false},
+		"hiera_config_path":          &hcldec.AttrSpec{Name: "hiera_config_path", Type: cty.String, Required: false},
+		"ignore_exit_codes":          &hcldec.AttrSpec{Name: "ignore_exit_codes", Type: cty.Bool, Required: false},
+		"module_paths":               &hcldec.AttrSpec{Name: "module_paths", Type: cty.List(cty.String), Required: false},
+		"manifest_file":              &hcldec.AttrSpec{Name: "manifest_file", Type: cty.String, Required: false},
+		"manifest_dir":               &hcldec.AttrSpec{Name: "manifest_dir", Type: cty.String, Required: false},
+		"prevent_sudo":               &hcldec.AttrSpec{Name: "prevent_sudo", Type: cty.Bool, Required: false},
+		"puppet_bin_dir":             &hcldec.AttrSpec{Name: "puppet_bin_dir", Type: cty.String, Required: false},
+		"staging_directory":          &hcldec.AttrSpec{Name: "staging_directory", Type: cty.String, Required: false},
+		"working_directory":          &hcldec.AttrSpec{Name: "working_directory", Type: cty.String, Required: false},
+		"elevated_user":              &hcldec.AttrSpec{Name: "elevated_user", Type: cty.String, Required: false},
+		"elevated_password":          &hcldec.AttrSpec{Name: "elevated_password", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/puppet-server/provisioner.go b/provisioner/puppet-server/provisioner.go
index 13ef1e46d..e4fc2adff 100644
--- a/provisioner/puppet-server/provisioner.go
+++ b/provisioner/puppet-server/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // Package puppetserver implements a provisioner for Packer that executes
 // Puppet on the remote machine connecting to a Puppet master.
 package puppetserver
diff --git a/provisioner/puppet-server/provisioner.hcl2spec.go b/provisioner/puppet-server/provisioner.hcl2spec.go
new file mode 100644
index 000000000..3c2eb2cde
--- /dev/null
+++ b/provisioner/puppet-server/provisioner.hcl2spec.go
@@ -0,0 +1,71 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package puppetserver
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName      *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType    *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug          *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce          *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError        *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars       map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars  []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	CleanStagingDir      *bool             `mapstructure:"clean_staging_directory" cty:"clean_staging_directory"`
+	ClientCertPath       *string           `mapstructure:"client_cert_path" cty:"client_cert_path"`
+	ClientPrivateKeyPath *string           `mapstructure:"client_private_key_path" cty:"client_private_key_path"`
+	ExecuteCommand       *string           `mapstructure:"execute_command" cty:"execute_command"`
+	ExtraArguments       []string          `mapstructure:"extra_arguments" cty:"extra_arguments"`
+	Facter               map[string]string `cty:"facter"`
+	GuestOSType          *string           `mapstructure:"guest_os_type" cty:"guest_os_type"`
+	IgnoreExitCodes      *bool             `mapstructure:"ignore_exit_codes" cty:"ignore_exit_codes"`
+	PreventSudo          *bool             `mapstructure:"prevent_sudo" cty:"prevent_sudo"`
+	PuppetBinDir         *string           `mapstructure:"puppet_bin_dir" cty:"puppet_bin_dir"`
+	PuppetNode           *string           `mapstructure:"puppet_node" cty:"puppet_node"`
+	PuppetServer         *string           `mapstructure:"puppet_server" cty:"puppet_server"`
+	StagingDir           *string           `mapstructure:"staging_dir" cty:"staging_dir"`
+	WorkingDir           *string           `mapstructure:"working_directory" cty:"working_directory"`
+	ElevatedUser         *string           `mapstructure:"elevated_user" cty:"elevated_user"`
+	ElevatedPassword     *string           `mapstructure:"elevated_password" cty:"elevated_password"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"clean_staging_directory":    &hcldec.AttrSpec{Name: "clean_staging_directory", Type: cty.Bool, Required: false},
+		"client_cert_path":           &hcldec.AttrSpec{Name: "client_cert_path", Type: cty.String, Required: false},
+		"client_private_key_path":    &hcldec.AttrSpec{Name: "client_private_key_path", Type: cty.String, Required: false},
+		"execute_command":            &hcldec.AttrSpec{Name: "execute_command", Type: cty.String, Required: false},
+		"extra_arguments":            &hcldec.AttrSpec{Name: "extra_arguments", Type: cty.List(cty.String), Required: false},
+		"facter":                     &hcldec.BlockAttrsSpec{TypeName: "facter", ElementType: cty.String, Required: false},
+		"guest_os_type":              &hcldec.AttrSpec{Name: "guest_os_type", Type: cty.String, Required: false},
+		"ignore_exit_codes":          &hcldec.AttrSpec{Name: "ignore_exit_codes", Type: cty.Bool, Required: false},
+		"prevent_sudo":               &hcldec.AttrSpec{Name: "prevent_sudo", Type: cty.Bool, Required: false},
+		"puppet_bin_dir":             &hcldec.AttrSpec{Name: "puppet_bin_dir", Type: cty.String, Required: false},
+		"puppet_node":                &hcldec.AttrSpec{Name: "puppet_node", Type: cty.String, Required: false},
+		"puppet_server":              &hcldec.AttrSpec{Name: "puppet_server", Type: cty.String, Required: false},
+		"staging_dir":                &hcldec.AttrSpec{Name: "staging_dir", Type: cty.String, Required: false},
+		"working_directory":          &hcldec.AttrSpec{Name: "working_directory", Type: cty.String, Required: false},
+		"elevated_user":              &hcldec.AttrSpec{Name: "elevated_user", Type: cty.String, Required: false},
+		"elevated_password":          &hcldec.AttrSpec{Name: "elevated_password", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/salt-masterless/provisioner.go b/provisioner/salt-masterless/provisioner.go
index 83bc326fb..5531d76b9 100644
--- a/provisioner/salt-masterless/provisioner.go
+++ b/provisioner/salt-masterless/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // This package implements a provisioner for Packer that executes a
 // saltstack state within the remote machine
 package saltmasterless
diff --git a/provisioner/salt-masterless/provisioner.hcl2spec.go b/provisioner/salt-masterless/provisioner.hcl2spec.go
new file mode 100644
index 000000000..9d918990b
--- /dev/null
+++ b/provisioner/salt-masterless/provisioner.hcl2spec.go
@@ -0,0 +1,73 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package saltmasterless
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	SkipBootstrap       *bool             `mapstructure:"skip_bootstrap" cty:"skip_bootstrap"`
+	BootstrapArgs       *string           `mapstructure:"bootstrap_args" cty:"bootstrap_args"`
+	DisableSudo         *bool             `mapstructure:"disable_sudo" cty:"disable_sudo"`
+	CustomState         *string           `mapstructure:"custom_state" cty:"custom_state"`
+	MinionConfig        *string           `mapstructure:"minion_config" cty:"minion_config"`
+	GrainsFile          *string           `mapstructure:"grains_file" cty:"grains_file"`
+	LocalStateTree      *string           `mapstructure:"local_state_tree" cty:"local_state_tree"`
+	LocalPillarRoots    *string           `mapstructure:"local_pillar_roots" cty:"local_pillar_roots"`
+	RemoteStateTree     *string           `mapstructure:"remote_state_tree" cty:"remote_state_tree"`
+	RemotePillarRoots   *string           `mapstructure:"remote_pillar_roots" cty:"remote_pillar_roots"`
+	TempConfigDir       *string           `mapstructure:"temp_config_dir" cty:"temp_config_dir"`
+	NoExitOnFailure     *bool             `mapstructure:"no_exit_on_failure" cty:"no_exit_on_failure"`
+	LogLevel            *string           `mapstructure:"log_level" cty:"log_level"`
+	SaltCallArgs        *string           `mapstructure:"salt_call_args" cty:"salt_call_args"`
+	SaltBinDir          *string           `mapstructure:"salt_bin_dir" cty:"salt_bin_dir"`
+	CmdArgs             *string           `cty:"cmd_args"`
+	GuestOSType         *string           `mapstructure:"guest_os_type" cty:"guest_os_type"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"skip_bootstrap":             &hcldec.AttrSpec{Name: "skip_bootstrap", Type: cty.Bool, Required: false},
+		"bootstrap_args":             &hcldec.AttrSpec{Name: "bootstrap_args", Type: cty.String, Required: false},
+		"disable_sudo":               &hcldec.AttrSpec{Name: "disable_sudo", Type: cty.Bool, Required: false},
+		"custom_state":               &hcldec.AttrSpec{Name: "custom_state", Type: cty.String, Required: false},
+		"minion_config":              &hcldec.AttrSpec{Name: "minion_config", Type: cty.String, Required: false},
+		"grains_file":                &hcldec.AttrSpec{Name: "grains_file", Type: cty.String, Required: false},
+		"local_state_tree":           &hcldec.AttrSpec{Name: "local_state_tree", Type: cty.String, Required: false},
+		"local_pillar_roots":         &hcldec.AttrSpec{Name: "local_pillar_roots", Type: cty.String, Required: false},
+		"remote_state_tree":          &hcldec.AttrSpec{Name: "remote_state_tree", Type: cty.String, Required: false},
+		"remote_pillar_roots":        &hcldec.AttrSpec{Name: "remote_pillar_roots", Type: cty.String, Required: false},
+		"temp_config_dir":            &hcldec.AttrSpec{Name: "temp_config_dir", Type: cty.String, Required: false},
+		"no_exit_on_failure":         &hcldec.AttrSpec{Name: "no_exit_on_failure", Type: cty.Bool, Required: false},
+		"log_level":                  &hcldec.AttrSpec{Name: "log_level", Type: cty.String, Required: false},
+		"salt_call_args":             &hcldec.AttrSpec{Name: "salt_call_args", Type: cty.String, Required: false},
+		"salt_bin_dir":               &hcldec.AttrSpec{Name: "salt_bin_dir", Type: cty.String, Required: false},
+		"cmd_args":                   &hcldec.AttrSpec{Name: "cmd_args", Type: cty.String, Required: false},
+		"guest_os_type":              &hcldec.AttrSpec{Name: "guest_os_type", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/shell/provisioner.go b/provisioner/shell/provisioner.go
index b022c94fc..3181c63ae 100644
--- a/provisioner/shell/provisioner.go
+++ b/provisioner/shell/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // This package implements a provisioner for Packer that executes
 // shell scripts within the remote machine.
 package shell
diff --git a/provisioner/shell/provisioner.hcl2spec.go b/provisioner/shell/provisioner.hcl2spec.go
new file mode 100644
index 000000000..f07abce86
--- /dev/null
+++ b/provisioner/shell/provisioner.hcl2spec.go
@@ -0,0 +1,71 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package shell
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName      *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType    *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug          *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce          *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError        *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars       map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars  []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Binary               *bool             `cty:"binary"`
+	ExecuteCommand       *string           `mapstructure:"execute_command" cty:"execute_command"`
+	Inline               []string          `cty:"inline"`
+	RemotePath           *string           `mapstructure:"remote_path" cty:"remote_path"`
+	Script               *string           `cty:"script"`
+	Scripts              []string          `cty:"scripts"`
+	ValidExitCodes       []int             `mapstructure:"valid_exit_codes" cty:"valid_exit_codes"`
+	Vars                 []string          `mapstructure:"environment_vars" cty:"environment_vars"`
+	InlineShebang        *string           `mapstructure:"inline_shebang" cty:"inline_shebang"`
+	RawPauseAfter        *string           `mapstructure:"pause_after" cty:"pause_after"`
+	UseEnvVarFile        *bool             `mapstructure:"use_env_var_file" cty:"use_env_var_file"`
+	RemoteFolder         *string           `mapstructure:"remote_folder" cty:"remote_folder"`
+	RemoteFile           *string           `mapstructure:"remote_file" cty:"remote_file"`
+	RawStartRetryTimeout *string           `mapstructure:"start_retry_timeout" cty:"start_retry_timeout"`
+	SkipClean            *bool             `mapstructure:"skip_clean" cty:"skip_clean"`
+	ExpectDisconnect     *bool             `mapstructure:"expect_disconnect" cty:"expect_disconnect"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"binary":                     &hcldec.AttrSpec{Name: "binary", Type: cty.Bool, Required: false},
+		"execute_command":            &hcldec.AttrSpec{Name: "execute_command", Type: cty.String, Required: false},
+		"inline":                     &hcldec.AttrSpec{Name: "inline", Type: cty.List(cty.String), Required: false},
+		"remote_path":                &hcldec.AttrSpec{Name: "remote_path", Type: cty.String, Required: false},
+		"script":                     &hcldec.AttrSpec{Name: "script", Type: cty.String, Required: false},
+		"scripts":                    &hcldec.AttrSpec{Name: "scripts", Type: cty.List(cty.String), Required: false},
+		"valid_exit_codes":           &hcldec.AttrSpec{Name: "valid_exit_codes", Type: cty.List(cty.Number), Required: false},
+		"environment_vars":           &hcldec.AttrSpec{Name: "environment_vars", Type: cty.List(cty.String), Required: false},
+		"inline_shebang":             &hcldec.AttrSpec{Name: "inline_shebang", Type: cty.String, Required: false},
+		"pause_after":                &hcldec.AttrSpec{Name: "pause_after", Type: cty.String, Required: false},
+		"use_env_var_file":           &hcldec.AttrSpec{Name: "use_env_var_file", Type: cty.Bool, Required: false},
+		"remote_folder":              &hcldec.AttrSpec{Name: "remote_folder", Type: cty.String, Required: false},
+		"remote_file":                &hcldec.AttrSpec{Name: "remote_file", Type: cty.String, Required: false},
+		"start_retry_timeout":        &hcldec.AttrSpec{Name: "start_retry_timeout", Type: cty.String, Required: false},
+		"skip_clean":                 &hcldec.AttrSpec{Name: "skip_clean", Type: cty.Bool, Required: false},
+		"expect_disconnect":          &hcldec.AttrSpec{Name: "expect_disconnect", Type: cty.Bool, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/sleep/provisioner.go b/provisioner/sleep/provisioner.go
index ecd4a4b40..646f1c4dd 100644
--- a/provisioner/sleep/provisioner.go
+++ b/provisioner/sleep/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Provisioner
+
 package sleep
 
 import (
diff --git a/provisioner/sleep/provisioner.hcl2spec.go b/provisioner/sleep/provisioner.hcl2spec.go
new file mode 100644
index 000000000..60f3ed89d
--- /dev/null
+++ b/provisioner/sleep/provisioner.hcl2spec.go
@@ -0,0 +1,27 @@
+// Code generated by "mapstructure-to-hcl2 -type Provisioner"; DO NOT EDIT.
+package sleep
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatProvisioner is an auto-generated flat version of Provisioner.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatProvisioner struct {
+	Duration *string `cty:"duration"`
+}
+
+// FlatMapstructure returns a new FlatProvisioner.
+// FlatProvisioner is an auto-generated flat version of Provisioner.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Provisioner) FlatMapstructure() interface{} { return new(FlatProvisioner) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatProvisioner.
+// This spec is used by HCL to read the fields of FlatProvisioner.
+func (*FlatProvisioner) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"duration": &hcldec.AttrSpec{Name: "duration", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/provisioner/windows-restart/provisioner.go b/provisioner/windows-restart/provisioner.go
index fba55f8cb..4f019c94b 100644
--- a/provisioner/windows-restart/provisioner.go
+++ b/provisioner/windows-restart/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 package restart
 
 import (
diff --git a/provisioner/windows-restart/provisioner.hcl2spec.go b/provisioner/windows-restart/provisioner.hcl2spec.go
new file mode 100644
index 000000000..eda8f486e
--- /dev/null
+++ b/provisioner/windows-restart/provisioner.hcl2spec.go
@@ -0,0 +1,49 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package restart
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	RestartCommand      *string           `mapstructure:"restart_command" cty:"restart_command"`
+	RestartCheckCommand *string           `mapstructure:"restart_check_command" cty:"restart_check_command"`
+	RestartTimeout      *string           `mapstructure:"restart_timeout" cty:"restart_timeout"`
+	CheckKey            *bool             `mapstructure:"check_registry" cty:"check_registry"`
+	RegistryKeys        []string          `mapstructure:"registry_keys" cty:"registry_keys"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"restart_command":            &hcldec.AttrSpec{Name: "restart_command", Type: cty.String, Required: false},
+		"restart_check_command":      &hcldec.AttrSpec{Name: "restart_check_command", Type: cty.String, Required: false},
+		"restart_timeout":            &hcldec.AttrSpec{Name: "restart_timeout", Type: cty.String, Required: false},
+		"check_registry":             &hcldec.AttrSpec{Name: "check_registry", Type: cty.Bool, Required: false},
+		"registry_keys":              &hcldec.AttrSpec{Name: "registry_keys", Type: cty.List(cty.String), Required: false},
+	}
+	return s
+}
diff --git a/provisioner/windows-shell/provisioner.go b/provisioner/windows-shell/provisioner.go
index 480568cc1..a2927017c 100644
--- a/provisioner/windows-shell/provisioner.go
+++ b/provisioner/windows-shell/provisioner.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Config
+
 // This package implements a provisioner for Packer that executes
 // shell scripts within the remote machine.
 package shell
diff --git a/provisioner/windows-shell/provisioner.hcl2spec.go b/provisioner/windows-shell/provisioner.hcl2spec.go
new file mode 100644
index 000000000..3258045c9
--- /dev/null
+++ b/provisioner/windows-shell/provisioner.hcl2spec.go
@@ -0,0 +1,59 @@
+// Code generated by "mapstructure-to-hcl2 -type Config"; DO NOT EDIT.
+package shell
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatConfig struct {
+	PackerBuildName     *string           `mapstructure:"packer_build_name" cty:"packer_build_name"`
+	PackerBuilderType   *string           `mapstructure:"packer_builder_type" cty:"packer_builder_type"`
+	PackerDebug         *bool             `mapstructure:"packer_debug" cty:"packer_debug"`
+	PackerForce         *bool             `mapstructure:"packer_force" cty:"packer_force"`
+	PackerOnError       *string           `mapstructure:"packer_on_error" cty:"packer_on_error"`
+	PackerUserVars      map[string]string `mapstructure:"packer_user_variables" cty:"packer_user_variables"`
+	PackerSensitiveVars []string          `mapstructure:"packer_sensitive_variables" cty:"packer_sensitive_variables"`
+	Binary              *bool             `cty:"binary"`
+	ExecuteCommand      *string           `mapstructure:"execute_command" cty:"execute_command"`
+	Inline              []string          `cty:"inline"`
+	RemotePath          *string           `mapstructure:"remote_path" cty:"remote_path"`
+	Script              *string           `cty:"script"`
+	Scripts             []string          `cty:"scripts"`
+	ValidExitCodes      []int             `mapstructure:"valid_exit_codes" cty:"valid_exit_codes"`
+	Vars                []string          `mapstructure:"environment_vars" cty:"environment_vars"`
+	StartRetryTimeout   *string           `mapstructure:"start_retry_timeout" cty:"start_retry_timeout"`
+	EnvVarFormat        *string           `mapstructure:"env_var_format" cty:"env_var_format"`
+}
+
+// FlatMapstructure returns a new FlatConfig.
+// FlatConfig is an auto-generated flat version of Config.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Config) FlatMapstructure() interface{} { return new(FlatConfig) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatConfig.
+// This spec is used by HCL to read the fields of FlatConfig.
+func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"packer_build_name":          &hcldec.AttrSpec{Name: "packer_build_name", Type: cty.String, Required: false},
+		"packer_builder_type":        &hcldec.AttrSpec{Name: "packer_builder_type", Type: cty.String, Required: false},
+		"packer_debug":               &hcldec.AttrSpec{Name: "packer_debug", Type: cty.Bool, Required: false},
+		"packer_force":               &hcldec.AttrSpec{Name: "packer_force", Type: cty.Bool, Required: false},
+		"packer_on_error":            &hcldec.AttrSpec{Name: "packer_on_error", Type: cty.String, Required: false},
+		"packer_user_variables":      &hcldec.BlockAttrsSpec{TypeName: "packer_user_variables", ElementType: cty.String, Required: false},
+		"packer_sensitive_variables": &hcldec.AttrSpec{Name: "packer_sensitive_variables", Type: cty.List(cty.String), Required: false},
+		"binary":                     &hcldec.AttrSpec{Name: "binary", Type: cty.Bool, Required: false},
+		"execute_command":            &hcldec.AttrSpec{Name: "execute_command", Type: cty.String, Required: false},
+		"inline":                     &hcldec.AttrSpec{Name: "inline", Type: cty.List(cty.String), Required: false},
+		"remote_path":                &hcldec.AttrSpec{Name: "remote_path", Type: cty.String, Required: false},
+		"script":                     &hcldec.AttrSpec{Name: "script", Type: cty.String, Required: false},
+		"scripts":                    &hcldec.AttrSpec{Name: "scripts", Type: cty.List(cty.String), Required: false},
+		"valid_exit_codes":           &hcldec.AttrSpec{Name: "valid_exit_codes", Type: cty.List(cty.Number), Required: false},
+		"environment_vars":           &hcldec.AttrSpec{Name: "environment_vars", Type: cty.List(cty.String), Required: false},
+		"start_retry_timeout":        &hcldec.AttrSpec{Name: "start_retry_timeout", Type: cty.String, Required: false},
+		"env_var_format":             &hcldec.AttrSpec{Name: "env_var_format", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/template/template.go b/template/template.go
index aba88c7d0..6bab8d4c2 100644
--- a/template/template.go
+++ b/template/template.go
@@ -1,3 +1,5 @@
+//go:generate mapstructure-to-hcl2 -type Provisioner
+
 package template
 
 import (
diff --git a/template/template.hcl2spec.go b/template/template.hcl2spec.go
new file mode 100644
index 000000000..988b6fc79
--- /dev/null
+++ b/template/template.hcl2spec.go
@@ -0,0 +1,39 @@
+// Code generated by "mapstructure-to-hcl2 -type Provisioner"; DO NOT EDIT.
+package template
+
+import (
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FlatProvisioner is an auto-generated flat version of Provisioner.
+// Where the contents of a field with a `mapstructure:,squash` tag are bubbled up.
+type FlatProvisioner struct {
+	Only        []string               `json:"only,omitempty" cty:"only"`
+	Except      []string               `json:"except,omitempty" cty:"except"`
+	Type        *string                `json:"type" cty:"type"`
+	Config      map[string]interface{} `json:"config,omitempty" cty:"config"`
+	Override    map[string]interface{} `json:"override,omitempty" cty:"override"`
+	PauseBefore *string                `mapstructure:"pause_before" json:"pause_before,omitempty" cty:"pause_before"`
+	Timeout     *string                `mapstructure:"timeout" json:"timeout,omitempty" cty:"timeout"`
+}
+
+// FlatMapstructure returns a new FlatProvisioner.
+// FlatProvisioner is an auto-generated flat version of Provisioner.
+// Where the contents a fields with a `mapstructure:,squash` tag are bubbled up.
+func (*Provisioner) FlatMapstructure() interface{} { return new(FlatProvisioner) }
+
+// HCL2Spec returns the hcldec.Spec of a FlatProvisioner.
+// This spec is used by HCL to read the fields of FlatProvisioner.
+func (*FlatProvisioner) HCL2Spec() map[string]hcldec.Spec {
+	s := map[string]hcldec.Spec{
+		"only":         &hcldec.AttrSpec{Name: "only", Type: cty.List(cty.String), Required: false},
+		"except":       &hcldec.AttrSpec{Name: "except", Type: cty.List(cty.String), Required: false},
+		"type":         &hcldec.AttrSpec{Name: "type", Type: cty.String, Required: false},
+		"config":       &hcldec.BlockAttrsSpec{TypeName: "config", ElementType: cty.String, Required: false},
+		"override":     &hcldec.BlockAttrsSpec{TypeName: "override", ElementType: cty.String, Required: false},
+		"pause_before": &hcldec.AttrSpec{Name: "pause_before", Type: cty.String, Required: false},
+		"timeout":      &hcldec.AttrSpec{Name: "timeout", Type: cty.String, Required: false},
+	}
+	return s
+}
diff --git a/website/source/partials/builder/amazon/chroot/_BlockDevice-not-required.html.md b/website/source/partials/builder/amazon/chroot/_BlockDevice-not-required.html.md
deleted file mode 100644
index be5d68ffe..000000000
--- a/website/source/partials/builder/amazon/chroot/_BlockDevice-not-required.html.md
+++ /dev/null
@@ -1,10 +0,0 @@
-<!-- Code generated from the comments of the BlockDevice struct in builder/amazon/chroot/block_device.go; DO NOT EDIT MANUALLY -->
-
--   `kms_key_id` (string) - ID, alias or ARN of the KMS key to use for boot volume encryption. This
-    only applies to the main region, other regions where the AMI will be
-    copied will be encrypted by the default EBS KMS key. For valid formats
-    see KmsKeyId in the [AWS API docs -
-    CopyImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopyImage.html)
-    This field is validated by Packer, when using an alias, you will have to
-    prefix kms_key_id with alias/.
-    
\ No newline at end of file
diff --git a/website/source/partials/builder/amazon/chroot/_Config-not-required.html.md b/website/source/partials/builder/amazon/chroot/_Config-not-required.html.md
index cf9f6c573..aca876e04 100644
--- a/website/source/partials/builder/amazon/chroot/_Config-not-required.html.md
+++ b/website/source/partials/builder/amazon/chroot/_Config-not-required.html.md
@@ -1,6 +1,6 @@
 <!-- Code generated from the comments of the Config struct in builder/amazon/chroot/builder.go; DO NOT EDIT MANUALLY -->
 
--   `ami_block_device_mappings` (BlockDevices) - Add one or more [block device
+-   `ami_block_device_mappings` (awscommon.BlockDevices) - Add one or more [block device
     mappings](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html)
     to the AMI. If this field is populated, and you are building from an
     existing source image, the block device mappings in the source image
diff --git a/website/source/partials/builder/googlecompute/_Config-not-required.html.md b/website/source/partials/builder/googlecompute/_Config-not-required.html.md
index 4f0942747..0f137015b 100644
--- a/website/source/partials/builder/googlecompute/_Config-not-required.html.md
+++ b/website/source/partials/builder/googlecompute/_Config-not-required.html.md
@@ -30,7 +30,7 @@
     
 -   `image_description` (string) - The description of the resulting image.
     
--   `image_encryption_key` (\*compute.CustomerEncryptionKey) - Image encryption key to apply to the created image. Possible values:
+-   `image_encryption_key` (\*CustomerEncryptionKey) - Image encryption key to apply to the created image. Possible values:
     * kmsKeyName -  The name of the encryption key that is stored in Google Cloud KMS.
     * RawKey: - A 256-bit customer-supplied encryption key, encodes in RFC 4648 base64.
     
diff --git a/website/source/partials/builder/vmware/iso/_Config-not-required.html.md b/website/source/partials/builder/vmware/iso/_Config-not-required.html.md
index 8562b0a4b..d0ee6c8ee 100644
--- a/website/source/partials/builder/vmware/iso/_Config-not-required.html.md
+++ b/website/source/partials/builder/vmware/iso/_Config-not-required.html.md
@@ -49,13 +49,6 @@
       Guide](https://www.vmware.com/pdf/VirtualDiskManager.pdf) for desktop
       VMware clients. For ESXi, refer to the proper ESXi documentation.
     
--   `format` (string) - Either "ovf", "ova" or "vmx", this specifies the output
-    format of the exported virtual machine. This defaults to "ovf".
-    Before using this option, you need to install ovftool. This option
-    currently only works when option remote_type is set to "esx5".
-    Since ovftool is only capable of password based authentication
-    remote_password must be set when exporting the VM.
-    
 -   `cdrom_adapter_type` (string) - The adapter type (or bus) that will be used
     by the cdrom device. This is chosen by default based on the disk adapter
     type. VMware tends to lean towards ide for the cdrom device unless
diff --git a/website/source/partials/builder/vmware/vmx/_Config-not-required.html.md b/website/source/partials/builder/vmware/vmx/_Config-not-required.html.md
index 38b63d0f7..a4d905a96 100644
--- a/website/source/partials/builder/vmware/vmx/_Config-not-required.html.md
+++ b/website/source/partials/builder/vmware/vmx/_Config-not-required.html.md
@@ -14,11 +14,6 @@
     scenarios. Most users will wish to create a full clone instead. Defaults
     to false.
     
--   `remote_type` (string) - The type of remote machine that will be used to
-    build this VM rather than a local desktop product. The only value accepted
-    for this currently is esx5. If this is not set, a desktop product will
-    be used. By default, this is not set.
-    
 -   `vm_name` (string) - This is the name of the VMX file for the new virtual
     machine, without the file extension. By default this is packer-BUILDNAME,
     where "BUILDNAME" is the name of the build.

From 2b0e0d4eab8dd197649c30f59ed9dfa8ab42351a Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 17:02:53 +0200
Subject: [PATCH 079/155] add hcl2template pkg

Package hcl2template defines code to parse hcl2 template files correctly.

In order to configure a packer builder,provisioner,communicator and post
processor.

Checkout the files in testdata/complete/ to see what a packer config could
look like.
---
 hcl2template/config_load.go                   | 101 ++++++
 hcl2template/docs.go                          |   9 +
 hcl2template/load_test.go                     | 333 ++++++++++++++++++
 hcl2template/parser.go                        | 182 ++++++++++
 hcl2template/parser_test.go                   | 213 +++++++++++
 hcl2template/testdata/build/basic.pkr.hcl     |  66 ++++
 .../testdata/communicator/basic.pkr.hcl       |  27 ++
 hcl2template/testdata/complete/build.pkr.hcl  |   1 +
 .../testdata/complete/communicator.pkr.hcl    |   1 +
 .../testdata/complete/sources.pkr.hcl         |   1 +
 .../complete/subfolder/shouldnotload.pkr.hcl  |  61 ++++
 .../testdata/complete/variables.pkr.hcl       |   1 +
 hcl2template/testdata/sources/basic.pkr.hcl   |  37 ++
 hcl2template/testdata/variables/basic.pkr.hcl |   6 +
 hcl2template/types.build.from.go              |  68 ++++
 hcl2template/types.build.go                   |  61 ++++
 hcl2template/types.build.provisioners.go      |  70 ++++
 hcl2template/types.communicator.go            |  88 +++++
 hcl2template/types.decodable.go               |  56 +++
 hcl2template/types.hcl_ref.go                 |  20 ++
 hcl2template/types.packer_config.go           | 165 +++++++++
 hcl2template/types.source.go                  | 113 ++++++
 hcl2template/types.variable.go                |  27 ++
 hcl2template/zz_retrocompat.go                | 156 ++++++++
 24 files changed, 1863 insertions(+)
 create mode 100644 hcl2template/config_load.go
 create mode 100644 hcl2template/docs.go
 create mode 100644 hcl2template/load_test.go
 create mode 100644 hcl2template/parser.go
 create mode 100644 hcl2template/parser_test.go
 create mode 100644 hcl2template/testdata/build/basic.pkr.hcl
 create mode 100644 hcl2template/testdata/communicator/basic.pkr.hcl
 create mode 120000 hcl2template/testdata/complete/build.pkr.hcl
 create mode 120000 hcl2template/testdata/complete/communicator.pkr.hcl
 create mode 120000 hcl2template/testdata/complete/sources.pkr.hcl
 create mode 100644 hcl2template/testdata/complete/subfolder/shouldnotload.pkr.hcl
 create mode 120000 hcl2template/testdata/complete/variables.pkr.hcl
 create mode 100644 hcl2template/testdata/sources/basic.pkr.hcl
 create mode 100644 hcl2template/testdata/variables/basic.pkr.hcl
 create mode 100644 hcl2template/types.build.from.go
 create mode 100644 hcl2template/types.build.go
 create mode 100644 hcl2template/types.build.provisioners.go
 create mode 100644 hcl2template/types.communicator.go
 create mode 100644 hcl2template/types.decodable.go
 create mode 100644 hcl2template/types.hcl_ref.go
 create mode 100644 hcl2template/types.packer_config.go
 create mode 100644 hcl2template/types.source.go
 create mode 100644 hcl2template/types.variable.go
 create mode 100644 hcl2template/zz_retrocompat.go

diff --git a/hcl2template/config_load.go b/hcl2template/config_load.go
new file mode 100644
index 000000000..1be7928c4
--- /dev/null
+++ b/hcl2template/config_load.go
@@ -0,0 +1,101 @@
+package hcl2template
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+) 
+
+type Artifacts map[ArtifactRef]*Artifact
+
+type Artifact struct {
+	Type string
+	Name string
+
+	DeclRange hcl.Range
+
+	Config hcl.Body
+}
+
+func (a *Artifact) Ref() ArtifactRef {
+	return ArtifactRef{
+		Type: a.Type,
+		Name: a.Name,
+	}
+}
+
+type ArtifactRef struct {
+	Type string
+	Name string
+}
+
+// NoArtifact is the zero value of ArtifactRef, representing the absense of an
+// artifact.
+var NoArtifact ArtifactRef
+
+func artifactRefFromAbsTraversal(t hcl.Traversal) (ArtifactRef, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	if len(t) != 3 {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid artifact reference",
+			Detail:   "An artifact reference must have three parts separated by periods: the keyword \"artifact\", the builder type name, and the artifact name.",
+			Subject:  t.SourceRange().Ptr(),
+		})
+		return NoArtifact, diags
+	}
+
+	if t.RootName() != "artifact" {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid artifact reference",
+			Detail:   "The first part of an artifact reference must be the keyword \"artifact\".",
+			Subject:  t[0].SourceRange().Ptr(),
+		})
+		return NoArtifact, diags
+	}
+	btStep, ok := t[1].(hcl.TraverseAttr)
+	if !ok {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid artifact reference",
+			Detail:   "The second part of an artifact reference must be an identifier giving the builder type of the artifact.",
+			Subject:  t[1].SourceRange().Ptr(),
+		})
+		return NoArtifact, diags
+	}
+	nameStep, ok := t[2].(hcl.TraverseAttr)
+	if !ok {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid artifact reference",
+			Detail:   "The third part of an artifact reference must be an identifier giving the name of the artifact.",
+			Subject:  t[2].SourceRange().Ptr(),
+		})
+		return NoArtifact, diags
+	}
+
+	return ArtifactRef{
+		Type: btStep.Name,
+		Name: nameStep.Name,
+	}, diags
+}
+
+func (r ArtifactRef) String() string {
+	return fmt.Sprintf("%s.%s", r.Type, r.Name)
+}
+
+// decodeBodyWithoutSchema is a generic alternative to hcldec.Decode that
+// just extracts whatever attributes are present and rejects any nested blocks,
+// for compatibility with legacy builders that can't provide explicit schema.
+func decodeBodyWithoutSchema(body hcl.Body, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	attrs, diags := body.JustAttributes()
+	vals := make(map[string]cty.Value)
+	for name, attr := range attrs {
+		val, moreDiags := attr.Expr.Value(ctx)
+		diags = append(diags, moreDiags...)
+		vals[name] = val
+	}
+	return cty.ObjectVal(vals), diags
+}
diff --git a/hcl2template/docs.go b/hcl2template/docs.go
new file mode 100644
index 000000000..f285d7dcd
--- /dev/null
+++ b/hcl2template/docs.go
@@ -0,0 +1,9 @@
+// Package hcl2template defines code to parse hcl2 template files correctly.
+//
+// In order to configure a packer builder,provisioner,communicator and post
+// processor.
+//
+// Checkout the files in testdata/complete/ to see what a packer config could
+// look like.
+//
+package hcl2template
diff --git a/hcl2template/load_test.go b/hcl2template/load_test.go
new file mode 100644
index 000000000..1503f085c
--- /dev/null
+++ b/hcl2template/load_test.go
@@ -0,0 +1,333 @@
+package hcl2template
+
+import (
+	"testing"
+
+	awscommon "github.com/hashicorp/packer/builder/amazon/common"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclparse"
+	"github.com/zclconf/go-cty/cty"
+
+	"github.com/hashicorp/packer/helper/communicator"
+
+	amazonebs "github.com/hashicorp/packer/builder/amazon/ebs"
+	"github.com/hashicorp/packer/builder/virtualbox/iso"
+
+	"github.com/hashicorp/packer/provisioner/file"
+	"github.com/hashicorp/packer/provisioner/shell"
+
+	amazon_import "github.com/hashicorp/packer/post-processor/amazon-import"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+)
+
+func getBasicParser() *Parser {
+	return &Parser{
+		Parser: hclparse.NewParser(),
+		ProvisionersSchemas: map[string]Decodable{
+			"shell": &shell.Config{},
+			"file":  &file.Config{},
+		},
+		PostProvisionersSchemas: map[string]Decodable{
+			"amazon-import": &amazon_import.Config{},
+		},
+		CommunicatorSchemas: map[string]Decodable{
+			"ssh":   &communicator.SSH{},
+			"winrm": &communicator.WinRM{},
+		},
+		SourceSchemas: map[string]Decodable{
+			"amazon-ebs":     &amazonebs.Config{},
+			"virtualbox-iso": &iso.Config{},
+		},
+	}
+}
+
+func TestParser_ParseFile(t *testing.T) {
+	defaultParser := getBasicParser()
+
+	type fields struct {
+		Parser *hclparse.Parser
+	}
+	type args struct {
+		filename string
+		cfg      *PackerConfig
+	}
+	tests := []struct {
+		name             string
+		parser           *Parser
+		args             args
+		wantPackerConfig *PackerConfig
+		wantDiags        bool
+	}{
+		{
+			"valid " + sourceLabel + " load",
+			defaultParser,
+			args{"testdata/sources/basic.pkr.hcl", new(PackerConfig)},
+			&PackerConfig{
+				Sources: map[SourceRef]*Source{
+					SourceRef{
+						Type: "virtualbox-iso",
+						Name: "ubuntu-1204",
+					}: {
+						Type: "virtualbox-iso",
+						Name: "ubuntu-1204",
+						Cfg: &iso.FlatConfig{
+							HTTPDir:         strPtr("xxx"),
+							ISOChecksum:     strPtr("769474248a3897f4865817446f9a4a53"),
+							ISOChecksumType: strPtr("md5"),
+							RawSingleISOUrl: strPtr("http://releases.ubuntu.com/12.04/ubuntu-12.04.5-server-amd64.iso"),
+							BootCommand:     []string{"..."},
+							ShutdownCommand: strPtr("echo 'vagrant' | sudo -S shutdown -P now"),
+							RawBootWait:     strPtr("10s"),
+							VBoxManage:      [][]string{},
+							VBoxManagePost:  [][]string{},
+						},
+					},
+					SourceRef{
+						Type: "amazon-ebs",
+						Name: "ubuntu-1604",
+					}: {
+						Type: "amazon-ebs",
+						Name: "ubuntu-1604",
+						Cfg: &amazonebs.FlatConfig{
+							RawRegion:            strPtr("eu-west-3"),
+							AMIEncryptBootVolume: boolPtr(true),
+							InstanceType:         strPtr("t2.micro"),
+							SourceAmiFilter: &awscommon.FlatAmiFilterOptions{
+								Filters: map[string]string{
+									"name":                "ubuntu/images/*ubuntu-xenial-{16.04}-amd64-server-*",
+									"root-device-type":    "ebs",
+									"virtualization-type": "hvm",
+								},
+								Owners: []string{"099720109477"},
+							},
+							AMIMappings:    []awscommon.FlatBlockDevice{},
+							LaunchMappings: []awscommon.FlatBlockDevice{},
+						},
+					},
+					SourceRef{
+						Type: "amazon-ebs",
+						Name: "that-ubuntu-1.0",
+					}: {
+						Type: "amazon-ebs",
+						Name: "that-ubuntu-1.0",
+						Cfg: &amazonebs.FlatConfig{
+							RawRegion:            strPtr("eu-west-3"),
+							AMIEncryptBootVolume: boolPtr(true),
+							InstanceType:         strPtr("t2.micro"),
+							SourceAmiFilter: &awscommon.FlatAmiFilterOptions{
+								MostRecent: boolPtr(true),
+							},
+							AMIMappings:    []awscommon.FlatBlockDevice{},
+							LaunchMappings: []awscommon.FlatBlockDevice{},
+						},
+					},
+				},
+			},
+			false,
+		},
+
+		{
+			"valid " + communicatorLabel + " load",
+			defaultParser,
+			args{"testdata/communicator/basic.pkr.hcl", new(PackerConfig)},
+			&PackerConfig{
+				Communicators: map[CommunicatorRef]*Communicator{
+					{Type: "ssh", Name: "vagrant"}: {
+						Type: "ssh", Name: "vagrant",
+						Cfg: &communicator.FlatSSH{
+							SSHUsername:               strPtr("vagrant"),
+							SSHPassword:               strPtr("s3cr4t"),
+							SSHClearAuthorizedKeys:    boolPtr(true),
+							SSHHost:                   strPtr("sssssh.hashicorp.io"),
+							SSHHandshakeAttempts:      intPtr(32),
+							SSHPort:                   intPtr(42),
+							SSHFileTransferMethod:     strPtr("scp"),
+							SSHPrivateKeyFile:         strPtr("file.pem"),
+							SSHPty:                    boolPtr(false),
+							SSHTimeout:                strPtr("5m"),
+							SSHAgentAuth:              boolPtr(false),
+							SSHDisableAgentForwarding: boolPtr(true),
+							SSHBastionHost:            strPtr(""),
+							SSHBastionPort:            intPtr(0),
+							SSHBastionAgentAuth:       boolPtr(true),
+							SSHBastionUsername:        strPtr(""),
+							SSHBastionPassword:        strPtr(""),
+							SSHBastionPrivateKeyFile:  strPtr(""),
+							SSHProxyHost:              strPtr("ninja-potatoes.com"),
+							SSHProxyPort:              intPtr(42),
+							SSHProxyUsername:          strPtr("dark-father"),
+							SSHProxyPassword:          strPtr("pickle-rick"),
+							SSHKeepAliveInterval:      strPtr("10s"),
+							SSHReadWriteTimeout:       strPtr("5m"),
+						},
+					},
+				},
+			},
+			false,
+		},
+
+		// {
+		// 	"duplicate " + sourceLabel, defaultParser,
+		// 	args{"testdata/sources/basic.pkr.hcl", &PackerConfig{
+		// 		Sources: map[SourceRef]*Source{
+		// 			SourceRef{
+		// 				Type: "amazon-ebs",
+		// 				Name: "ubuntu-1604",
+		// 			}: {
+		// 				Type: "amazon-ebs",
+		// 				Name: "ubuntu-1604",
+		// 				Cfg:  &amazonebs.FlatConfig{RawRegion: "eu-west-3", InstanceType: "t2.micro"},
+		// 			},
+		// 		},
+		// 	},
+		// 	},
+		// 	&PackerConfig{
+		// 		Sources: map[SourceRef]*Source{
+		// 			SourceRef{
+		// 				Type: "virtualbox-iso",
+		// 				Name: "ubuntu-1204",
+		// 			}: {
+		// 				Type: "virtualbox-iso",
+		// 				Name: "ubuntu-1204",
+		// 				Cfg: &iso.FlatConfig{
+		// 					HTTPDir:         "xxx",
+		// 					ISOChecksum:     "769474248a3897f4865817446f9a4a53",
+		// 					ISOChecksumType: "md5",
+		// 					RawSingleISOUrl: "http://releases.ubuntu.com/12.04/ubuntu-12.04.5-server-amd64.iso",
+		// 					BootCommand:     []string{"..."},
+		// 					ShutdownCommand: "echo 'vagrant' | sudo -S shutdown -P now",
+		// 					RawBootWait:     "10s",
+		// 				},
+		// 			},
+		// 			SourceRef{
+		// 				Type: "amazon-ebs",
+		// 				Name: "ubuntu-1604",
+		// 			}: {
+		// 				Type: "amazon-ebs",
+		// 				Name: "ubuntu-1604",
+		// 				Cfg:  &amazonebs.FlatConfig{RawRegion: "eu-west-3", InstanceType: "t2.micro"},
+		// 			},
+		// 			SourceRef{
+		// 				Type: "amazon-ebs",
+		// 				Name: "that-ubuntu-1.0",
+		// 			}: {
+		// 				Type: "amazon-ebs",
+		// 				Name: "that-ubuntu-1.0",
+		// 				Cfg:  &amazonebs.FlatConfig{RawRegion: "eu-west-3", InstanceType: "t2.micro"},
+		// 			},
+		// 		},
+		// 	},
+		// 	true,
+		// },
+
+		// {"valid variables load", defaultParser,
+		// 	args{"testdata/variables/basic.pkr.hcl", new(PackerConfig)},
+		// 	&PackerConfig{
+		// 		Variables: PackerV1Variables{
+		// 			"image_name": "foo-image-{{user `my_secret`}}",
+		// 			"key":        "value",
+		// 			"my_secret":  "foo",
+		// 		},
+		// 	},
+		// 	false,
+		// },
+
+		// {"valid " + buildLabel + " load", defaultParser,
+		// 	args{"testdata/build/basic.pkr.hcl", new(PackerConfig)},
+		// 	&PackerConfig{
+		// 		Builds: Builds{
+		// 			{
+		// 				Froms: BuildFromList{
+		// 					{
+		// 						Src: SourceRef{"amazon-ebs", "ubuntu-1604"},
+		// 					},
+		// 					{
+		// 						Src: SourceRef{"virtualbox-iso", "ubuntu-1204"},
+		// 					},
+		// 				},
+		// 				ProvisionerGroups: ProvisionerGroups{
+		// 					&ProvisionerGroup{
+		// 						CommunicatorRef: CommunicatorRef{"ssh", "vagrant"},
+		// 						Provisioners: []Provisioner{
+		// 							{Cfg: &shell.FlatConfig{
+		// 								Inline: []string{"echo '{{user `my_secret`}}' :D"},
+		// 							}},
+		// 							{Cfg: &shell.FlatConfig{
+		// 								Scripts:        []string{"script-1.sh", "script-2.sh"},
+		// 								ValidExitCodes: []int{0, 42},
+		// 							}},
+		// 							{Cfg: &file.FlatConfig{
+		// 								Source:      "app.tar.gz",
+		// 								Destination: "/tmp/app.tar.gz",
+		// 							}},
+		// 						},
+		// 					},
+		// 				},
+		// 				PostProvisionerGroups: ProvisionerGroups{
+		// 					&ProvisionerGroup{
+		// 						Provisioners: []Provisioner{
+		// 							{Cfg: &amazon_import.FlatConfig{
+		// 								Name: "that-ubuntu-1.0",
+		// 							}},
+		// 						},
+		// 					},
+		// 				},
+		// 			},
+		// 			&Build{
+		// 				Froms: BuildFromList{
+		// 					{
+		// 						Src: SourceRef{"amazon", "that-ubuntu-1"},
+		// 					},
+		// 				},
+		// 				ProvisionerGroups: ProvisionerGroups{
+		// 					&ProvisionerGroup{
+		// 						Provisioners: []Provisioner{
+		// 							{Cfg: &shell.FlatConfig{
+		// 								Inline: []string{"echo HOLY GUACAMOLE !"},
+		// 							}},
+		// 						},
+		// 					},
+		// 				},
+		// 			},
+		// 		},
+		// 	},
+		// 	false,
+		// },
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := tt.parser
+			f, moreDiags := p.ParseHCLFile(tt.args.filename)
+			if moreDiags != nil {
+				t.Fatalf("diags: %s", moreDiags)
+			}
+			diags := p.ParseFile(f, tt.args.cfg)
+			if tt.wantDiags == (diags == nil) {
+				for _, diag := range diags {
+					t.Errorf("PackerConfig.Load() unexpected diagnostics. %v", diag)
+				}
+				t.Error("")
+			}
+			if diff := cmp.Diff(tt.wantPackerConfig, tt.args.cfg,
+				cmpopts.IgnoreUnexported(cty.Value{}),
+				cmpopts.IgnoreTypes(HCL2Ref{}),
+				cmpopts.IgnoreTypes([]hcl.Range{}),
+				cmpopts.IgnoreTypes(hcl.Range{}),
+				cmpopts.IgnoreInterfaces(struct{ hcl.Expression }{}),
+				cmpopts.IgnoreInterfaces(struct{ hcl.Body }{}),
+			); diff != "" {
+				t.Errorf("PackerConfig.Load() wrong packer config. %s", diff)
+			}
+			if t.Failed() {
+				t.Fatal()
+			}
+		})
+	}
+}
+
+func strPtr(s string) *string { return &s }
+func intPtr(i int) *int       { return &i }
+func boolPtr(b bool) *bool    { return &b }
diff --git a/hcl2template/parser.go b/hcl2template/parser.go
new file mode 100644
index 000000000..97bd1e8d6
--- /dev/null
+++ b/hcl2template/parser.go
@@ -0,0 +1,182 @@
+package hcl2template
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclparse"
+)
+
+const (
+	sourceLabel       = "source"
+	variablesLabel    = "variables"
+	buildLabel        = "build"
+	communicatorLabel = "communicator"
+)
+
+var configSchema = &hcl.BodySchema{
+	Blocks: []hcl.BlockHeaderSchema{
+		{Type: sourceLabel, LabelNames: []string{"type", "name"}},
+		{Type: variablesLabel},
+		{Type: buildLabel},
+		{Type: communicatorLabel, LabelNames: []string{"type", "name"}},
+	},
+}
+
+type Parser struct {
+	*hclparse.Parser
+
+	ProvisionersSchemas map[string]Decodable
+
+	PostProvisionersSchemas map[string]Decodable
+
+	CommunicatorSchemas map[string]Decodable
+
+	SourceSchemas map[string]Decodable
+}
+
+const hcl2FileExt = ".pkr.hcl"
+
+func (p *Parser) Parse(filename string) (*PackerConfig, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	hclFiles := []string{}
+	jsonFiles := []string{}
+	if strings.HasSuffix(filename, hcl2FileExt) {
+		hclFiles = append(hclFiles, hcl2FileExt)
+	} else if strings.HasSuffix(filename, ".json") {
+		jsonFiles = append(jsonFiles, hcl2FileExt)
+	} else {
+		fileInfos, err := ioutil.ReadDir(filename)
+		if err != nil {
+			diag := &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Cannot read hcl directory",
+				Detail:   err.Error(),
+			}
+			diags = append(diags, diag)
+		}
+		for _, fileInfo := range fileInfos {
+			if fileInfo.IsDir() {
+				continue
+			}
+			filename := filepath.Join(filename, fileInfo.Name())
+			if strings.HasSuffix(filename, hcl2FileExt) {
+				hclFiles = append(hclFiles, filename)
+			} else if strings.HasSuffix(filename, ".json") {
+				jsonFiles = append(jsonFiles, filename)
+			}
+		}
+	}
+
+	var files []*hcl.File
+	for _, filename := range hclFiles {
+		f, moreDiags := p.ParseHCLFile(filename)
+		diags = append(diags, moreDiags...)
+		files = append(files, f)
+	}
+	for _, filename := range jsonFiles {
+		f, moreDiags := p.ParseJSONFile(filename)
+		diags = append(diags, moreDiags...)
+		files = append(files, f)
+	}
+	if diags.HasErrors() {
+		return nil, diags
+	}
+
+	cfg := &PackerConfig{}
+	for _, file := range files {
+		moreDiags := p.ParseFile(file, cfg)
+		diags = append(diags, moreDiags...)
+	}
+	if diags.HasErrors() {
+		return cfg, diags
+	}
+
+	return cfg, nil
+}
+
+// ParseFile filename content into cfg.
+//
+// ParseFile may be called multiple times with the same cfg on a different file.
+//
+// ParseFile returns as complete a config as we can manage, even if there are
+// errors, since a partial result can be useful for careful analysis by
+// development tools such as text editor extensions.
+func (p *Parser) ParseFile(f *hcl.File, cfg *PackerConfig) hcl.Diagnostics {
+	var diags hcl.Diagnostics
+
+	content, moreDiags := f.Body.Content(configSchema)
+	diags = append(diags, moreDiags...)
+
+	for _, block := range content.Blocks {
+		switch block.Type {
+		case sourceLabel:
+			if cfg.Sources == nil {
+				cfg.Sources = map[SourceRef]*Source{}
+			}
+
+			source, moreDiags := p.decodeSource(block, p.SourceSchemas)
+			diags = append(diags, moreDiags...)
+
+			ref := source.Ref()
+			if existing := cfg.Sources[ref]; existing != nil {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Duplicate " + sourceLabel + " block",
+					Detail: fmt.Sprintf("This "+sourceLabel+" block has the "+
+						"same builder type and name as a previous block declared "+
+						"at %s. Each "+sourceLabel+" must have a unique name per builder type.",
+						existing.HCL2Ref.DeclRange),
+					Subject: &source.HCL2Ref.DeclRange,
+				})
+				continue
+			}
+			cfg.Sources[ref] = source
+
+		case variablesLabel:
+			if cfg.Variables == nil {
+				cfg.Variables = PackerV1Variables{}
+			}
+
+			moreDiags := cfg.Variables.decodeConfig(block)
+			diags = append(diags, moreDiags...)
+
+		case buildLabel:
+			build, moreDiags := p.decodeBuildConfig(block)
+			diags = append(diags, moreDiags...)
+			cfg.Builds = append(cfg.Builds, build)
+
+		case communicatorLabel:
+			if cfg.Communicators == nil {
+				cfg.Communicators = map[CommunicatorRef]*Communicator{}
+			}
+			communicator, moreDiags := p.decodeCommunicatorConfig(block)
+			diags = append(diags, moreDiags...)
+
+			ref := communicator.Ref()
+
+			if existing := cfg.Communicators[ref]; existing != nil {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Duplicate " + communicatorLabel + " block",
+					Detail: fmt.Sprintf("This "+communicatorLabel+" block has the "+
+						"same type and name as a previous block declared "+
+						"at %s. Each "+communicatorLabel+" must have a unique name per type.",
+						existing.HCL2Ref.DeclRange),
+					Subject: &communicator.HCL2Ref.DeclRange,
+				})
+				continue
+			}
+			cfg.Communicators[ref] = communicator
+
+		default:
+			panic(fmt.Sprintf("unexpected block type %q", block.Type)) // TODO(azr): err
+		}
+	}
+
+	return diags
+}
diff --git a/hcl2template/parser_test.go b/hcl2template/parser_test.go
new file mode 100644
index 000000000..c62bf6bdb
--- /dev/null
+++ b/hcl2template/parser_test.go
@@ -0,0 +1,213 @@
+package hcl2template
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+
+	awscommon "github.com/hashicorp/packer/builder/amazon/common"
+	amazonebs "github.com/hashicorp/packer/builder/amazon/ebs"
+	"github.com/hashicorp/packer/builder/virtualbox/iso"
+
+	"github.com/hashicorp/packer/helper/communicator"
+
+	amazon_import "github.com/hashicorp/packer/post-processor/amazon-import"
+
+	"github.com/hashicorp/packer/provisioner/file"
+	"github.com/hashicorp/packer/provisioner/shell"
+)
+
+func TestParser_Parse(t *testing.T) {
+	defaultParser := getBasicParser()
+
+	type args struct {
+		filename string
+	}
+	tests := []struct {
+		name      string
+		parser    *Parser
+		args      args
+		wantCfg   *PackerConfig
+		wantDiags bool
+	}{
+		{"complete",
+			defaultParser,
+			args{"testdata/complete"},
+			&PackerConfig{
+				Sources: map[SourceRef]*Source{
+					SourceRef{
+						Type: "virtualbox-iso",
+						Name: "ubuntu-1204",
+					}: {
+						Type: "virtualbox-iso",
+						Name: "ubuntu-1204",
+						Cfg: &iso.FlatConfig{
+							HTTPDir:         strPtr("xxx"),
+							ISOChecksum:     strPtr("769474248a3897f4865817446f9a4a53"),
+							ISOChecksumType: strPtr("md5"),
+							RawSingleISOUrl: strPtr("http://releases.ubuntu.com/12.04/ubuntu-12.04.5-server-amd64.iso"),
+							BootCommand:     []string{"..."},
+							ShutdownCommand: strPtr("echo 'vagrant' | sudo -S shutdown -P now"),
+							RawBootWait:     strPtr("10s"),
+							VBoxManage:      [][]string{},
+							VBoxManagePost:  [][]string{},
+						},
+					},
+					SourceRef{
+						Type: "amazon-ebs",
+						Name: "ubuntu-1604",
+					}: {
+						Type: "amazon-ebs",
+						Name: "ubuntu-1604",
+						Cfg: &amazonebs.FlatConfig{
+							RawRegion:            strPtr("eu-west-3"),
+							AMIEncryptBootVolume: boolPtr(true),
+							InstanceType:         strPtr("t2.micro"),
+							SourceAmiFilter: &awscommon.FlatAmiFilterOptions{
+								Filters: map[string]string{
+									"name":                "ubuntu/images/*ubuntu-xenial-{16.04}-amd64-server-*",
+									"root-device-type":    "ebs",
+									"virtualization-type": "hvm",
+								},
+								Owners: []string{"099720109477"},
+							},
+							AMIMappings:    []awscommon.FlatBlockDevice{},
+							LaunchMappings: []awscommon.FlatBlockDevice{},
+						},
+					},
+					SourceRef{
+						Type: "amazon-ebs",
+						Name: "that-ubuntu-1.0",
+					}: {
+						Type: "amazon-ebs",
+						Name: "that-ubuntu-1.0",
+						Cfg: &amazonebs.FlatConfig{
+							RawRegion:            strPtr("eu-west-3"),
+							AMIEncryptBootVolume: boolPtr(true),
+							InstanceType:         strPtr("t2.micro"),
+							SourceAmiFilter: &awscommon.FlatAmiFilterOptions{
+								MostRecent: boolPtr(true),
+							},
+							AMIMappings:    []awscommon.FlatBlockDevice{},
+							LaunchMappings: []awscommon.FlatBlockDevice{},
+						},
+					},
+				},
+				Communicators: map[CommunicatorRef]*Communicator{
+					{Type: "ssh", Name: "vagrant"}: {
+						Type: "ssh", Name: "vagrant",
+						Cfg: &communicator.FlatSSH{
+							SSHUsername:               strPtr("vagrant"),
+							SSHPassword:               strPtr("s3cr4t"),
+							SSHClearAuthorizedKeys:    boolPtr(true),
+							SSHHost:                   strPtr("sssssh.hashicorp.io"),
+							SSHHandshakeAttempts:      intPtr(32),
+							SSHPort:                   intPtr(42),
+							SSHFileTransferMethod:     strPtr("scp"),
+							SSHPrivateKeyFile:         strPtr("file.pem"),
+							SSHPty:                    boolPtr(false),
+							SSHTimeout:                strPtr("5m"),
+							SSHAgentAuth:              boolPtr(false),
+							SSHDisableAgentForwarding: boolPtr(true),
+							SSHBastionHost:            strPtr(""),
+							SSHBastionPort:            intPtr(0),
+							SSHBastionAgentAuth:       boolPtr(true),
+							SSHBastionUsername:        strPtr(""),
+							SSHBastionPassword:        strPtr(""),
+							SSHBastionPrivateKeyFile:  strPtr(""),
+							SSHProxyHost:              strPtr("ninja-potatoes.com"),
+							SSHProxyPort:              intPtr(42),
+							SSHProxyUsername:          strPtr("dark-father"),
+							SSHProxyPassword:          strPtr("pickle-rick"),
+							SSHKeepAliveInterval:      strPtr("10s"),
+							SSHReadWriteTimeout:       strPtr("5m"),
+						},
+					},
+				},
+				Variables: PackerV1Variables{
+					"image_name": "foo-image-{{user `my_secret`}}",
+					"key":        "value",
+					"my_secret":  "foo",
+				},
+				Builds: Builds{
+					{
+						Froms: BuildFromList{
+							{
+								Src: SourceRef{"amazon-ebs", "ubuntu-1604"},
+							},
+							{
+								Src: SourceRef{"virtualbox-iso", "ubuntu-1204"},
+							},
+						},
+						ProvisionerGroups: ProvisionerGroups{
+							&ProvisionerGroup{
+								CommunicatorRef: CommunicatorRef{"ssh", "vagrant"},
+								Provisioners: []Provisioner{
+									{Cfg: &shell.FlatConfig{
+										Inline: []string{"echo '{{user `my_secret`}}' :D"},
+									}},
+									{Cfg: &shell.FlatConfig{
+										Scripts:        []string{"script-1.sh", "script-2.sh"},
+										ValidExitCodes: []int{0, 42},
+									}},
+									{Cfg: &file.FlatConfig{
+										Source:      strPtr("app.tar.gz"),
+										Destination: strPtr("/tmp/app.tar.gz"),
+									}},
+								},
+							},
+						},
+						PostProvisionerGroups: ProvisionerGroups{
+							&ProvisionerGroup{
+								Provisioners: []Provisioner{
+									{Cfg: &amazon_import.FlatConfig{
+										Name: strPtr("that-ubuntu-1.0"),
+									}},
+								},
+							},
+						},
+					},
+					&Build{
+						Froms: BuildFromList{
+							{
+								Src: SourceRef{"amazon", "that-ubuntu-1"},
+							},
+						},
+						ProvisionerGroups: ProvisionerGroups{
+							&ProvisionerGroup{
+								Provisioners: []Provisioner{
+									{Cfg: &shell.FlatConfig{
+										Inline: []string{"echo HOLY GUACAMOLE !"},
+									}},
+								},
+							},
+						},
+					},
+				},
+			}, false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotCfg, gotDiags := tt.parser.Parse(tt.args.filename)
+			if tt.wantDiags == (gotDiags == nil) {
+				t.Errorf("Parser.Parse() unexpected diagnostics. %s", gotDiags)
+			}
+			if diff := cmp.Diff(tt.wantCfg, gotCfg,
+				cmpopts.IgnoreUnexported(cty.Value{}),
+				cmpopts.IgnoreTypes(HCL2Ref{}),
+				cmpopts.IgnoreTypes([]hcl.Range{}),
+				cmpopts.IgnoreTypes(hcl.Range{}),
+				cmpopts.IgnoreInterfaces(struct{ hcl.Expression }{}),
+				cmpopts.IgnoreInterfaces(struct{ hcl.Body }{}),
+			); diff != "" {
+				t.Errorf("Parser.Parse() wrong packer config. %s", diff)
+			}
+
+		})
+	}
+}
diff --git a/hcl2template/testdata/build/basic.pkr.hcl b/hcl2template/testdata/build/basic.pkr.hcl
new file mode 100644
index 000000000..c48847c94
--- /dev/null
+++ b/hcl2template/testdata/build/basic.pkr.hcl
@@ -0,0 +1,66 @@
+
+// starts resources to provision them.
+build {
+    from "src.amazon-ebs.ubuntu-1604" {
+        ami_name = "that-ubuntu-1.0"
+    }
+
+    from "src.virtualbox-iso.ubuntu-1204" {
+        // build name is defaulted from the label "src.virtualbox-iso.ubuntu-1204"
+        outout_dir = "path/"
+    }
+
+    provision {
+        communicator = "comm.ssh.vagrant"
+
+        shell {
+            inline = [
+                "echo '{{user `my_secret`}}' :D"
+            ]
+        }
+
+        shell {
+            valid_exit_codes = [
+                0,
+                42,
+            ]
+            scripts = [
+                "script-1.sh",
+                "script-2.sh",
+            ]
+            // override "vmware-iso" { // TODO(azr): handle common fields
+            //     execute_command = "echo 'password' | sudo -S bash {{.Path}}"
+            // }
+        }
+
+        file {
+            source = "app.tar.gz"
+            destination = "/tmp/app.tar.gz"
+            // timeout = "5s" // TODO(azr): handle common fields
+        }
+
+    }
+
+    post_provision {
+        amazon-import {
+            // only = ["src.virtualbox-iso.ubuntu-1204"] // TODO(azr): handle common fields
+            ami_name = "that-ubuntu-1.0"
+        }
+    }
+}
+
+build {
+    // build an ami using the ami from the previous build block.
+    from "src.amazon.that-ubuntu-1.0" {
+        ami_name = "fooooobaaaar"
+    }
+
+    provision {
+
+        shell {
+            inline = [
+                "echo HOLY GUACAMOLE !"
+            ]
+        }
+    }
+}
\ No newline at end of file
diff --git a/hcl2template/testdata/communicator/basic.pkr.hcl b/hcl2template/testdata/communicator/basic.pkr.hcl
new file mode 100644
index 000000000..b752333e9
--- /dev/null
+++ b/hcl2template/testdata/communicator/basic.pkr.hcl
@@ -0,0 +1,27 @@
+
+communicator "ssh" "vagrant" {
+  ssh_password                 = "s3cr4t"
+  ssh_username                 = "vagrant"
+  ssh_agent_auth               = false
+  ssh_bastion_agent_auth       = true
+  ssh_bastion_host             = ""
+  ssh_bastion_password         = ""
+  ssh_bastion_port             = 0
+  ssh_bastion_private_key_file = ""
+  ssh_bastion_username         = ""
+  ssh_clear_authorized_keys    = true
+  ssh_disable_agent_forwarding = true
+  ssh_file_transfer_method     = "scp"
+  ssh_handshake_attempts       = 32
+  ssh_host                     = "sssssh.hashicorp.io"
+  ssh_port                     = 42
+  ssh_keep_alive_interval      = "10s"
+  ssh_private_key_file         = "file.pem"
+  ssh_proxy_host               = "ninja-potatoes.com"
+  ssh_proxy_password           = "pickle-rick"
+  ssh_proxy_port               = "42"
+  ssh_proxy_username           = "dark-father"
+  ssh_pty                      = false
+  ssh_read_write_timeout       = "5m"
+  ssh_timeout                  = "5m"
+}
diff --git a/hcl2template/testdata/complete/build.pkr.hcl b/hcl2template/testdata/complete/build.pkr.hcl
new file mode 120000
index 000000000..bf17682ed
--- /dev/null
+++ b/hcl2template/testdata/complete/build.pkr.hcl
@@ -0,0 +1 @@
+../build/basic.pkr.hcl
\ No newline at end of file
diff --git a/hcl2template/testdata/complete/communicator.pkr.hcl b/hcl2template/testdata/complete/communicator.pkr.hcl
new file mode 120000
index 000000000..2a350af04
--- /dev/null
+++ b/hcl2template/testdata/complete/communicator.pkr.hcl
@@ -0,0 +1 @@
+../communicator/basic.pkr.hcl
\ No newline at end of file
diff --git a/hcl2template/testdata/complete/sources.pkr.hcl b/hcl2template/testdata/complete/sources.pkr.hcl
new file mode 120000
index 000000000..68b98eaa6
--- /dev/null
+++ b/hcl2template/testdata/complete/sources.pkr.hcl
@@ -0,0 +1 @@
+../sources/basic.pkr.hcl
\ No newline at end of file
diff --git a/hcl2template/testdata/complete/subfolder/shouldnotload.pkr.hcl b/hcl2template/testdata/complete/subfolder/shouldnotload.pkr.hcl
new file mode 100644
index 000000000..6f2d3076c
--- /dev/null
+++ b/hcl2template/testdata/complete/subfolder/shouldnotload.pkr.hcl
@@ -0,0 +1,61 @@
+
+// starts resources to provision them.
+build {
+    from "src.amazon-ebs.ubuntu-1604" {
+        ami_name = "that-ubuntu-1.0"
+    }
+
+    from "src.virtualbox-iso.ubuntu-1204" {
+        // build name is defaulted from the label "src.virtualbox-iso.ubuntu-1204"
+        outout_dir = "path/"
+    }
+
+    provision {
+        communicator = comm.ssh.vagrant
+
+        shell {
+            inline = [
+                "echo '{{user `my_secret`}}' :D"
+            ]
+        }
+
+        shell {
+            script = [
+                "script-1.sh",
+                "script-2.sh",
+            ]
+            override "vmware-iso" {
+                execute_command = "echo 'password' | sudo -S bash {{.Path}}"
+            }
+        }
+
+        upload "log.go" "/tmp" {
+            timeout = "5s"
+        }
+
+    }
+
+    post_provision {
+        amazon-import {
+            only = ["src.virtualbox-iso.ubuntu-1204"]
+            ami_name = "that-ubuntu-1.0"
+        }
+    }
+}
+
+build {
+    // build an ami using the ami from the previous build block.
+    from "src.amazon.that-ubuntu-1.0" {
+        ami_name = "fooooobaaaar"
+    }
+
+    provision {
+        communicator = comm.ssh.vagrant
+
+        shell {
+            inline = [
+                "echo HOLY GUACAMOLE !"
+            ]
+        }
+    }
+}
\ No newline at end of file
diff --git a/hcl2template/testdata/complete/variables.pkr.hcl b/hcl2template/testdata/complete/variables.pkr.hcl
new file mode 120000
index 000000000..c8296b22b
--- /dev/null
+++ b/hcl2template/testdata/complete/variables.pkr.hcl
@@ -0,0 +1 @@
+../variables/basic.pkr.hcl
\ No newline at end of file
diff --git a/hcl2template/testdata/sources/basic.pkr.hcl b/hcl2template/testdata/sources/basic.pkr.hcl
new file mode 100644
index 000000000..43e3af082
--- /dev/null
+++ b/hcl2template/testdata/sources/basic.pkr.hcl
@@ -0,0 +1,37 @@
+// a source represents a reusable setting for a system boot/start.
+source "virtualbox-iso" "ubuntu-1204" {
+    iso_url = "http://releases.ubuntu.com/12.04/ubuntu-12.04.5-server-amd64.iso"
+    iso_checksum = "769474248a3897f4865817446f9a4a53"
+    iso_checksum_type = "md5"
+
+    boot_wait = "10s"
+    http_directory = "xxx"
+    boot_command = ["..."]
+
+    shutdown_command = "echo 'vagrant' | sudo -S shutdown -P now"
+}
+
+source "amazon-ebs" "ubuntu-1604" {
+    instance_type = "t2.micro"
+    encrypt_boot = true
+    region = "eu-west-3"
+    source_ami_filter {
+        filters {
+            virtualization-type = "hvm"
+            name = "ubuntu/images/*ubuntu-xenial-{16.04}-amd64-server-*"
+            root-device-type = "ebs"
+        }
+        owners = [
+            "099720109477"
+        ]
+    }
+}
+
+source "amazon-ebs" "that-ubuntu-1.0" {
+    instance_type = "t2.micro"
+    encrypt_boot = true
+    region = "eu-west-3"
+    source_ami_filter {
+        most_recent = true
+    }
+}
diff --git a/hcl2template/testdata/variables/basic.pkr.hcl b/hcl2template/testdata/variables/basic.pkr.hcl
new file mode 100644
index 000000000..d4e651247
--- /dev/null
+++ b/hcl2template/testdata/variables/basic.pkr.hcl
@@ -0,0 +1,6 @@
+
+variables {
+    key = "value"
+    my_secret = "foo"
+    image_name = "foo-image-{{user `my_secret`}}"
+}
diff --git a/hcl2template/types.build.from.go b/hcl2template/types.build.from.go
new file mode 100644
index 000000000..3d1d8d383
--- /dev/null
+++ b/hcl2template/types.build.from.go
@@ -0,0 +1,68 @@
+package hcl2template
+
+import (
+	"strings"
+
+	"github.com/hashicorp/hcl/v2/gohcl"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+type BuildFromList []BuildFrom
+
+type BuildFrom struct {
+	// source to take config from
+	Src SourceRef `hcl:"-"`
+
+	HCL2Ref HCL2Ref
+}
+
+func sourceRefFromString(in string) SourceRef {
+	args := strings.Split(in, ".")
+	if len(args) < 2 {
+		return NoSource
+	}
+	if len(args) > 2 {
+		// src.type.name
+		args = args[1:]
+	}
+	return SourceRef{
+		Type: args[0],
+		Name: args[1],
+	}
+}
+
+func (bf *BuildFrom) decodeConfig(block *hcl.Block) hcl.Diagnostics {
+
+	bf.Src = sourceRefFromString(block.Labels[0])
+	bf.HCL2Ref.DeclRange = block.DefRange
+
+	var b struct {
+		Config hcl.Body `hcl:",remain"`
+	}
+	diags := gohcl.DecodeBody(block.Body, nil, &b)
+
+	if bf.Src == NoSource {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid " + sourceLabel + " reference",
+			Detail: "A " + sourceLabel + " type must start with a letter and " +
+				"may contain only letters, digits, underscores, and dashes." +
+				"A valid source reference looks like: `src.type.name`",
+			Subject: &block.LabelRanges[0],
+		})
+	}
+	if !hclsyntax.ValidIdentifier(bf.Src.Type) ||
+		!hclsyntax.ValidIdentifier(bf.Src.Name) {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid " + sourceLabel + " reference",
+			Detail: "A " + sourceLabel + " type must start with a letter and " +
+				"may contain only letters, digits, underscores, and dashes." +
+				"A valid source reference looks like: `src.type.name`",
+			Subject: &block.LabelRanges[0],
+		})
+	}
+
+	return diags
+}
diff --git a/hcl2template/types.build.go b/hcl2template/types.build.go
new file mode 100644
index 000000000..d758bfc5a
--- /dev/null
+++ b/hcl2template/types.build.go
@@ -0,0 +1,61 @@
+package hcl2template
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+const (
+	buildFromLabel = "from"
+
+	buildProvisionnersLabel = "provision"
+
+	buildPostProvisionnersLabel = "post_provision"
+)
+
+var buildSchema = &hcl.BodySchema{
+	Blocks: []hcl.BlockHeaderSchema{
+		{Type: buildFromLabel, LabelNames: []string{"src"}},
+		{Type: buildProvisionnersLabel},
+		{Type: buildPostProvisionnersLabel},
+	},
+}
+
+type Build struct {
+	// Ordered list of provisioner groups
+	ProvisionerGroups ProvisionerGroups
+
+	// Ordered list of post-provisioner groups
+	PostProvisionerGroups ProvisionerGroups
+
+	// Ordered list of output stanzas
+	Froms BuildFromList
+
+	HCL2Ref HCL2Ref
+}
+
+type Builds []*Build
+
+func (p *Parser) decodeBuildConfig(block *hcl.Block) (*Build, hcl.Diagnostics) {
+	build := &Build{}
+
+	content, diags := block.Body.Content(buildSchema)
+	for _, block := range content.Blocks {
+		switch block.Type {
+		case buildFromLabel:
+			bf := BuildFrom{}
+			moreDiags := bf.decodeConfig(block)
+			diags = append(diags, moreDiags...)
+			build.Froms = append(build.Froms, bf)
+		case buildProvisionnersLabel:
+			pg, moreDiags := p.decodeProvisionerGroup(block, p.ProvisionersSchemas)
+			diags = append(diags, moreDiags...)
+			build.ProvisionerGroups = append(build.ProvisionerGroups, pg)
+		case buildPostProvisionnersLabel:
+			pg, moreDiags := p.decodeProvisionerGroup(block, p.PostProvisionersSchemas)
+			diags = append(diags, moreDiags...)
+			build.PostProvisionerGroups = append(build.PostProvisionerGroups, pg)
+		}
+	}
+
+	return build, diags
+}
diff --git a/hcl2template/types.build.provisioners.go b/hcl2template/types.build.provisioners.go
new file mode 100644
index 000000000..77ec57c99
--- /dev/null
+++ b/hcl2template/types.build.provisioners.go
@@ -0,0 +1,70 @@
+package hcl2template
+
+import (
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/gohcl"
+)
+
+// Provisioner represents a parsed provisioner
+type Provisioner struct {
+	// Cfg is a parsed config
+	Cfg interface{}
+}
+
+type ProvisionerGroup struct {
+	CommunicatorRef CommunicatorRef
+
+	Provisioners []Provisioner
+	HCL2Ref      HCL2Ref
+}
+
+// ProvisionerGroups is a slice of provision blocks; which contains
+// provisioners
+type ProvisionerGroups []*ProvisionerGroup
+
+func (p *Parser) decodeProvisionerGroup(block *hcl.Block, provisionerSpecs map[string]Decodable) (*ProvisionerGroup, hcl.Diagnostics) {
+	var b struct {
+		Communicator string   `hcl:"communicator,optional"`
+		Remain       hcl.Body `hcl:",remain"`
+	}
+
+	diags := gohcl.DecodeBody(block.Body, nil, &b)
+
+	pg := &ProvisionerGroup{}
+	pg.CommunicatorRef = communicatorRefFromString(b.Communicator)
+	pg.HCL2Ref.DeclRange = block.DefRange
+
+	buildSchema := &hcl.BodySchema{
+		Blocks: []hcl.BlockHeaderSchema{},
+	}
+	for k := range provisionerSpecs {
+		buildSchema.Blocks = append(buildSchema.Blocks, hcl.BlockHeaderSchema{
+			Type: k,
+		})
+	}
+
+	content, moreDiags := b.Remain.Content(buildSchema)
+	diags = append(diags, moreDiags...)
+	for _, block := range content.Blocks {
+		provisioner, found := provisionerSpecs[block.Type]
+		if !found {
+			diags = append(diags, &hcl.Diagnostic{
+				Summary: "Unknown " + buildProvisionnersLabel + " type",
+				Subject: &block.LabelRanges[0],
+			})
+			continue
+		}
+		flatProvisinerCfg, moreDiags := decodeDecodable(block, nil, provisioner)
+		diags = append(diags, moreDiags...)
+		pg.Provisioners = append(pg.Provisioners, Provisioner{flatProvisinerCfg})
+	}
+
+	return pg, diags
+}
+
+func (pgs ProvisionerGroups) FirstCommunicatorRef() CommunicatorRef {
+	if len(pgs) == 0 {
+		return NoCommunicator
+	}
+	return pgs[0].CommunicatorRef
+}
diff --git a/hcl2template/types.communicator.go b/hcl2template/types.communicator.go
new file mode 100644
index 000000000..0cc0841c6
--- /dev/null
+++ b/hcl2template/types.communicator.go
@@ -0,0 +1,88 @@
+package hcl2template
+
+import (
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+type Communicator struct {
+	// Type of communicator; ex: ssh
+	Type string
+	// Given name
+	Name string
+
+	Cfg interface{}
+
+	HCL2Ref HCL2Ref
+}
+
+func (communicator *Communicator) Ref() CommunicatorRef {
+	return CommunicatorRef{
+		Type: communicator.Type,
+		Name: communicator.Name,
+	}
+}
+
+func (p *Parser) decodeCommunicatorConfig(block *hcl.Block) (*Communicator, hcl.Diagnostics) {
+
+	output := &Communicator{}
+	output.Type = block.Labels[0]
+	output.Name = block.Labels[1]
+	output.HCL2Ref.DeclRange = block.DefRange
+
+	diags := hcl.Diagnostics{}
+
+	communicator, found := p.CommunicatorSchemas[output.Type]
+	if !found {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Unknown " + communicatorLabel + " type " + output.Type,
+			Detail: "A " + communicatorLabel + " type must start with a letter and " +
+				"may contain only letters, digits, underscores, and dashes.",
+			Subject: &block.DefRange,
+		})
+		return output, diags
+	}
+
+	flatCommunicator, moreDiags := decodeDecodable(block, nil, communicator)
+	diags = append(diags, moreDiags...)
+	output.Cfg = flatCommunicator
+
+	if !hclsyntax.ValidIdentifier(output.Name) {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid " + communicatorLabel + " name",
+			Detail: "A " + communicatorLabel + " type must start with a letter and " +
+				"may contain only letters, digits, underscores, and dashes.",
+			Subject: &block.DefRange,
+		})
+	}
+
+	return output, diags
+}
+
+type CommunicatorRef struct {
+	Type string
+	Name string
+}
+
+// NoCommunicator is the zero value of CommunicatorRef, representing the
+// absense of Communicator.
+var NoCommunicator CommunicatorRef
+
+func communicatorRefFromString(in string) CommunicatorRef {
+	args := strings.Split(in, ".")
+	if len(args) < 2 {
+		return NoCommunicator
+	}
+	if len(args) > 2 {
+		// comm.type.name
+		args = args[1:]
+	}
+	return CommunicatorRef{
+		Type: args[0],
+		Name: args[1],
+	}
+}
diff --git a/hcl2template/types.decodable.go b/hcl2template/types.decodable.go
new file mode 100644
index 000000000..18c7dfe46
--- /dev/null
+++ b/hcl2template/types.decodable.go
@@ -0,0 +1,56 @@
+package hcl2template
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+type Decodable interface {
+	FlatMapstructure() interface{}
+}
+
+type SelfSpecified interface {
+	HCL2Spec() map[string]hcldec.Spec
+}
+
+func decodeDecodable(block *hcl.Block, ctx *hcl.EvalContext, dec Decodable) (interface{}, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	flatCfg := dec.FlatMapstructure()
+	var spec hcldec.ObjectSpec
+	if ss, selfSpecified := flatCfg.(SelfSpecified); selfSpecified {
+		spec = hcldec.ObjectSpec(ss.HCL2Spec())
+	} else {
+		diags = append(diags, &hcl.Diagnostic{
+			Summary: "Unknown type",
+			Subject: &block.DefRange,
+			Detail:  fmt.Sprintf("Cannot get spec from a %T", flatCfg),
+		})
+		return nil, diags
+	}
+	val, moreDiags := hcldec.Decode(block.Body, spec, ctx)
+	diags = append(diags, moreDiags...)
+
+	err := gocty.FromCtyValue(val, flatCfg)
+	if err != nil {
+		switch err := err.(type) {
+		case cty.PathError:
+			diags = append(diags, &hcl.Diagnostic{
+				Summary: "gocty.FromCtyValue: " + err.Error(),
+				Subject: &block.DefRange,
+				Detail:  fmt.Sprintf("%v", err.Path),
+			})
+		default:
+			diags = append(diags, &hcl.Diagnostic{
+				Summary: "gocty.FromCtyValue: " + err.Error(),
+				Subject: &block.DefRange,
+				Detail:  fmt.Sprintf("%v", err),
+			})
+		}
+	}
+	return flatCfg, diags
+}
diff --git a/hcl2template/types.hcl_ref.go b/hcl2template/types.hcl_ref.go
new file mode 100644
index 000000000..06568fb11
--- /dev/null
+++ b/hcl2template/types.hcl_ref.go
@@ -0,0 +1,20 @@
+package hcl2template
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// reference to the source definition in configuration text file
+type HCL2Ref struct {
+	// reference to the source definition in configuration text file
+	DeclRange hcl.Range
+
+	// remainder of unparsed body
+	Remain hcl.Body
+}
+
+// func (hr *HCL2Ref) Blah() {
+// 	// hr.Remain.
+// 	ctyjson.Marshal(nil, nil)
+// 	hr.DeclRange.
+// }
diff --git a/hcl2template/types.packer_config.go b/hcl2template/types.packer_config.go
new file mode 100644
index 000000000..a1d3371e8
--- /dev/null
+++ b/hcl2template/types.packer_config.go
@@ -0,0 +1,165 @@
+package hcl2template
+
+import (
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/packer/template"
+)
+
+// PackerConfig represents a loaded packer config
+type PackerConfig struct {
+	Sources map[SourceRef]*Source
+
+	Variables PackerV1Variables
+
+	Builds Builds
+
+	Communicators map[CommunicatorRef]*Communicator
+}
+
+type PackerV1Build struct {
+	Builders       []*template.Builder
+	Provisioners   []*template.Provisioner
+	PostProcessors []*template.PostProcessor
+}
+
+func (pkrCfg *PackerConfig) ToV1Build() PackerV1Build {
+	var diags hcl.Diagnostics
+	res := PackerV1Build{}
+
+	for _, build := range pkrCfg.Builds {
+		communicator, _ := pkrCfg.Communicators[build.ProvisionerGroups.FirstCommunicatorRef()]
+
+		for _, from := range build.Froms {
+			source, found := pkrCfg.Sources[from.Src]
+			if !found {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unknown " + sourceLabel + " reference",
+					Detail:   "",
+					Subject:  &from.HCL2Ref.DeclRange,
+				})
+
+				continue
+			}
+
+			// provisioners := build.ProvisionerGroups.FlatProvisioners()
+			// postProcessors := build.PostProvisionerGroups.FlatProvisioners()
+
+			_ = from
+			_ = source
+			_ = communicator
+			// _ = provisioners
+			// _ = postProcessors
+		}
+	}
+	return res
+}
+
+func (pkrCfg *PackerConfig) ToTemplate() (*template.Template, error) {
+	var result template.Template
+	// var errs error
+
+	result.Comments = nil
+	result.Variables = pkrCfg.Variables.Variables()
+	// TODO(azr): add sensitive variables
+
+	builder := pkrCfg.ToV1Build()
+	_ = builder
+
+	// // Gather all the post-processors
+	// if len(r.PostProcessors) > 0 {
+	// 	result.PostProcessors = make([][]*PostProcessor, 0, len(r.PostProcessors))
+	// }
+	// for i, v := range r.PostProcessors {
+	// 	// Parse the configurations. We need to do this because post-processors
+	// 	// can take three different formats.
+	// 	configs, err := r.parsePostProcessor(i, v)
+	// 	if err != nil {
+	// 		errs = multierror.Append(errs, err)
+	// 		continue
+	// 	}
+
+	// 	// Parse the PostProcessors out of the configs
+	// 	pps := make([]*PostProcessor, 0, len(configs))
+	// 	for j, c := range configs {
+	// 		var pp PostProcessor
+	// 		if err := r.decoder(&pp, nil).Decode(c); err != nil {
+	// 			errs = multierror.Append(errs, fmt.Errorf(
+	// 				"post-processor %d.%d: %s", i+1, j+1, err))
+	// 			continue
+	// 		}
+
+	// 		// Type is required
+	// 		if pp.Type == "" {
+	// 			errs = multierror.Append(errs, fmt.Errorf(
+	// 				"post-processor %d.%d: type is required", i+1, j+1))
+	// 			continue
+	// 		}
+
+	// 		// Set the raw configuration and delete any special keys
+	// 		pp.Config = c
+
+	// 		// The name defaults to the type if it isn't set
+	// 		if pp.Name == "" {
+	// 			pp.Name = pp.Type
+	// 		}
+
+	// 		delete(pp.Config, "except")
+	// 		delete(pp.Config, "only")
+	// 		delete(pp.Config, "keep_input_artifact")
+	// 		delete(pp.Config, "type")
+	// 		delete(pp.Config, "name")
+
+	// 		if len(pp.Config) == 0 {
+	// 			pp.Config = nil
+	// 		}
+
+	// 		pps = append(pps, &pp)
+	// 	}
+
+	// 	result.PostProcessors = append(result.PostProcessors, pps)
+	// }
+
+	// // Gather all the provisioners
+	// if len(r.Provisioners) > 0 {
+	// 	result.Provisioners = make([]*Provisioner, 0, len(r.Provisioners))
+	// }
+	// for i, v := range r.Provisioners {
+	// 	var p Provisioner
+	// 	if err := r.decoder(&p, nil).Decode(v); err != nil {
+	// 		errs = multierror.Append(errs, fmt.Errorf(
+	// 			"provisioner %d: %s", i+1, err))
+	// 		continue
+	// 	}
+
+	// 	// Type is required before any richer validation
+	// 	if p.Type == "" {
+	// 		errs = multierror.Append(errs, fmt.Errorf(
+	// 			"provisioner %d: missing 'type'", i+1))
+	// 		continue
+	// 	}
+
+	// 	// Set the raw configuration and delete any special keys
+	// 	p.Config = v.(map[string]interface{})
+
+	// 	delete(p.Config, "except")
+	// 	delete(p.Config, "only")
+	// 	delete(p.Config, "override")
+	// 	delete(p.Config, "pause_before")
+	// 	delete(p.Config, "type")
+	// 	delete(p.Config, "timeout")
+
+	// 	if len(p.Config) == 0 {
+	// 		p.Config = nil
+	// 	}
+
+	// 	result.Provisioners = append(result.Provisioners, &p)
+	// }
+
+	// // If we have errors, return those with a nil result
+	// if errs != nil {
+	// 	return nil, errs
+	// }
+
+	return &result, nil
+}
diff --git a/hcl2template/types.source.go b/hcl2template/types.source.go
new file mode 100644
index 000000000..17844b323
--- /dev/null
+++ b/hcl2template/types.source.go
@@ -0,0 +1,113 @@
+package hcl2template
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// A source field in an HCL file will load into the Source type.
+//
+type Source struct {
+	// Type of source; ex: virtualbox-iso
+	Type string
+	// Given name; if any
+	Name string
+
+	Cfg interface{}
+
+	HCL2Ref HCL2Ref
+}
+
+func (p *Parser) decodeSource(block *hcl.Block, sourceSpecs map[string]Decodable) (*Source, hcl.Diagnostics) {
+	source := &Source{
+		Type: block.Labels[0],
+		Name: block.Labels[1],
+	}
+	source.HCL2Ref.DeclRange = block.DefRange
+
+	var diags hcl.Diagnostics
+
+	sourceSpec, found := sourceSpecs[source.Type]
+	if !found {
+		diags = append(diags, &hcl.Diagnostic{
+			Summary: "Unknown " + sourceLabel + " type",
+			Subject: &block.LabelRanges[0],
+		})
+		return source, diags
+	}
+
+	flatSource, moreDiags := decodeDecodable(block, nil, sourceSpec)
+	diags = append(diags, moreDiags...)
+	source.Cfg = flatSource
+
+	return source, diags
+}
+
+func (source *Source) Ref() SourceRef {
+	return SourceRef{
+		Type: source.Type,
+		Name: source.Name,
+	}
+}
+
+type SourceRef struct {
+	Type string
+	Name string
+}
+
+// NoSource is the zero value of sourceRef, representing the absense of an
+// source.
+var NoSource SourceRef
+
+func sourceRefFromAbsTraversal(t hcl.Traversal) (SourceRef, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	if len(t) != 3 {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid " + sourceLabel + " reference",
+			Detail:   "A " + sourceLabel + " reference must have three parts separated by periods: the keyword \"" + sourceLabel + "\", the builder type name, and the source name.",
+			Subject:  t.SourceRange().Ptr(),
+		})
+		return NoSource, diags
+	}
+
+	if t.RootName() != sourceLabel {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid " + sourceLabel + " reference",
+			Detail:   "The first part of an source reference must be the keyword \"" + sourceLabel + "\".",
+			Subject:  t[0].SourceRange().Ptr(),
+		})
+		return NoSource, diags
+	}
+	btStep, ok := t[1].(hcl.TraverseAttr)
+	if !ok {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid " + sourceLabel + " reference",
+			Detail:   "The second part of an " + sourceLabel + " reference must be an identifier giving the builder type of the " + sourceLabel + ".",
+			Subject:  t[1].SourceRange().Ptr(),
+		})
+		return NoSource, diags
+	}
+	nameStep, ok := t[2].(hcl.TraverseAttr)
+	if !ok {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Invalid " + sourceLabel + " reference",
+			Detail:   "The third part of an " + sourceLabel + " reference must be an identifier giving the name of the " + sourceLabel + ".",
+			Subject:  t[2].SourceRange().Ptr(),
+		})
+		return NoSource, diags
+	}
+
+	return SourceRef{
+		Type: btStep.Name,
+		Name: nameStep.Name,
+	}, diags
+}
+
+func (r SourceRef) String() string {
+	return fmt.Sprintf("%s.%s", r.Type, r.Name)
+}
diff --git a/hcl2template/types.variable.go b/hcl2template/types.variable.go
new file mode 100644
index 000000000..e03462ff5
--- /dev/null
+++ b/hcl2template/types.variable.go
@@ -0,0 +1,27 @@
+package hcl2template
+
+import (
+	"github.com/hashicorp/hcl/v2/gohcl"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/packer/template"
+)
+
+type PackerV1Variables map[string]string
+
+// decodeConfig decodes a "variables" section the way packer 1 used to
+func (variables *PackerV1Variables) decodeConfig(block *hcl.Block) hcl.Diagnostics {
+	return gohcl.DecodeBody(block.Body, nil, variables)
+}
+
+func (variables PackerV1Variables) Variables() map[string]*template.Variable {
+	res := map[string]*template.Variable{}
+
+	for k, v := range variables {
+		res[k] = &template.Variable{
+			Key:     k,
+			Default: v,
+		}
+	}
+
+	return res
+}
diff --git a/hcl2template/zz_retrocompat.go b/hcl2template/zz_retrocompat.go
new file mode 100644
index 000000000..2e67b8947
--- /dev/null
+++ b/hcl2template/zz_retrocompat.go
@@ -0,0 +1,156 @@
+package hcl2template
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+)
+
+func translateBuilder(path string) (string, error) {
+
+	type ConfigV1 map[string]json.RawMessage
+
+	type ConfigV1V2 struct {
+		Artifact map[string]map[string]json.RawMessage `json:"artifact"`
+	}
+
+	type Type struct {
+		Name string `json:"name"`
+		Type string `json:"type"`
+	}
+	type PostProcessor struct {
+		Type   string   `json:"type"`
+		Except []string `json:"except"`
+		Only   []string `json:"only"`
+	}
+
+	b, err := ioutil.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+	c1 := ConfigV1{}
+	if err := json.Unmarshal(b, &c1); err != nil {
+		return "", err
+	}
+	c12 := ConfigV1V2{}
+	if err := json.Unmarshal(b, &c12); err != nil {
+		return "", err
+	}
+
+	rawBuilder, found := c1["builders"]
+	if !found {
+		// no v1 builders
+		return path, nil
+	}
+
+	var tn []Type
+	if err := json.Unmarshal([]byte(rawBuilder), &tn); err != nil {
+		return "", err
+	}
+	var rawbuilders []json.RawMessage
+	if err := json.Unmarshal([]byte(rawBuilder), &rawbuilders); err != nil {
+		return "", err
+	}
+
+	var typePPs []PostProcessor
+	var rawPPs []json.RawMessage
+	if rawPP := c1["post-processors"]; len(rawPP) != 0 {
+		if err := json.Unmarshal([]byte(rawPP), &typePPs); err != nil {
+			return "", err
+		}
+		if err := json.Unmarshal([]byte(rawPP), &rawPPs); err != nil {
+			return "", err
+		}
+	}
+
+	for n, tn := range tn {
+		builderName := tn.Type
+		if tn.Name != "" {
+			builderName = tn.Name
+		}
+
+		if c12.Artifact[tn.Type] == nil {
+			c12.Artifact[tn.Type] = map[string]json.RawMessage{}
+		}
+
+		name := tn.Name
+		if name == "" {
+			name = fmt.Sprintf("autotranslated-builder-%d", len(c12.Artifact[tn.Type]))
+		}
+		if _, exists := c12.Artifact[tn.Type][name]; exists {
+			return "", fmt.Errorf("%s-%s is defined in old and new config", tn.Type, name)
+		}
+		rawbuilder := rawbuilders[n]
+		rawbuilder = removeKey(rawbuilder, "name", "only", "type")
+		c12.Artifact[tn.Type][name] = rawbuilder
+
+		for n, pp := range typePPs {
+			skip := false
+			for _, except := range pp.Except {
+				if except == builderName {
+					skip = true
+					break
+				}
+			}
+			for _, only := range pp.Only {
+				if only != builderName {
+					skip = true
+					break
+				}
+			}
+			if skip {
+				continue
+			}
+			if c12.Artifact[pp.Type] == nil {
+				c12.Artifact[pp.Type] = map[string]json.RawMessage{}
+			}
+			name := fmt.Sprintf("autotranslated-post-processor-%d", len(c12.Artifact[pp.Type]))
+			if _, exists := c12.Artifact[tn.Type][name]; exists {
+				return "", fmt.Errorf("%s-%s is defined in old and new config", tn.Type, name)
+			}
+			rawpp := rawPPs[n]
+			rawpp = rawpp[:len(rawpp)-1]
+			rawpp = append(rawpp, json.RawMessage(`,"source":"$artifacts.`+tn.Type+`.`+builderName+`"}`)...)
+			rawpp = removeKey(rawpp, "name", "only", "type")
+			c12.Artifact[pp.Type][name] = rawpp
+
+			log.Printf("%s", rawpp)
+		}
+
+	}
+
+	path = strings.TrimSuffix(path, ".json")
+	path = strings.TrimSuffix(path, ".pk")
+	path = path + ".v2.pk.json"
+
+	file, err := os.Create(path)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	enc := json.NewEncoder(file)
+	enc.SetIndent("", "  ")
+
+	return path, enc.Encode(c12)
+}
+
+func removeKey(in json.RawMessage, keys ...string) json.RawMessage {
+	m := map[string]json.RawMessage{}
+	if err := json.Unmarshal(in, &m); err != nil {
+		panic(err)
+	}
+
+	for _, key := range keys {
+		delete(m, key)
+	}
+
+	b, err := json.Marshal(m)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}

From 8b1fcbb3bd40512cd2f2320705d64d6f483ddcb8 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 16:21:52 +0200
Subject: [PATCH 080/155] vendor vendors

---
 go.mod                                        |    59 +-
 go.sum                                        |   124 +-
 .../ChrisTrenkamp/goxpath/goxpath.go          |     2 +-
 .../goxpath/internal/execxp/execxp.go         |     2 +-
 .../{parser => execxp}/findutil/findUtil.go   |     4 +-
 .../{parser => execxp}/intfns/boolfns.go      |     0
 .../{parser => execxp}/intfns/intfns.go       |     0
 .../{parser => execxp}/intfns/nodesetfns.go   |     0
 .../{parser => execxp}/intfns/numfns.go       |     0
 .../{parser => execxp}/intfns/stringfns.go    |     0
 .../goxpath/internal/execxp/paths.go          |    13 +-
 .../goxpath/{internal => }/lexer/lexer.go     |     0
 .../goxpath/{internal => }/lexer/paths.go     |     2 +-
 .../goxpath/{internal => }/lexer/xmlchars.go  |     0
 .../goxpath/{internal => }/parser/ast.go      |     2 +-
 .../goxpath/{internal => }/parser/parser.go   |     2 +-
 .../parser/pathexpr/pathexpr.go               |     0
 .../goxpath/{internal => }/xconst/xconst.go   |     0
 .../github.com/agext/levenshtein/.gitignore   |    53 +
 .../github.com/agext/levenshtein/.travis.yml  |    25 +
 vendor/github.com/agext/levenshtein/DCO       |    36 +
 .../levenshtein}/LICENSE                      |     3 +-
 .../github.com/agext/levenshtein/MAINTAINERS  |     1 +
 vendor/github.com/agext/levenshtein/NOTICE    |     5 +
 vendor/github.com/agext/levenshtein/README.md |    38 +
 vendor/github.com/agext/levenshtein/go.mod    |     1 +
 .../agext/levenshtein/levenshtein.go          |   290 +
 vendor/github.com/agext/levenshtein/params.go |   152 +
 vendor/github.com/agext/levenshtein/test.sh   |    10 +
 .../aliyun/aliyun-oss-go-sdk/oss/auth.go      |    35 +-
 .../aliyun/aliyun-oss-go-sdk/oss/bucket.go    |   706 +-
 .../aliyun/aliyun-oss-go-sdk/oss/client.go    |   457 +-
 .../aliyun/aliyun-oss-go-sdk/oss/conf.go      |    56 +-
 .../aliyun/aliyun-oss-go-sdk/oss/conn.go      |   311 +-
 .../aliyun/aliyun-oss-go-sdk/oss/const.go     |    98 +-
 .../aliyun/aliyun-oss-go-sdk/oss/crc.go       |    87 +-
 .../aliyun/aliyun-oss-go-sdk/oss/download.go  |   330 +-
 .../aliyun/aliyun-oss-go-sdk/oss/error.go     |    46 +-
 .../aliyun/aliyun-oss-go-sdk/oss/mime.go      |     2 +-
 .../aliyun/aliyun-oss-go-sdk/oss/model.go     |    24 +-
 .../aliyun/aliyun-oss-go-sdk/oss/multicopy.go |   227 +-
 .../aliyun/aliyun-oss-go-sdk/oss/multipart.go |   187 +-
 .../aliyun/aliyun-oss-go-sdk/oss/option.go    |   150 +-
 .../aliyun/aliyun-oss-go-sdk/oss/progress.go  |    25 +-
 .../aliyun-oss-go-sdk/oss/transport_1_6.go    |    26 +
 .../aliyun-oss-go-sdk/oss/transport_1_7.go    |    28 +
 .../aliyun/aliyun-oss-go-sdk/oss/type.go      |   308 +-
 .../aliyun/aliyun-oss-go-sdk/oss/upload.go    |   225 +-
 .../aliyun/aliyun-oss-go-sdk/oss/utils.go     |   150 +-
 vendor/github.com/antchfx/xpath/.travis.yml   |     4 +-
 vendor/github.com/antchfx/xpath/README.md     |    84 +-
 vendor/github.com/antchfx/xpath/build.go      |   164 +-
 vendor/github.com/antchfx/xpath/func.go       |   242 +-
 vendor/github.com/antchfx/xpath/func_go110.go |     9 +
 .../antchfx/xpath/func_pre_go110.go           |    15 +
 vendor/github.com/antchfx/xpath/parse.go      |    50 +-
 vendor/github.com/antchfx/xpath/query.go      |    71 +-
 vendor/github.com/antchfx/xpath/xpath.go      |     3 +
 vendor/github.com/antchfx/xquery/xml/node.go  |    27 +-
 .../apparentlymart/go-textseg/LICENSE         |    95 +
 .../go-textseg/textseg/all_tokens.go          |    30 +
 .../go-textseg/textseg/generate.go            |     7 +
 .../go-textseg/textseg/grapheme_clusters.go   |  5276 ++
 .../go-textseg/textseg/grapheme_clusters.rl   |   132 +
 .../textseg/grapheme_clusters_table.rl        |  1583 +
 .../go-textseg/textseg/tables.go              |  5700 ++
 .../go-textseg/textseg/unicode2ragel.rb       |   335 +
 .../go-textseg/textseg/utf8_seqs.go           |    19 +
 vendor/github.com/dylanmei/winrmtest/go.mod   |    11 +
 vendor/github.com/dylanmei/winrmtest/go.sum   |    17 +
 .../google/go-cmp/cmp/cmpopts/equate.go       |    89 +
 .../google/go-cmp/cmp/cmpopts/ignore.go       |   207 +
 .../google/go-cmp/cmp/cmpopts/sort.go         |   147 +
 .../go-cmp/cmp/cmpopts/struct_filter.go       |   182 +
 .../google/go-cmp/cmp/cmpopts/xform.go        |    35 +
 vendor/github.com/google/uuid/go.mod          |     1 +
 vendor/github.com/google/uuid/node.go         |     1 +
 vendor/github.com/google/uuid/uuid.go         |    73 +-
 .../utils/openstack/clientconfig/requests.go  |     6 +-
 .../utils/openstack/clientconfig/results.go   |    62 +-
 .../github.com/gorilla/websocket/.gitignore   |     2 +-
 .../github.com/gorilla/websocket/.travis.yml  |    10 +-
 vendor/github.com/gorilla/websocket/AUTHORS   |     1 +
 vendor/github.com/gorilla/websocket/README.md |     2 +-
 vendor/github.com/gorilla/websocket/client.go |   253 +-
 vendor/github.com/gorilla/websocket/conn.go   |   174 +-
 .../gorilla/websocket/conn_read_legacy.go     |    21 -
 .../websocket/{conn_read.go => conn_write.go} |    15 +-
 .../gorilla/websocket/conn_write_legacy.go    |    18 +
 vendor/github.com/gorilla/websocket/doc.go    |    56 +-
 vendor/github.com/gorilla/websocket/json.go   |    11 +-
 vendor/github.com/gorilla/websocket/mask.go   |     1 -
 .../github.com/gorilla/websocket/prepared.go  |     1 -
 vendor/github.com/gorilla/websocket/proxy.go  |    77 +
 vendor/github.com/gorilla/websocket/server.go |   136 +-
 vendor/github.com/gorilla/websocket/trace.go  |    19 +
 .../github.com/gorilla/websocket/trace_17.go  |    12 +
 vendor/github.com/gorilla/websocket/util.go   |    35 +-
 .../gorilla/websocket/x_net_proxy.go          |   473 +
 .../go-checkpoint/{checkpoint.go => check.go} |   154 +-
 .../github.com/hashicorp/go-checkpoint/go.mod |     6 +
 .../github.com/hashicorp/go-checkpoint/go.sum |     4 +
 .../hashicorp/go-checkpoint/telemetry.go      |   118 +
 .../hashicorp/go-checkpoint/versions.go       |    90 +
 .../github.com/hashicorp/go-getter/get_git.go |     3 +
 .../github.com/hashicorp/go-rootcerts/go.mod  |     3 +
 .../github.com/hashicorp/go-rootcerts/go.sum  |     2 +
 .../github.com/hashicorp/hcl/v2/CHANGELOG.md  |    23 +
 vendor/github.com/hashicorp/hcl/v2/LICENSE    |   353 +
 vendor/github.com/hashicorp/hcl/v2/README.md  |   204 +
 .../github.com/hashicorp/hcl/v2/diagnostic.go |   143 +
 .../hashicorp/hcl/v2/diagnostic_text.go       |   311 +
 .../github.com/hashicorp/hcl/v2/didyoumean.go |    24 +
 vendor/github.com/hashicorp/hcl/v2/doc.go     |    34 +
 .../hashicorp/hcl/v2/eval_context.go          |    25 +
 .../github.com/hashicorp/hcl/v2/expr_call.go  |    46 +
 .../github.com/hashicorp/hcl/v2/expr_list.go  |    37 +
 .../github.com/hashicorp/hcl/v2/expr_map.go   |    44 +
 .../hashicorp/hcl/v2/expr_unwrap.go           |    68 +
 vendor/github.com/hashicorp/hcl/v2/go.mod     |    21 +
 vendor/github.com/hashicorp/hcl/v2/go.sum     |    51 +
 .../hashicorp/hcl/v2/gohcl/decode.go          |   304 +
 .../github.com/hashicorp/hcl/v2/gohcl/doc.go  |    53 +
 .../hashicorp/hcl/v2/gohcl/encode.go          |   191 +
 .../hashicorp/hcl/v2/gohcl/schema.go          |   174 +
 .../hashicorp/hcl/v2/gohcl/types.go           |    16 +
 .../hashicorp/hcl/v2/hcldec/block_labels.go   |    21 +
 .../hashicorp/hcl/v2/hcldec/decode.go         |    36 +
 .../github.com/hashicorp/hcl/v2/hcldec/doc.go |    12 +
 .../github.com/hashicorp/hcl/v2/hcldec/gob.go |    23 +
 .../hashicorp/hcl/v2/hcldec/public.go         |    81 +
 .../hashicorp/hcl/v2/hcldec/schema.go         |    36 +
 .../hashicorp/hcl/v2/hcldec/spec.go           |  1567 +
 .../hashicorp/hcl/v2/hcldec/variables.go      |    36 +
 .../hashicorp/hcl/v2/hclparse/parser.go       |   135 +
 .../hashicorp/hcl/v2/hclsyntax/diagnostics.go |    23 +
 .../hashicorp/hcl/v2/hclsyntax/didyoumean.go  |    24 +
 .../hashicorp/hcl/v2/hclsyntax/doc.go         |     7 +
 .../hashicorp/hcl/v2/hclsyntax/expression.go  |  1477 +
 .../hcl/v2/hclsyntax/expression_ops.go        |   268 +
 .../hcl/v2/hclsyntax/expression_template.go   |   220 +
 .../hcl/v2/hclsyntax/expression_vars.go       |    76 +
 .../hashicorp/hcl/v2/hclsyntax/file.go        |    20 +
 .../hashicorp/hcl/v2/hclsyntax/generate.go    |     9 +
 .../hashicorp/hcl/v2/hclsyntax/keywords.go    |    21 +
 .../hashicorp/hcl/v2/hclsyntax/navigation.go  |    59 +
 .../hashicorp/hcl/v2/hclsyntax/node.go        |    22 +
 .../hashicorp/hcl/v2/hclsyntax/parser.go      |  2054 +
 .../hcl/v2/hclsyntax/parser_template.go       |   799 +
 .../hcl/v2/hclsyntax/parser_traversal.go      |   159 +
 .../hashicorp/hcl/v2/hclsyntax/peeker.go      |   212 +
 .../hashicorp/hcl/v2/hclsyntax/public.go      |   171 +
 .../hcl/v2/hclsyntax/scan_string_lit.go       |   301 +
 .../hcl/v2/hclsyntax/scan_string_lit.rl       |   105 +
 .../hashicorp/hcl/v2/hclsyntax/scan_tokens.go |  5265 ++
 .../hashicorp/hcl/v2/hclsyntax/scan_tokens.rl |   395 +
 .../hashicorp/hcl/v2/hclsyntax/spec.md        |   941 +
 .../hashicorp/hcl/v2/hclsyntax/structure.go   |   394 +
 .../hcl/v2/hclsyntax/structure_at_pos.go      |   118 +
 .../hashicorp/hcl/v2/hclsyntax/token.go       |   320 +
 .../hcl/v2/hclsyntax/token_type_string.go     |   131 +
 .../hcl/v2/hclsyntax/unicode2ragel.rb         |   335 +
 .../hcl/v2/hclsyntax/unicode_derived.rl       |  2135 +
 .../hashicorp/hcl/v2/hclsyntax/variables.go   |    86 +
 .../hashicorp/hcl/v2/hclsyntax/walk.go        |    41 +
 .../hashicorp/hcl/v2/hclwrite/ast.go          |   121 +
 .../hcl/v2/hclwrite/ast_attribute.go          |    48 +
 .../hashicorp/hcl/v2/hclwrite/ast_block.go    |   118 +
 .../hashicorp/hcl/v2/hclwrite/ast_body.go     |   219 +
 .../hcl/v2/hclwrite/ast_expression.go         |   201 +
 .../hashicorp/hcl/v2/hclwrite/doc.go          |    11 +
 .../hashicorp/hcl/v2/hclwrite/format.go       |   463 +
 .../hashicorp/hcl/v2/hclwrite/generate.go     |   250 +
 .../hcl/v2/hclwrite/native_node_sorter.go     |    23 +
 .../hashicorp/hcl/v2/hclwrite/node.go         |   260 +
 .../hashicorp/hcl/v2/hclwrite/parser.go       |   599 +
 .../hashicorp/hcl/v2/hclwrite/public.go       |    44 +
 .../hashicorp/hcl/v2/hclwrite/tokens.go       |   122 +
 .../github.com/hashicorp/hcl/v2/json/ast.go   |   121 +
 .../hashicorp/hcl/v2/json/didyoumean.go       |    33 +
 .../github.com/hashicorp/hcl/v2/json/doc.go   |    12 +
 .../hashicorp/hcl/v2/json/navigation.go       |    70 +
 .../hashicorp/hcl/v2/json/parser.go           |   496 +
 .../hashicorp/hcl/v2/json/peeker.go           |    25 +
 .../hashicorp/hcl/v2/json/public.go           |    94 +
 .../hashicorp/hcl/v2/json/scanner.go          |   297 +
 .../github.com/hashicorp/hcl/v2/json/spec.md  |   405 +
 .../hashicorp/hcl/v2/json/structure.go        |   637 +
 .../hashicorp/hcl/v2/json/tokentype_string.go |    29 +
 vendor/github.com/hashicorp/hcl/v2/merged.go  |   226 +
 vendor/github.com/hashicorp/hcl/v2/ops.go     |   288 +
 vendor/github.com/hashicorp/hcl/v2/pos.go     |   275 +
 .../hashicorp/hcl/v2/pos_scanner.go           |   152 +
 vendor/github.com/hashicorp/hcl/v2/schema.go  |    21 +
 vendor/github.com/hashicorp/hcl/v2/spec.md    |   691 +
 .../hashicorp/hcl/v2/static_expr.go           |    40 +
 .../github.com/hashicorp/hcl/v2/structure.go  |   151 +
 .../hashicorp/hcl/v2/structure_at_pos.go      |   117 +
 .../github.com/hashicorp/hcl/v2/traversal.go  |   293 +
 .../hashicorp/hcl/v2/traversal_for_expr.go    |   124 +
 vendor/github.com/kardianos/osext/go.mod      |     1 +
 .../azure-sdk-for-go/core/http/chunked.go     |   203 -
 .../azure-sdk-for-go/core/http/client.go      |   487 -
 .../azure-sdk-for-go/core/http/cookie.go      |   363 -
 .../azure-sdk-for-go/core/http/doc.go         |    80 -
 .../core/http/filetransport.go                |   123 -
 .../azure-sdk-for-go/core/http/fs.go          |   549 -
 .../azure-sdk-for-go/core/http/header.go      |   211 -
 .../azure-sdk-for-go/core/http/jar.go         |    27 -
 .../azure-sdk-for-go/core/http/lex.go         |    96 -
 .../azure-sdk-for-go/core/http/race.go        |    11 -
 .../azure-sdk-for-go/core/http/request.go     |   875 -
 .../azure-sdk-for-go/core/http/response.go    |   291 -
 .../azure-sdk-for-go/core/http/server.go      |  2052 -
 .../azure-sdk-for-go/core/http/sniff.go       |   214 -
 .../azure-sdk-for-go/core/http/status.go      |   120 -
 .../azure-sdk-for-go/core/http/transfer.go    |   730 -
 .../azure-sdk-for-go/core/http/transport.go   |  1208 -
 .../azure-sdk-for-go/core/tls/alert.go        |    77 -
 .../core/tls/cipher_suites.go                 |   270 -
 .../azure-sdk-for-go/core/tls/common.go       |   438 -
 .../azure-sdk-for-go/core/tls/conn.go         |  1026 -
 .../core/tls/handshake_client.go              |   411 -
 .../core/tls/handshake_messages.go            |  1304 -
 .../core/tls/handshake_server.go              |   638 -
 .../core/tls/key_agreement.go                 |   400 -
 .../azure-sdk-for-go/core/tls/prf.go          |   291 -
 .../azure-sdk-for-go/core/tls/ticket.go       |   182 -
 .../azure-sdk-for-go/core/tls/tls.go          |   225 -
 vendor/github.com/masterzen/winrm/.travis.yml |     2 -
 vendor/github.com/masterzen/winrm/README.md   |    40 +
 vendor/github.com/masterzen/winrm/auth.go     |    26 +-
 vendor/github.com/masterzen/winrm/client.go   |     2 +-
 vendor/github.com/masterzen/winrm/go.mod      |    13 +
 vendor/github.com/masterzen/winrm/go.sum      |    21 +
 vendor/github.com/masterzen/winrm/http.go     |    23 +-
 vendor/github.com/masterzen/winrm/ntlm.go     |    10 +
 .../github.com/masterzen/winrm/parameters.go  |     3 +
 .../mattn/go-colorable/colorable_windows.go   |   214 +-
 vendor/github.com/mattn/go-colorable/go.mod   |     3 +
 vendor/github.com/mattn/go-colorable/go.sum   |     4 +
 vendor/github.com/mattn/go-isatty/go.mod      |     3 +
 vendor/github.com/mattn/go-isatty/go.sum      |     2 +
 .../mattn/go-isatty/isatty_appengine.go       |    15 -
 .../github.com/mattn/go-isatty/isatty_bsd.go  |     6 +
 .../mattn/go-isatty/isatty_linux.go           |    20 +-
 .../mattn/go-isatty/isatty_linux_ppc64x.go    |    19 -
 .../mattn/go-isatty/isatty_others.go          |    11 +-
 .../mattn/go-isatty/isatty_solaris.go         |     6 +
 .../mitchellh/go-homedir/homedir.go           |    10 +
 .../mitchellh/go-wordwrap/LICENSE.md          |    21 +
 .../mitchellh/go-wordwrap/README.md           |    39 +
 .../github.com/mitchellh/go-wordwrap/go.mod   |     1 +
 .../mitchellh/go-wordwrap/wordwrap.go         |    73 +
 vendor/github.com/mitchellh/panicwrap/go.mod  |     3 +
 vendor/github.com/mitchellh/panicwrap/go.sum  |     2 +
 vendor/github.com/mitchellh/prefixedio/go.mod |     1 +
 vendor/github.com/posener/complete/.gitignore |     2 +
 .../github.com/posener/complete/.travis.yml   |     7 +-
 vendor/github.com/posener/complete/args.go    |     9 +
 vendor/github.com/posener/complete/cmd/cmd.go |     2 +-
 .../posener/complete/cmd/install/fish.go      |    18 +-
 .../posener/complete/cmd/install/install.go   |     2 +-
 .../posener/complete/cmd/install/utils.go     |     5 +-
 .../github.com/posener/complete/complete.go   |    30 +-
 vendor/github.com/posener/complete/go.mod     |     3 +
 vendor/github.com/posener/complete/go.sum     |     4 +
 vendor/github.com/posener/complete/log.go     |     3 +-
 .../posener/complete/metalinter.json          |    21 -
 vendor/github.com/posener/complete/readme.md  |     1 +
 vendor/github.com/ugorji/go/codec/0doc.go     |   173 +-
 vendor/github.com/ugorji/go/codec/README.md   |    88 +-
 vendor/github.com/ugorji/go/codec/binc.go     |   472 +-
 vendor/github.com/ugorji/go/codec/build.sh    |   220 +
 vendor/github.com/ugorji/go/codec/cbor.go     |   357 +-
 vendor/github.com/ugorji/go/codec/decode.go   |  2777 +-
 vendor/github.com/ugorji/go/codec/encode.go   |  1719 +-
 .../ugorji/go/codec/fast-path.generated.go    | 45077 +++++++---------
 .../ugorji/go/codec/fast-path.go.tmpl         |   614 +-
 .../ugorji/go/codec/fast-path.not.go          |    19 +-
 .../ugorji/go/codec/gen-dec-array.go.tmpl     |   108 +-
 .../ugorji/go/codec/gen-dec-map.go.tmpl       |    42 +-
 .../ugorji/go/codec/gen-enc-chan.go.tmpl      |    27 +
 .../ugorji/go/codec/gen-helper.generated.go   |   272 +-
 .../ugorji/go/codec/gen-helper.go.tmpl        |   411 +-
 .../ugorji/go/codec/gen.generated.go          |   181 +-
 vendor/github.com/ugorji/go/codec/gen.go      |  1228 +-
 .../go/codec/goversion_arrayof_gte_go15.go    |    14 +
 .../go/codec/goversion_arrayof_lt_go15.go     |    14 +
 .../go/codec/goversion_makemap_gte_go19.go    |    15 +
 .../go/codec/goversion_makemap_lt_go19.go     |    12 +
 ...version_unexportedembeddedptr_gte_go110.go |     8 +
 ...oversion_unexportedembeddedptr_lt_go110.go |     8 +
 .../go/codec/goversion_unsupported_lt_go14.go |    17 +
 .../go/codec/goversion_vendor_eq_go15.go      |    10 +
 .../go/codec/goversion_vendor_eq_go16.go      |    10 +
 .../go/codec/goversion_vendor_gte_go17.go     |     8 +
 .../go/codec/goversion_vendor_lt_go15.go      |     8 +
 vendor/github.com/ugorji/go/codec/helper.go   |  2081 +-
 .../ugorji/go/codec/helper_internal.go        |   139 +-
 .../ugorji/go/codec/helper_not_unsafe.go      |   256 +-
 .../ugorji/go/codec/helper_unsafe.go          |   624 +-
 vendor/github.com/ugorji/go/codec/json.go     |  1840 +-
 .../ugorji/go/codec/mammoth-test.go.tmpl      |   154 +
 .../ugorji/go/codec/mammoth2-test.go.tmpl     |    94 +
 vendor/github.com/ugorji/go/codec/msgpack.go  |   471 +-
 vendor/github.com/ugorji/go/codec/noop.go     |   213 -
 vendor/github.com/ugorji/go/codec/prebuild.go |     3 -
 vendor/github.com/ugorji/go/codec/prebuild.sh |   199 -
 vendor/github.com/ugorji/go/codec/rpc.go      |   200 +-
 vendor/github.com/ugorji/go/codec/simple.go   |   295 +-
 vendor/github.com/ugorji/go/codec/test.py     |     8 +-
 vendor/github.com/ugorji/go/codec/tests.sh    |    80 -
 vendor/github.com/ugorji/go/codec/time.go     |   233 -
 vendor/github.com/zclconf/go-cty/LICENSE      |    21 +
 .../github.com/zclconf/go-cty/cty/capsule.go  |    89 +
 .../zclconf/go-cty/cty/collection.go          |    34 +
 .../go-cty/cty/convert/compare_types.go       |   165 +
 .../zclconf/go-cty/cty/convert/conversion.go  |   143 +
 .../cty/convert/conversion_collection.go      |   340 +
 .../go-cty/cty/convert/conversion_dynamic.go  |    33 +
 .../go-cty/cty/convert/conversion_object.go   |    76 +
 .../cty/convert/conversion_primitive.go       |    48 +
 .../go-cty/cty/convert/conversion_tuple.go    |    71 +
 .../zclconf/go-cty/cty/convert/doc.go         |    15 +
 .../go-cty/cty/convert/mismatch_msg.go        |   220 +
 .../zclconf/go-cty/cty/convert/public.go      |    83 +
 .../zclconf/go-cty/cty/convert/sort_types.go  |    69 +
 .../zclconf/go-cty/cty/convert/unify.go       |   314 +
 vendor/github.com/zclconf/go-cty/cty/doc.go   |    18 +
 .../zclconf/go-cty/cty/element_iterator.go    |   191 +
 vendor/github.com/zclconf/go-cty/cty/error.go |    55 +
 .../zclconf/go-cty/cty/function/argument.go   |    50 +
 .../zclconf/go-cty/cty/function/doc.go        |     6 +
 .../zclconf/go-cty/cty/function/error.go      |    50 +
 .../zclconf/go-cty/cty/function/function.go   |   291 +
 .../go-cty/cty/function/stdlib/bool.go        |    73 +
 .../go-cty/cty/function/stdlib/bytes.go       |   112 +
 .../go-cty/cty/function/stdlib/collection.go  |   140 +
 .../zclconf/go-cty/cty/function/stdlib/csv.go |    93 +
 .../go-cty/cty/function/stdlib/datetime.go    |   385 +
 .../zclconf/go-cty/cty/function/stdlib/doc.go |    13 +
 .../go-cty/cty/function/stdlib/format.go      |   501 +
 .../go-cty/cty/function/stdlib/format_fsm.go  |   374 +
 .../go-cty/cty/function/stdlib/format_fsm.rl  |   198 +
 .../go-cty/cty/function/stdlib/general.go     |   107 +
 .../go-cty/cty/function/stdlib/json.go        |    72 +
 .../go-cty/cty/function/stdlib/number.go      |   428 +
 .../go-cty/cty/function/stdlib/regexp.go      |   233 +
 .../go-cty/cty/function/stdlib/sequence.go    |   218 +
 .../zclconf/go-cty/cty/function/stdlib/set.go |   195 +
 .../go-cty/cty/function/stdlib/string.go      |   234 +
 .../go-cty/cty/function/unpredictable.go      |    31 +
 vendor/github.com/zclconf/go-cty/cty/gob.go   |   125 +
 .../zclconf/go-cty/cty/gocty/doc.go           |     7 +
 .../zclconf/go-cty/cty/gocty/helpers.go       |    43 +
 .../github.com/zclconf/go-cty/cty/gocty/in.go |   548 +
 .../zclconf/go-cty/cty/gocty/out.go           |   686 +
 .../zclconf/go-cty/cty/gocty/type_implied.go  |   108 +
 .../github.com/zclconf/go-cty/cty/helper.go   |    99 +
 vendor/github.com/zclconf/go-cty/cty/json.go  |   176 +
 .../github.com/zclconf/go-cty/cty/json/doc.go |    11 +
 .../zclconf/go-cty/cty/json/marshal.go        |   189 +
 .../zclconf/go-cty/cty/json/simple.go         |    41 +
 .../zclconf/go-cty/cty/json/type.go           |    23 +
 .../zclconf/go-cty/cty/json/type_implied.go   |   170 +
 .../zclconf/go-cty/cty/json/unmarshal.go      |   459 +
 .../zclconf/go-cty/cty/json/value.go          |    65 +
 .../zclconf/go-cty/cty/list_type.go           |    74 +
 .../github.com/zclconf/go-cty/cty/map_type.go |    74 +
 vendor/github.com/zclconf/go-cty/cty/null.go  |    14 +
 .../zclconf/go-cty/cty/object_type.go         |   135 +
 vendor/github.com/zclconf/go-cty/cty/path.go  |   250 +
 .../github.com/zclconf/go-cty/cty/path_set.go |   198 +
 .../zclconf/go-cty/cty/primitive_type.go      |   122 +
 .../github.com/zclconf/go-cty/cty/set/gob.go  |    76 +
 .../zclconf/go-cty/cty/set/iterator.go        |    15 +
 .../github.com/zclconf/go-cty/cty/set/ops.go  |   210 +
 .../zclconf/go-cty/cty/set/rules.go           |    43 +
 .../github.com/zclconf/go-cty/cty/set/set.go  |    62 +
 .../zclconf/go-cty/cty/set_helper.go          |   126 +
 .../zclconf/go-cty/cty/set_internals.go       |   216 +
 .../github.com/zclconf/go-cty/cty/set_type.go |    72 +
 .../zclconf/go-cty/cty/tuple_type.go          |   121 +
 vendor/github.com/zclconf/go-cty/cty/type.go  |   120 +
 .../zclconf/go-cty/cty/type_conform.go        |   139 +
 .../zclconf/go-cty/cty/types_to_register.go   |    57 +
 .../github.com/zclconf/go-cty/cty/unknown.go  |    84 +
 .../zclconf/go-cty/cty/unknown_as_null.go     |    64 +
 vendor/github.com/zclconf/go-cty/cty/value.go |    98 +
 .../zclconf/go-cty/cty/value_init.go          |   314 +
 .../zclconf/go-cty/cty/value_ops.go           |  1138 +
 vendor/github.com/zclconf/go-cty/cty/walk.go  |   182 +
 vendor/golang.org/x/crypto/ed25519/ed25519.go |     5 +
 .../x/crypto/ed25519/ed25519_go113.go         |    73 +
 .../x/crypto/internal/chacha20/asm_ppc64le.s  |     2 +-
 .../internal/chacha20/chacha_ppc64le.go       |     7 +-
 vendor/golang.org/x/crypto/ssh/common.go      |     7 +
 vendor/golang.org/x/crypto/ssh/kex.go         |   249 +
 vendor/golang.org/x/crypto/ssh/messages.go    |    30 +
 vendor/golang.org/x/crypto/ssh/server.go      |     6 +
 .../golang.org/x/sys/unix/affinity_linux.go   |     8 +-
 vendor/golang.org/x/sys/unix/dirent.go        |    91 +-
 vendor/golang.org/x/sys/unix/endian_little.go |     2 +-
 vendor/golang.org/x/sys/unix/mkerrors.sh      |     3 +
 vendor/golang.org/x/sys/unix/syscall_aix.go   |    16 +
 .../golang.org/x/sys/unix/syscall_darwin.go   |    12 +
 .../x/sys/unix/syscall_dragonfly.go           |    16 +
 .../golang.org/x/sys/unix/syscall_freebsd.go  |    12 +
 vendor/golang.org/x/sys/unix/syscall_linux.go |    16 +
 .../golang.org/x/sys/unix/syscall_netbsd.go   |    12 +
 .../golang.org/x/sys/unix/syscall_openbsd.go  |    12 +
 .../golang.org/x/sys/unix/syscall_solaris.go  |    16 +
 .../x/sys/unix/zerrors_linux_386.go           |    34 +
 .../x/sys/unix/zerrors_linux_amd64.go         |    34 +
 .../x/sys/unix/zerrors_linux_arm.go           |    34 +
 .../x/sys/unix/zerrors_linux_arm64.go         |    34 +
 .../x/sys/unix/zerrors_linux_mips.go          |    34 +
 .../x/sys/unix/zerrors_linux_mips64.go        |    34 +
 .../x/sys/unix/zerrors_linux_mips64le.go      |    34 +
 .../x/sys/unix/zerrors_linux_mipsle.go        |    34 +
 .../x/sys/unix/zerrors_linux_ppc64.go         |    34 +
 .../x/sys/unix/zerrors_linux_ppc64le.go       |    34 +
 .../x/sys/unix/zerrors_linux_riscv64.go       |    34 +
 .../x/sys/unix/zerrors_linux_s390x.go         |    34 +
 .../x/sys/unix/zerrors_linux_sparc64.go       |    34 +
 .../x/sys/unix/zsysnum_linux_386.go           |     6 +
 .../x/sys/unix/zsysnum_linux_amd64.go         |     6 +
 .../x/sys/unix/zsysnum_linux_arm.go           |     6 +
 .../x/sys/unix/zsysnum_linux_arm64.go         |     6 +
 .../x/sys/unix/zsysnum_linux_mips.go          |     6 +
 .../x/sys/unix/zsysnum_linux_mips64.go        |     6 +
 .../x/sys/unix/zsysnum_linux_mips64le.go      |     6 +
 .../x/sys/unix/zsysnum_linux_mipsle.go        |     6 +
 .../x/sys/unix/zsysnum_linux_ppc64.go         |     6 +
 .../x/sys/unix/zsysnum_linux_ppc64le.go       |     6 +
 .../x/sys/unix/zsysnum_linux_riscv64.go       |     6 +
 .../x/sys/unix/zsysnum_linux_s390x.go         |     6 +
 .../x/sys/unix/zsysnum_linux_sparc64.go       |     6 +
 .../golang.org/x/sys/unix/ztypes_linux_386.go |    37 +
 .../x/sys/unix/ztypes_linux_amd64.go          |    38 +
 .../golang.org/x/sys/unix/ztypes_linux_arm.go |    37 +
 .../x/sys/unix/ztypes_linux_arm64.go          |    38 +
 .../x/sys/unix/ztypes_linux_mips.go           |    37 +
 .../x/sys/unix/ztypes_linux_mips64.go         |    38 +
 .../x/sys/unix/ztypes_linux_mips64le.go       |    38 +
 .../x/sys/unix/ztypes_linux_mipsle.go         |    37 +
 .../x/sys/unix/ztypes_linux_ppc64.go          |    38 +
 .../x/sys/unix/ztypes_linux_ppc64le.go        |    38 +
 .../x/sys/unix/ztypes_linux_riscv64.go        |    38 +
 .../x/sys/unix/ztypes_linux_s390x.go          |    38 +
 .../x/sys/unix/ztypes_linux_sparc64.go        |    38 +
 vendor/golang.org/x/sys/windows/service.go    |     4 +
 .../golang.org/x/sys/windows/types_windows.go |     7 +-
 vendor/golang.org/x/tools/AUTHORS             |     3 +
 vendor/golang.org/x/tools/CONTRIBUTORS        |     3 +
 vendor/golang.org/x/tools/LICENSE             |    27 +
 vendor/golang.org/x/tools/PATENTS             |    22 +
 .../x/tools/go/gcexportdata/gcexportdata.go   |   109 +
 .../x/tools/go/gcexportdata/importer.go       |    73 +
 .../x/tools/go/internal/gcimporter/bexport.go |   852 +
 .../x/tools/go/internal/gcimporter/bimport.go |  1036 +
 .../go/internal/gcimporter/exportdata.go      |    93 +
 .../go/internal/gcimporter/gcimporter.go      |  1078 +
 .../x/tools/go/internal/gcimporter/iexport.go |   723 +
 .../x/tools/go/internal/gcimporter/iimport.go |   606 +
 .../go/internal/gcimporter/newInterface10.go  |    21 +
 .../go/internal/gcimporter/newInterface11.go  |    13 +
 .../tools/go/internal/packagesdriver/sizes.go |   160 +
 vendor/golang.org/x/tools/go/packages/doc.go  |   222 +
 .../x/tools/go/packages/external.go           |    79 +
 .../golang.org/x/tools/go/packages/golist.go  |   870 +
 .../x/tools/go/packages/golist_overlay.go     |   300 +
 .../x/tools/go/packages/packages.go           |  1075 +
 .../golang.org/x/tools/go/packages/visit.go   |    55 +
 .../x/tools/internal/fastwalk/fastwalk.go     |   196 +
 .../fastwalk/fastwalk_dirent_fileno.go        |    13 +
 .../internal/fastwalk/fastwalk_dirent_ino.go  |    14 +
 .../fastwalk/fastwalk_dirent_namlen_bsd.go    |    13 +
 .../fastwalk/fastwalk_dirent_namlen_linux.go  |    29 +
 .../internal/fastwalk/fastwalk_portable.go    |    37 +
 .../tools/internal/fastwalk/fastwalk_unix.go  |   127 +
 .../x/tools/internal/gopathwalk/walk.go       |   250 +
 .../x/tools/internal/semver/semver.go         |   388 +
 vendor/modules.txt                            |    90 +-
 485 files changed, 99277 insertions(+), 45870 deletions(-)
 rename vendor/github.com/ChrisTrenkamp/goxpath/internal/{parser => execxp}/findutil/findUtil.go (98%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/internal/{parser => execxp}/intfns/boolfns.go (100%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/internal/{parser => execxp}/intfns/intfns.go (100%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/internal/{parser => execxp}/intfns/nodesetfns.go (100%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/internal/{parser => execxp}/intfns/numfns.go (100%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/internal/{parser => execxp}/intfns/stringfns.go (100%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/{internal => }/lexer/lexer.go (100%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/{internal => }/lexer/paths.go (98%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/{internal => }/lexer/xmlchars.go (100%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/{internal => }/parser/ast.go (97%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/{internal => }/parser/parser.go (98%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/{internal => }/parser/pathexpr/pathexpr.go (100%)
 rename vendor/github.com/ChrisTrenkamp/goxpath/{internal => }/xconst/xconst.go (100%)
 create mode 100644 vendor/github.com/agext/levenshtein/.gitignore
 create mode 100644 vendor/github.com/agext/levenshtein/.travis.yml
 create mode 100644 vendor/github.com/agext/levenshtein/DCO
 rename vendor/github.com/{masterzen/azure-sdk-for-go => agext/levenshtein}/LICENSE (99%)
 create mode 100644 vendor/github.com/agext/levenshtein/MAINTAINERS
 create mode 100644 vendor/github.com/agext/levenshtein/NOTICE
 create mode 100644 vendor/github.com/agext/levenshtein/README.md
 create mode 100644 vendor/github.com/agext/levenshtein/go.mod
 create mode 100644 vendor/github.com/agext/levenshtein/levenshtein.go
 create mode 100644 vendor/github.com/agext/levenshtein/params.go
 create mode 100644 vendor/github.com/agext/levenshtein/test.sh
 create mode 100644 vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/transport_1_6.go
 create mode 100644 vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/transport_1_7.go
 create mode 100644 vendor/github.com/antchfx/xpath/func_go110.go
 create mode 100644 vendor/github.com/antchfx/xpath/func_pre_go110.go
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/LICENSE
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/generate.go
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/tables.go
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb
 create mode 100644 vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go
 create mode 100644 vendor/github.com/dylanmei/winrmtest/go.mod
 create mode 100644 vendor/github.com/dylanmei/winrmtest/go.sum
 create mode 100644 vendor/github.com/google/go-cmp/cmp/cmpopts/equate.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/cmpopts/ignore.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/cmpopts/sort.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/cmpopts/struct_filter.go
 create mode 100644 vendor/github.com/google/go-cmp/cmp/cmpopts/xform.go
 create mode 100644 vendor/github.com/google/uuid/go.mod
 delete mode 100644 vendor/github.com/gorilla/websocket/conn_read_legacy.go
 rename vendor/github.com/gorilla/websocket/{conn_read.go => conn_write.go} (52%)
 create mode 100644 vendor/github.com/gorilla/websocket/conn_write_legacy.go
 create mode 100644 vendor/github.com/gorilla/websocket/proxy.go
 create mode 100644 vendor/github.com/gorilla/websocket/trace.go
 create mode 100644 vendor/github.com/gorilla/websocket/trace_17.go
 create mode 100644 vendor/github.com/gorilla/websocket/x_net_proxy.go
 rename vendor/github.com/hashicorp/go-checkpoint/{checkpoint.go => check.go} (70%)
 create mode 100644 vendor/github.com/hashicorp/go-checkpoint/go.mod
 create mode 100644 vendor/github.com/hashicorp/go-checkpoint/go.sum
 create mode 100644 vendor/github.com/hashicorp/go-checkpoint/telemetry.go
 create mode 100644 vendor/github.com/hashicorp/go-checkpoint/versions.go
 create mode 100644 vendor/github.com/hashicorp/go-rootcerts/go.mod
 create mode 100644 vendor/github.com/hashicorp/go-rootcerts/go.sum
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/CHANGELOG.md
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/LICENSE
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/README.md
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/diagnostic.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/diagnostic_text.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/didyoumean.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/eval_context.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/expr_call.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/expr_list.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/expr_map.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/expr_unwrap.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/go.mod
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/go.sum
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/decode.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/encode.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/schema.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/gohcl/types.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hcldec/block_labels.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hcldec/decode.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hcldec/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hcldec/gob.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hcldec/public.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hcldec/schema.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hcldec/spec.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hcldec/variables.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclparse/parser.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/diagnostics.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/didyoumean.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_ops.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_template.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_vars.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/file.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/generate.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/keywords.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/navigation.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/node.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_template.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_traversal.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/peeker.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/public.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.rl
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.rl
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/spec.md
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure_at_pos.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/token.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/token_type_string.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode2ragel.rb
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode_derived.rl
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/variables.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclsyntax/walk.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_attribute.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_block.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_body.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_expression.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/format.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/generate.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/native_node_sorter.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/node.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/parser.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/public.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/hclwrite/tokens.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/ast.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/didyoumean.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/doc.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/navigation.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/parser.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/peeker.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/public.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/scanner.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/spec.md
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/structure.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/json/tokentype_string.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/merged.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/ops.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/pos.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/pos_scanner.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/schema.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/spec.md
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/static_expr.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/structure.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/structure_at_pos.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/traversal.go
 create mode 100644 vendor/github.com/hashicorp/hcl/v2/traversal_for_expr.go
 create mode 100644 vendor/github.com/kardianos/osext/go.mod
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/chunked.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/client.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/cookie.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/doc.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/filetransport.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/fs.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/header.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/jar.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/lex.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/race.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/request.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/response.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/server.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/sniff.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/status.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/transfer.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/http/transport.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/alert.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/cipher_suites.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/common.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/conn.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_client.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_messages.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_server.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/key_agreement.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/prf.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/ticket.go
 delete mode 100644 vendor/github.com/masterzen/azure-sdk-for-go/core/tls/tls.go
 create mode 100644 vendor/github.com/masterzen/winrm/go.mod
 create mode 100644 vendor/github.com/masterzen/winrm/go.sum
 create mode 100644 vendor/github.com/mattn/go-colorable/go.mod
 create mode 100644 vendor/github.com/mattn/go-colorable/go.sum
 create mode 100644 vendor/github.com/mattn/go-isatty/go.mod
 create mode 100644 vendor/github.com/mattn/go-isatty/go.sum
 delete mode 100644 vendor/github.com/mattn/go-isatty/isatty_appengine.go
 delete mode 100644 vendor/github.com/mattn/go-isatty/isatty_linux_ppc64x.go
 create mode 100644 vendor/github.com/mitchellh/go-wordwrap/LICENSE.md
 create mode 100644 vendor/github.com/mitchellh/go-wordwrap/README.md
 create mode 100644 vendor/github.com/mitchellh/go-wordwrap/go.mod
 create mode 100644 vendor/github.com/mitchellh/go-wordwrap/wordwrap.go
 create mode 100644 vendor/github.com/mitchellh/panicwrap/go.mod
 create mode 100644 vendor/github.com/mitchellh/panicwrap/go.sum
 create mode 100644 vendor/github.com/mitchellh/prefixedio/go.mod
 create mode 100644 vendor/github.com/posener/complete/go.mod
 create mode 100644 vendor/github.com/posener/complete/go.sum
 delete mode 100644 vendor/github.com/posener/complete/metalinter.json
 create mode 100644 vendor/github.com/ugorji/go/codec/build.sh
 create mode 100644 vendor/github.com/ugorji/go/codec/gen-enc-chan.go.tmpl
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_arrayof_gte_go15.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_makemap_gte_go19.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_makemap_lt_go19.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_gte_go110.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_lt_go110.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_unsupported_lt_go14.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go15.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go
 create mode 100644 vendor/github.com/ugorji/go/codec/goversion_vendor_lt_go15.go
 create mode 100644 vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl
 create mode 100644 vendor/github.com/ugorji/go/codec/mammoth2-test.go.tmpl
 delete mode 100644 vendor/github.com/ugorji/go/codec/noop.go
 delete mode 100644 vendor/github.com/ugorji/go/codec/prebuild.go
 delete mode 100644 vendor/github.com/ugorji/go/codec/prebuild.sh
 delete mode 100644 vendor/github.com/ugorji/go/codec/tests.sh
 delete mode 100644 vendor/github.com/ugorji/go/codec/time.go
 create mode 100644 vendor/github.com/zclconf/go-cty/LICENSE
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/capsule.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/collection.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/conversion_tuple.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/doc.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/mismatch_msg.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/public.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/convert/unify.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/doc.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/element_iterator.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/error.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/argument.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/doc.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/error.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/function.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gob.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/in.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/out.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/helper.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/doc.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/marshal.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/simple.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/type.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/json/value.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/list_type.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/map_type.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/null.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/object_type.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/path.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/path_set.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/primitive_type.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/set/gob.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/set/iterator.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/set/ops.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/set/rules.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/set/set.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/set_helper.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/set_internals.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/set_type.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/tuple_type.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/type.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/type_conform.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/types_to_register.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/unknown.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/unknown_as_null.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/value.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/value_init.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/value_ops.go
 create mode 100644 vendor/github.com/zclconf/go-cty/cty/walk.go
 create mode 100644 vendor/golang.org/x/crypto/ed25519/ed25519_go113.go
 create mode 100644 vendor/golang.org/x/tools/AUTHORS
 create mode 100644 vendor/golang.org/x/tools/CONTRIBUTORS
 create mode 100644 vendor/golang.org/x/tools/LICENSE
 create mode 100644 vendor/golang.org/x/tools/PATENTS
 create mode 100644 vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
 create mode 100644 vendor/golang.org/x/tools/go/gcexportdata/importer.go
 create mode 100644 vendor/golang.org/x/tools/go/internal/gcimporter/bexport.go
 create mode 100644 vendor/golang.org/x/tools/go/internal/gcimporter/bimport.go
 create mode 100644 vendor/golang.org/x/tools/go/internal/gcimporter/exportdata.go
 create mode 100644 vendor/golang.org/x/tools/go/internal/gcimporter/gcimporter.go
 create mode 100644 vendor/golang.org/x/tools/go/internal/gcimporter/iexport.go
 create mode 100644 vendor/golang.org/x/tools/go/internal/gcimporter/iimport.go
 create mode 100644 vendor/golang.org/x/tools/go/internal/gcimporter/newInterface10.go
 create mode 100644 vendor/golang.org/x/tools/go/internal/gcimporter/newInterface11.go
 create mode 100644 vendor/golang.org/x/tools/go/internal/packagesdriver/sizes.go
 create mode 100644 vendor/golang.org/x/tools/go/packages/doc.go
 create mode 100644 vendor/golang.org/x/tools/go/packages/external.go
 create mode 100644 vendor/golang.org/x/tools/go/packages/golist.go
 create mode 100644 vendor/golang.org/x/tools/go/packages/golist_overlay.go
 create mode 100644 vendor/golang.org/x/tools/go/packages/packages.go
 create mode 100644 vendor/golang.org/x/tools/go/packages/visit.go
 create mode 100644 vendor/golang.org/x/tools/internal/fastwalk/fastwalk.go
 create mode 100644 vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_fileno.go
 create mode 100644 vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_ino.go
 create mode 100644 vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_namlen_bsd.go
 create mode 100644 vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_namlen_linux.go
 create mode 100644 vendor/golang.org/x/tools/internal/fastwalk/fastwalk_portable.go
 create mode 100644 vendor/golang.org/x/tools/internal/fastwalk/fastwalk_unix.go
 create mode 100644 vendor/golang.org/x/tools/internal/gopathwalk/walk.go
 create mode 100644 vendor/golang.org/x/tools/internal/semver/semver.go

diff --git a/go.mod b/go.mod
index 327a88162..d2e1fe53c 100644
--- a/go.mod
+++ b/go.mod
@@ -5,24 +5,23 @@ require (
 	github.com/1and1/oneandone-cloudserver-sdk-go v1.0.1
 	github.com/Azure/azure-sdk-for-go v30.0.0+incompatible
 	github.com/Azure/go-autorest v12.0.0+incompatible
-	github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4 // indirect
-	github.com/ChrisTrenkamp/goxpath v0.0.0-20170625215350-4fe035839290
+	github.com/ChrisTrenkamp/goxpath v0.0.0-20170922090931-c385f95c6022
 	github.com/NaverCloudPlatform/ncloud-sdk-go v0.0.0-20180110055012-c2e73f942591
 	github.com/PuerkitoBio/goquery v1.5.0 // indirect
 	github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect
 	github.com/Telmate/proxmox-api-go v0.0.0-20190815172943-ef9222844e60
 	github.com/abdullin/seq v0.0.0-20160510034733-d5467c17e7af // indirect
+	github.com/agext/levenshtein v1.2.2 // indirect
 	github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190418113227-25233c783f4e
-	github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20170113022742-e6dbea820a9f
+	github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20190103054945-8205d1f41e70
 	github.com/antchfx/htmlquery v1.0.0 // indirect
 	github.com/antchfx/xmlquery v1.0.0 // indirect
-
-	github.com/antchfx/xpath v0.0.0-20170728053731-b5c552e1acbd // indirect
-	github.com/antchfx/xquery v0.0.0-20170730121040-eb8c3c172607 // indirect
 	github.com/antihax/optional v0.0.0-20180407024304-ca021399b1a6 // indirect
+	github.com/apparentlymart/go-dump v0.0.0-20190214190832-042adf3cf4a0 // indirect
 	github.com/approvals/go-approval-tests v0.0.0-20160714161514-ad96e53bea43
 	github.com/armon/go-radix v1.0.0 // indirect
 	github.com/aws/aws-sdk-go v1.24.1
+	github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f // indirect
 	github.com/biogo/hts v0.0.0-20160420073057-50da7d4131a3
 	github.com/c2h5oh/datasize v0.0.0-20171227191756-4eba002a5eae
 	github.com/cheggaaa/pb v1.0.27
@@ -38,7 +37,7 @@ require (
 	github.com/docker/docker v0.0.0-20180422163414-57142e89befe // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
 	github.com/dylanmei/iso8601 v0.1.0 // indirect
-	github.com/dylanmei/winrmtest v0.0.0-20170819153634-c2fbb09e6c08
+	github.com/dylanmei/winrmtest v0.0.0-20190225150635-99b7fe2fddf1
 	github.com/exoscale/egoscale v0.18.1
 	github.com/fatih/camelcase v1.0.0
 	github.com/fatih/structtag v1.0.0
@@ -48,28 +47,31 @@ require (
 	github.com/gocolly/colly v1.2.0
 	github.com/gofrs/flock v0.7.1
 	github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
+	github.com/golang/example v0.0.0-20170904185048-46695d81d1fa // indirect
 	github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
 	github.com/google/go-cmp v0.3.0
 	github.com/google/go-querystring v1.0.0 // indirect
 	github.com/google/shlex v0.0.0-20150127133951-6f45313302b9
-	github.com/google/uuid v1.0.0
+	github.com/google/uuid v1.1.1
 	github.com/gophercloud/gophercloud v0.2.0
-	github.com/gophercloud/utils v0.0.0-20190124192022-a5c25e7a53a6
+	github.com/gophercloud/utils v0.0.0-20190128072930-fbb6ab446f01
 	github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e // indirect
-	github.com/gorilla/websocket v0.0.0-20170319172727-a91eba7f9777 // indirect
+	github.com/gorilla/websocket v1.4.0 // indirect
 	github.com/grpc-ecosystem/go-grpc-middleware v1.1.0
 	github.com/hashicorp/consul v1.4.0
 	github.com/hashicorp/errwrap v1.0.0
-	github.com/hashicorp/go-checkpoint v0.0.0-20171009173528-1545e56e46de
+	github.com/hashicorp/go-checkpoint v0.5.0
 	github.com/hashicorp/go-cleanhttp v0.5.0
-	github.com/hashicorp/go-getter v1.3.1-0.20190906090232-a0f878cb75da
+	github.com/hashicorp/go-getter v1.4.0
+	github.com/hashicorp/go-msgpack v0.5.4 // indirect
 	github.com/hashicorp/go-multierror v1.0.0
 	github.com/hashicorp/go-oracle-terraform v0.0.0-20181016190316-007121241b79
 	github.com/hashicorp/go-retryablehttp v0.5.2 // indirect
-	github.com/hashicorp/go-rootcerts v0.0.0-20160503143440-6bb64b370b90 // indirect
+	github.com/hashicorp/go-rootcerts v1.0.0 // indirect
 	github.com/hashicorp/go-uuid v1.0.1
 	github.com/hashicorp/go-version v1.2.0
 	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/hashicorp/hcl/v2 v2.0.0
 	github.com/hashicorp/serf v0.8.2 // indirect
 	github.com/hashicorp/vault v1.1.0
 	github.com/hashicorp/yamux v0.0.0-20181012175058-2f1d1f20f75d
@@ -80,50 +82,49 @@ require (
 	github.com/joyent/triton-go v0.0.0-20180116165742-545edbe0d564
 	github.com/json-iterator/go v1.1.6 // indirect
 	github.com/jtolds/gls v4.2.1+incompatible // indirect
-	github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1
+	github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0
 	github.com/kennygrant/sanitize v1.2.4 // indirect
 	github.com/klauspost/compress v0.0.0-20160131094358-f86d2e6d8a77 // indirect
 	github.com/klauspost/cpuid v0.0.0-20160106104451-349c67577817 // indirect
 	github.com/klauspost/crc32 v0.0.0-20160114101742-999f3125931f // indirect
 	github.com/klauspost/pgzip v0.0.0-20151221113845-47f36e165cec
 	github.com/kr/fs v0.0.0-20131111012553-2788f0dbd169 // indirect
-	github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 // indirect
+	github.com/kylelemons/godebug v1.1.0 // indirect
 	github.com/linode/linodego v0.7.1
-	github.com/masterzen/azure-sdk-for-go v0.0.0-20161014135628-ee4f0065d00c // indirect
 	github.com/masterzen/simplexml v0.0.0-20190410153822-31eea3082786 // indirect
-	github.com/masterzen/winrm v0.0.0-20180224160350-7e40f93ae939
+	github.com/masterzen/winrm v0.0.0-20190223112901-5e5c9a7fe54b
+	github.com/mattn/go-colorable v0.1.1 // indirect
 	github.com/mattn/go-tty v0.0.0-20190424173100-523744f04859
 	github.com/miekg/dns v1.1.1 // indirect
 	github.com/mitchellh/cli v1.0.0
 	github.com/mitchellh/go-fs v0.0.0-20180402234041-7b48fa161ea7
-	github.com/mitchellh/go-homedir v1.0.0
+	github.com/mitchellh/go-homedir v1.1.0
 	github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed
+	github.com/mitchellh/go-wordwrap v1.0.0 // indirect
 	github.com/mitchellh/iochan v1.0.0
 	github.com/mitchellh/mapstructure v0.0.0-20180111000720-b4575eea38cc
-	github.com/mitchellh/panicwrap v0.0.0-20170106182340-fce601fe5557
-	github.com/mitchellh/prefixedio v0.0.0-20151214002211-6e6954073784
+	github.com/mitchellh/panicwrap v0.0.0-20190213213626-17011010aaa4
+	github.com/mitchellh/prefixedio v0.0.0-20190213213902-5733675afd51
 	github.com/mitchellh/reflectwalk v1.0.0
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.1 // indirect
 	github.com/moul/anonuuid v0.0.0-20160222162117-609b752a95ef // indirect
 	github.com/moul/gotty-client v0.0.0-20180327180212-b26a57ebc215 // indirect
 	github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32 // indirect
-	github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d // indirect
 	github.com/olekukonko/tablewriter v0.0.0-20180105111133-96aac992fc8b
-	github.com/onsi/ginkgo v1.7.0 // indirect
-	github.com/onsi/gomega v1.4.3 // indirect
+	github.com/onsi/ginkgo v1.10.2 // indirect
+	github.com/onsi/gomega v1.7.0 // indirect
 	github.com/oracle/oci-go-sdk v1.8.0
 	github.com/outscale/osc-go v0.0.1
 	github.com/packer-community/winrmcp v0.0.0-20180921204643-0fd363d6159a
 	github.com/pierrec/lz4 v2.0.5+incompatible
 	github.com/pkg/errors v0.8.1
 	github.com/pkg/sftp v0.0.0-20160118190721-e84cc8c755ca
-	github.com/posener/complete v1.1.1
+	github.com/posener/complete v1.2.1
 	github.com/profitbricks/profitbricks-sdk-go v4.0.2+incompatible
 	github.com/renstrom/fuzzysearch v0.0.0-20160331204855-2d205ac6ec17 // indirect
 	github.com/ryanuber/go-glob v0.0.0-20170128012129-256dc444b735 // indirect
 	github.com/saintfish/chardet v0.0.0-20120816061221-3af4cd4741ca // indirect
-	github.com/satori/go.uuid v1.2.0 // indirect
 	github.com/scaleway/scaleway-cli v0.0.0-20180921094345-7b12c9699d70
 	github.com/shirou/gopsutil v2.18.12+incompatible
 	github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4 // indirect
@@ -133,17 +134,19 @@ require (
 	github.com/temoto/robotstxt v1.1.1 // indirect
 	github.com/tencentcloud/tencentcloud-sdk-go v3.0.71+incompatible
 	github.com/ucloud/ucloud-sdk-go v0.8.7
-	github.com/ugorji/go v0.0.0-20151218193438-646ae4a518c1
+	github.com/ugorji/go v0.0.0-20180813092308-00b869d2f4a5
 	github.com/ulikunitz/xz v0.5.5
 	github.com/vmware/govmomi v0.0.0-20170707011325-c2105a174311
 	github.com/xanzy/go-cloudstack v0.0.0-20190526095453-42f262b63ed0
 	github.com/yandex-cloud/go-genproto v0.0.0-20190916101622-7617782d381e
 	github.com/yandex-cloud/go-sdk v0.0.0-20190916101744-c781afa45829
-	golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5
+	github.com/zclconf/go-cty v1.1.0
+	golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4
 	golang.org/x/net v0.0.0-20190620200207-3b0461eec859
 	golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45
 	golang.org/x/sync v0.0.0-20190423024810-112230192c58
-	golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0
+	golang.org/x/sys v0.0.0-20190804053845-51ab0e2deafa
+	golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0
 	google.golang.org/api v0.9.0
 	google.golang.org/grpc v1.21.1
 	gopkg.in/h2non/gock.v1 v1.0.12 // indirect
diff --git a/go.sum b/go.sum
index 6735fbbb6..fd7987504 100644
--- a/go.sum
+++ b/go.sum
@@ -19,8 +19,8 @@ github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4 h1:pSm8mp0T2OH2CP
 github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4/go.mod h1:chxPXzSsl7ZWRAuOIE23GDNzjWuZquvFlgA8xmpunjU=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/ChrisTrenkamp/goxpath v0.0.0-20170625215350-4fe035839290 h1:K9I21XUHNbYD3GNMmJBN0UKJCpdP+glftwNZ7Bo8kqY=
-github.com/ChrisTrenkamp/goxpath v0.0.0-20170625215350-4fe035839290/go.mod h1:nuWgzSkT5PnyOd+272uUmV0dnAnAn42Mk7PiQC5VzN4=
+github.com/ChrisTrenkamp/goxpath v0.0.0-20170922090931-c385f95c6022 h1:y8Gs8CzNfDF5AZvjr+5UyGQvQEBL7pwo+v+wX6q9JI8=
+github.com/ChrisTrenkamp/goxpath v0.0.0-20170922090931-c385f95c6022/go.mod h1:nuWgzSkT5PnyOd+272uUmV0dnAnAn42Mk7PiQC5VzN4=
 github.com/NaverCloudPlatform/ncloud-sdk-go v0.0.0-20180110055012-c2e73f942591 h1:/P9HCl71+Eh6vDbKNyRu+rpIIR70UCZWNOGexVV3e6k=
 github.com/NaverCloudPlatform/ncloud-sdk-go v0.0.0-20180110055012-c2e73f942591/go.mod h1:EHGzQGbwozJBj/4qj3WGrTJ0FqjgOTOxLQ0VNWvPn08=
 github.com/PuerkitoBio/goquery v1.5.0 h1:uGvmFXOA73IKluu/F84Xd1tt/z07GYm8X49XKHP7EJk=
@@ -31,22 +31,31 @@ github.com/Telmate/proxmox-api-go v0.0.0-20190815172943-ef9222844e60 h1:iEmbIRk4
 github.com/Telmate/proxmox-api-go v0.0.0-20190815172943-ef9222844e60/go.mod h1:OGWyIMJ87/k/GCz8CGiWB2HOXsOVDM6Lpe/nFPkC4IQ=
 github.com/abdullin/seq v0.0.0-20160510034733-d5467c17e7af h1:DBNMBMuMiWYu0b+8KMJuWmfCkcxl09JwdlqwDZZ6U14=
 github.com/abdullin/seq v0.0.0-20160510034733-d5467c17e7af/go.mod h1:5Jv4cbFiHJMsVxt52+i0Ha45fjshj6wxYr1r19tB9bw=
+github.com/agext/levenshtein v1.2.1 h1:QmvMAjj2aEICytGiWzmxoE0x2KZvE0fvmqMOfy2tjT8=
+github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
+github.com/agext/levenshtein v1.2.2 h1:0S/Yg6LYmFJ5stwQeRp6EeOcCbj7xiqQSdNelsXvaqE=
+github.com/agext/levenshtein v1.2.2/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
 github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190418113227-25233c783f4e h1:/8wOj52pewmIX/8d5eVO3t7Rr3astkBI/ruyg4WNqRo=
 github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190418113227-25233c783f4e/go.mod h1:T9M45xf79ahXVelWoOBmH0y4aC1t5kXO5BxwyakgIGA=
-github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20170113022742-e6dbea820a9f h1:jI4DIE5Vf4oRaHfthB0oRhU+yuYuoOTurDzwAlskP00=
-github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20170113022742-e6dbea820a9f/go.mod h1:T/Aws4fEfogEE9v+HPhhw+CntffsBHJ8nXQCwKr0/g8=
+github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20190103054945-8205d1f41e70 h1:FrF4uxA24DF3ARNXVbUin3wa5fDLaB1Cy8mKks/LRz4=
+github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20190103054945-8205d1f41e70/go.mod h1:T/Aws4fEfogEE9v+HPhhw+CntffsBHJ8nXQCwKr0/g8=
 github.com/andybalholm/cascadia v1.0.0 h1:hOCXnnZ5A+3eVDX8pvgl4kofXv2ELss0bKcqRySc45o=
 github.com/andybalholm/cascadia v1.0.0/go.mod h1:GsXiBklL0woXo1j/WYWtSYYC4ouU9PqHO0sqidkEA4Y=
 github.com/antchfx/htmlquery v1.0.0 h1:O5IXz8fZF3B3MW+B33MZWbTHBlYmcfw0BAxgErHuaMA=
 github.com/antchfx/htmlquery v1.0.0/go.mod h1:MS9yksVSQXls00iXkiMqXr0J+umL/AmxXKuP28SUJM8=
 github.com/antchfx/xmlquery v1.0.0 h1:YuEPqexGG2opZKNc9JU3Zw6zFXwC47wNcy6/F8oKsrM=
 github.com/antchfx/xmlquery v1.0.0/go.mod h1:/+CnyD/DzHRnv2eRxrVbieRU/FIF6N0C+7oTtyUtCKk=
-github.com/antchfx/xpath v0.0.0-20170728053731-b5c552e1acbd h1:S3Fr6QnkpW9VRjiEY4psQHhhbbahASuNVj52YIce7lI=
-github.com/antchfx/xpath v0.0.0-20170728053731-b5c552e1acbd/go.mod h1:Yee4kTMuNiPYJ7nSNorELQMr1J33uOpXDMByNYhvtNk=
-github.com/antchfx/xquery v0.0.0-20170730121040-eb8c3c172607 h1:BFFG6KP8ASFBg2ptWsJn8p8RDufBjBDKIxLU7BTYGOM=
-github.com/antchfx/xquery v0.0.0-20170730121040-eb8c3c172607/go.mod h1:LzD22aAzDP8/dyiCKFp31He4m2GPjl0AFyzDtZzUu9M=
+github.com/antchfx/xpath v0.0.0-20190129040759-c8489ed3251e h1:ptBAamGVd6CfRsUtyHD+goy2JGhv1QC32v3gqM8mYAM=
+github.com/antchfx/xpath v0.0.0-20190129040759-c8489ed3251e/go.mod h1:Yee4kTMuNiPYJ7nSNorELQMr1J33uOpXDMByNYhvtNk=
+github.com/antchfx/xquery v0.0.0-20180515051857-ad5b8c7a47b0 h1:JaCC8jz0zdMLk2m+qCCVLLLM/PL93p84w4pK3aJWj60=
+github.com/antchfx/xquery v0.0.0-20180515051857-ad5b8c7a47b0/go.mod h1:LzD22aAzDP8/dyiCKFp31He4m2GPjl0AFyzDtZzUu9M=
 github.com/antihax/optional v0.0.0-20180407024304-ca021399b1a6 h1:uZuxRZCz65cG1o6K/xUqImNcYKtmk9ylqaH0itMSvzA=
 github.com/antihax/optional v0.0.0-20180407024304-ca021399b1a6/go.mod h1:V8iCPQYkqmusNa815XgQio277wI47sdRh1dUOLdyC6Q=
+github.com/apparentlymart/go-dump v0.0.0-20180507223929-23540a00eaa3/go.mod h1:oL81AME2rN47vu18xqj1S1jPIPuN7afo62yKTNn3XMM=
+github.com/apparentlymart/go-dump v0.0.0-20190214190832-042adf3cf4a0 h1:MzVXffFUye+ZcSR6opIgz9Co7WcDx6ZcY+RjfFHoA0I=
+github.com/apparentlymart/go-dump v0.0.0-20190214190832-042adf3cf4a0/go.mod h1:oL81AME2rN47vu18xqj1S1jPIPuN7afo62yKTNn3XMM=
+github.com/apparentlymart/go-textseg v1.0.0 h1:rRmlIsPEEhUTIKQb7T++Nz/A5Q6C9IuX2wFoYVvnCs0=
+github.com/apparentlymart/go-textseg v1.0.0/go.mod h1:z96Txxhf3xSFMPmb5X/1W05FF/Nj9VFpLOpjS5yuumk=
 github.com/approvals/go-approval-tests v0.0.0-20160714161514-ad96e53bea43 h1:ePCAQPf5tUc5IMcUvu6euhSGna7jzs7eiXtJXHig6Zc=
 github.com/approvals/go-approval-tests v0.0.0-20160714161514-ad96e53bea43/go.mod h1:S6puKjZ9ZeqUPBv2hEBnMZGcM2J6mOsDRQcmxkMAND0=
 github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
@@ -61,6 +70,8 @@ github.com/aws/aws-sdk-go v1.24.1 h1:B2NRyTV1/+h+Dg8Bh7vnuvW6QZz/NBL+uzgC2uILDMI
 github.com/aws/aws-sdk-go v1.24.1/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/azr/flock v0.0.0-20190823144736-958d66434653 h1:2H3Cu0cbG8iszfcgnANwC/cm0YkPJIQvaJ9/tSpwh9o=
 github.com/azr/flock v0.0.0-20190823144736-958d66434653/go.mod h1:EI7lzWWilX2K3ZMZ7Ta+E4DZtWzMC2tbn3cM3oVPuAU=
+github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f h1:ZNv7On9kyUzm7fvRZumSyy/IUiSC7AzL0I1jKKtwooA=
+github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f/go.mod h1:AuiFmCCPBSrqvVMvuqFuk0qogytodnVFVSN5CeJB8Gc=
 github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
 github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
 github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY=
@@ -101,8 +112,8 @@ github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dylanmei/iso8601 v0.1.0 h1:812NGQDBcqquTfH5Yeo7lwR0nzx/cKdsmf3qMjPURUI=
 github.com/dylanmei/iso8601 v0.1.0/go.mod h1:w9KhXSgIyROl1DefbMYIE7UVSIvELTbMrCfx+QkYnoQ=
-github.com/dylanmei/winrmtest v0.0.0-20170819153634-c2fbb09e6c08 h1:0bp6/GrNOrTDtSXe9YYGCwf8jp5Fb/b+4a6MTRm4qzY=
-github.com/dylanmei/winrmtest v0.0.0-20170819153634-c2fbb09e6c08/go.mod h1:VBVDFSBXCIW8JaHQpI8lldSKfYaLMzP9oyq6IJ4fhzY=
+github.com/dylanmei/winrmtest v0.0.0-20190225150635-99b7fe2fddf1 h1:r1oACdS2XYiAWcfF8BJXkoU8l1J71KehGR+d99yWEDA=
+github.com/dylanmei/winrmtest v0.0.0-20190225150635-99b7fe2fddf1/go.mod h1:lcy9/2gH1jn/VCLouHA6tOEwLoNVd4GW6zhuKLmHC2Y=
 github.com/exoscale/egoscale v0.18.1 h1:1FNZVk8jHUx0AvWhOZxLEDNlacTU0chMXUUNkm9EZaI=
 github.com/exoscale/egoscale v0.18.1/go.mod h1:Z7OOdzzTOz1Q1PjQXumlz9Wn/CddH0zSYdCF3rnBKXE=
 github.com/fatih/camelcase v1.0.0 h1:hxNvNX/xYBp0ovncs8WyWZrOrpBNub/JfaMvbURyft8=
@@ -119,6 +130,8 @@ github.com/go-ini/ini v1.25.4 h1:Mujh4R/dH6YL8bxuISne3xX2+qcQ9p0IxKAP6ExWoUo=
 github.com/go-ini/ini v1.25.4/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
 github.com/go-ole/go-ole v1.2.4 h1:nNBDSCOigTSiarFpYE9J/KtEA1IOW4CNeqT9TQDqCxI=
 github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM=
+github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
+github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
 github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
 github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
 github.com/gocolly/colly v1.2.0 h1:qRz9YAn8FIH0qzgNUw+HT9UN7wm1oF9OBAilwEWpyrI=
@@ -130,11 +143,14 @@ github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRx
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3 h1:zN2lZNZRflqFyxVaTIU61KNKQ9C0055u9CAfpmqUvo4=
 github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3/go.mod h1:nPpo7qLxd6XL3hWJG/O60sR8ZKfMCiIoNap5GvD12KU=
+github.com/golang/example v0.0.0-20170904185048-46695d81d1fa h1:iqCQC2Z53KkwGgTN9szyL4q0OQHmuNjeoNnMT6lk66k=
+github.com/golang/example v0.0.0-20170904185048-46695d81d1fa/go.mod h1:tO/5UvQ/uKigUjQBPqzstj6uxd3fUIjddi19DxGJeWg=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
@@ -159,19 +175,19 @@ github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OI
 github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
 github.com/google/shlex v0.0.0-20150127133951-6f45313302b9 h1:JM174NTeGNJ2m/oLH3UOWOvWQQKd+BoL3hcSCUWFLt0=
 github.com/google/shlex v0.0.0-20150127133951-6f45313302b9/go.mod h1:RpwtwJQFrIEPstU94h88MWPXP2ektJZ8cZ0YntAmXiE=
-github.com/google/uuid v1.0.0 h1:b4Gk+7WdP/d3HZH8EJsZpvV7EtDOgaZLtnaNGIu1adA=
-github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5 h1:sjZBwGj9Jlw33ImPtvFviGYvseOtDM7hkSKB7+Tv3SM=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
 github.com/gophercloud/gophercloud v0.2.0 h1:lD2Bce2xBAMNNcFZ0dObTpXkGLlVIb33RPVUNVpw6ic=
 github.com/gophercloud/gophercloud v0.2.0/go.mod h1:vxM41WHh5uqHVBMZHzuwNOHh8XEoIEcSTewFxm1c5g8=
-github.com/gophercloud/utils v0.0.0-20190124192022-a5c25e7a53a6 h1:Cw/B8Bu7Rryomxf7bjc8zNfIyLgjxsDd91n0eGRWpuo=
-github.com/gophercloud/utils v0.0.0-20190124192022-a5c25e7a53a6/go.mod h1:wjDF8z83zTeg5eMLml5EBSlAhbF7G8DobyI1YsMuyzw=
+github.com/gophercloud/utils v0.0.0-20190128072930-fbb6ab446f01 h1:OgCNGSnEalfkRpn//WGJHhpo7fkP+LhTpvEITZ7CkK4=
+github.com/gophercloud/utils v0.0.0-20190128072930-fbb6ab446f01/go.mod h1:wjDF8z83zTeg5eMLml5EBSlAhbF7G8DobyI1YsMuyzw=
 github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e h1:JKmoR8x90Iww1ks85zJ1lfDGgIiMDuIptTOhJq+zKyg=
 github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
-github.com/gorilla/websocket v0.0.0-20170319172727-a91eba7f9777 h1:JIM+OacoOJRU30xpjMf8sulYqjr0ViA3WDrTX6j/yDI=
-github.com/gorilla/websocket v0.0.0-20170319172727-a91eba7f9777/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/grpc-ecosystem/go-grpc-middleware v1.1.0 h1:THDBEeQ9xZ8JEaCLyLQqXMMdRqNr0QAUJTIkQAUtFjg=
 github.com/grpc-ecosystem/go-grpc-middleware v1.1.0/go.mod h1:f5nM7jw/oeRSadq3xCzHAvxcr8HZnzsqU6ILg/0NiiE=
 github.com/grpc-ecosystem/grpc-gateway v1.8.5 h1:2+KSC78XiO6Qy0hIjfc1OD9H+hsaJdJlb8Kqsd41CTE=
@@ -180,24 +196,26 @@ github.com/hashicorp/consul v1.4.0 h1:PQTW4xCuAExEiSbhrsFsikzbW5gVBoi74BjUvYFyKH
 github.com/hashicorp/consul v1.4.0/go.mod h1:mFrjN1mfidgJfYP1xrJCF+AfRhr6Eaqhb2+sfyn/OOI=
 github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/go-checkpoint v0.0.0-20171009173528-1545e56e46de h1:XDCSythtg8aWSRSO29uwhgh7b127fWr+m5SemqjSUL8=
-github.com/hashicorp/go-checkpoint v0.0.0-20171009173528-1545e56e46de/go.mod h1:xIwEieBHERyEvaeKF/TcHh1Hu+lxPM+n2vT1+g9I4m4=
+github.com/hashicorp/go-checkpoint v0.5.0 h1:MFYpPZCnQqQTE18jFwSII6eUQrD/oxMFp3mlgcqk5mU=
+github.com/hashicorp/go-checkpoint v0.5.0/go.mod h1:7nfLNL10NsxqO4iWuW6tWW0HjZuDrwkBuEQsVcpCOgg=
 github.com/hashicorp/go-cleanhttp v0.5.0 h1:wvCrVc9TjDls6+YGAF2hAifE1E5U1+b4tH6KdvN3Gig=
 github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
-github.com/hashicorp/go-getter v1.3.1-0.20190906090232-a0f878cb75da h1:HAasZmyRrb7/paYuww5RfVwY3wkFpsbMNYwBxOSZquY=
-github.com/hashicorp/go-getter v1.3.1-0.20190906090232-a0f878cb75da/go.mod h1:7qxyCd8rBfcShwsvxgIguu4KbS3l8bUCwg2Umn7RjeY=
+github.com/hashicorp/go-getter v1.4.0 h1:ENHNi8494porjD0ZhIrjlAHnveSFhY7hvOJrV/fsKkw=
+github.com/hashicorp/go-getter v1.4.0/go.mod h1:7qxyCd8rBfcShwsvxgIguu4KbS3l8bUCwg2Umn7RjeY=
 github.com/hashicorp/go-immutable-radix v1.0.0 h1:AKDB1HM5PWEA7i4nhcpwOrO2byshxBjXVn/J/3+z5/0=
 github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
 github.com/hashicorp/go-msgpack v0.5.3 h1:zKjpN5BK/P5lMYrLmBHdBULWbJ0XpYR+7NGzqkZzoD4=
 github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
+github.com/hashicorp/go-msgpack v0.5.4 h1:SFT72YqIkOcLdWJUYcriVX7hbrZpwc/f7h8aW2NUqrA=
+github.com/hashicorp/go-msgpack v0.5.4/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
 github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o=
 github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
 github.com/hashicorp/go-oracle-terraform v0.0.0-20181016190316-007121241b79 h1:RKu7yAXZTaQsxj1K9GDsh+QVw0+Wu1SWHxtbFN0n+hE=
 github.com/hashicorp/go-oracle-terraform v0.0.0-20181016190316-007121241b79/go.mod h1:09jT3Y/OIsjTjQ2+3bkVNPDKqWcGIYYvjB2BEKVUdvc=
 github.com/hashicorp/go-retryablehttp v0.5.2 h1:AoISa4P4IsW0/m4T6St8Yw38gTl5GtBAgfkhYh1xAz4=
 github.com/hashicorp/go-retryablehttp v0.5.2/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
-github.com/hashicorp/go-rootcerts v0.0.0-20160503143440-6bb64b370b90 h1:VBj0QYQ0u2MCJzBfeYXGexnAl17GsH1yidnoxCqqD9E=
-github.com/hashicorp/go-rootcerts v0.0.0-20160503143440-6bb64b370b90/go.mod h1:o4zcYY1e0GEZI6eSEr+43QDYmuGglw1qSO6qdHUHCgg=
+github.com/hashicorp/go-rootcerts v1.0.0 h1:Rqb66Oo1X/eSV1x66xbDccZjhJigjg0+e82kpwzSwCI=
+github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
 github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo=
 github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
 github.com/hashicorp/go-sockaddr v1.0.0 h1:GeH6tui99pF4NJgfnhp+L6+FfobzVW3Ah46sLo0ICXs=
@@ -217,6 +235,9 @@ github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/hashicorp/hcl/v2 v2.0.0 h1:efQznTz+ydmQXq3BOnRa3AXzvCeTq1P4dKj/z5GLlY8=
+github.com/hashicorp/hcl/v2 v2.0.0/go.mod h1:oVVDG71tEinNGYCxinCYadcmKU9bglqW9pV3txagJ90=
+github.com/hashicorp/logutils v1.0.0 h1:dLEQVugN8vlakKOUE3ihGLTZJRB4j+M2cdTm/ORI65Y=
 github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
 github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
 github.com/hashicorp/memberlist v0.1.3 h1:EmmoJme1matNzb+hMpDuR/0sbJSUisxyqBGG676r31M=
@@ -249,6 +270,8 @@ github.com/jtolds/gls v4.2.1+incompatible h1:fSuqC+Gmlu6l/ZYAoZzx2pyucC8Xza35fpR
 github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1 h1:PJPDf8OUfOK1bb/NeTKd4f1QXZItOX389VN3B6qC8ro=
 github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
+github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0 h1:iQTw/8FWTuc7uiaSepXwyf3o52HaUYcV+Tu66S3F5GA=
+github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
 github.com/kennygrant/sanitize v1.2.4 h1:gN25/otpP5vAsO2djbMhF/LQX6R7+O1TB4yv8NzpJ3o=
 github.com/kennygrant/sanitize v1.2.4/go.mod h1:LGsjYYtgxbetdg5owWB2mpgUL6e2nfw2eObZ0u0qvak=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
@@ -272,19 +295,24 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
 github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/linode/linodego v0.7.1 h1:4WZmMpSA2NRwlPZcc0+4Gyn7rr99Evk9bnr0B3gXRKE=
 github.com/linode/linodego v0.7.1/go.mod h1:ga11n3ivecUrPCHN0rANxKmfWBJVkOXfLMZinAbj2sY=
-github.com/masterzen/azure-sdk-for-go v0.0.0-20161014135628-ee4f0065d00c h1:FMUOnVGy8nWk1cvlMCAoftRItQGMxI0vzJ3dQjeZTCE=
-github.com/masterzen/azure-sdk-for-go v0.0.0-20161014135628-ee4f0065d00c/go.mod h1:mf8fjOu33zCqxUjuiU3I8S1lJMyEAlH+0F2+M5xl3hE=
+github.com/masterzen/simplexml v0.0.0-20160608183007-4572e39b1ab9/go.mod h1:kCEbxUJlNDEBNbdQMkPSp6yaKcRXVI6f4ddk8Riv4bc=
 github.com/masterzen/simplexml v0.0.0-20190410153822-31eea3082786 h1:2ZKn+w/BJeL43sCxI2jhPLRv73oVVOjEKZjKkflyqxg=
 github.com/masterzen/simplexml v0.0.0-20190410153822-31eea3082786/go.mod h1:kCEbxUJlNDEBNbdQMkPSp6yaKcRXVI6f4ddk8Riv4bc=
-github.com/masterzen/winrm v0.0.0-20180224160350-7e40f93ae939 h1:cRFHA33ER97Xy5jmjS519OXCS/yE3AT3zdbQAg0Z53g=
-github.com/masterzen/winrm v0.0.0-20180224160350-7e40f93ae939/go.mod h1:CfZSN7zwz5gJiFhZJz49Uzk7mEBHIceWmbFmYx7Hf7E=
+github.com/masterzen/winrm v0.0.0-20190223112901-5e5c9a7fe54b h1:/1RFh2SLCJ+tEnT73+Fh5R2AO89sQqs8ba7o+hx1G0Y=
+github.com/masterzen/winrm v0.0.0-20190223112901-5e5c9a7fe54b/go.mod h1:wr1VqkwW0AB5JS0QLy5GpVMS9E3VtRoSYXUYyVk46KY=
 github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-colorable v0.1.1 h1:G1f5SKeVxmagw/IyvzvtZE4Gybcc4Tr1tf7I8z0XgOg=
+github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.5 h1:tHXDdz1cpzGaovsTB+TVB8q90WEokoVmfMqoVcrLUgw=
+github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y=
 github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/mattn/go-tty v0.0.0-20190424173100-523744f04859 h1:smQbSzmT3EHl4EUwtFwFGmGIpiYgIiiPeVv1uguIQEE=
@@ -298,20 +326,26 @@ github.com/mitchellh/go-fs v0.0.0-20180402234041-7b48fa161ea7 h1:PXPMDtfqV+rZJsh
 github.com/mitchellh/go-fs v0.0.0-20180402234041-7b48fa161ea7/go.mod h1:g7SZj7ABpStq3tM4zqHiVEG5un/DZ1+qJJKO7qx1EvU=
 github.com/mitchellh/go-homedir v1.0.0 h1:vKb8ShqSby24Yrqr/yDYkuFz8d0WUjys40rvnGC8aR0=
 github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-testing-interface v1.0.0 h1:fzU/JVNcaqHQEcVFAKeR41fkiLdIPrefOvVG1VZ96U0=
 github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
 github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed h1:FI2NIv6fpef6BQl2u3IZX/Cj20tfypRF4yd+uaHOMtI=
 github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed/go.mod h1:3rdaFaCv4AyBgu5ALFM0+tSuHrBh6v692nyQe3ikrq0=
+github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
+github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
+github.com/mitchellh/go-wordwrap v1.0.0 h1:6GlHJ/LTGMrIJbwgdqdl2eEH8o+Exx/0m8ir9Gns0u4=
+github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
 github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
 github.com/mitchellh/iochan v1.0.0 h1:C+X3KsSTLFVBr/tK1eYN/vs4rJcvsiLU338UhYPJWeY=
 github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
 github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v0.0.0-20180111000720-b4575eea38cc h1:5T6hzGUO5OrL6MdYXYoLQtRWJDDgjdlOVBn9mIqGY1g=
 github.com/mitchellh/mapstructure v0.0.0-20180111000720-b4575eea38cc/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/mitchellh/panicwrap v0.0.0-20170106182340-fce601fe5557 h1:w1QuuAA2km2Hax+EPamrq5ZRBeaNv2vsjvgB4an0zoU=
-github.com/mitchellh/panicwrap v0.0.0-20170106182340-fce601fe5557/go.mod h1:QuAqW7/z+iv6aWFJdrA8kCbsF0OOJVKCICqTcYBexuY=
-github.com/mitchellh/prefixedio v0.0.0-20151214002211-6e6954073784 h1:+DAetXqxv/mSyCkE9KBIYOZs9b68y7SUaDCxQMRjA68=
-github.com/mitchellh/prefixedio v0.0.0-20151214002211-6e6954073784/go.mod h1:kB1naBgV9ORnkiTVeyJOI1DavaJkG4oNIq0Af6ZVKUo=
+github.com/mitchellh/panicwrap v0.0.0-20190213213626-17011010aaa4 h1:jw9tsdJ1FQmUkyTXdIF/nByTX+mMnnp16glnvGZMsC4=
+github.com/mitchellh/panicwrap v0.0.0-20190213213626-17011010aaa4/go.mod h1:YYMf4xtQnR8LRC0vKi3afvQ5QwRPQ17zjcpkBCufb+I=
+github.com/mitchellh/prefixedio v0.0.0-20190213213902-5733675afd51 h1:eD92Am0Qf3rqhsOeA1zwBHSfRkoHrt4o6uORamdmJP8=
+github.com/mitchellh/prefixedio v0.0.0-20190213213902-5733675afd51/go.mod h1:kB1naBgV9ORnkiTVeyJOI1DavaJkG4oNIq0Af6ZVKUo=
 github.com/mitchellh/reflectwalk v1.0.0 h1:9D+8oIskB4VJBN5SFlmc27fSlIBZaov1Wpk/IfikLNY=
 github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
@@ -329,10 +363,10 @@ github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d/go.mod h1:YUTz3bUH
 github.com/olekukonko/tablewriter v0.0.0-20180105111133-96aac992fc8b h1:LGItPaClbzopugAomw5VFKnG3h1dUr9QW5KOU+m8gu0=
 github.com/olekukonko/tablewriter v0.0.0-20180105111133-96aac992fc8b/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/ginkgo v1.10.2 h1:uqH7bpe+ERSiDa34FDOF7RikN6RzXgduUF8yarlZp94=
+github.com/onsi/ginkgo v1.10.2/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.7.0 h1:XPnZz8VVBHjVsy1vzJmRwIcSwiUO+JFfrv/xGiigmME=
+github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/oracle/oci-go-sdk v1.8.0 h1:4SO45bKV0I3/Mn1os3ANDZmV0eSE5z5CLdSUIkxtyzs=
 github.com/oracle/oci-go-sdk v1.8.0/go.mod h1:VQb79nF8Z2cwLkLS35ukwStZIg5F66tcBccjip/j888=
@@ -354,6 +388,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/posener/complete v1.1.1 h1:ccV59UEOTzVDnDUEFdT95ZzHVZ+5+158q8+SJb2QV5w=
 github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
+github.com/posener/complete v1.2.1 h1:LrvDIY//XNo65Lq84G/akBuMGlawHvGBABv8f/ZN6DI=
+github.com/posener/complete v1.2.1/go.mod h1:6gapUrK/U1TAN7ciCoNRIdVC5sbdBTUh1DKN0g6uH7E=
 github.com/profitbricks/profitbricks-sdk-go v4.0.2+incompatible h1:ZoVHH6voxW9Onzo6z2yLtocVoN6mBocyDoqoyAMHokE=
 github.com/profitbricks/profitbricks-sdk-go v4.0.2+incompatible/go.mod h1:T3/WrziK7fYH3C8ilAFAHe99R452/IzIG3YYkqaOFeQ=
 github.com/renstrom/fuzzysearch v0.0.0-20160331204855-2d205ac6ec17 h1:4qPms2txLWMLXKzqlnYSulKRS4cS9aYgPtAEpUelQok=
@@ -370,6 +406,8 @@ github.com/scaleway/scaleway-cli v0.0.0-20180921094345-7b12c9699d70 h1:DaqC32ZwO
 github.com/scaleway/scaleway-cli v0.0.0-20180921094345-7b12c9699d70/go.mod h1:XjlXWPd6VONhsRSEuzGkV8mzRpH7ou1cdLV7IKJk96s=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
 github.com/shirou/gopsutil v2.18.12+incompatible h1:1eaJvGomDnH74/5cF4CTmTbLHAriGFsTZppLXDX93OM=
 github.com/shirou/gopsutil v2.18.12+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4 h1:udFKJ0aHUL60LboW/A+DfgoHVedieIzIXE8uylPue0U=
@@ -382,6 +420,7 @@ github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykE
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c h1:Ho+uVpkel/udgjbwB5Lktg9BtvJSh2DT0Hi6LPSyI2w=
 github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
+github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
@@ -397,10 +436,11 @@ github.com/tencentcloud/tencentcloud-sdk-go v3.0.71+incompatible h1:9sIWfe6ZC7xo
 github.com/tencentcloud/tencentcloud-sdk-go v3.0.71+incompatible/go.mod h1:0PfYow01SHPMhKY31xa+EFz2RStxIqj6JFAJS+IkCi4=
 github.com/ucloud/ucloud-sdk-go v0.8.7 h1:BmXOb5RivI0Uu4oZRpjI6SQ9/y7n/H9wxTGR1txIE8o=
 github.com/ucloud/ucloud-sdk-go v0.8.7/go.mod h1:lM6fpI8y6iwACtlbHUav823/uKPdXsNBlnBpRF2fj3c=
-github.com/ugorji/go v0.0.0-20151218193438-646ae4a518c1 h1:U6ufy3mLDgg9RYupntOvAF7xCmNNquyKaYaaVHo1Nnk=
-github.com/ugorji/go v0.0.0-20151218193438-646ae4a518c1/go.mod h1:hnLbHMwcvSihnDhEfx2/BzKp2xb0Y+ErdfYcrs9tkJQ=
+github.com/ugorji/go v0.0.0-20180813092308-00b869d2f4a5 h1:cMjKdf4PxEBN9K5HaD9UMW8gkTbM0kMzkTa9SJe0WNQ=
+github.com/ugorji/go v0.0.0-20180813092308-00b869d2f4a5/go.mod h1:hnLbHMwcvSihnDhEfx2/BzKp2xb0Y+ErdfYcrs9tkJQ=
 github.com/ulikunitz/xz v0.5.5 h1:pFrO0lVpTBXLpYw+pnLj6TbvHuyjXMfjGeCwSqCVwok=
 github.com/ulikunitz/xz v0.5.5/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
+github.com/vmihailenco/msgpack v3.3.3+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
 github.com/vmware/govmomi v0.0.0-20170707011325-c2105a174311 h1:s5pyxd5S6wRs2WpEE0xRfWUF46Wbz44h203KnbX0ecI=
 github.com/vmware/govmomi v0.0.0-20170707011325-c2105a174311/go.mod h1:URlwyTFZX72RmxtxuaFL2Uj3fD1JTvZdx59bHWk6aFU=
 github.com/xanzy/go-cloudstack v0.0.0-20190526095453-42f262b63ed0 h1:NJrcIkdzq0C3I8ypAZwFE9RHtGbfp+mJvqIcoFATZuk=
@@ -409,6 +449,8 @@ github.com/yandex-cloud/go-genproto v0.0.0-20190916101622-7617782d381e h1:hzwq5G
 github.com/yandex-cloud/go-genproto v0.0.0-20190916101622-7617782d381e/go.mod h1:HEUYX/p8966tMUHHT+TsS0hF/Ca/NYwqprC5WXSDMfE=
 github.com/yandex-cloud/go-sdk v0.0.0-20190916101744-c781afa45829 h1:2FGwbx03GpP1Ulzg/L46tSoKh9t4yg8BhMKQl/Ff1x8=
 github.com/yandex-cloud/go-sdk v0.0.0-20190916101744-c781afa45829/go.mod h1:Eml0jFLU4VVHgIN8zPHMuNwZXVzUMILyO6lQZSfz854=
+github.com/zclconf/go-cty v1.1.0 h1:uJwc9HiBOCpoKIObTQaLR+tsEXx1HBHnOsOOpcdhZgw=
+github.com/zclconf/go-cty v1.1.0/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=
 go.opencensus.io v0.21.0 h1:mU6zScU4U1YAFPHEHYk+3JC4SY7JxgkqS10ZOSyksNg=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0 h1:C9hSCOW830chIVkdja34wa6Ky+IzWllkUinR+BtRZd4=
@@ -420,10 +462,14 @@ golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3 h1:KYQXGkl6vs02hK7pK4eIbw0NpNPedieTSTEiJ//bwGs=
 golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190222235706-ffb98f73852f/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5 h1:58fnuSXlxZmFdJyvtTFVmVhcMLU6v5fEb/ok4wyqtNU=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4 h1:HuIa8hRrWRSrqYzx1qI49NNxhdi2PrY7gxVSq1JjLDc=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
@@ -435,6 +481,7 @@ golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHl
 golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
 golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180811021610-c39426892332/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -477,14 +524,18 @@ golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190209173611-3b5209105503/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502175342-a43fa875dd82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0 h1:HyfiK1WMnHj5FXFXatD+Qs1A/xC2Run6RzeW1SyHxpc=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190804053845-51ab0e2deafa h1:KIDDMLT1O0Nr7TSxp8xM5tJcdn8tgyAONntO829og1M=
+golang.org/x/sys v0.0.0-20190804053845-51ab0e2deafa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2 h1:z99zHgr7hKfrUcX/KsoJk5FJfjTceCKIp96+biqP4To=
@@ -506,6 +557,7 @@ golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3
 golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0 h1:Dh6fw+p6FyRl5x/FvNswO1ji0lIGzm3KP8Y9VkS9PTE=
 golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
 google.golang.org/api v0.4.0 h1:KKgc1aqhV8wDPbDzlDtpvyjZFY3vjz85FP7p4wcQUyI=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/goxpath.go b/vendor/github.com/ChrisTrenkamp/goxpath/goxpath.go
index af2e2f141..189ebb9c2 100644
--- a/vendor/github.com/ChrisTrenkamp/goxpath/goxpath.go
+++ b/vendor/github.com/ChrisTrenkamp/goxpath/goxpath.go
@@ -5,7 +5,7 @@ import (
 	"fmt"
 
 	"github.com/ChrisTrenkamp/goxpath/internal/execxp"
-	"github.com/ChrisTrenkamp/goxpath/internal/parser"
+	"github.com/ChrisTrenkamp/goxpath/parser"
 	"github.com/ChrisTrenkamp/goxpath/tree"
 )
 
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/execxp.go b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/execxp.go
index 0746eacac..7b3251568 100644
--- a/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/execxp.go
+++ b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/execxp.go
@@ -3,7 +3,7 @@ package execxp
 import (
 	"encoding/xml"
 
-	"github.com/ChrisTrenkamp/goxpath/internal/parser"
+	"github.com/ChrisTrenkamp/goxpath/parser"
 	"github.com/ChrisTrenkamp/goxpath/tree"
 )
 
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/findutil/findUtil.go b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/findutil/findUtil.go
similarity index 98%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/findutil/findUtil.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/findutil/findUtil.go
index 6a6d44abe..058f79a0b 100644
--- a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/findutil/findUtil.go
+++ b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/findutil/findUtil.go
@@ -3,9 +3,9 @@ package findutil
 import (
 	"encoding/xml"
 
-	"github.com/ChrisTrenkamp/goxpath/internal/parser/pathexpr"
-	"github.com/ChrisTrenkamp/goxpath/internal/xconst"
+	"github.com/ChrisTrenkamp/goxpath/parser/pathexpr"
 	"github.com/ChrisTrenkamp/goxpath/tree"
+	"github.com/ChrisTrenkamp/goxpath/xconst"
 )
 
 const (
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/boolfns.go b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/boolfns.go
similarity index 100%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/boolfns.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/boolfns.go
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/intfns.go b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/intfns.go
similarity index 100%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/intfns.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/intfns.go
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/nodesetfns.go b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/nodesetfns.go
similarity index 100%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/nodesetfns.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/nodesetfns.go
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/numfns.go b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/numfns.go
similarity index 100%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/numfns.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/numfns.go
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/stringfns.go b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/stringfns.go
similarity index 100%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/intfns/stringfns.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns/stringfns.go
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/paths.go b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/paths.go
index 60ada7ab1..5a78138ee 100644
--- a/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/paths.go
+++ b/vendor/github.com/ChrisTrenkamp/goxpath/internal/execxp/paths.go
@@ -6,15 +6,14 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/ChrisTrenkamp/goxpath/internal/parser"
-	"github.com/ChrisTrenkamp/goxpath/internal/parser/findutil"
-	"github.com/ChrisTrenkamp/goxpath/internal/parser/intfns"
-	"github.com/ChrisTrenkamp/goxpath/internal/xconst"
+	"github.com/ChrisTrenkamp/goxpath/internal/execxp/findutil"
+	"github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns"
 	"github.com/ChrisTrenkamp/goxpath/internal/xsort"
-
-	"github.com/ChrisTrenkamp/goxpath/internal/lexer"
-	"github.com/ChrisTrenkamp/goxpath/internal/parser/pathexpr"
+	"github.com/ChrisTrenkamp/goxpath/lexer"
+	"github.com/ChrisTrenkamp/goxpath/parser"
+	"github.com/ChrisTrenkamp/goxpath/parser/pathexpr"
 	"github.com/ChrisTrenkamp/goxpath/tree"
+	"github.com/ChrisTrenkamp/goxpath/xconst"
 )
 
 type xpFilt struct {
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/lexer/lexer.go b/vendor/github.com/ChrisTrenkamp/goxpath/lexer/lexer.go
similarity index 100%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/lexer/lexer.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/lexer/lexer.go
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/lexer/paths.go b/vendor/github.com/ChrisTrenkamp/goxpath/lexer/paths.go
similarity index 98%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/lexer/paths.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/lexer/paths.go
index 2393f6966..dac30d6b6 100644
--- a/vendor/github.com/ChrisTrenkamp/goxpath/internal/lexer/paths.go
+++ b/vendor/github.com/ChrisTrenkamp/goxpath/lexer/paths.go
@@ -3,7 +3,7 @@ package lexer
 import (
 	"fmt"
 
-	"github.com/ChrisTrenkamp/goxpath/internal/xconst"
+	"github.com/ChrisTrenkamp/goxpath/xconst"
 )
 
 func absLocPathState(l *Lexer) stateFn {
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/lexer/xmlchars.go b/vendor/github.com/ChrisTrenkamp/goxpath/lexer/xmlchars.go
similarity index 100%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/lexer/xmlchars.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/lexer/xmlchars.go
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/ast.go b/vendor/github.com/ChrisTrenkamp/goxpath/parser/ast.go
similarity index 97%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/ast.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/parser/ast.go
index ec62206ea..89678f6ba 100644
--- a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/ast.go
+++ b/vendor/github.com/ChrisTrenkamp/goxpath/parser/ast.go
@@ -1,6 +1,6 @@
 package parser
 
-import "github.com/ChrisTrenkamp/goxpath/internal/lexer"
+import "github.com/ChrisTrenkamp/goxpath/lexer"
 
 //NodeType enumerations
 const (
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/parser.go b/vendor/github.com/ChrisTrenkamp/goxpath/parser/parser.go
similarity index 98%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/parser.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/parser/parser.go
index 9029c7a74..ff664ff78 100644
--- a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/parser.go
+++ b/vendor/github.com/ChrisTrenkamp/goxpath/parser/parser.go
@@ -3,7 +3,7 @@ package parser
 import (
 	"fmt"
 
-	"github.com/ChrisTrenkamp/goxpath/internal/lexer"
+	"github.com/ChrisTrenkamp/goxpath/lexer"
 )
 
 type stateType int
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/pathexpr/pathexpr.go b/vendor/github.com/ChrisTrenkamp/goxpath/parser/pathexpr/pathexpr.go
similarity index 100%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/parser/pathexpr/pathexpr.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/parser/pathexpr/pathexpr.go
diff --git a/vendor/github.com/ChrisTrenkamp/goxpath/internal/xconst/xconst.go b/vendor/github.com/ChrisTrenkamp/goxpath/xconst/xconst.go
similarity index 100%
rename from vendor/github.com/ChrisTrenkamp/goxpath/internal/xconst/xconst.go
rename to vendor/github.com/ChrisTrenkamp/goxpath/xconst/xconst.go
diff --git a/vendor/github.com/agext/levenshtein/.gitignore b/vendor/github.com/agext/levenshtein/.gitignore
new file mode 100644
index 000000000..4473da19b
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/.gitignore
@@ -0,0 +1,53 @@
+# Ignore docs files
+_gh_pages
+_site
+
+# Ignore temporary files
+README.html
+coverage.out
+.tmp
+
+# Numerous always-ignore extensions
+*.diff
+*.err
+*.log
+*.orig
+*.rej
+*.swo
+*.swp
+*.vi
+*.zip
+*~
+
+# OS or Editor folders
+._*
+.cache
+.DS_Store
+.idea
+.project
+.settings
+.tmproj
+*.esproj
+*.sublime-project
+*.sublime-workspace
+nbproject
+Thumbs.db
+
+# Komodo
+.komodotools
+*.komodoproject
+
+# SCSS-Lint
+scss-lint-report.xml
+
+# grunt-contrib-sass cache
+.sass-cache
+
+# Jekyll metadata
+docs/.jekyll-metadata
+
+# Folders to ignore
+.build
+.test
+bower_components
+node_modules
diff --git a/vendor/github.com/agext/levenshtein/.travis.yml b/vendor/github.com/agext/levenshtein/.travis.yml
new file mode 100644
index 000000000..a51a14466
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/.travis.yml
@@ -0,0 +1,25 @@
+language: go
+sudo: false
+matrix:
+  fast_finish: true
+  include:
+    - go: 1.11.x
+      env: TEST_METHOD=goveralls
+    - go: 1.10.x
+    - go: tip
+    - go: 1.9.x
+    - go: 1.8.x
+    - go: 1.7.x
+    - go: 1.6.x
+    - go: 1.5.x
+  allow_failures:
+    - go: tip
+    - go: 1.9.x
+    - go: 1.8.x
+    - go: 1.7.x
+    - go: 1.6.x
+    - go: 1.5.x
+script: ./test.sh $TEST_METHOD
+notifications:
+  email:
+    on_success: never
diff --git a/vendor/github.com/agext/levenshtein/DCO b/vendor/github.com/agext/levenshtein/DCO
new file mode 100644
index 000000000..716561d5d
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/DCO
@@ -0,0 +1,36 @@
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+660 York Street, Suite 102,
+San Francisco, CA 94110 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/LICENSE b/vendor/github.com/agext/levenshtein/LICENSE
similarity index 99%
rename from vendor/github.com/masterzen/azure-sdk-for-go/LICENSE
rename to vendor/github.com/agext/levenshtein/LICENSE
index af39a91e7..261eeb9e9 100644
--- a/vendor/github.com/masterzen/azure-sdk-for-go/LICENSE
+++ b/vendor/github.com/agext/levenshtein/LICENSE
@@ -1,4 +1,3 @@
-
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
@@ -187,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2016 Microsoft Corporation
+   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.
diff --git a/vendor/github.com/agext/levenshtein/MAINTAINERS b/vendor/github.com/agext/levenshtein/MAINTAINERS
new file mode 100644
index 000000000..726c2afb3
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/MAINTAINERS
@@ -0,0 +1 @@
+Alex Bucataru <alex@alrux.com> (@AlexBucataru)
diff --git a/vendor/github.com/agext/levenshtein/NOTICE b/vendor/github.com/agext/levenshtein/NOTICE
new file mode 100644
index 000000000..eaffaab94
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/NOTICE
@@ -0,0 +1,5 @@
+Alrux Go EXTensions (AGExt) - package levenshtein
+Copyright 2016 ALRUX Inc.
+
+This product includes software developed at ALRUX Inc.
+(http://www.alrux.com/).
diff --git a/vendor/github.com/agext/levenshtein/README.md b/vendor/github.com/agext/levenshtein/README.md
new file mode 100644
index 000000000..9e4255879
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/README.md
@@ -0,0 +1,38 @@
+# A Go package for calculating the Levenshtein distance between two strings
+
+[![Release](https://img.shields.io/github/release/agext/levenshtein.svg?style=flat)](https://github.com/agext/levenshtein/releases/latest)
+[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/agext/levenshtein) 
+[![Build Status](https://travis-ci.org/agext/levenshtein.svg?branch=master&style=flat)](https://travis-ci.org/agext/levenshtein)
+[![Coverage Status](https://coveralls.io/repos/github/agext/levenshtein/badge.svg?style=flat)](https://coveralls.io/github/agext/levenshtein)
+[![Go Report Card](https://goreportcard.com/badge/github.com/agext/levenshtein?style=flat)](https://goreportcard.com/report/github.com/agext/levenshtein)
+
+
+This package implements distance and similarity metrics for strings, based on the Levenshtein measure, in [Go](http://golang.org).
+
+## Project Status
+
+v1.2.2 Stable: Guaranteed no breaking changes to the API in future v1.x releases. Probably safe to use in production, though provided on "AS IS" basis.
+
+This package is being actively maintained. If you encounter any problems or have any suggestions for improvement, please [open an issue](https://github.com/agext/levenshtein/issues). Pull requests are welcome.
+
+## Overview
+
+The Levenshtein `Distance` between two strings is the minimum total cost of edits that would convert the first string into the second. The allowed edit operations are insertions, deletions, and substitutions, all at character (one UTF-8 code point) level. Each operation has a default cost of 1, but each can be assigned its own cost equal to or greater than 0.
+
+A `Distance` of 0 means the two strings are identical, and the higher the value the more different the strings. Since in practice we are interested in finding if the two strings are "close enough", it often does not make sense to continue the calculation once the result is mathematically guaranteed to exceed a desired threshold. Providing this value to the `Distance` function allows it to take a shortcut and return a lower bound instead of an exact cost when the threshold is exceeded.
+
+The `Similarity` function calculates the distance, then converts it into a normalized metric within the range 0..1, with 1 meaning the strings are identical, and 0 that they have nothing in common. A minimum similarity threshold can be provided to speed up the calculation of the metric for strings that are far too dissimilar for the purpose at hand. All values under this threshold are rounded down to 0.
+
+The `Match` function provides a similarity metric, with the same range and meaning as `Similarity`, but with a bonus for string pairs that share a common prefix and have a similarity above a "bonus threshold". It uses the same method as proposed by Winkler for the Jaro distance, and the reasoning behind it is that these string pairs are very likely spelling variations or errors, and they are more closely linked than the edit distance alone would suggest.
+
+The underlying `Calculate` function is also exported, to allow the building of other derivative metrics, if needed.
+
+## Installation
+
+```
+go get github.com/agext/levenshtein
+```
+
+## License
+
+Package levenshtein is released under the Apache 2.0 license. See the [LICENSE](LICENSE) file for details.
diff --git a/vendor/github.com/agext/levenshtein/go.mod b/vendor/github.com/agext/levenshtein/go.mod
new file mode 100644
index 000000000..545d432be
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/go.mod
@@ -0,0 +1 @@
+module github.com/agext/levenshtein
diff --git a/vendor/github.com/agext/levenshtein/levenshtein.go b/vendor/github.com/agext/levenshtein/levenshtein.go
new file mode 100644
index 000000000..df69ce701
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/levenshtein.go
@@ -0,0 +1,290 @@
+// Copyright 2016 ALRUX Inc.
+//
+// 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 levenshtein implements distance and similarity metrics for strings, based on the Levenshtein measure.
+
+The Levenshtein `Distance` between two strings is the minimum total cost of edits that would convert the first string into the second. The allowed edit operations are insertions, deletions, and substitutions, all at character (one UTF-8 code point) level. Each operation has a default cost of 1, but each can be assigned its own cost equal to or greater than 0.
+
+A `Distance` of 0 means the two strings are identical, and the higher the value the more different the strings. Since in practice we are interested in finding if the two strings are "close enough", it often does not make sense to continue the calculation once the result is mathematically guaranteed to exceed a desired threshold. Providing this value to the `Distance` function allows it to take a shortcut and return a lower bound instead of an exact cost when the threshold is exceeded.
+
+The `Similarity` function calculates the distance, then converts it into a normalized metric within the range 0..1, with 1 meaning the strings are identical, and 0 that they have nothing in common. A minimum similarity threshold can be provided to speed up the calculation of the metric for strings that are far too dissimilar for the purpose at hand. All values under this threshold are rounded down to 0.
+
+The `Match` function provides a similarity metric, with the same range and meaning as `Similarity`, but with a bonus for string pairs that share a common prefix and have a similarity above a "bonus threshold". It uses the same method as proposed by Winkler for the Jaro distance, and the reasoning behind it is that these string pairs are very likely spelling variations or errors, and they are more closely linked than the edit distance alone would suggest.
+
+The underlying `Calculate` function is also exported, to allow the building of other derivative metrics, if needed.
+*/
+package levenshtein
+
+// Calculate determines the Levenshtein distance between two strings, using
+// the given costs for each edit operation. It returns the distance along with
+// the lengths of the longest common prefix and suffix.
+//
+// If maxCost is non-zero, the calculation stops as soon as the distance is determined
+// to be greater than maxCost. Therefore, any return value higher than maxCost is a
+// lower bound for the actual distance.
+func Calculate(str1, str2 []rune, maxCost, insCost, subCost, delCost int) (dist, prefixLen, suffixLen int) {
+	l1, l2 := len(str1), len(str2)
+	// trim common prefix, if any, as it doesn't affect the distance
+	for ; prefixLen < l1 && prefixLen < l2; prefixLen++ {
+		if str1[prefixLen] != str2[prefixLen] {
+			break
+		}
+	}
+	str1, str2 = str1[prefixLen:], str2[prefixLen:]
+	l1 -= prefixLen
+	l2 -= prefixLen
+	// trim common suffix, if any, as it doesn't affect the distance
+	for 0 < l1 && 0 < l2 {
+		if str1[l1-1] != str2[l2-1] {
+			str1, str2 = str1[:l1], str2[:l2]
+			break
+		}
+		l1--
+		l2--
+		suffixLen++
+	}
+	// if the first string is empty, the distance is the length of the second string times the cost of insertion
+	if l1 == 0 {
+		dist = l2 * insCost
+		return
+	}
+	// if the second string is empty, the distance is the length of the first string times the cost of deletion
+	if l2 == 0 {
+		dist = l1 * delCost
+		return
+	}
+
+	// variables used in inner "for" loops
+	var y, dy, c, l int
+
+	// if maxCost is greater than or equal to the maximum possible distance, it's equivalent to 'unlimited'
+	if maxCost > 0 {
+		if subCost < delCost+insCost {
+			if maxCost >= l1*subCost+(l2-l1)*insCost {
+				maxCost = 0
+			}
+		} else {
+			if maxCost >= l1*delCost+l2*insCost {
+				maxCost = 0
+			}
+		}
+	}
+
+	if maxCost > 0 {
+		// prefer the longer string first, to minimize time;
+		// a swap also transposes the meanings of insertion and deletion.
+		if l1 < l2 {
+			str1, str2, l1, l2, insCost, delCost = str2, str1, l2, l1, delCost, insCost
+		}
+
+		// the length differential times cost of deletion is a lower bound for the cost;
+		// if it is higher than the maxCost, there is no point going into the main calculation.
+		if dist = (l1 - l2) * delCost; dist > maxCost {
+			return
+		}
+
+		d := make([]int, l1+1)
+
+		// offset and length of d in the current row
+		doff, dlen := 0, 1
+		for y, dy = 1, delCost; y <= l1 && dy <= maxCost; dlen++ {
+			d[y] = dy
+			y++
+			dy = y * delCost
+		}
+		// fmt.Printf("%q -> %q: init doff=%d dlen=%d d[%d:%d]=%v\n", str1, str2, doff, dlen, doff, doff+dlen, d[doff:doff+dlen])
+
+		for x := 0; x < l2; x++ {
+			dy, d[doff] = d[doff], d[doff]+insCost
+			for d[doff] > maxCost && dlen > 0 {
+				if str1[doff] != str2[x] {
+					dy += subCost
+				}
+				doff++
+				dlen--
+				if c = d[doff] + insCost; c < dy {
+					dy = c
+				}
+				dy, d[doff] = d[doff], dy
+			}
+			for y, l = doff, doff+dlen-1; y < l; dy, d[y] = d[y], dy {
+				if str1[y] != str2[x] {
+					dy += subCost
+				}
+				if c = d[y] + delCost; c < dy {
+					dy = c
+				}
+				y++
+				if c = d[y] + insCost; c < dy {
+					dy = c
+				}
+			}
+			if y < l1 {
+				if str1[y] != str2[x] {
+					dy += subCost
+				}
+				if c = d[y] + delCost; c < dy {
+					dy = c
+				}
+				for ; dy <= maxCost && y < l1; dy, d[y] = dy+delCost, dy {
+					y++
+					dlen++
+				}
+			}
+			// fmt.Printf("%q -> %q: x=%d doff=%d dlen=%d d[%d:%d]=%v\n", str1, str2, x, doff, dlen, doff, doff+dlen, d[doff:doff+dlen])
+			if dlen == 0 {
+				dist = maxCost + 1
+				return
+			}
+		}
+		if doff+dlen-1 < l1 {
+			dist = maxCost + 1
+			return
+		}
+		dist = d[l1]
+	} else {
+		// ToDo: This is O(l1*l2) time and O(min(l1,l2)) space; investigate if it is
+		// worth to implement diagonal approach - O(l1*(1+dist)) time, up to O(l1*l2) space
+		// http://www.csse.monash.edu.au/~lloyd/tildeStrings/Alignment/92.IPL.html
+
+		// prefer the shorter string first, to minimize space; time is O(l1*l2) anyway;
+		// a swap also transposes the meanings of insertion and deletion.
+		if l1 > l2 {
+			str1, str2, l1, l2, insCost, delCost = str2, str1, l2, l1, delCost, insCost
+		}
+		d := make([]int, l1+1)
+
+		for y = 1; y <= l1; y++ {
+			d[y] = y * delCost
+		}
+		for x := 0; x < l2; x++ {
+			dy, d[0] = d[0], d[0]+insCost
+			for y = 0; y < l1; dy, d[y] = d[y], dy {
+				if str1[y] != str2[x] {
+					dy += subCost
+				}
+				if c = d[y] + delCost; c < dy {
+					dy = c
+				}
+				y++
+				if c = d[y] + insCost; c < dy {
+					dy = c
+				}
+			}
+		}
+		dist = d[l1]
+	}
+
+	return
+}
+
+// Distance returns the Levenshtein distance between str1 and str2, using the
+// default or provided cost values. Pass nil for the third argument to use the
+// default cost of 1 for all three operations, with no maximum.
+func Distance(str1, str2 string, p *Params) int {
+	if p == nil {
+		p = defaultParams
+	}
+	dist, _, _ := Calculate([]rune(str1), []rune(str2), p.maxCost, p.insCost, p.subCost, p.delCost)
+	return dist
+}
+
+// Similarity returns a score in the range of 0..1 for how similar the two strings are.
+// A score of 1 means the strings are identical, and 0 means they have nothing in common.
+//
+// A nil third argument uses the default cost of 1 for all three operations.
+//
+// If a non-zero MinScore value is provided in the parameters, scores lower than it
+// will be returned as 0.
+func Similarity(str1, str2 string, p *Params) float64 {
+	return Match(str1, str2, p.Clone().BonusThreshold(1.1)) // guaranteed no bonus
+}
+
+// Match returns a similarity score adjusted by the same method as proposed by Winkler for
+// the Jaro distance - giving a bonus to string pairs that share a common prefix, only if their
+// similarity score is already over a threshold.
+//
+// The score is in the range of 0..1, with 1 meaning the strings are identical,
+// and 0 meaning they have nothing in common.
+//
+// A nil third argument uses the default cost of 1 for all three operations, maximum length of
+// common prefix to consider for bonus of 4, scaling factor of 0.1, and bonus threshold of 0.7.
+//
+// If a non-zero MinScore value is provided in the parameters, scores lower than it
+// will be returned as 0.
+func Match(str1, str2 string, p *Params) float64 {
+	s1, s2 := []rune(str1), []rune(str2)
+	l1, l2 := len(s1), len(s2)
+	// two empty strings are identical; shortcut also avoids divByZero issues later on.
+	if l1 == 0 && l2 == 0 {
+		return 1
+	}
+
+	if p == nil {
+		p = defaultParams
+	}
+
+	// a min over 1 can never be satisfied, so the score is 0.
+	if p.minScore > 1 {
+		return 0
+	}
+
+	insCost, delCost, maxDist, max := p.insCost, p.delCost, 0, 0
+	if l1 > l2 {
+		l1, l2, insCost, delCost = l2, l1, delCost, insCost
+	}
+
+	if p.subCost < delCost+insCost {
+		maxDist = l1*p.subCost + (l2-l1)*insCost
+	} else {
+		maxDist = l1*delCost + l2*insCost
+	}
+
+	// a zero min is always satisfied, so no need to set a max cost.
+	if p.minScore > 0 {
+		// if p.minScore is lower than p.bonusThreshold, we can use a simplified formula
+		// for the max cost, because a sim score below min cannot receive a bonus.
+		if p.minScore < p.bonusThreshold {
+			// round down the max - a cost equal to a rounded up max would already be under min.
+			max = int((1 - p.minScore) * float64(maxDist))
+		} else {
+			// p.minScore <= sim + p.bonusPrefix*p.bonusScale*(1-sim)
+			// p.minScore <= (1-dist/maxDist) + p.bonusPrefix*p.bonusScale*(1-(1-dist/maxDist))
+			// p.minScore <= 1 - dist/maxDist + p.bonusPrefix*p.bonusScale*dist/maxDist
+			// 1 - p.minScore >= dist/maxDist - p.bonusPrefix*p.bonusScale*dist/maxDist
+			// (1-p.minScore)*maxDist/(1-p.bonusPrefix*p.bonusScale) >= dist
+			max = int((1 - p.minScore) * float64(maxDist) / (1 - float64(p.bonusPrefix)*p.bonusScale))
+		}
+	}
+
+	dist, pl, _ := Calculate(s1, s2, max, p.insCost, p.subCost, p.delCost)
+	if max > 0 && dist > max {
+		return 0
+	}
+	sim := 1 - float64(dist)/float64(maxDist)
+
+	if sim >= p.bonusThreshold && sim < 1 && p.bonusPrefix > 0 && p.bonusScale > 0 {
+		if pl > p.bonusPrefix {
+			pl = p.bonusPrefix
+		}
+		sim += float64(pl) * p.bonusScale * (1 - sim)
+	}
+
+	if sim < p.minScore {
+		return 0
+	}
+
+	return sim
+}
diff --git a/vendor/github.com/agext/levenshtein/params.go b/vendor/github.com/agext/levenshtein/params.go
new file mode 100644
index 000000000..a85727b3e
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/params.go
@@ -0,0 +1,152 @@
+// Copyright 2016 ALRUX Inc.
+//
+// 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 levenshtein
+
+// Params represents a set of parameter values for the various formulas involved
+// in the calculation of the Levenshtein string metrics.
+type Params struct {
+	insCost        int
+	subCost        int
+	delCost        int
+	maxCost        int
+	minScore       float64
+	bonusPrefix    int
+	bonusScale     float64
+	bonusThreshold float64
+}
+
+var (
+	defaultParams = NewParams()
+)
+
+// NewParams creates a new set of parameters and initializes it with the default values.
+func NewParams() *Params {
+	return &Params{
+		insCost:        1,
+		subCost:        1,
+		delCost:        1,
+		maxCost:        0,
+		minScore:       0,
+		bonusPrefix:    4,
+		bonusScale:     .1,
+		bonusThreshold: .7,
+	}
+}
+
+// Clone returns a pointer to a copy of the receiver parameter set, or of a new
+// default parameter set if the receiver is nil.
+func (p *Params) Clone() *Params {
+	if p == nil {
+		return NewParams()
+	}
+	return &Params{
+		insCost:        p.insCost,
+		subCost:        p.subCost,
+		delCost:        p.delCost,
+		maxCost:        p.maxCost,
+		minScore:       p.minScore,
+		bonusPrefix:    p.bonusPrefix,
+		bonusScale:     p.bonusScale,
+		bonusThreshold: p.bonusThreshold,
+	}
+}
+
+// InsCost overrides the default value of 1 for the cost of insertion.
+// The new value must be zero or positive.
+func (p *Params) InsCost(v int) *Params {
+	if v >= 0 {
+		p.insCost = v
+	}
+	return p
+}
+
+// SubCost overrides the default value of 1 for the cost of substitution.
+// The new value must be zero or positive.
+func (p *Params) SubCost(v int) *Params {
+	if v >= 0 {
+		p.subCost = v
+	}
+	return p
+}
+
+// DelCost overrides the default value of 1 for the cost of deletion.
+// The new value must be zero or positive.
+func (p *Params) DelCost(v int) *Params {
+	if v >= 0 {
+		p.delCost = v
+	}
+	return p
+}
+
+// MaxCost overrides the default value of 0 (meaning unlimited) for the maximum cost.
+// The calculation of Distance() stops when the result is guaranteed to exceed
+// this maximum, returning a lower-bound rather than exact value.
+// The new value must be zero or positive.
+func (p *Params) MaxCost(v int) *Params {
+	if v >= 0 {
+		p.maxCost = v
+	}
+	return p
+}
+
+// MinScore overrides the default value of 0 for the minimum similarity score.
+// Scores below this threshold are returned as 0 by Similarity() and Match().
+// The new value must be zero or positive. Note that a minimum greater than 1
+// can never be satisfied, resulting in a score of 0 for any pair of strings.
+func (p *Params) MinScore(v float64) *Params {
+	if v >= 0 {
+		p.minScore = v
+	}
+	return p
+}
+
+// BonusPrefix overrides the default value for the maximum length of
+// common prefix to be considered for bonus by Match().
+// The new value must be zero or positive.
+func (p *Params) BonusPrefix(v int) *Params {
+	if v >= 0 {
+		p.bonusPrefix = v
+	}
+	return p
+}
+
+// BonusScale overrides the default value for the scaling factor used by Match()
+// in calculating the bonus.
+// The new value must be zero or positive. To guarantee that the similarity score
+// remains in the interval 0..1, this scaling factor is not allowed to exceed
+// 1 / BonusPrefix.
+func (p *Params) BonusScale(v float64) *Params {
+	if v >= 0 {
+		p.bonusScale = v
+	}
+
+	// the bonus cannot exceed (1-sim), or the score may become greater than 1.
+	if float64(p.bonusPrefix)*p.bonusScale > 1 {
+		p.bonusScale = 1 / float64(p.bonusPrefix)
+	}
+
+	return p
+}
+
+// BonusThreshold overrides the default value for the minimum similarity score
+// for which Match() can assign a bonus.
+// The new value must be zero or positive. Note that a threshold greater than 1
+// effectively makes Match() become the equivalent of Similarity().
+func (p *Params) BonusThreshold(v float64) *Params {
+	if v >= 0 {
+		p.bonusThreshold = v
+	}
+	return p
+}
diff --git a/vendor/github.com/agext/levenshtein/test.sh b/vendor/github.com/agext/levenshtein/test.sh
new file mode 100644
index 000000000..c5ed72466
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/test.sh
@@ -0,0 +1,10 @@
+set -ev
+
+if [[ "$1" == "goveralls" ]]; then
+	echo "Testing with goveralls..."
+	go get github.com/mattn/goveralls
+	$HOME/gopath/bin/goveralls -service=travis-ci
+else
+	echo "Testing with go test..."
+	go test -v ./...
+fi
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/auth.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/auth.go
index 02c1f144e..ee90591b2 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/auth.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/auth.go
@@ -12,15 +12,23 @@ import (
 	"strings"
 )
 
-// 用于signHeader的字典排序存放容器。
+// headerSorter defines the key-value structure for storing the sorted data in signHeader.
 type headerSorter struct {
 	Keys []string
 	Vals []string
 }
 
-// 生成签名方法（直接设置请求的Header）。
+// signHeader signs the header and sets it as the authorization header.
 func (conn Conn) signHeader(req *http.Request, canonicalizedResource string) {
-	// Find out the "x-oss-"'s address in this request'header
+	// Get the final authorization string
+	authorizationStr := "OSS " + conn.config.AccessKeyID + ":" + conn.getSignedStr(req, canonicalizedResource)
+
+	// Give the parameter "Authorization" value
+	req.Header.Set(HTTPHeaderAuthorization, authorizationStr)
+}
+
+func (conn Conn) getSignedStr(req *http.Request, canonicalizedResource string) string {
+	// Find out the "x-oss-"'s address in header of the request
 	temp := make(map[string]string)
 
 	for k, v := range req.Header {
@@ -30,16 +38,17 @@ func (conn Conn) signHeader(req *http.Request, canonicalizedResource string) {
 	}
 	hs := newHeaderSorter(temp)
 
-	// Sort the temp by the Ascending Order
+	// Sort the temp by the ascending order
 	hs.Sort()
 
-	// Get the CanonicalizedOSSHeaders
+	// Get the canonicalizedOSSHeaders
 	canonicalizedOSSHeaders := ""
 	for i := range hs.Keys {
 		canonicalizedOSSHeaders += hs.Keys[i] + ":" + hs.Vals[i] + "\n"
 	}
 
 	// Give other parameters values
+	// when sign URL, date is expires
 	date := req.Header.Get(HTTPHeaderDate)
 	contentType := req.Header.Get(HTTPHeaderContentType)
 	contentMd5 := req.Header.Get(HTTPHeaderContentMD5)
@@ -49,14 +58,10 @@ func (conn Conn) signHeader(req *http.Request, canonicalizedResource string) {
 	io.WriteString(h, signStr)
 	signedStr := base64.StdEncoding.EncodeToString(h.Sum(nil))
 
-	// Get the final Authorization' string
-	authorizationStr := "OSS " + conn.config.AccessKeyID + ":" + signedStr
-
-	// Give the parameter "Authorization" value
-	req.Header.Set(HTTPHeaderAuthorization, authorizationStr)
+	return signedStr
 }
 
-// Additional function for function SignHeader.
+// newHeaderSorter is an additional function for function SignHeader.
 func newHeaderSorter(m map[string]string) *headerSorter {
 	hs := &headerSorter{
 		Keys: make([]string, 0, len(m)),
@@ -70,22 +75,22 @@ func newHeaderSorter(m map[string]string) *headerSorter {
 	return hs
 }
 
-// Additional function for function SignHeader.
+// Sort is an additional function for function SignHeader.
 func (hs *headerSorter) Sort() {
 	sort.Sort(hs)
 }
 
-// Additional function for function SignHeader.
+// Len is an additional function for function SignHeader.
 func (hs *headerSorter) Len() int {
 	return len(hs.Vals)
 }
 
-// Additional function for function SignHeader.
+// Less is an additional function for function SignHeader.
 func (hs *headerSorter) Less(i, j int) bool {
 	return bytes.Compare([]byte(hs.Keys[i]), []byte(hs.Keys[j])) < 0
 }
 
-// Additional function for function SignHeader.
+// Swap is an additional function for function SignHeader.
 func (hs *headerSorter) Swap(i, j int) {
 	hs.Vals[i], hs.Vals[j] = hs.Vals[j], hs.Vals[i]
 	hs.Keys[i], hs.Keys[j] = hs.Keys[j], hs.Keys[i]
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/bucket.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/bucket.go
index 1da3c0765..067855e09 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/bucket.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/bucket.go
@@ -5,14 +5,16 @@ import (
 	"crypto/md5"
 	"encoding/base64"
 	"encoding/xml"
+	"fmt"
 	"hash"
 	"hash/crc64"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/url"
 	"os"
 	"strconv"
+	"strings"
+	"time"
 )
 
 // Bucket implements the operations of object.
@@ -21,16 +23,15 @@ type Bucket struct {
 	BucketName string
 }
 
+// PutObject creates a new object and it will overwrite the original one if it exists already.
 //
-// PutObject 新建Object，如果Object已存在，覆盖原有Object。
+// objectKey    the object key in UTF-8 encoding. The length must be between 1 and 1023, and cannot start with "/" or "\".
+// reader    io.Reader instance for reading the data for uploading
+// options    the options for uploading the object. The valid options here are CacheControl, ContentDisposition, ContentEncoding
+//            Expires, ServerSideEncryption, ObjectACL and Meta. Refer to the link below for more details.
+//            https://help.aliyun.com/document_detail/oss/api-reference/object/PutObject.html
 //
-// objectKey  上传对象的名称，使用UTF-8编码、长度必须在1-1023字节之间、不能以“/”或者“\”字符开头。
-// reader     io.Reader读取object的数据。
-// options    上传对象时可以指定对象的属性，可用选项有CacheControl、ContentDisposition、ContentEncoding、
-// Expires、ServerSideEncryption、ObjectACL、Meta，具体含义请参看
-// https://help.aliyun.com/document_detail/oss/api-reference/object/PutObject.html
-//
-// error  操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) PutObject(objectKey string, reader io.Reader, options ...Option) error {
 	opts := addContentType(options, objectKey)
@@ -48,14 +49,13 @@ func (bucket Bucket) PutObject(objectKey string, reader io.Reader, options ...Op
 	return err
 }
 
+// PutObjectFromFile creates a new object from the local file.
 //
-// PutObjectFromFile 新建Object，内容从本地文件中读取。
+// objectKey    object key.
+// filePath    the local file path to upload.
+// options    the options for uploading the object. Refer to the parameter options in PutObject for more details.
 //
-// objectKey 上传对象的名称。
-// filePath  本地文件，上传对象的值为该文件内容。
-// options   上传对象时可以指定对象的属性。详见PutObject的options。
-//
-// error  操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) PutObjectFromFile(objectKey, filePath string, options ...Option) error {
 	fd, err := os.Open(filePath)
@@ -79,14 +79,13 @@ func (bucket Bucket) PutObjectFromFile(objectKey, filePath string, options ...Op
 	return err
 }
 
+// DoPutObject does the actual upload work.
 //
-// DoPutObject 上传文件。
+// request    the request instance for uploading an object.
+// options    the options for uploading an object.
 //
-// request  上传请求。
-// options  上传选项。
-//
-// Response 上传请求返回值。
-// error  操作无错误为nil，非nil为错误信息。
+// Response    the response from OSS.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) DoPutObject(request *PutObjectRequest, options []Option) (*Response, error) {
 	isOptSet, _, _ := isOptionSet(options, HTTPHeaderContentType)
@@ -96,7 +95,8 @@ func (bucket Bucket) DoPutObject(request *PutObjectRequest, options []Option) (*
 
 	listener := getProgressListener(options)
 
-	resp, err := bucket.do("PUT", request.ObjectKey, "", "", options, request.Reader, listener)
+	params := map[string]interface{}{}
+	resp, err := bucket.do("PUT", request.ObjectKey, params, options, request.Reader, listener)
 	if err != nil {
 		return nil, err
 	}
@@ -113,60 +113,64 @@ func (bucket Bucket) DoPutObject(request *PutObjectRequest, options []Option) (*
 	return resp, err
 }
 
+// GetObject downloads the object.
 //
-// GetObject 下载文件。
+// objectKey    the object key.
+// options    the options for downloading the object. The valid values are: Range, IfModifiedSince, IfUnmodifiedSince, IfMatch,
+//            IfNoneMatch, AcceptEncoding. For more details, please check out:
+//            https://help.aliyun.com/document_detail/oss/api-reference/object/GetObject.html
 //
-// objectKey 下载的文件名称。
-// options   对象的属性限制项，可选值有Range、IfModifiedSince、IfUnmodifiedSince、IfMatch、
-// IfNoneMatch、AcceptEncoding，详细请参考
-// https://help.aliyun.com/document_detail/oss/api-reference/object/GetObject.html
-//
-// io.ReadCloser  reader，读取数据后需要close。error为nil时有效。
-// error  操作无错误为nil，非nil为错误信息。
+// io.ReadCloser    reader instance for reading data from response. It must be called close() after the usage and only valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) GetObject(objectKey string, options ...Option) (io.ReadCloser, error) {
 	result, err := bucket.DoGetObject(&GetObjectRequest{objectKey}, options)
 	if err != nil {
 		return nil, err
 	}
-	return result.Response.Body, nil
+
+	return result.Response, nil
 }
 
+// GetObjectToFile downloads the data to a local file.
 //
-// GetObjectToFile 下载文件。
+// objectKey    the object key to download.
+// filePath    the local file to store the object data.
+// options    the options for downloading the object. Refer to the parameter options in method GetObject for more details.
 //
-// objectKey  下载的文件名称。
-// filePath   下载对象的内容写到该本地文件。
-// options    对象的属性限制项。详见GetObject的options。
-//
-// error  操作无错误时返回error为nil，非nil为错误说明。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) GetObjectToFile(objectKey, filePath string, options ...Option) error {
 	tempFilePath := filePath + TempFileSuffix
 
-	// 读取Object内容
+	// Calls the API to actually download the object. Returns the result instance.
 	result, err := bucket.DoGetObject(&GetObjectRequest{objectKey}, options)
 	if err != nil {
 		return err
 	}
-	defer result.Response.Body.Close()
+	defer result.Response.Close()
 
-	// 如果文件不存在则创建，存在则清空
+	// If the local file does not exist, create a new one. If it exists, overwrite it.
 	fd, err := os.OpenFile(tempFilePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, FilePermMode)
 	if err != nil {
 		return err
 	}
 
-	// 存储数据到文件
+	// Copy the data to the local file path.
 	_, err = io.Copy(fd, result.Response.Body)
 	fd.Close()
 	if err != nil {
 		return err
 	}
 
-	// 比较CRC值
+	// Compares the CRC value
 	hasRange, _, _ := isOptionSet(options, HTTPHeaderRange)
-	if bucket.getConfig().IsEnableCRC && !hasRange {
+	encodeOpt, _ := findOption(options, HTTPHeaderAcceptEncoding, nil)
+	acceptEncoding := ""
+	if encodeOpt != nil {
+		acceptEncoding = encodeOpt.(string)
+	}
+	if bucket.getConfig().IsEnableCRC && !hasRange && acceptEncoding != "gzip" {
 		result.Response.ClientCRC = result.ClientCRC.Sum64()
 		err = checkCRC(result.Response, "GetObjectToFile")
 		if err != nil {
@@ -178,17 +182,17 @@ func (bucket Bucket) GetObjectToFile(objectKey, filePath string, options ...Opti
 	return os.Rename(tempFilePath, filePath)
 }
 
+// DoGetObject is the actual API that gets the object. It's the internal function called by other public APIs.
 //
-// DoGetObject 下载文件
+// request    the request to download the object.
+// options    the options for downloading the file. Checks out the parameter options in method GetObject.
 //
-// request 下载请求
-// options    对象的属性限制项。详见GetObject的options。
-//
-// GetObjectResult 下载请求返回值。
-// error  操作无错误为nil，非nil为错误信息。
+// GetObjectResult    the result instance of getting the object.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) DoGetObject(request *GetObjectRequest, options []Option) (*GetObjectResult, error) {
-	resp, err := bucket.do("GET", request.ObjectKey, "", "", options, nil, nil)
+	params, _ := getRawParams(options)
+	resp, err := bucket.do("GET", request.ObjectKey, params, options, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -197,7 +201,7 @@ func (bucket Bucket) DoGetObject(request *GetObjectRequest, options []Option) (*
 		Response: resp,
 	}
 
-	// crc
+	// CRC
 	var crcCalc hash.Hash64
 	hasRange, _, _ := isOptionSet(options, HTTPHeaderRange)
 	if bucket.getConfig().IsEnableCRC && !hasRange {
@@ -206,32 +210,32 @@ func (bucket Bucket) DoGetObject(request *GetObjectRequest, options []Option) (*
 		result.ClientCRC = crcCalc
 	}
 
-	// progress
+	// Progress
 	listener := getProgressListener(options)
 
 	contentLen, _ := strconv.ParseInt(resp.Headers.Get(HTTPHeaderContentLength), 10, 64)
-	resp.Body = ioutil.NopCloser(TeeReader(resp.Body, crcCalc, contentLen, listener, nil))
+	resp.Body = TeeReader(resp.Body, crcCalc, contentLen, listener, nil)
 
 	return result, nil
 }
 
+// CopyObject copies the object inside the bucket.
 //
-// CopyObject 同一个bucket内拷贝Object。
+// srcObjectKey    the source object to copy.
+// destObjectKey    the target object to copy.
+// options    options for copying an object. You can specify the conditions of copy. The valid conditions are CopySourceIfMatch,
+//            CopySourceIfNoneMatch, CopySourceIfModifiedSince, CopySourceIfUnmodifiedSince, MetadataDirective.
+//            Also you can specify the target object's attributes, such as CacheControl, ContentDisposition, ContentEncoding, Expires,
+//            ServerSideEncryption, ObjectACL, Meta. Refer to the link below for more details :
+//            https://help.aliyun.com/document_detail/oss/api-reference/object/CopyObject.html
 //
-// srcObjectKey  Copy的源对象。
-// destObjectKey Copy的目标对象。
-// options  Copy对象时，您可以指定源对象的限制条件，满足限制条件时copy，不满足时返回错误，您可以选择如下选项CopySourceIfMatch、
-// CopySourceIfNoneMatch、CopySourceIfModifiedSince、CopySourceIfUnmodifiedSince、MetadataDirective。
-// Copy对象时，您可以指定目标对象的属性，如CacheControl、ContentDisposition、ContentEncoding、Expires、
-// ServerSideEncryption、ObjectACL、Meta，选项的含义请参看
-// https://help.aliyun.com/document_detail/oss/api-reference/object/CopyObject.html
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) CopyObject(srcObjectKey, destObjectKey string, options ...Option) (CopyObjectResult, error) {
 	var out CopyObjectResult
 	options = append(options, CopySource(bucket.BucketName, url.QueryEscape(srcObjectKey)))
-	resp, err := bucket.do("PUT", destObjectKey, "", "", options, nil, nil)
+	params := map[string]interface{}{}
+	resp, err := bucket.do("PUT", destObjectKey, params, options, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -241,29 +245,28 @@ func (bucket Bucket) CopyObject(srcObjectKey, destObjectKey string, options ...O
 	return out, err
 }
 
+// CopyObjectTo copies the object to another bucket.
 //
-// CopyObjectTo bucket间拷贝object。
+// srcObjectKey    source object key. The source bucket is Bucket.BucketName .
+// destBucketName    target bucket name.
+// destObjectKey    target object name.
+// options    copy options, check out parameter options in function CopyObject for more details.
 //
-// srcObjectKey   源Object名称。源Bucket名称为Bucket.BucketName。
-// destBucketName  目标Bucket名称。
-// destObjectKey  目标Object名称。
-// options        Copy选项，详见CopyObject的options。
-//
-// error  操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) CopyObjectTo(destBucketName, destObjectKey, srcObjectKey string, options ...Option) (CopyObjectResult, error) {
 	return bucket.copy(srcObjectKey, destBucketName, destObjectKey, options...)
 }
 
 //
-// CopyObjectFrom bucket间拷贝object。
+// CopyObjectFrom copies the object to another bucket.
 //
-// srcBucketName  源Bucket名称。
-// srcObjectKey   源Object名称。
-// destObjectKey  目标Object名称。目标Bucket名称为Bucket.BucketName。
-// options        Copy选项，详见CopyObject的options。
+// srcBucketName    source bucket name.
+// srcObjectKey    source object name.
+// destObjectKey    target object name. The target bucket name is Bucket.BucketName.
+// options    copy options. Check out parameter options in function CopyObject.
 //
-// error  操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) CopyObjectFrom(srcBucketName, srcObjectKey, destObjectKey string, options ...Option) (CopyObjectResult, error) {
 	destBucketName := bucket.BucketName
@@ -284,7 +287,8 @@ func (bucket Bucket) copy(srcObjectKey, destBucketName, destObjectKey string, op
 	if err != nil {
 		return out, err
 	}
-	resp, err := bucket.Client.Conn.Do("PUT", destBucketName, destObjectKey, "", "", headers, nil, 0, nil)
+	params := map[string]interface{}{}
+	resp, err := bucket.Client.Conn.Do("PUT", destBucketName, destObjectKey, params, headers, nil, 0, nil)
 	if err != nil {
 		return out, err
 	}
@@ -294,22 +298,21 @@ func (bucket Bucket) copy(srcObjectKey, destBucketName, destObjectKey string, op
 	return out, err
 }
 
+// AppendObject uploads the data in the way of appending an existing or new object.
 //
-// AppendObject 追加方式上传。
+// AppendObject the parameter appendPosition specifies which postion (in the target object) to append. For the first append (to a non-existing file),
+// the appendPosition should be 0. The appendPosition in the subsequent calls will be the current object length.
+// For example, the first appendObject's appendPosition is 0 and it uploaded 65536 bytes data, then the second call's position is 65536.
+// The response header x-oss-next-append-position after each successful request also specifies the next call's append position (so the caller need not to maintain this information).
 //
-// AppendObject参数必须包含position，其值指定从何处进行追加。首次追加操作的position必须为0，
-// 后续追加操作的position是Object的当前长度。例如，第一次Append Object请求指定position值为0，
-// content-length是65536；那么，第二次Append Object需要指定position为65536。
-// 每次操作成功后，响应头部x-oss-next-append-position也会标明下一次追加的position。
+// objectKey    the target object to append to.
+// reader    io.Reader. The read instance for reading the data to append.
+// appendPosition    the start position to append.
+// destObjectProperties    the options for the first appending, such as CacheControl, ContentDisposition, ContentEncoding,
+//                         Expires, ServerSideEncryption, ObjectACL.
 //
-// objectKey  需要追加的Object。
-// reader     io.Reader，读取追的内容。
-// appendPosition  object追加的起始位置。
-// destObjectProperties  第一次追加时指定新对象的属性，如CacheControl、ContentDisposition、ContentEncoding、
-// Expires、ServerSideEncryption、ObjectACL。
-//
-// int64 下次追加的开始位置，error为nil空时有效。
-// error 操作无错误为nil，非nil为错误信息。
+// int64    the next append position, it's valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) AppendObject(objectKey string, reader io.Reader, appendPosition int64, options ...Option) (int64, error) {
 	request := &AppendObjectRequest{
@@ -319,21 +322,25 @@ func (bucket Bucket) AppendObject(objectKey string, reader io.Reader, appendPosi
 	}
 
 	result, err := bucket.DoAppendObject(request, options)
+	if err != nil {
+		return appendPosition, err
+	}
 
 	return result.NextPosition, err
 }
 
+// DoAppendObject is the actual API that does the object append.
 //
-// DoAppendObject 追加上传。
+// request    the request object for appending object.
+// options    the options for appending object.
 //
-// request 追加上传请求。
-// options 追加上传选项。
-//
-// AppendObjectResult 追加上传请求返回值。
-// error  操作无错误为nil，非nil为错误信息。
+// AppendObjectResult    the result object for appending object.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) DoAppendObject(request *AppendObjectRequest, options []Option) (*AppendObjectResult, error) {
-	params := "append&position=" + strconv.FormatInt(request.Position, 10)
+	params := map[string]interface{}{}
+	params["append"] = nil
+	params["position"] = strconv.FormatInt(request.Position, 10)
 	headers := make(map[string]string)
 
 	opts := addContentType(options, request.ObjectKey)
@@ -348,7 +355,7 @@ func (bucket Bucket) DoAppendObject(request *AppendObjectRequest, options []Opti
 	listener := getProgressListener(options)
 
 	handleOptions(headers, opts)
-	resp, err := bucket.Client.Conn.Do("POST", bucket.BucketName, request.ObjectKey, params, params, headers,
+	resp, err := bucket.Client.Conn.Do("POST", bucket.BucketName, request.ObjectKey, params, headers,
 		request.Reader, initCRC, listener)
 	if err != nil {
 		return nil, err
@@ -371,15 +378,15 @@ func (bucket Bucket) DoAppendObject(request *AppendObjectRequest, options []Opti
 	return result, nil
 }
 
+// DeleteObject deletes the object.
 //
-// DeleteObject 删除Object。
+// objectKey    the object key to delete.
 //
-// objectKey 待删除Object。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) DeleteObject(objectKey string) error {
-	resp, err := bucket.do("DELETE", objectKey, "", "", nil, nil, nil)
+	params := map[string]interface{}{}
+	resp, err := bucket.do("DELETE", objectKey, params, nil, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -387,14 +394,14 @@ func (bucket Bucket) DeleteObject(objectKey string) error {
 	return checkRespCode(resp.StatusCode, []int{http.StatusNoContent})
 }
 
+// DeleteObjects deletes multiple objects.
 //
-// DeleteObjects 批量删除object。
+// objectKeys    the object keys to delete.
+// options    the options for deleting objects.
+//            Supported option is DeleteObjectsQuiet which means it will not return error even deletion failed (not recommended). By default it's not used.
 //
-// objectKeys 待删除object类表。
-// options 删除选项，DeleteObjectsQuiet，是否是安静模式，默认不使用。
-//
-// DeleteObjectsResult 非安静模式的的返回值。
-// error 操作无错误为nil，非nil为错误信息。
+// DeleteObjectsResult    the result object.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) DeleteObjects(objectKeys []string, options ...Option) (DeleteObjectsResult, error) {
 	out := DeleteObjectsResult{}
@@ -404,7 +411,6 @@ func (bucket Bucket) DeleteObjects(objectKeys []string, options ...Option) (Dele
 	}
 	isQuiet, _ := findOption(options, deleteObjectsQuiet, false)
 	dxml.Quiet = isQuiet.(bool)
-	encode := "&encoding-type=url"
 
 	bs, err := xml.Marshal(dxml)
 	if err != nil {
@@ -418,7 +424,12 @@ func (bucket Bucket) DeleteObjects(objectKeys []string, options ...Option) (Dele
 	sum := md5.Sum(bs)
 	b64 := base64.StdEncoding.EncodeToString(sum[:])
 	options = append(options, ContentMD5(b64))
-	resp, err := bucket.do("POST", "", "delete"+encode, "delete", options, buffer, nil)
+
+	params := map[string]interface{}{}
+	params["delete"] = nil
+	params["encoding-type"] = "url"
+
+	resp, err := bucket.do("POST", "", params, options, buffer, nil)
 	if err != nil {
 		return out, err
 	}
@@ -432,54 +443,58 @@ func (bucket Bucket) DeleteObjects(objectKeys []string, options ...Option) (Dele
 	return out, err
 }
 
+// IsObjectExist checks if the object exists.
 //
-// IsObjectExist object是否存在。
+// bool    flag of object's existence (true:exists; false:non-exist) when error is nil.
 //
-// bool  object是否存在，true存在，false不存在。error为nil时有效。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) IsObjectExist(objectKey string) (bool, error) {
-	listRes, err := bucket.ListObjects(Prefix(objectKey), MaxKeys(1))
-	if err != nil {
-		return false, err
-	}
-
-	if len(listRes.Objects) == 1 && listRes.Objects[0].Key == objectKey {
+	_, err := bucket.GetObjectMeta(objectKey)
+	if err == nil {
 		return true, nil
 	}
-	return false, nil
+
+	switch err.(type) {
+	case ServiceError:
+		if err.(ServiceError).StatusCode == 404 {
+			return false, nil
+		}
+	}
+
+	return false, err
 }
 
+// ListObjects lists the objects under the current bucket.
 //
-// ListObjects 获得Bucket下筛选后所有的object的列表。
+// options    it contains all the filters for listing objects.
+//            It could specify a prefix filter on object keys,  the max keys count to return and the object key marker and the delimiter for grouping object names.
+//            The key marker means the returned objects' key must be greater than it in lexicographic order.
 //
-// options  ListObject的筛选行为。Prefix指定的前缀、MaxKeys最大数目、Marker第一个开始、Delimiter对Object名字进行分组的字符。
+//            For example, if the bucket has 8 objects, my-object-1, my-object-11, my-object-2, my-object-21,
+//            my-object-22, my-object-3, my-object-31, my-object-32. If the prefix is my-object-2 (no other filters), then it returns
+//            my-object-2, my-object-21, my-object-22 three objects. If the marker is my-object-22 (no other filters), then it returns
+//            my-object-3, my-object-31, my-object-32 three objects. If the max keys is 5, then it returns 5 objects.
+//            The three filters could be used together to achieve filter and paging functionality.
+//            If the prefix is the folder name, then it could list all files under this folder (including the files under its subfolders).
+//            But if the delimiter is specified with '/', then it only returns that folder's files (no subfolder's files). The direct subfolders are in the commonPrefixes properties.
+//            For example, if the bucket has three objects fun/test.jpg, fun/movie/001.avi, fun/movie/007.avi. And if the prefix is "fun/", then it returns all three objects.
+//            But if the delimiter is '/', then only "fun/test.jpg" is returned as files and fun/movie/ is returned as common prefix.
 //
-// 您有如下8个object，my-object-1, my-object-11, my-object-2, my-object-21,
-// my-object-22, my-object-3, my-object-31, my-object-32。如果您指定了Prefix为my-object-2,
-// 则返回my-object-2, my-object-21, my-object-22三个object。如果您指定了Marker为my-object-22，
-// 则返回my-object-3, my-object-31, my-object-32三个object。如果您指定MaxKeys则每次最多返回MaxKeys个，
-// 最后一次可能不足。这三个参数可以组合使用，实现分页等功能。如果把prefix设为某个文件夹名，就可以罗列以此prefix开头的文件，
-// 即该文件夹下递归的所有的文件和子文件夹。如果再把delimiter设置为"/"时，返回值就只罗列该文件夹下的文件，该文件夹下的子文件名
-// 返回在CommonPrefixes部分，子文件夹下递归的文件和文件夹不被显示。例如一个bucket存在三个object，fun/test.jpg、
-// fun/movie/001.avi、fun/movie/007.avi。若设定prefix为"fun/"，则返回三个object；如果增加设定
-// delimiter为"/"，则返回文件"fun/test.jpg"和前缀"fun/movie/"，即实现了文件夹的逻辑。
+//            For common usage scenario, check out sample/list_object.go.
 //
-// 常用场景，请参数示例sample/list_object.go。
-//
-// ListObjectsResponse  操作成功后的返回值，成员Objects为bucket中对象列表。error为nil时该返回值有效。
+// ListObjectsResponse    the return value after operation succeeds (only valid when error is nil).
 //
 func (bucket Bucket) ListObjects(options ...Option) (ListObjectsResult, error) {
 	var out ListObjectsResult
 
 	options = append(options, EncodingType("url"))
-	params, err := handleParams(options)
+	params, err := getRawParams(options)
 	if err != nil {
 		return out, err
 	}
 
-	resp, err := bucket.do("GET", "", params, "", nil, nil, nil)
+	resp, err := bucket.do("GET", "", params, options, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -494,14 +509,13 @@ func (bucket Bucket) ListObjects(options ...Option) (ListObjectsResult, error) {
 	return out, err
 }
 
+// SetObjectMeta sets the metadata of the Object.
 //
-// SetObjectMeta 设置Object的Meta。
+// objectKey    object
+// options    options for setting the metadata. The valid options are CacheControl, ContentDisposition, ContentEncoding, Expires,
+//            ServerSideEncryption, and custom metadata.
 //
-// objectKey object
-// options 指定对象的属性，有以下可选项CacheControl、ContentDisposition、ContentEncoding、Expires、
-// ServerSideEncryption、Meta。
-//
-// error 操作无错误时error为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) SetObjectMeta(objectKey string, options ...Option) error {
 	options = append(options, MetadataDirective(MetaReplace))
@@ -509,18 +523,18 @@ func (bucket Bucket) SetObjectMeta(objectKey string, options ...Option) error {
 	return err
 }
 
+// GetObjectDetailedMeta gets the object's detailed metadata
 //
-// GetObjectDetailedMeta 查询Object的头信息。
+// objectKey    object key.
+// options    the constraints of the object. Only when the object meets the requirements this method will return the metadata. Otherwise returns error. Valid options are IfModifiedSince, IfUnmodifiedSince,
+//            IfMatch, IfNoneMatch. For more details check out https://help.aliyun.com/document_detail/oss/api-reference/object/HeadObject.html
 //
-// objectKey object名称。
-// objectPropertyConstraints 对象的属性限制项，满足时正常返回，不满足时返回错误。现在项有IfModifiedSince、IfUnmodifiedSince、
-// IfMatch、IfNoneMatch。具体含义请参看 https://help.aliyun.com/document_detail/oss/api-reference/object/HeadObject.html
-//
-// http.Header  对象的meta，error为nil时有效。
-// error  操作无错误为nil，非nil为错误信息。
+// http.Header    object meta when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) GetObjectDetailedMeta(objectKey string, options ...Option) (http.Header, error) {
-	resp, err := bucket.do("HEAD", objectKey, "", "", options, nil, nil)
+	params := map[string]interface{}{}
+	resp, err := bucket.do("HEAD", objectKey, params, options, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -529,19 +543,21 @@ func (bucket Bucket) GetObjectDetailedMeta(objectKey string, options ...Option)
 	return resp.Headers, nil
 }
 
+// GetObjectMeta gets object metadata.
 //
-// GetObjectMeta 查询Object的头信息。
+// GetObjectMeta is more lightweight than GetObjectDetailedMeta as it only returns basic metadata including ETag
+// size, LastModified. The size information is in the HTTP header Content-Length.
 //
-// GetObjectMeta相比GetObjectDetailedMeta更轻量，仅返回指定Object的少量基本meta信息，
-// 包括该Object的ETag、Size（对象大小）、LastModified，其中Size由响应头Content-Length的数值表示。
+// objectKey    object key
 //
-// objectKey object名称。
+// http.Header    the object's metadata, valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
-// http.Header 对象的meta，error为nil时有效。
-// error 操作无错误为nil，非nil为错误信息。
-//
-func (bucket Bucket) GetObjectMeta(objectKey string) (http.Header, error) {
-	resp, err := bucket.do("GET", objectKey, "?objectMeta", "", nil, nil, nil)
+func (bucket Bucket) GetObjectMeta(objectKey string, options ...Option) (http.Header, error) {
+	params := map[string]interface{}{}
+	params["objectMeta"] = nil
+	//resp, err := bucket.do("GET", objectKey, "?objectMeta", "", nil, nil, nil)
+	resp, err := bucket.do("HEAD", objectKey, params, options, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -550,26 +566,27 @@ func (bucket Bucket) GetObjectMeta(objectKey string) (http.Header, error) {
 	return resp.Headers, nil
 }
 
+// SetObjectACL updates the object's ACL.
 //
-// SetObjectACL 修改Object的ACL权限。
+// Only the bucket's owner could update object's ACL which priority is higher than bucket's ACL.
+// For example, if the bucket ACL is private and object's ACL is public-read-write.
+// Then object's ACL is used and it means all users could read or write that object.
+// When the object's ACL is not set, then bucket's ACL is used as the object's ACL.
 //
-// 只有Bucket Owner才有权限调用PutObjectACL来修改Object的ACL。Object ACL优先级高于Bucket ACL。
-// 例如Bucket ACL是private的，而Object ACL是public-read-write的，则访问这个Object时，
-// 先判断Object的ACL，所以所有用户都拥有这个Object的访问权限，即使这个Bucket是private bucket。
-// 如果某个Object从来没设置过ACL，则访问权限遵循Bucket ACL。
+// Object read operations include GetObject, HeadObject, CopyObject and UploadPartCopy on the source object;
+// Object write operations include PutObject, PostObject, AppendObject, DeleteObject, DeleteMultipleObjects,
+// CompleteMultipartUpload and CopyObject on target object.
 //
-// Object的读操作包括GetObject，HeadObject，CopyObject和UploadPartCopy中的对source object的读；
-// Object的写操作包括：PutObject，PostObject，AppendObject，DeleteObject，
-// DeleteMultipleObjects，CompleteMultipartUpload以及CopyObject对新的Object的写。
+// objectKey    the target object key (to set the ACL on)
+// objectAcl    object ACL. Valid options are PrivateACL, PublicReadACL, PublicReadWriteACL.
 //
-// objectKey 设置权限的object。
-// objectAcl 对象权限。可选值PrivateACL(私有读写)、PublicReadACL(公共读私有写)、PublicReadWriteACL(公共读写)。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) SetObjectACL(objectKey string, objectACL ACLType) error {
 	options := []Option{ObjectACL(objectACL)}
-	resp, err := bucket.do("PUT", objectKey, "acl", "acl", options, nil, nil)
+	params := map[string]interface{}{}
+	params["acl"] = nil
+	resp, err := bucket.do("PUT", objectKey, params, options, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -577,17 +594,18 @@ func (bucket Bucket) SetObjectACL(objectKey string, objectACL ACLType) error {
 	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
 }
 
+// GetObjectACL gets object's ACL
 //
-// GetObjectACL 获取对象的ACL权限。
+// objectKey    the object to get ACL from.
 //
-// objectKey 获取权限的object。
-//
-// GetObjectAclResponse 获取权限操作返回值，error为nil时有效。GetObjectAclResponse.Acl为对象的权限。
-// error 操作无错误为nil，非nil为错误信息。
+// GetObjectACLResult    the result object when error is nil. GetObjectACLResult.Acl is the object ACL.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (bucket Bucket) GetObjectACL(objectKey string) (GetObjectACLResult, error) {
 	var out GetObjectACLResult
-	resp, err := bucket.do("GET", objectKey, "acl", "acl", nil, nil, nil)
+	params := map[string]interface{}{}
+	params["acl"] = nil
+	resp, err := bucket.do("GET", objectKey, params, nil, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -597,8 +615,320 @@ func (bucket Bucket) GetObjectACL(objectKey string) (GetObjectACLResult, error)
 	return out, err
 }
 
+// PutSymlink creates a symlink (to point to an existing object)
+//
+// Symlink cannot point to another symlink.
+// When creating a symlink, it does not check the existence of the target file, and does not check if the target file is symlink.
+// Neither it checks the caller's permission on the target file. All these checks are deferred to the actual GetObject call via this symlink.
+// If trying to add an existing file, as long as the caller has the write permission, the existing one will be overwritten.
+// If the x-oss-meta- is specified, it will be added as the metadata of the symlink file.
+//
+// symObjectKey    the symlink object's key.
+// targetObjectKey    the target object key to point to.
+//
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) PutSymlink(symObjectKey string, targetObjectKey string, options ...Option) error {
+	options = append(options, symlinkTarget(url.QueryEscape(targetObjectKey)))
+	params := map[string]interface{}{}
+	params["symlink"] = nil
+	resp, err := bucket.do("PUT", symObjectKey, params, options, nil, nil)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
+}
+
+// GetSymlink gets the symlink object with the specified key.
+// If the symlink object does not exist, returns 404.
+//
+// objectKey    the symlink object's key.
+//
+// error    it's nil if no error, otherwise it's an error object.
+//          When error is nil, the target file key is in the X-Oss-Symlink-Target header of the returned object.
+//
+func (bucket Bucket) GetSymlink(objectKey string) (http.Header, error) {
+	params := map[string]interface{}{}
+	params["symlink"] = nil
+	resp, err := bucket.do("GET", objectKey, params, nil, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	targetObjectKey := resp.Headers.Get(HTTPHeaderOssSymlinkTarget)
+	targetObjectKey, err = url.QueryUnescape(targetObjectKey)
+	if err != nil {
+		return resp.Headers, err
+	}
+	resp.Headers.Set(HTTPHeaderOssSymlinkTarget, targetObjectKey)
+	return resp.Headers, err
+}
+
+// RestoreObject restores the object from the archive storage.
+//
+// An archive object is in cold status by default and it cannot be accessed.
+// When restore is called on the cold object, it will become available for access after some time.
+// If multiple restores are called on the same file when the object is being restored, server side does nothing for additional calls but returns success.
+// By default, the restored object is available for access for one day. After that it will be unavailable again.
+// But if another RestoreObject are called after the file is restored, then it will extend one day's access time of that object, up to 7 days.
+//
+// objectKey    object key to restore.
+//
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) RestoreObject(objectKey string) error {
+	params := map[string]interface{}{}
+	params["restore"] = nil
+	resp, err := bucket.do("POST", objectKey, params, nil, nil, nil)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return checkRespCode(resp.StatusCode, []int{http.StatusOK, http.StatusAccepted})
+}
+
+// SignURL signs the URL. Users could access the object directly with this URL without getting the AK.
+//
+// objectKey    the target object to sign.
+// signURLConfig    the configuration for the signed URL
+//
+// string    returns the signed URL, when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) SignURL(objectKey string, method HTTPMethod, expiredInSec int64, options ...Option) (string, error) {
+	if expiredInSec < 0 {
+		return "", fmt.Errorf("invalid expires: %d, expires must bigger than 0", expiredInSec)
+	}
+	expiration := time.Now().Unix() + expiredInSec
+
+	params, err := getRawParams(options)
+	if err != nil {
+		return "", err
+	}
+
+	headers := make(map[string]string)
+	err = handleOptions(headers, options)
+	if err != nil {
+		return "", err
+	}
+
+	return bucket.Client.Conn.signURL(method, bucket.BucketName, objectKey, expiration, params, headers), nil
+}
+
+// PutObjectWithURL uploads an object with the URL. If the object exists, it will be overwritten.
+// PutObjectWithURL It will not generate minetype according to the key name.
+//
+// signedURL    signed URL.
+// reader    io.Reader the read instance for reading the data for the upload.
+// options    the options for uploading the data. The valid options are CacheControl, ContentDisposition, ContentEncoding,
+//            Expires, ServerSideEncryption, ObjectACL and custom metadata. Check out the following link for details:
+//            https://help.aliyun.com/document_detail/oss/api-reference/object/PutObject.html
+//
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) PutObjectWithURL(signedURL string, reader io.Reader, options ...Option) error {
+	resp, err := bucket.DoPutObjectWithURL(signedURL, reader, options)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	return err
+}
+
+// PutObjectFromFileWithURL uploads an object from a local file with the signed URL.
+// PutObjectFromFileWithURL It does not generate mimetype according to object key's name or the local file name.
+//
+// signedURL    the signed URL.
+// filePath    local file path, such as dirfile.txt, for uploading.
+// options    options for uploading, same as the options in PutObject function.
+//
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) PutObjectFromFileWithURL(signedURL, filePath string, options ...Option) error {
+	fd, err := os.Open(filePath)
+	if err != nil {
+		return err
+	}
+	defer fd.Close()
+
+	resp, err := bucket.DoPutObjectWithURL(signedURL, fd, options)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	return err
+}
+
+// DoPutObjectWithURL is the actual API that does the upload with URL work(internal for SDK)
+//
+// signedURL    the signed URL.
+// reader    io.Reader the read instance for getting the data to upload.
+// options    options for uploading.
+//
+// Response    the response object which contains the HTTP response.
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) DoPutObjectWithURL(signedURL string, reader io.Reader, options []Option) (*Response, error) {
+	listener := getProgressListener(options)
+
+	params := map[string]interface{}{}
+	resp, err := bucket.doURL("PUT", signedURL, params, options, reader, listener)
+	if err != nil {
+		return nil, err
+	}
+
+	if bucket.getConfig().IsEnableCRC {
+		err = checkCRC(resp, "DoPutObjectWithURL")
+		if err != nil {
+			return resp, err
+		}
+	}
+
+	err = checkRespCode(resp.StatusCode, []int{http.StatusOK})
+
+	return resp, err
+}
+
+// GetObjectWithURL downloads the object and returns the reader instance,  with the signed URL.
+//
+// signedURL    the signed URL.
+// options    options for downloading the object. Valid options are IfModifiedSince, IfUnmodifiedSince, IfMatch,
+//            IfNoneMatch, AcceptEncoding. For more information, check out the following link:
+//            https://help.aliyun.com/document_detail/oss/api-reference/object/GetObject.html
+//
+// io.ReadCloser    the reader object for getting the data from response. It needs be closed after the usage. It's only valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) GetObjectWithURL(signedURL string, options ...Option) (io.ReadCloser, error) {
+	result, err := bucket.DoGetObjectWithURL(signedURL, options)
+	if err != nil {
+		return nil, err
+	}
+	return result.Response, nil
+}
+
+// GetObjectToFileWithURL downloads the object into a local file with the signed URL.
+//
+// signedURL    the signed URL
+// filePath    the local file path to download to.
+// options    the options for downloading object. Check out the parameter options in function GetObject for the reference.
+//
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) GetObjectToFileWithURL(signedURL, filePath string, options ...Option) error {
+	tempFilePath := filePath + TempFileSuffix
+
+	// Get the object's content
+	result, err := bucket.DoGetObjectWithURL(signedURL, options)
+	if err != nil {
+		return err
+	}
+	defer result.Response.Close()
+
+	// If the file does not exist, create one. If exists, then overwrite it.
+	fd, err := os.OpenFile(tempFilePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, FilePermMode)
+	if err != nil {
+		return err
+	}
+
+	// Save the data to the file.
+	_, err = io.Copy(fd, result.Response.Body)
+	fd.Close()
+	if err != nil {
+		return err
+	}
+
+	// Compare the CRC value. If CRC values do not match, return error.
+	hasRange, _, _ := isOptionSet(options, HTTPHeaderRange)
+	encodeOpt, _ := findOption(options, HTTPHeaderAcceptEncoding, nil)
+	acceptEncoding := ""
+	if encodeOpt != nil {
+		acceptEncoding = encodeOpt.(string)
+	}
+
+	if bucket.getConfig().IsEnableCRC && !hasRange && acceptEncoding != "gzip" {
+		result.Response.ClientCRC = result.ClientCRC.Sum64()
+		err = checkCRC(result.Response, "GetObjectToFileWithURL")
+		if err != nil {
+			os.Remove(tempFilePath)
+			return err
+		}
+	}
+
+	return os.Rename(tempFilePath, filePath)
+}
+
+// DoGetObjectWithURL is the actual API that downloads the file with the signed URL.
+//
+// signedURL    the signed URL.
+// options    the options for getting object. Check out parameter options in GetObject for the reference.
+//
+// GetObjectResult    the result object when the error is nil.
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) DoGetObjectWithURL(signedURL string, options []Option) (*GetObjectResult, error) {
+	params, _ := getRawParams(options)
+	resp, err := bucket.doURL("GET", signedURL, params, options, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	result := &GetObjectResult{
+		Response: resp,
+	}
+
+	// CRC
+	var crcCalc hash.Hash64
+	hasRange, _, _ := isOptionSet(options, HTTPHeaderRange)
+	if bucket.getConfig().IsEnableCRC && !hasRange {
+		crcCalc = crc64.New(crcTable())
+		result.ServerCRC = resp.ServerCRC
+		result.ClientCRC = crcCalc
+	}
+
+	// Progress
+	listener := getProgressListener(options)
+
+	contentLen, _ := strconv.ParseInt(resp.Headers.Get(HTTPHeaderContentLength), 10, 64)
+	resp.Body = TeeReader(resp.Body, crcCalc, contentLen, listener, nil)
+
+	return result, nil
+}
+
+//
+// ProcessObject apply process on the specified image file.
+//
+// The supported process includes resize, rotate, crop, watermark, format,
+// udf, customized style, etc.
+//
+//
+// objectKey	object key to process.
+// process	process string, such as "image/resize,w_100|sys/saveas,o_dGVzdC5qcGc,b_dGVzdA"
+//
+// error    it's nil if no error, otherwise it's an error object.
+//
+func (bucket Bucket) ProcessObject(objectKey string, process string) (ProcessObjectResult, error) {
+	var out ProcessObjectResult
+	params := map[string]interface{}{}
+	params["x-oss-process"] = nil
+	processData := fmt.Sprintf("%v=%v", "x-oss-process", process)
+	data := strings.NewReader(processData)
+	resp, err := bucket.do("POST", objectKey, params, nil, data, nil)
+	if err != nil {
+		return out, err
+	}
+	defer resp.Body.Close()
+
+	err = jsonUnmarshal(resp.Body, &out)
+	return out, err
+}
+
 // Private
-func (bucket Bucket) do(method, objectName, urlParams, subResource string, options []Option,
+func (bucket Bucket) do(method, objectName string, params map[string]interface{}, options []Option,
 	data io.Reader, listener ProgressListener) (*Response, error) {
 	headers := make(map[string]string)
 	err := handleOptions(headers, options)
@@ -606,7 +936,17 @@ func (bucket Bucket) do(method, objectName, urlParams, subResource string, optio
 		return nil, err
 	}
 	return bucket.Client.Conn.Do(method, bucket.BucketName, objectName,
-		urlParams, subResource, headers, data, 0, listener)
+		params, headers, data, 0, listener)
+}
+
+func (bucket Bucket) doURL(method HTTPMethod, signedURL string, params map[string]interface{}, options []Option,
+	data io.Reader, listener ProgressListener) (*Response, error) {
+	headers := make(map[string]string)
+	err := handleOptions(headers, options)
+	if err != nil {
+		return nil, err
+	}
+	return bucket.Client.Conn.DoURL(method, signedURL, headers, data, 0, listener)
 }
 
 func (bucket Bucket) getConfig() *Config {
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/client.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/client.go
index 23df9bc1a..d29351c87 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/client.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/client.go
@@ -11,70 +11,68 @@ import (
 	"time"
 )
 
-//
-// Client Sdk的入口，Client的方法可以完成bucket的各种操作，如create/delete bucket，
-// set/get acl/lifecycle/referer/logging/website等。文件(object)的上传下载通过Bucket完成。
-// 用户用oss.New创建Client。
+// Client SDK's entry point. It's for bucket related options such as create/delete/set bucket (such as set/get ACL/lifecycle/referer/logging/website).
+// Object related operations are done by Bucket class.
+// Users use oss.New to create Client instance.
 //
 type (
-	// Client oss client
+	// Client OSS client
 	Client struct {
-		Config *Config // Oss Client configure
-		Conn   *Conn   // Send http request
+		Config     *Config      // OSS client configuration
+		Conn       *Conn        // Send HTTP request
+		HTTPClient *http.Client //http.Client to use - if nil will make its own
 	}
 
 	// ClientOption client option such as UseCname, Timeout, SecurityToken.
 	ClientOption func(*Client)
 )
 
+// New creates a new client.
 //
-// New 生成一个新的Client。
+// endpoint    the OSS datacenter endpoint such as http://oss-cn-hangzhou.aliyuncs.com .
+// accessKeyId    access key Id.
+// accessKeySecret    access key secret.
 //
-// endpoint        用户Bucket所在数据中心的访问域名，如http://oss-cn-hangzhou.aliyuncs.com。
-// accessKeyId     用户标识。
-// accessKeySecret 用户密钥。
-//
-// Client 生成的新Client。error为nil时有效。
-// error  操作无错误时为nil，非nil时表示操作出错。
+// Client    creates the new client instance, the returned value is valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func New(endpoint, accessKeyID, accessKeySecret string, options ...ClientOption) (*Client, error) {
-	// configuration
+	// Configuration
 	config := getDefaultOssConfig()
 	config.Endpoint = endpoint
 	config.AccessKeyID = accessKeyID
 	config.AccessKeySecret = accessKeySecret
 
-	// url parse
+	// URL parse
 	url := &urlMaker{}
 	url.Init(config.Endpoint, config.IsCname, config.IsUseProxy)
 
-	// http connect
+	// HTTP connect
 	conn := &Conn{config: config, url: url}
 
-	// oss client
+	// OSS client
 	client := &Client{
-		config,
-		conn,
+		Config: config,
+		Conn:   conn,
 	}
 
-	// client options parse
+	// Client options parse
 	for _, option := range options {
 		option(client)
 	}
 
-	// create http connect
-	err := conn.init(config, url)
+	// Create HTTP connection
+	err := conn.init(config, url, client.HTTPClient)
 
 	return client, err
 }
 
+// Bucket gets the bucket instance.
 //
-// Bucket 取存储空间（Bucket）的对象实例。
+// bucketName    the bucket name.
+// Bucket    the bucket object, when error is nil.
 //
-// bucketName 存储空间名称。
-// Bucket     新的Bucket。error为nil时有效。
-//
-// error 操作无错误时返回nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) Bucket(bucketName string) (*Bucket, error) {
 	return &Bucket{
@@ -83,21 +81,36 @@ func (client Client) Bucket(bucketName string) (*Bucket, error) {
 	}, nil
 }
 
+// CreateBucket creates a bucket.
 //
-// CreateBucket 创建Bucket。
+// bucketName    the bucket name, it's globably unique and immutable. The bucket name can only consist of lowercase letters, numbers and dash ('-').
+//               It must start with lowercase letter or number and the length can only be between 3 and 255.
+// options    options for creating the bucket, with optional ACL. The ACL could be ACLPrivate, ACLPublicRead, and ACLPublicReadWrite. By default it's ACLPrivate.
+//            It could also be specified with StorageClass option, which supports StorageStandard, StorageIA(infrequent access), StorageArchive.
 //
-// bucketName bucket名称，在整个OSS中具有全局唯一性，且不能修改。bucket名称的只能包括小写字母，数字和短横线-，
-// 必须以小写字母或者数字开头，长度必须在3-255字节之间。
-// options  创建bucket的选项。您可以使用选项ACL，指定bucket的访问权限。Bucket有以下三种访问权限，私有读写（ACLPrivate）、
-// 公共读私有写（ACLPublicRead），公共读公共写(ACLPublicReadWrite)，默认访问权限是私有读写。
-//
-// error 操作无错误时返回nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) CreateBucket(bucketName string, options ...Option) error {
 	headers := make(map[string]string)
 	handleOptions(headers, options)
 
-	resp, err := client.do("PUT", bucketName, "", "", headers, nil)
+	buffer := new(bytes.Buffer)
+
+	isOptSet, val, _ := isOptionSet(options, storageClass)
+	if isOptSet {
+		cbConfig := createBucketConfiguration{StorageClass: val.(StorageClassType)}
+		bs, err := xml.Marshal(cbConfig)
+		if err != nil {
+			return err
+		}
+		buffer.Write(bs)
+
+		contentType := http.DetectContentType(buffer.Bytes())
+		headers[HTTPHeaderContentType] = contentType
+	}
+
+	params := map[string]interface{}{}
+	resp, err := client.do("PUT", bucketName, params, headers, buffer)
 	if err != nil {
 		return err
 	}
@@ -106,25 +119,25 @@ func (client Client) CreateBucket(bucketName string, options ...Option) error {
 	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
 }
 
+// ListBuckets lists buckets of the current account under the given endpoint, with optional filters.
 //
-// ListBuckets 获取当前用户下的bucket。
+// options    specifies the filters such as Prefix, Marker and MaxKeys. Prefix is the bucket name's prefix filter.
+//            And marker makes sure the returned buckets' name are greater than it in lexicographic order.
+//            Maxkeys limits the max keys to return, and by default it's 100 and up to 1000.
+//            For the common usage scenario, please check out list_bucket.go in the sample.
+// ListBucketsResponse    the response object if error is nil.
 //
-// options 指定ListBuckets的筛选行为，Prefix、Marker、MaxKeys三个选项。Prefix限定前缀。
-// Marker设定从Marker之后的第一个开始返回。MaxKeys限定此次返回的最大数目，默认为100。
-// 常用使用场景的实现，参数示例程序list_bucket.go。
-// ListBucketsResponse 操作成功后的返回值，error为nil时该返回值有效。
-//
-// error 操作无错误时返回nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) ListBuckets(options ...Option) (ListBucketsResult, error) {
 	var out ListBucketsResult
 
-	params, err := handleParams(options)
+	params, err := getRawParams(options)
 	if err != nil {
 		return out, err
 	}
 
-	resp, err := client.do("GET", "", params, "", nil, nil)
+	resp, err := client.do("GET", "", params, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -134,13 +147,12 @@ func (client Client) ListBuckets(options ...Option) (ListBucketsResult, error) {
 	return out, err
 }
 
+// IsBucketExist checks if the bucket exists
 //
-// IsBucketExist Bucket是否存在。
+// bucketName    the bucket name.
 //
-// bucketName 存储空间名称。
-//
-// bool  存储空间是否存在。error为nil时有效。
-// error 操作无错误时返回nil，非nil为错误信息。
+// bool    true if it exists, and it's only valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) IsBucketExist(bucketName string) (bool, error) {
 	listRes, err := client.ListBuckets(Prefix(bucketName), MaxKeys(1))
@@ -154,15 +166,15 @@ func (client Client) IsBucketExist(bucketName string) (bool, error) {
 	return false, nil
 }
 
+// DeleteBucket deletes the bucket. Only empty bucket can be deleted (no object and parts).
 //
-// DeleteBucket 删除空存储空间。非空时请先清理Object、Upload。
+// bucketName    the bucket name.
 //
-// bucketName 存储空间名称。
-//
-// error 操作无错误时返回nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) DeleteBucket(bucketName string) error {
-	resp, err := client.do("DELETE", bucketName, "", "", nil, nil)
+	params := map[string]interface{}{}
+	resp, err := client.do("DELETE", bucketName, params, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -171,19 +183,20 @@ func (client Client) DeleteBucket(bucketName string) error {
 	return checkRespCode(resp.StatusCode, []int{http.StatusNoContent})
 }
 
+// GetBucketLocation gets the bucket location.
 //
-// GetBucketLocation 查看Bucket所属数据中心位置的信息。
-//
-// 如果您想了解"访问域名和数据中心"详细信息，请参看
+// Checks out the following link for more information :
 // https://help.aliyun.com/document_detail/oss/user_guide/oss_concept/endpoint.html
 //
-// bucketName 存储空间名称。
+// bucketName    the bucket name
 //
-// string Bucket所属的数据中心位置信息。
-// error  操作无错误时返回nil，非nil为错误信息。
+// string    bucket's datacenter location
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) GetBucketLocation(bucketName string) (string, error) {
-	resp, err := client.do("GET", bucketName, "location", "location", nil, nil)
+	params := map[string]interface{}{}
+	params["location"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
 	if err != nil {
 		return "", err
 	}
@@ -194,18 +207,17 @@ func (client Client) GetBucketLocation(bucketName string) (string, error) {
 	return LocationConstraint, err
 }
 
+// SetBucketACL sets bucket's ACL.
 //
-// SetBucketACL 修改Bucket的访问权限。
+// bucketName    the bucket name
+// bucketAcl    the bucket ACL: ACLPrivate, ACLPublicRead and ACLPublicReadWrite.
 //
-// bucketName 存储空间名称。
-// bucketAcl  bucket的访问权限。Bucket有以下三种访问权限，Bucket有以下三种访问权限，私有读写（ACLPrivate）、
-// 公共读私有写（ACLPublicRead），公共读公共写(ACLPublicReadWrite)。
-//
-// error 操作无错误时返回nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) SetBucketACL(bucketName string, bucketACL ACLType) error {
 	headers := map[string]string{HTTPHeaderOssACL: string(bucketACL)}
-	resp, err := client.do("PUT", bucketName, "", "", headers, nil)
+	params := map[string]interface{}{}
+	resp, err := client.do("PUT", bucketName, params, headers, nil)
 	if err != nil {
 		return err
 	}
@@ -213,17 +225,18 @@ func (client Client) SetBucketACL(bucketName string, bucketACL ACLType) error {
 	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
 }
 
+// GetBucketACL gets the bucket ACL.
 //
-// GetBucketACL 获得Bucket的访问权限。
+// bucketName    the bucket name.
 //
-// bucketName 存储空间名称。
-//
-// GetBucketAclResponse 操作成功后的返回值，error为nil时该返回值有效。
-// error 操作无错误时返回nil，非nil为错误信息。
+// GetBucketAclResponse    the result object, and it's only valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) GetBucketACL(bucketName string) (GetBucketACLResult, error) {
 	var out GetBucketACLResult
-	resp, err := client.do("GET", bucketName, "acl", "acl", nil, nil)
+	params := map[string]interface{}{}
+	params["acl"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -233,19 +246,16 @@ func (client Client) GetBucketACL(bucketName string) (GetBucketACLResult, error)
 	return out, err
 }
 
+// SetBucketLifecycle sets the bucket's lifecycle.
 //
-// SetBucketLifecycle 修改Bucket的生命周期设置。
-//
-// OSS提供Object生命周期管理来为用户管理对象。用户可以为某个Bucket定义生命周期配置，来为该Bucket的Object定义各种规则。
-// Bucket的拥有者可以通过SetBucketLifecycle来设置Bucket的Lifecycle配置。Lifecycle开启后，OSS将按照配置，
-// 定期自动删除与Lifecycle规则相匹配的Object。如果您想了解更多的生命周期的信息，请参看
+// For more information, checks out following link:
 // https://help.aliyun.com/document_detail/oss/user_guide/manage_object/object_lifecycle.html
 //
-// bucketName 存储空间名称。
-// rules 生命周期规则列表。生命周期规则有两种格式，指定绝对和相对过期时间，分布由days和year/month/day控制。
-// 具体用法请参考示例程序sample/bucket_lifecycle.go。
+// bucketName    the bucket name.
+// rules    the lifecycle rules. There're two kind of rules: absolute time expiration and relative time expiration in days and day/month/year respectively.
+//          Check out sample/bucket_lifecycle.go for more details.
 //
-// error 操作无错误时返回error为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) SetBucketLifecycle(bucketName string, rules []LifecycleRule) error {
 	lxml := lifecycleXML{Rules: convLifecycleRule(rules)}
@@ -260,7 +270,9 @@ func (client Client) SetBucketLifecycle(bucketName string, rules []LifecycleRule
 	headers := map[string]string{}
 	headers[HTTPHeaderContentType] = contentType
 
-	resp, err := client.do("PUT", bucketName, "lifecycle", "lifecycle", headers, buffer)
+	params := map[string]interface{}{}
+	params["lifecycle"] = nil
+	resp, err := client.do("PUT", bucketName, params, headers, buffer)
 	if err != nil {
 		return err
 	}
@@ -268,16 +280,17 @@ func (client Client) SetBucketLifecycle(bucketName string, rules []LifecycleRule
 	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
 }
 
-//
-// DeleteBucketLifecycle 删除Bucket的生命周期设置。
+// DeleteBucketLifecycle deletes the bucket's lifecycle.
 //
 //
-// bucketName 存储空间名称。
+// bucketName    the bucket name.
 //
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) DeleteBucketLifecycle(bucketName string) error {
-	resp, err := client.do("DELETE", bucketName, "lifecycle", "lifecycle", nil, nil)
+	params := map[string]interface{}{}
+	params["lifecycle"] = nil
+	resp, err := client.do("DELETE", bucketName, params, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -285,17 +298,18 @@ func (client Client) DeleteBucketLifecycle(bucketName string) error {
 	return checkRespCode(resp.StatusCode, []int{http.StatusNoContent})
 }
 
+// GetBucketLifecycle gets the bucket's lifecycle settings.
 //
-// GetBucketLifecycle 查看Bucket的生命周期设置。
+// bucketName    the bucket name.
 //
-// bucketName 存储空间名称。
-//
-// GetBucketLifecycleResponse 操作成功的返回值，error为nil时该返回值有效。Rules为该bucket上的规则列表。
-// error 操作无错误时为nil，非nil为错误信息。
+// GetBucketLifecycleResponse    the result object upon successful request. It's only valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) GetBucketLifecycle(bucketName string) (GetBucketLifecycleResult, error) {
 	var out GetBucketLifecycleResult
-	resp, err := client.do("GET", bucketName, "lifecycle", "lifecycle", nil, nil)
+	params := map[string]interface{}{}
+	params["lifecycle"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -305,21 +319,20 @@ func (client Client) GetBucketLifecycle(bucketName string) (GetBucketLifecycleRe
 	return out, err
 }
 
+// SetBucketReferer sets the bucket's referer whitelist and the flag if allowing empty referrer.
 //
-// SetBucketReferer 设置bucket的referer访问白名单和是否允许referer字段为空的请求访问。
-//
-// 防止用户在OSS上的数据被其他人盗用，OSS支持基于HTTP header中表头字段referer的防盗链方法。可以通过OSS控制台或者API的方式对
-// 一个bucket设置referer字段的白名单和是否允许referer字段为空的请求访问。例如，对于一个名为oss-example的bucket，
-// 设置其referer白名单为http://www.aliyun.com。则所有referer为http://www.aliyun.com的请求才能访问oss-example
-// 这个bucket中的object。如果您还需要了解更多信息，请参看
+// To avoid stealing link on OSS data, OSS supports the HTTP referrer header. A whitelist referrer could be set either by API or web console, as well as
+// the allowing empty referrer flag. Note that this applies to requests from webbrowser only.
+// For example, for a bucket os-example and its referrer http://www.aliyun.com, all requests from this URL could access the bucket.
+// For more information, please check out this link :
 // https://help.aliyun.com/document_detail/oss/user_guide/security_management/referer.html
 //
-// bucketName  存储空间名称。
-// referers  访问白名单列表。一个bucket可以支持多个referer参数。referer参数支持通配符"*"和"?"。
-// 用法请参看示例sample/bucket_referer.go
-// allowEmptyReferer  指定是否允许referer字段为空的请求访问。 默认为true。
+// bucketName    the bucket name.
+// referers    the referrer white list. A bucket could have a referrer list and each referrer supports one '*' and multiple '?' as wildcards.
+//             The sample could be found in sample/bucket_referer.go
+// allowEmptyReferer    the flag of allowing empty referrer. By default it's true.
 //
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) SetBucketReferer(bucketName string, referers []string, allowEmptyReferer bool) error {
 	rxml := RefererXML{}
@@ -343,7 +356,9 @@ func (client Client) SetBucketReferer(bucketName string, referers []string, allo
 	headers := map[string]string{}
 	headers[HTTPHeaderContentType] = contentType
 
-	resp, err := client.do("PUT", bucketName, "referer", "referer", headers, buffer)
+	params := map[string]interface{}{}
+	params["referer"] = nil
+	resp, err := client.do("PUT", bucketName, params, headers, buffer)
 	if err != nil {
 		return err
 	}
@@ -351,17 +366,18 @@ func (client Client) SetBucketReferer(bucketName string, referers []string, allo
 	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
 }
 
+// GetBucketReferer gets the bucket's referrer white list.
 //
-// GetBucketReferer 获得Bucket的白名单地址。
+// bucketName    the bucket name.
 //
-// bucketName 存储空间名称。
-//
-// GetBucketRefererResponse 操作成功的返回值，error为nil时该返回值有效。
-// error 操作无错误时为nil，非nil为错误信息。
+// GetBucketRefererResponse    the result object upon successful request. It's only valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) GetBucketReferer(bucketName string) (GetBucketRefererResult, error) {
 	var out GetBucketRefererResult
-	resp, err := client.do("GET", bucketName, "referer", "referer", nil, nil)
+	params := map[string]interface{}{}
+	params["referer"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -371,18 +387,17 @@ func (client Client) GetBucketReferer(bucketName string) (GetBucketRefererResult
 	return out, err
 }
 
+// SetBucketLogging sets the bucket logging settings.
 //
-// SetBucketLogging 修改Bucket的日志设置。
+// OSS could automatically store the access log. Only the bucket owner could enable the logging.
+// Once enabled, OSS would save all the access log into hourly log files in a specified bucket.
+// For more information, please check out https://help.aliyun.com/document_detail/oss/user_guide/security_management/logging.html
 //
-// OSS为您提供自动保存访问日志记录功能。Bucket的拥有者可以开启访问日志记录功能。当一个bucket开启访问日志记录功能后，
-// OSS自动将访问这个bucket的请求日志，以小时为单位，按照固定的命名规则，生成一个Object写入用户指定的bucket中。
-// 如果您需要更多，请参看 https://help.aliyun.com/document_detail/oss/user_guide/security_management/logging.html
+// bucketName    bucket name to enable the log.
+// targetBucket    the target bucket name to store the log files.
+// targetPrefix    the log files' prefix.
 //
-// bucketName   需要记录访问日志的Bucket。
-// targetBucket 访问日志记录到的Bucket。
-// targetPrefix bucketName中需要存储访问日志记录的object前缀。为空记录所有object的访问日志。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) SetBucketLogging(bucketName, targetBucket, targetPrefix string,
 	isEnable bool) error {
@@ -409,7 +424,9 @@ func (client Client) SetBucketLogging(bucketName, targetBucket, targetPrefix str
 	headers := map[string]string{}
 	headers[HTTPHeaderContentType] = contentType
 
-	resp, err := client.do("PUT", bucketName, "logging", "logging", headers, buffer)
+	params := map[string]interface{}{}
+	params["logging"] = nil
+	resp, err := client.do("PUT", bucketName, params, headers, buffer)
 	if err != nil {
 		return err
 	}
@@ -417,15 +434,16 @@ func (client Client) SetBucketLogging(bucketName, targetBucket, targetPrefix str
 	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
 }
 
+// DeleteBucketLogging deletes the logging configuration to disable the logging on the bucket.
 //
-// DeleteBucketLogging 删除Bucket的日志设置。
+// bucketName    the bucket name to disable the logging.
 //
-// bucketName 需要删除访问日志的Bucket。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) DeleteBucketLogging(bucketName string) error {
-	resp, err := client.do("DELETE", bucketName, "logging", "logging", nil, nil)
+	params := map[string]interface{}{}
+	params["logging"] = nil
+	resp, err := client.do("DELETE", bucketName, params, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -433,17 +451,18 @@ func (client Client) DeleteBucketLogging(bucketName string) error {
 	return checkRespCode(resp.StatusCode, []int{http.StatusNoContent})
 }
 
+// GetBucketLogging gets the bucket's logging settings
 //
-// GetBucketLogging 获得Bucket的日志设置。
+// bucketName    the bucket name
+// GetBucketLoggingResponse    the result object upon successful request. It's only valid when error is nil.
 //
-// bucketName  需要删除访问日志的Bucket。
-// GetBucketLoggingResponse  操作成功的返回值，error为nil时该返回值有效。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) GetBucketLogging(bucketName string) (GetBucketLoggingResult, error) {
 	var out GetBucketLoggingResult
-	resp, err := client.do("GET", bucketName, "logging", "logging", nil, nil)
+	params := map[string]interface{}{}
+	params["logging"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -453,17 +472,16 @@ func (client Client) GetBucketLogging(bucketName string) (GetBucketLoggingResult
 	return out, err
 }
 
+// SetBucketWebsite sets the bucket's static website's index and error page.
 //
-// SetBucketWebsite 设置/修改Bucket的默认首页以及错误页。
+// OSS supports static web site hosting for the bucket data. When the bucket is enabled with that, you can access the file in the bucket like the way to access a static website.
+// For more information, please check out: https://help.aliyun.com/document_detail/oss/user_guide/static_host_website.html
 //
-// OSS支持静态网站托管，Website操作可以将一个bucket设置成静态网站托管模式 。您可以将自己的Bucket配置成静态网站托管模式。
-// 如果您需要更多，请参看 https://help.aliyun.com/document_detail/oss/user_guide/static_host_website.html
+// bucketName    the bucket name to enable static web site.
+// indexDocument    index page.
+// errorDocument    error page.
 //
-// bucketName     需要设置Website的Bucket。
-// indexDocument  索引文档。
-// errorDocument  错误文档。
-//
-// error  操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) SetBucketWebsite(bucketName, indexDocument, errorDocument string) error {
 	wxml := WebsiteXML{}
@@ -481,7 +499,9 @@ func (client Client) SetBucketWebsite(bucketName, indexDocument, errorDocument s
 	headers := make(map[string]string)
 	headers[HTTPHeaderContentType] = contentType
 
-	resp, err := client.do("PUT", bucketName, "website", "website", headers, buffer)
+	params := map[string]interface{}{}
+	params["website"] = nil
+	resp, err := client.do("PUT", bucketName, params, headers, buffer)
 	if err != nil {
 		return err
 	}
@@ -489,15 +509,16 @@ func (client Client) SetBucketWebsite(bucketName, indexDocument, errorDocument s
 	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
 }
 
+// DeleteBucketWebsite deletes the bucket's static web site settings.
 //
-// DeleteBucketWebsite 删除Bucket的Website设置。
+// bucketName    the bucket name.
 //
-// bucketName  需要删除website设置的Bucket。
-//
-// error  操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) DeleteBucketWebsite(bucketName string) error {
-	resp, err := client.do("DELETE", bucketName, "website", "website", nil, nil)
+	params := map[string]interface{}{}
+	params["website"] = nil
+	resp, err := client.do("DELETE", bucketName, params, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -505,17 +526,18 @@ func (client Client) DeleteBucketWebsite(bucketName string) error {
 	return checkRespCode(resp.StatusCode, []int{http.StatusNoContent})
 }
 
+// GetBucketWebsite gets the bucket's default page (index page) and the error page.
 //
-// GetBucketWebsite 获得Bucket的默认首页以及错误页。
+// bucketName    the bucket name
 //
-// bucketName 存储空间名称。
-//
-// GetBucketWebsiteResponse 操作成功的返回值，error为nil时该返回值有效。
-// error 操作无错误为nil，非nil为错误信息。
+// GetBucketWebsiteResponse    the result object upon successful request. It's only valid when error is nil.
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) GetBucketWebsite(bucketName string) (GetBucketWebsiteResult, error) {
 	var out GetBucketWebsiteResult
-	resp, err := client.do("GET", bucketName, "website", "website", nil, nil)
+	params := map[string]interface{}{}
+	params["website"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -525,15 +547,14 @@ func (client Client) GetBucketWebsite(bucketName string) (GetBucketWebsiteResult
 	return out, err
 }
 
+// SetBucketCORS sets the bucket's CORS rules
 //
-// SetBucketCORS 设置Bucket的跨域访问(CORS)规则。
+// For more information, please check out https://help.aliyun.com/document_detail/oss/user_guide/security_management/cors.html
 //
-// 跨域访问的更多信息，请参看 https://help.aliyun.com/document_detail/oss/user_guide/security_management/cors.html
+// bucketName    the bucket name
+// corsRules    the CORS rules to set. The related sample code is in sample/bucket_cors.go.
 //
-// bucketName 需要设置Website的Bucket。
-// corsRules  待设置的CORS规则。用法请参看示例代码sample/bucket_cors.go。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) SetBucketCORS(bucketName string, corsRules []CORSRule) error {
 	corsxml := CORSXML{}
@@ -558,7 +579,9 @@ func (client Client) SetBucketCORS(bucketName string, corsRules []CORSRule) erro
 	headers := map[string]string{}
 	headers[HTTPHeaderContentType] = contentType
 
-	resp, err := client.do("PUT", bucketName, "cors", "cors", headers, buffer)
+	params := map[string]interface{}{}
+	params["cors"] = nil
+	resp, err := client.do("PUT", bucketName, params, headers, buffer)
 	if err != nil {
 		return err
 	}
@@ -566,15 +589,16 @@ func (client Client) SetBucketCORS(bucketName string, corsRules []CORSRule) erro
 	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
 }
 
+// DeleteBucketCORS deletes the bucket's static website settings.
 //
-// DeleteBucketCORS 删除Bucket的Website设置。
+// bucketName    the bucket name.
 //
-// bucketName 需要删除cors设置的Bucket。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) DeleteBucketCORS(bucketName string) error {
-	resp, err := client.do("DELETE", bucketName, "cors", "cors", nil, nil)
+	params := map[string]interface{}{}
+	params["cors"] = nil
+	resp, err := client.do("DELETE", bucketName, params, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -582,18 +606,18 @@ func (client Client) DeleteBucketCORS(bucketName string) error {
 	return checkRespCode(resp.StatusCode, []int{http.StatusNoContent})
 }
 
+// GetBucketCORS gets the bucket's CORS settings.
 //
-// GetBucketCORS 获得Bucket的CORS设置。
+// bucketName    the bucket name.
+// GetBucketCORSResult    the result object upon successful request. It's only valid when error is nil.
 //
-//
-// bucketName  存储空间名称。
-// GetBucketCORSResult  操作成功的返回值，error为nil时该返回值有效。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) GetBucketCORS(bucketName string) (GetBucketCORSResult, error) {
 	var out GetBucketCORSResult
-	resp, err := client.do("GET", bucketName, "cors", "cors", nil, nil)
+	params := map[string]interface{}{}
+	params["cors"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -603,17 +627,18 @@ func (client Client) GetBucketCORS(bucketName string) (GetBucketCORSResult, erro
 	return out, err
 }
 
+// GetBucketInfo gets the bucket information.
 //
-// GetBucketInfo 获得Bucket的信息。
+// bucketName    the bucket name.
+// GetBucketInfoResult    the result object upon successful request. It's only valid when error is nil.
 //
-// bucketName  存储空间名称。
-// GetBucketInfoResult  操作成功的返回值，error为nil时该返回值有效。
-//
-// error 操作无错误为nil，非nil为错误信息。
+// error    it's nil if no error, otherwise it's an error object.
 //
 func (client Client) GetBucketInfo(bucketName string) (GetBucketInfoResult, error) {
 	var out GetBucketInfoResult
-	resp, err := client.do("GET", bucketName, "bucketInfo", "bucketInfo", nil, nil)
+	params := map[string]interface{}{}
+	params["bucketInfo"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
 	if err != nil {
 		return out, err
 	}
@@ -623,10 +648,9 @@ func (client Client) GetBucketInfo(bucketName string) (GetBucketInfoResult, erro
 	return out, err
 }
 
+// UseCname sets the flag of using CName. By default it's false.
 //
-// UseCname 设置是否使用CNAME，默认不使用。
-//
-// isUseCname true设置endpoint格式是cname格式，false为非cname格式，默认false
+// isUseCname    true: the endpoint has the CName, false: the endpoint does not have cname. Default is false.
 //
 func UseCname(isUseCname bool) ClientOption {
 	return func(client *Client) {
@@ -635,11 +659,10 @@ func UseCname(isUseCname bool) ClientOption {
 	}
 }
 
+// Timeout sets the HTTP timeout in seconds.
 //
-// Timeout 设置HTTP超时时间。
-//
-// connectTimeoutSec HTTP链接超时时间，单位是秒，默认10秒。0表示永不超时。
-// readWriteTimeout  HTTP发送接受数据超时时间，单位是秒，默认20秒。0表示永不超时。
+// connectTimeoutSec    HTTP timeout in seconds. Default is 10 seconds. 0 means infinite (not recommended)
+// readWriteTimeout    HTTP read or write's timeout in seconds. Default is 20 seconds. 0 means infinite.
 //
 func Timeout(connectTimeoutSec, readWriteTimeout int64) ClientOption {
 	return func(client *Client) {
@@ -649,15 +672,16 @@ func Timeout(connectTimeoutSec, readWriteTimeout int64) ClientOption {
 			time.Second * time.Duration(readWriteTimeout)
 		client.Config.HTTPTimeout.HeaderTimeout =
 			time.Second * time.Duration(readWriteTimeout)
+		client.Config.HTTPTimeout.IdleConnTimeout =
+			time.Second * time.Duration(readWriteTimeout)
 		client.Config.HTTPTimeout.LongTimeout =
 			time.Second * time.Duration(readWriteTimeout*10)
 	}
 }
 
+// SecurityToken sets the temporary user's SecurityToken.
 //
-// SecurityToken 临时用户设置SecurityToken。
-//
-// token STS token
+// token    STS token
 //
 func SecurityToken(token string) ClientOption {
 	return func(client *Client) {
@@ -665,10 +689,9 @@ func SecurityToken(token string) ClientOption {
 	}
 }
 
+// EnableMD5 enables MD5 validation.
 //
-// EnableMD5 是否启用MD5校验，默认启用。
-//
-// isEnableMD5 true启用MD5校验，false不启用MD5校验
+// isEnableMD5    true: enable MD5 validation; false: disable MD5 validation.
 //
 func EnableMD5(isEnableMD5 bool) ClientOption {
 	return func(client *Client) {
@@ -676,10 +699,9 @@ func EnableMD5(isEnableMD5 bool) ClientOption {
 	}
 }
 
+// MD5ThresholdCalcInMemory sets the memory usage threshold for computing the MD5, default is 16MB.
 //
-// MD5ThresholdCalcInMemory 使用内存计算MD5值的上限，默认16MB。
-//
-// threshold 单位Byte。上传内容小于threshold在MD5在内存中计算，大于使用临时文件计算MD5
+// threshold    the memory threshold in bytes. When the uploaded content is more than 16MB, the temp file is used for computing the MD5.
 //
 func MD5ThresholdCalcInMemory(threshold int64) ClientOption {
 	return func(client *Client) {
@@ -687,10 +709,9 @@ func MD5ThresholdCalcInMemory(threshold int64) ClientOption {
 	}
 }
 
+// EnableCRC enables the CRC checksum. Default is true.
 //
-// EnableCRC 上传是否启用CRC校验，默认启用。
-//
-// isEnableCRC true启用CRC校验，false不启用CRC校验
+// isEnableCRC    true: enable CRC checksum; false: disable the CRC checksum.
 //
 func EnableCRC(isEnableCRC bool) ClientOption {
 	return func(client *Client) {
@@ -698,10 +719,9 @@ func EnableCRC(isEnableCRC bool) ClientOption {
 	}
 }
 
+// UserAgent specifies UserAgent. The default is aliyun-sdk-go/1.2.0 (windows/-/amd64;go1.5.2).
 //
-// UserAgent 指定UserAgent，默认如下aliyun-sdk-go/1.2.0 (windows/-/amd64;go1.5.2)。
-//
-// userAgent user agent字符串。
+// userAgent    the user agent string.
 //
 func UserAgent(userAgent string) ClientOption {
 	return func(client *Client) {
@@ -709,10 +729,9 @@ func UserAgent(userAgent string) ClientOption {
 	}
 }
 
+// Proxy sets the proxy (optional). The default is not using proxy.
 //
-// Proxy 设置代理服务器，默认不使用代理。
-//
-// proxyHost 代理服务器地址，格式是host或host:port
+// proxyHost    the proxy host in the format "host:port". For example, proxy.com:80 .
 //
 func Proxy(proxyHost string) ClientOption {
 	return func(client *Client) {
@@ -722,12 +741,11 @@ func Proxy(proxyHost string) ClientOption {
 	}
 }
 
+// AuthProxy sets the proxy information with user name and password.
 //
-// AuthProxy 设置需要认证的代理服务器，默认不使用代理。
-//
-// proxyHost 代理服务器地址，格式是host或host:port
-// proxyUser 代理服务器认证的用户名
-// proxyPassword 代理服务器认证的用户密码
+// proxyHost    the proxy host in the format "host:port". For example, proxy.com:80 .
+// proxyUser    the proxy user name.
+// proxyPassword    the proxy password.
 //
 func AuthProxy(proxyHost, proxyUser, proxyPassword string) ClientOption {
 	return func(client *Client) {
@@ -740,9 +758,18 @@ func AuthProxy(proxyHost, proxyUser, proxyPassword string) ClientOption {
 	}
 }
 
-// Private
-func (client Client) do(method, bucketName, urlParams, subResource string,
-	headers map[string]string, data io.Reader) (*Response, error) {
-	return client.Conn.Do(method, bucketName, "", urlParams,
-		subResource, headers, data, 0, nil)
+//
+// HTTPClient sets the http.Client in use to the one passed in
+//
+func HTTPClient(HTTPClient *http.Client) ClientOption {
+	return func(client *Client) {
+		client.HTTPClient = HTTPClient
+	}
+}
+
+// Private
+func (client Client) do(method, bucketName string, params map[string]interface{},
+	headers map[string]string, data io.Reader) (*Response, error) {
+	return client.Conn.Do(method, bucketName, "", params,
+		headers, data, 0, nil)
 }
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/conf.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/conf.go
index e8bee299e..f5db93e24 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/conf.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/conf.go
@@ -4,37 +4,44 @@ import (
 	"time"
 )
 
-// HTTPTimeout http timeout
+// HTTPTimeout defines HTTP timeout.
 type HTTPTimeout struct {
 	ConnectTimeout   time.Duration
 	ReadWriteTimeout time.Duration
 	HeaderTimeout    time.Duration
 	LongTimeout      time.Duration
+	IdleConnTimeout  time.Duration
 }
 
-// Config oss configure
+type HTTPMaxConns struct {
+	MaxIdleConns        int
+	MaxIdleConnsPerHost int
+}
+
+// Config defines oss configuration
 type Config struct {
-	Endpoint        string      // oss地址
-	AccessKeyID     string      // accessId
-	AccessKeySecret string      // accessKey
-	RetryTimes      uint        // 失败重试次数，默认5
-	UserAgent       string      // SDK名称/版本/系统信息
-	IsDebug         bool        // 是否开启调试模式，默认false
-	Timeout         uint        // 超时时间，默认60s
-	SecurityToken   string      // STS Token
-	IsCname         bool        // Endpoint是否是CNAME
-	HTTPTimeout     HTTPTimeout // HTTP的超时时间设置
-	IsUseProxy      bool        // 是否使用代理
-	ProxyHost       string      // 代理服务器地址
-	IsAuthProxy     bool        // 代理服务器是否使用用户认证
-	ProxyUser       string      // 代理服务器认证用户名
-	ProxyPassword   string      // 代理服务器认证密码
-	IsEnableMD5     bool        // 上传数据时是否启用MD5校验
-	MD5Threshold    int64       // 内存中计算MD5的上线大小，大于该值启用临时文件，单位Byte
-	IsEnableCRC     bool        // 上传数据时是否启用CRC64校验
+	Endpoint        string       // OSS endpoint
+	AccessKeyID     string       // AccessId
+	AccessKeySecret string       // AccessKey
+	RetryTimes      uint         // Retry count by default it's 5.
+	UserAgent       string       // SDK name/version/system information
+	IsDebug         bool         // Enable debug mode. Default is false.
+	Timeout         uint         // Timeout in seconds. By default it's 60.
+	SecurityToken   string       // STS Token
+	IsCname         bool         // If cname is in the endpoint.
+	HTTPTimeout     HTTPTimeout  // HTTP timeout
+	HTTPMaxConns    HTTPMaxConns // Http max connections
+	IsUseProxy      bool         // Flag of using proxy.
+	ProxyHost       string       // Flag of using proxy host.
+	IsAuthProxy     bool         // Flag of needing authentication.
+	ProxyUser       string       // Proxy user
+	ProxyPassword   string       // Proxy password
+	IsEnableMD5     bool         // Flag of enabling MD5 for upload.
+	MD5Threshold    int64        // Memory footprint threshold for each MD5 computation (16MB is the default), in byte. When the data is more than that, temp file is used.
+	IsEnableCRC     bool         // Flag of enabling CRC for upload.
 }
 
-// 获取默认配置
+// getDefaultOssConfig gets the default configuration.
 func getDefaultOssConfig() *Config {
 	config := Config{}
 
@@ -43,8 +50,8 @@ func getDefaultOssConfig() *Config {
 	config.AccessKeySecret = ""
 	config.RetryTimes = 5
 	config.IsDebug = false
-	config.UserAgent = userAgent
-	config.Timeout = 60 // seconds
+	config.UserAgent = userAgent()
+	config.Timeout = 60 // Seconds
 	config.SecurityToken = ""
 	config.IsCname = false
 
@@ -52,6 +59,9 @@ func getDefaultOssConfig() *Config {
 	config.HTTPTimeout.ReadWriteTimeout = time.Second * 60 // 60s
 	config.HTTPTimeout.HeaderTimeout = time.Second * 60    // 60s
 	config.HTTPTimeout.LongTimeout = time.Second * 300     // 300s
+	config.HTTPTimeout.IdleConnTimeout = time.Second * 50  // 50s
+	config.HTTPMaxConns.MaxIdleConns = 100
+	config.HTTPMaxConns.MaxIdleConnsPerHost = 100
 
 	config.IsUseProxy = false
 	config.ProxyHost = ""
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/conn.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/conn.go
index 77707bd92..74f768e5a 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/conn.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/conn.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"crypto/md5"
 	"encoding/base64"
+	"encoding/json"
 	"encoding/xml"
 	"fmt"
 	"hash"
@@ -13,64 +14,178 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
 )
 
-// Conn oss conn
+// Conn defines OSS Conn
 type Conn struct {
 	config *Config
 	url    *urlMaker
 	client *http.Client
 }
 
-// init 初始化Conn
-func (conn *Conn) init(config *Config, urlMaker *urlMaker) error {
-	httpTimeOut := conn.config.HTTPTimeout
+var signKeyList = []string{"acl", "uploads", "location", "cors", "logging", "website", "referer", "lifecycle", "delete", "append", "tagging", "objectMeta", "uploadId", "partNumber", "security-token", "position", "img", "style", "styleName", "replication", "replicationProgress", "replicationLocation", "cname", "bucketInfo", "comp", "qos", "live", "status", "vod", "startTime", "endTime", "symlink", "x-oss-process", "response-content-type", "response-content-language", "response-expires", "response-cache-control", "response-content-disposition", "response-content-encoding", "udf", "udfName", "udfImage", "udfId", "udfImageDesc", "udfApplication", "comp", "udfApplicationLog", "restore", "callback", "callback-var"}
 
-	// new Transport
-	transport := &http.Transport{
-		Dial: func(netw, addr string) (net.Conn, error) {
-			conn, err := net.DialTimeout(netw, addr, httpTimeOut.ConnectTimeout)
+// init initializes Conn
+func (conn *Conn) init(config *Config, urlMaker *urlMaker, client *http.Client) error {
+	if client == nil {
+		// New transport
+		transport := newTransport(conn, config)
+
+		// Proxy
+		if conn.config.IsUseProxy {
+			proxyURL, err := url.Parse(config.ProxyHost)
 			if err != nil {
-				return nil, err
+				return err
 			}
-			return newTimeoutConn(conn, httpTimeOut.ReadWriteTimeout, httpTimeOut.LongTimeout), nil
-		},
-		ResponseHeaderTimeout: httpTimeOut.HeaderTimeout,
-	}
-
-	// Proxy
-	if conn.config.IsUseProxy {
-		proxyURL, err := url.Parse(config.ProxyHost)
-		if err != nil {
-			return err
+			transport.Proxy = http.ProxyURL(proxyURL)
 		}
-		transport.Proxy = http.ProxyURL(proxyURL)
+		client = &http.Client{Transport: transport}
 	}
 
 	conn.config = config
 	conn.url = urlMaker
-	conn.client = &http.Client{Transport: transport}
+	conn.client = client
 
 	return nil
 }
 
-// Do 处理请求，返回响应结果。
-func (conn Conn) Do(method, bucketName, objectName, urlParams, subResource string, headers map[string]string,
+// Do sends request and returns the response
+func (conn Conn) Do(method, bucketName, objectName string, params map[string]interface{}, headers map[string]string,
 	data io.Reader, initCRC uint64, listener ProgressListener) (*Response, error) {
+	urlParams := conn.getURLParams(params)
+	subResource := conn.getSubResource(params)
 	uri := conn.url.getURL(bucketName, objectName, urlParams)
 	resource := conn.url.getResource(bucketName, objectName, subResource)
 	return conn.doRequest(method, uri, resource, headers, data, initCRC, listener)
 }
 
+// DoURL sends the request with signed URL and returns the response result.
+func (conn Conn) DoURL(method HTTPMethod, signedURL string, headers map[string]string,
+	data io.Reader, initCRC uint64, listener ProgressListener) (*Response, error) {
+	// Get URI from signedURL
+	uri, err := url.ParseRequestURI(signedURL)
+	if err != nil {
+		return nil, err
+	}
+
+	m := strings.ToUpper(string(method))
+	req := &http.Request{
+		Method:     m,
+		URL:        uri,
+		Proto:      "HTTP/1.1",
+		ProtoMajor: 1,
+		ProtoMinor: 1,
+		Header:     make(http.Header),
+		Host:       uri.Host,
+	}
+
+	tracker := &readerTracker{completedBytes: 0}
+	fd, crc := conn.handleBody(req, data, initCRC, listener, tracker)
+	if fd != nil {
+		defer func() {
+			fd.Close()
+			os.Remove(fd.Name())
+		}()
+	}
+
+	if conn.config.IsAuthProxy {
+		auth := conn.config.ProxyUser + ":" + conn.config.ProxyPassword
+		basic := "Basic " + base64.StdEncoding.EncodeToString([]byte(auth))
+		req.Header.Set("Proxy-Authorization", basic)
+	}
+
+	req.Header.Set(HTTPHeaderHost, conn.config.Endpoint)
+	req.Header.Set(HTTPHeaderUserAgent, conn.config.UserAgent)
+
+	if headers != nil {
+		for k, v := range headers {
+			req.Header.Set(k, v)
+		}
+	}
+
+	// Transfer started
+	event := newProgressEvent(TransferStartedEvent, 0, req.ContentLength)
+	publishProgress(listener, event)
+
+	resp, err := conn.client.Do(req)
+	if err != nil {
+		// Transfer failed
+		event = newProgressEvent(TransferFailedEvent, tracker.completedBytes, req.ContentLength)
+		publishProgress(listener, event)
+		return nil, err
+	}
+
+	// Transfer completed
+	event = newProgressEvent(TransferCompletedEvent, tracker.completedBytes, req.ContentLength)
+	publishProgress(listener, event)
+
+	return conn.handleResponse(resp, crc)
+}
+
+func (conn Conn) getURLParams(params map[string]interface{}) string {
+	// Sort
+	keys := make([]string, 0, len(params))
+	for k := range params {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	// Serialize
+	var buf bytes.Buffer
+	for _, k := range keys {
+		if buf.Len() > 0 {
+			buf.WriteByte('&')
+		}
+		buf.WriteString(url.QueryEscape(k))
+		if params[k] != nil {
+			buf.WriteString("=" + url.QueryEscape(params[k].(string)))
+		}
+	}
+
+	return buf.String()
+}
+
+func (conn Conn) getSubResource(params map[string]interface{}) string {
+	// Sort
+	keys := make([]string, 0, len(params))
+	for k := range params {
+		if conn.isParamSign(k) {
+			keys = append(keys, k)
+		}
+	}
+	sort.Strings(keys)
+
+	// Serialize
+	var buf bytes.Buffer
+	for _, k := range keys {
+		if buf.Len() > 0 {
+			buf.WriteByte('&')
+		}
+		buf.WriteString(k)
+		if params[k] != nil {
+			buf.WriteString("=" + params[k].(string))
+		}
+	}
+
+	return buf.String()
+}
+
+func (conn Conn) isParamSign(paramKey string) bool {
+	for _, k := range signKeyList {
+		if paramKey == k {
+			return true
+		}
+	}
+	return false
+}
+
 func (conn Conn) doRequest(method string, uri *url.URL, canonicalizedResource string, headers map[string]string,
 	data io.Reader, initCRC uint64, listener ProgressListener) (*Response, error) {
 	method = strings.ToUpper(method)
-	if !conn.config.IsUseProxy {
-		uri.Opaque = uri.Path
-	}
 	req := &http.Request{
 		Method:     method,
 		URL:        uri,
@@ -112,33 +227,72 @@ func (conn Conn) doRequest(method string, uri *url.URL, canonicalizedResource st
 
 	conn.signHeader(req, canonicalizedResource)
 
-	// transfer started
+	// Transfer started
 	event := newProgressEvent(TransferStartedEvent, 0, req.ContentLength)
 	publishProgress(listener, event)
 
 	resp, err := conn.client.Do(req)
 	if err != nil {
-		// transfer failed
+		// Transfer failed
 		event = newProgressEvent(TransferFailedEvent, tracker.completedBytes, req.ContentLength)
 		publishProgress(listener, event)
 		return nil, err
 	}
 
-	// transfer completed
+	// Transfer completed
 	event = newProgressEvent(TransferCompletedEvent, tracker.completedBytes, req.ContentLength)
 	publishProgress(listener, event)
 
 	return conn.handleResponse(resp, crc)
 }
 
-// handle request body
+func (conn Conn) signURL(method HTTPMethod, bucketName, objectName string, expiration int64, params map[string]interface{}, headers map[string]string) string {
+	if conn.config.SecurityToken != "" {
+		params[HTTPParamSecurityToken] = conn.config.SecurityToken
+	}
+	subResource := conn.getSubResource(params)
+	canonicalizedResource := conn.url.getResource(bucketName, objectName, subResource)
+
+	m := strings.ToUpper(string(method))
+	req := &http.Request{
+		Method: m,
+		Header: make(http.Header),
+	}
+
+	if conn.config.IsAuthProxy {
+		auth := conn.config.ProxyUser + ":" + conn.config.ProxyPassword
+		basic := "Basic " + base64.StdEncoding.EncodeToString([]byte(auth))
+		req.Header.Set("Proxy-Authorization", basic)
+	}
+
+	req.Header.Set(HTTPHeaderDate, strconv.FormatInt(expiration, 10))
+	req.Header.Set(HTTPHeaderHost, conn.config.Endpoint)
+	req.Header.Set(HTTPHeaderUserAgent, conn.config.UserAgent)
+
+	if headers != nil {
+		for k, v := range headers {
+			req.Header.Set(k, v)
+		}
+	}
+
+	signedStr := conn.getSignedStr(req, canonicalizedResource)
+
+	params[HTTPParamExpires] = strconv.FormatInt(expiration, 10)
+	params[HTTPParamAccessKeyID] = conn.config.AccessKeyID
+	params[HTTPParamSignature] = signedStr
+
+	urlParams := conn.getURLParams(params)
+	return conn.url.getSignURL(bucketName, objectName, urlParams)
+}
+
+// handleBody handles request body
 func (conn Conn) handleBody(req *http.Request, body io.Reader, initCRC uint64,
 	listener ProgressListener, tracker *readerTracker) (*os.File, hash.Hash64) {
 	var file *os.File
 	var crc hash.Hash64
 	reader := body
 
-	// length
+	// Length
 	switch v := body.(type) {
 	case *bytes.Buffer:
 		req.ContentLength = int64(v.Len())
@@ -153,20 +307,20 @@ func (conn Conn) handleBody(req *http.Request, body io.Reader, initCRC uint64,
 	}
 	req.Header.Set(HTTPHeaderContentLength, strconv.FormatInt(req.ContentLength, 10))
 
-	// md5
+	// MD5
 	if body != nil && conn.config.IsEnableMD5 && req.Header.Get(HTTPHeaderContentMD5) == "" {
 		md5 := ""
 		reader, md5, file, _ = calcMD5(body, req.ContentLength, conn.config.MD5Threshold)
 		req.Header.Set(HTTPHeaderContentMD5, md5)
 	}
 
-	// crc
+	// CRC
 	if reader != nil && conn.config.IsEnableCRC {
 		crc = NewCRC(crcTable(), initCRC)
 		reader = TeeReader(reader, crc, req.ContentLength, listener, tracker)
 	}
 
-	// http body
+	// HTTP body
 	rc, ok := reader.(io.ReadCloser)
 	if !ok && reader != nil {
 		rc = ioutil.NopCloser(reader)
@@ -181,7 +335,7 @@ func tryGetFileSize(f *os.File) int64 {
 	return fInfo.Size()
 }
 
-// handle response
+// handleResponse handles response
 func (conn Conn) handleResponse(resp *http.Response, crc hash.Hash64) (*Response, error) {
 	var cliCRC uint64
 	var srvCRC uint64
@@ -196,24 +350,28 @@ func (conn Conn) handleResponse(resp *http.Response, crc hash.Hash64) (*Response
 		}
 
 		if len(respBody) == 0 {
-			// no error in response body
-			err = fmt.Errorf("oss: service returned without a response body (%s)", resp.Status)
+			err = ServiceError{
+				StatusCode: statusCode,
+				RequestID:  resp.Header.Get(HTTPHeaderOssRequestID),
+			}
 		} else {
-			// response contains storage service error object, unmarshal
+			// Response contains storage service error object, unmarshal
 			srvErr, errIn := serviceErrFromXML(respBody, resp.StatusCode,
 				resp.Header.Get(HTTPHeaderOssRequestID))
-			if err != nil { // error unmarshaling the error response
-				err = errIn
+			if errIn != nil { // error unmarshaling the error response
+				err = fmt.Errorf("oss: service returned invalid response body, status = %s, RequestId = %s", resp.Status, resp.Header.Get(HTTPHeaderOssRequestID))
+			} else {
+				err = srvErr
 			}
-			err = srvErr
 		}
+
 		return &Response{
 			StatusCode: resp.StatusCode,
 			Headers:    resp.Header,
 			Body:       ioutil.NopCloser(bytes.NewReader(respBody)), // restore the body
 		}, err
 	} else if statusCode >= 300 && statusCode <= 307 {
-		// oss use 3xx, but response has no body
+		// OSS use 3xx, but response has no body
 		err := fmt.Errorf("oss: service returned %d,%s", resp.StatusCode, resp.Status)
 		return &Response{
 			StatusCode: resp.StatusCode,
@@ -239,7 +397,7 @@ func (conn Conn) handleResponse(resp *http.Response, crc hash.Hash64) (*Response
 
 func calcMD5(body io.Reader, contentLen, md5Threshold int64) (reader io.Reader, b64 string, tempFile *os.File, err error) {
 	if contentLen == 0 || contentLen > md5Threshold {
-		// huge body, use temporary file
+		// Huge body, use temporary file
 		tempFile, err = ioutil.TempFile(os.TempDir(), TempFilePrefix)
 		if tempFile != nil {
 			io.Copy(tempFile, body)
@@ -252,7 +410,7 @@ func calcMD5(body io.Reader, contentLen, md5Threshold int64) (reader io.Reader,
 			reader = tempFile
 		}
 	} else {
-		// small body, use memory
+		// Small body, use memory
 		buf, _ := ioutil.ReadAll(body)
 		sum := md5.Sum(buf)
 		b64 = base64.StdEncoding.EncodeToString(sum[:])
@@ -272,9 +430,11 @@ func readResponseBody(resp *http.Response) ([]byte, error) {
 
 func serviceErrFromXML(body []byte, statusCode int, requestID string) (ServiceError, error) {
 	var storageErr ServiceError
+
 	if err := xml.Unmarshal(body, &storageErr); err != nil {
 		return storageErr, err
 	}
+
 	storageErr.StatusCode = statusCode
 	storageErr.RequestID = requestID
 	storageErr.RawMessage = string(body)
@@ -289,7 +449,15 @@ func xmlUnmarshal(body io.Reader, v interface{}) error {
 	return xml.Unmarshal(data, v)
 }
 
-// Handle http timeout
+func jsonUnmarshal(body io.Reader, v interface{}) error {
+	data, err := ioutil.ReadAll(body)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(data, v)
+}
+
+// timeoutConn handles HTTP timeout
 type timeoutConn struct {
 	conn        net.Conn
 	timeout     time.Duration
@@ -343,7 +511,7 @@ func (c *timeoutConn) SetWriteDeadline(t time.Time) error {
 	return c.conn.SetWriteDeadline(t)
 }
 
-// UrlMaker - build url and resource
+// UrlMaker builds URL and resource
 const (
 	urlTypeCname  = 1
 	urlTypeIP     = 2
@@ -351,13 +519,13 @@ const (
 )
 
 type urlMaker struct {
-	Scheme  string // http or https
-	NetLoc  string // host or ip
-	Type    int    // 1 CNAME 2 IP 3 ALIYUN
-	IsProxy bool   // proxy
+	Scheme  string // HTTP or HTTPS
+	NetLoc  string // Host or IP
+	Type    int    // 1 CNAME, 2 IP, 3 ALIYUN
+	IsProxy bool   // Proxy
 }
 
-// Parse endpoint
+// Init parses endpoint
 func (um *urlMaker) Init(endpoint string, isCname bool, isProxy bool) {
 	if strings.HasPrefix(endpoint, "http://") {
 		um.Scheme = "http"
@@ -373,7 +541,11 @@ func (um *urlMaker) Init(endpoint string, isCname bool, isProxy bool) {
 	host, _, err := net.SplitHostPort(um.NetLoc)
 	if err != nil {
 		host = um.NetLoc
+		if host[0] == '[' && host[len(host)-1] == ']' {
+			host = host[1 : len(host)-1]
+		}
 	}
+
 	ip := net.ParseIP(host)
 	if ip != nil {
 		um.Type = urlTypeIP
@@ -385,14 +557,32 @@ func (um *urlMaker) Init(endpoint string, isCname bool, isProxy bool) {
 	um.IsProxy = isProxy
 }
 
-// Build URL
+// getURL gets URL
 func (um urlMaker) getURL(bucket, object, params string) *url.URL {
+	host, path := um.buildURL(bucket, object)
+	addr := ""
+	if params == "" {
+		addr = fmt.Sprintf("%s://%s%s", um.Scheme, host, path)
+	} else {
+		addr = fmt.Sprintf("%s://%s%s?%s", um.Scheme, host, path, params)
+	}
+	uri, _ := url.ParseRequestURI(addr)
+	return uri
+}
+
+// getSignURL gets sign URL
+func (um urlMaker) getSignURL(bucket, object, params string) string {
+	host, path := um.buildURL(bucket, object)
+	return fmt.Sprintf("%s://%s%s?%s", um.Scheme, host, path, params)
+}
+
+// buildURL builds URL
+func (um urlMaker) buildURL(bucket, object string) (string, string) {
 	var host = ""
 	var path = ""
 
-	if !um.IsProxy {
-		object = url.QueryEscape(object)
-	}
+	object = url.QueryEscape(object)
+	object = strings.Replace(object, "+", "%20", -1)
 
 	if um.Type == urlTypeCname {
 		host = um.NetLoc
@@ -415,17 +605,10 @@ func (um urlMaker) getURL(bucket, object, params string) *url.URL {
 		}
 	}
 
-	uri := &url.URL{
-		Scheme:   um.Scheme,
-		Host:     host,
-		Path:     path,
-		RawQuery: params,
-	}
-
-	return uri
+	return host, path
 }
 
-// Canonicalized Resource
+// getResource gets canonicalized resource
 func (um urlMaker) getResource(bucketName, objectName, subResource string) string {
 	if subResource != "" {
 		subResource = "?" + subResource
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/const.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/const.go
index 7120763d3..b5ee30bdf 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/const.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/const.go
@@ -2,35 +2,77 @@ package oss
 
 import "os"
 
-// ACLType Bucket/Object的访问控制
+// ACLType bucket/object ACL
 type ACLType string
 
 const (
-	// ACLPrivate 私有读写
+	// ACLPrivate definition : private read and write
 	ACLPrivate ACLType = "private"
 
-	// ACLPublicRead 公共读私有写
+	// ACLPublicRead definition : public read and private write
 	ACLPublicRead ACLType = "public-read"
 
-	// ACLPublicReadWrite 公共读写
+	// ACLPublicReadWrite definition : public read and public write
 	ACLPublicReadWrite ACLType = "public-read-write"
 
-	// ACLDefault Object默认权限，Bucket无此权限
+	// ACLDefault Object. It's only applicable for object.
 	ACLDefault ACLType = "default"
 )
 
-// MetadataDirectiveType 对象COPY时新对象是否使用原对象的Meta
+// MetadataDirectiveType specifying whether use the metadata of source object when copying object.
 type MetadataDirectiveType string
 
 const (
-	// MetaCopy 目标对象使用源对象的META
+	// MetaCopy the target object's metadata is copied from the source one
 	MetaCopy MetadataDirectiveType = "COPY"
 
-	// MetaReplace 目标对象使用自定义的META
+	// MetaReplace the target object's metadata is created as part of the copy request (not same as the source one)
 	MetaReplace MetadataDirectiveType = "REPLACE"
 )
 
-// Http头标签
+// StorageClassType bucket storage type
+type StorageClassType string
+
+const (
+	// StorageStandard standard
+	StorageStandard StorageClassType = "Standard"
+
+	// StorageIA infrequent access
+	StorageIA StorageClassType = "IA"
+
+	// StorageArchive archive
+	StorageArchive StorageClassType = "Archive"
+)
+
+// PayerType the type of request payer
+type PayerType string
+
+const (
+	// Requester the requester who send the request
+	Requester PayerType = "requester"
+)
+
+// HTTPMethod HTTP request method
+type HTTPMethod string
+
+const (
+	// HTTPGet HTTP GET
+	HTTPGet HTTPMethod = "GET"
+
+	// HTTPPut HTTP PUT
+	HTTPPut HTTPMethod = "PUT"
+
+	// HTTPHead HTTP HEAD
+	HTTPHead HTTPMethod = "HEAD"
+
+	// HTTPPost HTTP POST
+	HTTPPost HTTPMethod = "POST"
+
+	// HTTPDelete HTTP DELETE
+	HTTPDelete HTTPMethod = "DELETE"
+)
+
+// HTTP headers
 const (
 	HTTPHeaderAcceptEncoding     string = "Accept-Encoding"
 	HTTPHeaderAuthorization             = "Authorization"
@@ -61,6 +103,7 @@ const (
 	HTTPHeaderOssObjectACL                   = "X-Oss-Object-Acl"
 	HTTPHeaderOssSecurityToken               = "X-Oss-Security-Token"
 	HTTPHeaderOssServerSideEncryption        = "X-Oss-Server-Side-Encryption"
+	HTTPHeaderOssServerSideEncryptionKeyID   = "X-Oss-Server-Side-Encryption-Key-Id"
 	HTTPHeaderOssCopySource                  = "X-Oss-Copy-Source"
 	HTTPHeaderOssCopySourceRange             = "X-Oss-Copy-Source-Range"
 	HTTPHeaderOssCopySourceIfMatch           = "X-Oss-Copy-Source-If-Match"
@@ -71,19 +114,32 @@ const (
 	HTTPHeaderOssNextAppendPosition          = "X-Oss-Next-Append-Position"
 	HTTPHeaderOssRequestID                   = "X-Oss-Request-Id"
 	HTTPHeaderOssCRC64                       = "X-Oss-Hash-Crc64ecma"
+	HTTPHeaderOssSymlinkTarget               = "X-Oss-Symlink-Target"
+	HTTPHeaderOssStorageClass                = "X-Oss-Storage-Class"
+	HTTPHeaderOssCallback                    = "X-Oss-Callback"
+	HTTPHeaderOssCallbackVar                 = "X-Oss-Callback-Var"
+	HTTPHeaderOSSRequester                   = "X-Oss-Request-Payer"
 )
 
-// 其它常量
+// HTTP Param
 const (
-	MaxPartSize = 5 * 1024 * 1024 * 1024 // 文件片最大值，5GB
-	MinPartSize = 100 * 1024             // 文件片最小值，100KBß
-
-	FilePermMode = os.FileMode(0664) // 新建文件默认权限
-
-	TempFilePrefix = "oss-go-temp-" // 临时文件前缀
-	TempFileSuffix = ".temp"        // 临时文件后缀
-
-	CheckpointFileSuffix = ".cp" // Checkpoint文件后缀
-
-	Version = "1.3.0" // Go sdk版本
+	HTTPParamExpires       = "Expires"
+	HTTPParamAccessKeyID   = "OSSAccessKeyId"
+	HTTPParamSignature     = "Signature"
+	HTTPParamSecurityToken = "security-token"
+)
+
+// Other constants
+const (
+	MaxPartSize = 5 * 1024 * 1024 * 1024 // Max part size, 5GB
+	MinPartSize = 100 * 1024             // Min part size, 100KB
+
+	FilePermMode = os.FileMode(0664) // Default file permission
+
+	TempFilePrefix = "oss-go-temp-" // Temp file prefix
+	TempFileSuffix = ".temp"        // Temp file suffix
+
+	CheckpointFileSuffix = ".cp" // Checkpoint file suffix
+
+	Version = "1.9.2" // Go SDK version
 )
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/crc.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/crc.go
index 4f0958f42..c96694f28 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/crc.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/crc.go
@@ -11,11 +11,11 @@ type digest struct {
 	tab *crc64.Table
 }
 
-// NewCRC creates a new hash.Hash64 computing the CRC-64 checksum
+// NewCRC creates a new hash.Hash64 computing the CRC64 checksum
 // using the polynomial represented by the Table.
 func NewCRC(tab *crc64.Table, init uint64) hash.Hash64 { return &digest{init, tab} }
 
-// Size returns the number of bytes Sum will return.
+// Size returns the number of bytes sum will return.
 func (d *digest) Size() int { return crc64.Size }
 
 // BlockSize returns the hash's underlying block size.
@@ -24,7 +24,7 @@ func (d *digest) Size() int { return crc64.Size }
 // are a multiple of the block size.
 func (d *digest) BlockSize() int { return 1 }
 
-// Reset resets the Hash to its initial state.
+// Reset resets the hash to its initial state.
 func (d *digest) Reset() { d.crc = 0 }
 
 // Write (via the embedded io.Writer interface) adds more data to the running hash.
@@ -34,7 +34,7 @@ func (d *digest) Write(p []byte) (n int, err error) {
 	return len(p), nil
 }
 
-// Sum64 returns crc64 value.
+// Sum64 returns CRC64 value.
 func (d *digest) Sum64() uint64 { return d.crc }
 
 // Sum returns hash value.
@@ -42,3 +42,82 @@ func (d *digest) Sum(in []byte) []byte {
 	s := d.Sum64()
 	return append(in, byte(s>>56), byte(s>>48), byte(s>>40), byte(s>>32), byte(s>>24), byte(s>>16), byte(s>>8), byte(s))
 }
+
+// gf2Dim dimension of GF(2) vectors (length of CRC)
+const gf2Dim int = 64
+
+func gf2MatrixTimes(mat []uint64, vec uint64) uint64 {
+	var sum uint64
+	for i := 0; vec != 0; i++ {
+		if vec&1 != 0 {
+			sum ^= mat[i]
+		}
+
+		vec >>= 1
+	}
+	return sum
+}
+
+func gf2MatrixSquare(square []uint64, mat []uint64) {
+	for n := 0; n < gf2Dim; n++ {
+		square[n] = gf2MatrixTimes(mat, mat[n])
+	}
+}
+
+// CRC64Combine combines CRC64
+func CRC64Combine(crc1 uint64, crc2 uint64, len2 uint64) uint64 {
+	var even [gf2Dim]uint64 // Even-power-of-two zeros operator
+	var odd [gf2Dim]uint64  // Odd-power-of-two zeros operator
+
+	// Degenerate case
+	if len2 == 0 {
+		return crc1
+	}
+
+	// Put operator for one zero bit in odd
+	odd[0] = crc64.ECMA // CRC64 polynomial
+	var row uint64 = 1
+	for n := 1; n < gf2Dim; n++ {
+		odd[n] = row
+		row <<= 1
+	}
+
+	// Put operator for two zero bits in even
+	gf2MatrixSquare(even[:], odd[:])
+
+	// Put operator for four zero bits in odd
+	gf2MatrixSquare(odd[:], even[:])
+
+	// Apply len2 zeros to crc1, first square will put the operator for one zero byte, eight zero bits, in even
+	for {
+		// Apply zeros operator for this bit of len2
+		gf2MatrixSquare(even[:], odd[:])
+
+		if len2&1 != 0 {
+			crc1 = gf2MatrixTimes(even[:], crc1)
+		}
+
+		len2 >>= 1
+
+		// If no more bits set, then done
+		if len2 == 0 {
+			break
+		}
+
+		// Another iteration of the loop with odd and even swapped
+		gf2MatrixSquare(odd[:], even[:])
+		if len2&1 != 0 {
+			crc1 = gf2MatrixTimes(odd[:], crc1)
+		}
+		len2 >>= 1
+
+		// If no more bits set, then done
+		if len2 == 0 {
+			break
+		}
+	}
+
+	// Return combined CRC
+	crc1 ^= crc2
+	return crc1
+}
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/download.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/download.go
index ec3fe8b0c..f0f0857bd 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/download.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/download.go
@@ -5,53 +5,81 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"errors"
+	"fmt"
+	"hash"
+	"hash/crc64"
 	"io"
 	"io/ioutil"
+	"net/http"
 	"os"
+	"path/filepath"
 	"strconv"
 )
 
+// DownloadFile downloads files with multipart download.
 //
-// DownloadFile 分片下载文件
+// objectKey    the object key.
+// filePath    the local file to download from objectKey in OSS.
+// partSize    the part size in bytes.
+// options    object's constraints, check out GetObject for the reference.
 //
-// objectKey  object key。
-// filePath   本地文件。objectKey下载到文件。
-// partSize   本次上传文件片的大小，字节数。比如100 * 1024为每片100KB。
-// options    Object的属性限制项。详见GetObject。
-//
-// error 操作成功error为nil，非nil为错误信息。
+// error    it's nil when the call succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) DownloadFile(objectKey, filePath string, partSize int64, options ...Option) error {
-	if partSize < 1 || partSize > MaxPartSize {
-		return errors.New("oss: part size invalid range (1, 5GB]")
+	if partSize < 1 {
+		return errors.New("oss: part size smaller than 1")
 	}
 
-	cpConf, err := getCpConfig(options, filePath)
+	uRange, err := getRangeConfig(options)
 	if err != nil {
 		return err
 	}
 
+	cpConf := getCpConfig(options)
 	routines := getRoutines(options)
 
-	if cpConf.IsEnable {
-		return bucket.downloadFileWithCp(objectKey, filePath, partSize, options, cpConf.FilePath, routines)
+	if cpConf != nil && cpConf.IsEnable {
+		cpFilePath := getDownloadCpFilePath(cpConf, bucket.BucketName, objectKey, filePath)
+		if cpFilePath != "" {
+			return bucket.downloadFileWithCp(objectKey, filePath, partSize, options, cpFilePath, routines, uRange)
+		}
 	}
 
-	return bucket.downloadFile(objectKey, filePath, partSize, options, routines)
+	return bucket.downloadFile(objectKey, filePath, partSize, options, routines, uRange)
 }
 
-// ----- 并发无断点的下载  -----
+func getDownloadCpFilePath(cpConf *cpConfig, srcBucket, srcObject, destFile string) string {
+	if cpConf.FilePath == "" && cpConf.DirPath != "" {
+		src := fmt.Sprintf("oss://%v/%v", srcBucket, srcObject)
+		absPath, _ := filepath.Abs(destFile)
+		cpFileName := getCpFileName(src, absPath)
+		cpConf.FilePath = cpConf.DirPath + string(os.PathSeparator) + cpFileName
+	}
+	return cpConf.FilePath
+}
 
-// 工作协程参数
+// getRangeConfig gets the download range from the options.
+func getRangeConfig(options []Option) (*unpackedRange, error) {
+	rangeOpt, err := findOption(options, HTTPHeaderRange, nil)
+	if err != nil || rangeOpt == nil {
+		return nil, err
+	}
+	return parseRange(rangeOpt.(string))
+}
+
+// ----- concurrent download without checkpoint  -----
+
+// downloadWorkerArg is download worker's parameters
 type downloadWorkerArg struct {
-	bucket   *Bucket
-	key      string
-	filePath string
-	options  []Option
-	hook     downloadPartHook
+	bucket    *Bucket
+	key       string
+	filePath  string
+	options   []Option
+	hook      downloadPartHook
+	enableCRC bool
 }
 
-// Hook用于测试
+// downloadPartHook is hook for test
 type downloadPartHook func(part downloadPart) error
 
 var downloadPartHooker downloadPartHook = defaultDownloadPartHook
@@ -60,15 +88,15 @@ func defaultDownloadPartHook(part downloadPart) error {
 	return nil
 }
 
-// 默认ProgressListener，屏蔽GetObject的Options中ProgressListener
+// defaultDownloadProgressListener defines default ProgressListener, shields the ProgressListener in options of GetObject.
 type defaultDownloadProgressListener struct {
 }
 
-// ProgressChanged 静默处理
+// ProgressChanged no-ops
 func (listener *defaultDownloadProgressListener) ProgressChanged(event *ProgressEvent) {
 }
 
-// 工作协程
+// downloadWorker
 func downloadWorker(id int, arg downloadWorkerArg, jobs <-chan downloadPart, results chan<- downloadPart, failed chan<- error, die <-chan bool) {
 	for part := range jobs {
 		if err := arg.hook(part); err != nil {
@@ -76,11 +104,11 @@ func downloadWorker(id int, arg downloadWorkerArg, jobs <-chan downloadPart, res
 			break
 		}
 
-		// resolve options
+		// Resolve options
 		r := Range(part.Start, part.End)
 		p := Progress(&defaultDownloadProgressListener{})
 		opts := make([]Option, len(arg.options)+2)
-		// append orderly, can not be reversed!
+		// Append orderly, can not be reversed!
 		opts = append(opts, arg.options...)
 		opts = append(opts, r, p)
 
@@ -91,6 +119,14 @@ func downloadWorker(id int, arg downloadWorkerArg, jobs <-chan downloadPart, res
 		}
 		defer rd.Close()
 
+		var crcCalc hash.Hash64
+		if arg.enableCRC {
+			crcCalc = crc64.New(crcTable())
+			contentLen := part.End - part.Start + 1
+			rd = ioutil.NopCloser(TeeReader(rd, crcCalc, contentLen, nil, nil))
+		}
+		defer rd.Close()
+
 		select {
 		case <-die:
 			return
@@ -102,25 +138,31 @@ func downloadWorker(id int, arg downloadWorkerArg, jobs <-chan downloadPart, res
 			failed <- err
 			break
 		}
-		defer fd.Close()
 
-		_, err = fd.Seek(part.Start, os.SEEK_SET)
+		_, err = fd.Seek(part.Start-part.Offset, os.SEEK_SET)
 		if err != nil {
+			fd.Close()
 			failed <- err
 			break
 		}
 
 		_, err = io.Copy(fd, rd)
 		if err != nil {
+			fd.Close()
 			failed <- err
 			break
 		}
 
+		if arg.enableCRC {
+			part.CRC64 = crcCalc.Sum64()
+		}
+
+		fd.Close()
 		results <- part
 	}
 }
 
-// 调度协程
+// downloadScheduler
 func downloadScheduler(jobs chan downloadPart, parts []downloadPart) {
 	for _, part := range parts {
 		jobs <- part
@@ -128,39 +170,34 @@ func downloadScheduler(jobs chan downloadPart, parts []downloadPart) {
 	close(jobs)
 }
 
-// 下载片
+// downloadPart defines download part
 type downloadPart struct {
-	Index int   // 片序号，从0开始编号
-	Start int64 // 片起始位置
-	End   int64 // 片结束位置
+	Index  int    // Part number, starting from 0
+	Start  int64  // Start index
+	End    int64  // End index
+	Offset int64  // Offset
+	CRC64  uint64 // CRC check value of part
 }
 
-// 文件分片
-func getDownloadParts(bucket *Bucket, objectKey string, partSize int64) ([]downloadPart, error) {
-	meta, err := bucket.GetObjectDetailedMeta(objectKey)
-	if err != nil {
-		return nil, err
-	}
-
+// getDownloadParts gets download parts
+func getDownloadParts(objectSize, partSize int64, uRange *unpackedRange) []downloadPart {
 	parts := []downloadPart{}
-	objectSize, err := strconv.ParseInt(meta.Get(HTTPHeaderContentLength), 10, 0)
-	if err != nil {
-		return nil, err
-	}
-
 	part := downloadPart{}
 	i := 0
-	for offset := int64(0); offset < objectSize; offset += partSize {
+	start, end := adjustRange(uRange, objectSize)
+	for offset := start; offset < end; offset += partSize {
 		part.Index = i
 		part.Start = offset
-		part.End = GetPartEnd(offset, objectSize, partSize)
+		part.End = GetPartEnd(offset, end, partSize)
+		part.Offset = start
+		part.CRC64 = 0
 		parts = append(parts, part)
 		i++
 	}
-	return parts, nil
+	return parts
 }
 
-// 文件大小
+// getObjectBytes gets object bytes length
 func getObjectBytes(parts []downloadPart) int64 {
 	var ob int64
 	for _, part := range parts {
@@ -169,24 +206,59 @@ func getObjectBytes(parts []downloadPart) int64 {
 	return ob
 }
 
-// 并发无断点续传的下载
-func (bucket Bucket) downloadFile(objectKey, filePath string, partSize int64, options []Option, routines int) error {
+// combineCRCInParts caculates the total CRC of continuous parts
+func combineCRCInParts(dps []downloadPart) uint64 {
+	if dps == nil || len(dps) == 0 {
+		return 0
+	}
+
+	crc := dps[0].CRC64
+	for i := 1; i < len(dps); i++ {
+		crc = CRC64Combine(crc, dps[i].CRC64, (uint64)(dps[i].End-dps[i].Start+1))
+	}
+
+	return crc
+}
+
+// downloadFile downloads file concurrently without checkpoint.
+func (bucket Bucket) downloadFile(objectKey, filePath string, partSize int64, options []Option, routines int, uRange *unpackedRange) error {
 	tempFilePath := filePath + TempFileSuffix
 	listener := getProgressListener(options)
 
-	// 如果文件不存在则创建，存在不清空，下载分片会重写文件内容
+	payerOptions := []Option{}
+	payer := getPayer(options)
+	if payer != "" {
+		payerOptions = append(payerOptions, RequestPayer(PayerType(payer)))
+	}
+
+	// If the file does not exist, create one. If exists, the download will overwrite it.
 	fd, err := os.OpenFile(tempFilePath, os.O_WRONLY|os.O_CREATE, FilePermMode)
 	if err != nil {
 		return err
 	}
 	fd.Close()
 
-	// 分割文件
-	parts, err := getDownloadParts(&bucket, objectKey, partSize)
+	meta, err := bucket.GetObjectDetailedMeta(objectKey, payerOptions...)
 	if err != nil {
 		return err
 	}
 
+	objectSize, err := strconv.ParseInt(meta.Get(HTTPHeaderContentLength), 10, 0)
+	if err != nil {
+		return err
+	}
+
+	enableCRC := false
+	expectedCRC := (uint64)(0)
+	if bucket.getConfig().IsEnableCRC && meta.Get(HTTPHeaderOssCRC64) != "" {
+		if uRange == nil || (!uRange.hasStart && !uRange.hasEnd) {
+			enableCRC = true
+			expectedCRC, _ = strconv.ParseUint(meta.Get(HTTPHeaderOssCRC64), 10, 0)
+		}
+	}
+
+	// Get the parts of the file
+	parts := getDownloadParts(objectSize, partSize, uRange)
 	jobs := make(chan downloadPart, len(parts))
 	results := make(chan downloadPart, len(parts))
 	failed := make(chan error)
@@ -197,24 +269,23 @@ func (bucket Bucket) downloadFile(objectKey, filePath string, partSize int64, op
 	event := newProgressEvent(TransferStartedEvent, 0, totalBytes)
 	publishProgress(listener, event)
 
-	// 启动工作协程
-	arg := downloadWorkerArg{&bucket, objectKey, tempFilePath, options, downloadPartHooker}
+	// Start the download workers
+	arg := downloadWorkerArg{&bucket, objectKey, tempFilePath, options, downloadPartHooker, enableCRC}
 	for w := 1; w <= routines; w++ {
 		go downloadWorker(w, arg, jobs, results, failed, die)
 	}
 
-	// 并发上传分片
+	// Download parts concurrently
 	go downloadScheduler(jobs, parts)
 
-	// 等待分片下载完成
+	// Waiting for parts download finished
 	completed := 0
-	ps := make([]downloadPart, len(parts))
 	for completed < len(parts) {
 		select {
 		case part := <-results:
 			completed++
-			ps[part.Index] = part
 			completedBytes += (part.End - part.Start + 1)
+			parts[part.Index].CRC64 = part.CRC64
 			event = newProgressEvent(TransferDataEvent, completedBytes, totalBytes)
 			publishProgress(listener, event)
 		case err := <-failed:
@@ -232,32 +303,44 @@ func (bucket Bucket) downloadFile(objectKey, filePath string, partSize int64, op
 	event = newProgressEvent(TransferCompletedEvent, completedBytes, totalBytes)
 	publishProgress(listener, event)
 
+	if enableCRC {
+		actualCRC := combineCRCInParts(parts)
+		err = checkDownloadCRC(actualCRC, expectedCRC)
+		if err != nil {
+			return err
+		}
+	}
+
 	return os.Rename(tempFilePath, filePath)
 }
 
-// ----- 并发有断点的下载  -----
+// ----- Concurrent download with chcekpoint  -----
 
 const downloadCpMagic = "92611BED-89E2-46B6-89E5-72F273D4B0A3"
 
 type downloadCheckpoint struct {
-	Magic    string         // magic
-	MD5      string         // cp内容的MD5
-	FilePath string         // 本地文件
-	Object   string         // key
-	ObjStat  objectStat     // 文件状态
-	Parts    []downloadPart // 全部分片
-	PartStat []bool         // 分片下载是否完成
+	Magic     string         // Magic
+	MD5       string         // Checkpoint content MD5
+	FilePath  string         // Local file
+	Object    string         // Key
+	ObjStat   objectStat     // Object status
+	Parts     []downloadPart // All download parts
+	PartStat  []bool         // Parts' download status
+	Start     int64          // Start point of the file
+	End       int64          // End point of the file
+	enableCRC bool           // Whether has CRC check
+	CRC       uint64         // CRC check value
 }
 
 type objectStat struct {
-	Size         int64  // 大小
-	LastModified string // 最后修改时间
-	Etag         string // etag
+	Size         int64  // Object size
+	LastModified string // Last modified time
+	Etag         string // Etag
 }
 
-// CP数据是否有效，CP有效且Object没有更新时有效
-func (cp downloadCheckpoint) isValid(bucket *Bucket, objectKey string) (bool, error) {
-	// 比较CP的Magic及MD5
+// isValid flags of checkpoint data is valid. It returns true when the data is valid and the checkpoint is valid and the object is not updated.
+func (cp downloadCheckpoint) isValid(meta http.Header, uRange *unpackedRange) (bool, error) {
+	// Compare the CP's Magic and the MD5
 	cpb := cp
 	cpb.MD5 = ""
 	js, _ := json.Marshal(cpb)
@@ -268,28 +351,30 @@ func (cp downloadCheckpoint) isValid(bucket *Bucket, objectKey string) (bool, er
 		return false, nil
 	}
 
-	// 确认object没有更新
-	meta, err := bucket.GetObjectDetailedMeta(objectKey)
-	if err != nil {
-		return false, err
-	}
-
 	objectSize, err := strconv.ParseInt(meta.Get(HTTPHeaderContentLength), 10, 0)
 	if err != nil {
 		return false, err
 	}
 
-	// 比较Object的大小/最后修改时间/etag
+	// Compare the object size, last modified time and etag
 	if cp.ObjStat.Size != objectSize ||
 		cp.ObjStat.LastModified != meta.Get(HTTPHeaderLastModified) ||
 		cp.ObjStat.Etag != meta.Get(HTTPHeaderEtag) {
 		return false, nil
 	}
 
+	// Check the download range
+	if uRange != nil {
+		start, end := adjustRange(uRange, objectSize)
+		if start != cp.Start || end != cp.End {
+			return false, nil
+		}
+	}
+
 	return true, nil
 }
 
-// 从文件中load
+// load checkpoint from local file
 func (cp *downloadCheckpoint) load(filePath string) error {
 	contents, err := ioutil.ReadFile(filePath)
 	if err != nil {
@@ -300,11 +385,11 @@ func (cp *downloadCheckpoint) load(filePath string) error {
 	return err
 }
 
-// dump到文件
+// dump funciton dumps to file
 func (cp *downloadCheckpoint) dump(filePath string) error {
 	bcp := *cp
 
-	// 计算MD5
+	// Calculate MD5
 	bcp.MD5 = ""
 	js, err := json.Marshal(bcp)
 	if err != nil {
@@ -314,17 +399,17 @@ func (cp *downloadCheckpoint) dump(filePath string) error {
 	b64 := base64.StdEncoding.EncodeToString(sum[:])
 	bcp.MD5 = b64
 
-	// 序列化
+	// Serialize
 	js, err = json.Marshal(bcp)
 	if err != nil {
 		return err
 	}
 
-	// dump
+	// Dump
 	return ioutil.WriteFile(filePath, js, FilePermMode)
 }
 
-// 未完成的分片
+// todoParts gets unfinished parts
 func (cp downloadCheckpoint) todoParts() []downloadPart {
 	dps := []downloadPart{}
 	for i, ps := range cp.PartStat {
@@ -335,7 +420,7 @@ func (cp downloadCheckpoint) todoParts() []downloadPart {
 	return dps
 }
 
-// 完成的字节数
+// getCompletedBytes gets completed size
 func (cp downloadCheckpoint) getCompletedBytes() int64 {
 	var completedBytes int64
 	for i, part := range cp.Parts {
@@ -346,19 +431,13 @@ func (cp downloadCheckpoint) getCompletedBytes() int64 {
 	return completedBytes
 }
 
-// 初始化下载任务
-func (cp *downloadCheckpoint) prepare(bucket *Bucket, objectKey, filePath string, partSize int64) error {
-	// cp
+// prepare initiates download tasks
+func (cp *downloadCheckpoint) prepare(meta http.Header, bucket *Bucket, objectKey, filePath string, partSize int64, uRange *unpackedRange) error {
+	// CP
 	cp.Magic = downloadCpMagic
 	cp.FilePath = filePath
 	cp.Object = objectKey
 
-	// object
-	meta, err := bucket.GetObjectDetailedMeta(objectKey)
-	if err != nil {
-		return err
-	}
-
 	objectSize, err := strconv.ParseInt(meta.Get(HTTPHeaderContentLength), 10, 0)
 	if err != nil {
 		return err
@@ -368,11 +447,15 @@ func (cp *downloadCheckpoint) prepare(bucket *Bucket, objectKey, filePath string
 	cp.ObjStat.LastModified = meta.Get(HTTPHeaderLastModified)
 	cp.ObjStat.Etag = meta.Get(HTTPHeaderEtag)
 
-	// parts
-	cp.Parts, err = getDownloadParts(bucket, objectKey, partSize)
-	if err != nil {
-		return err
+	if bucket.getConfig().IsEnableCRC && meta.Get(HTTPHeaderOssCRC64) != "" {
+		if uRange == nil || (!uRange.hasStart && !uRange.hasEnd) {
+			cp.enableCRC = true
+			cp.CRC, _ = strconv.ParseUint(meta.Get(HTTPHeaderOssCRC64), 10, 0)
+		}
 	}
+
+	// Parts
+	cp.Parts = getDownloadParts(objectSize, partSize, uRange)
 	cp.PartStat = make([]bool, len(cp.Parts))
 	for i := range cp.PartStat {
 		cp.PartStat[i] = false
@@ -386,35 +469,47 @@ func (cp *downloadCheckpoint) complete(cpFilePath, downFilepath string) error {
 	return os.Rename(downFilepath, cp.FilePath)
 }
 
-// 并发带断点的下载
-func (bucket Bucket) downloadFileWithCp(objectKey, filePath string, partSize int64, options []Option, cpFilePath string, routines int) error {
+// downloadFileWithCp downloads files with checkpoint.
+func (bucket Bucket) downloadFileWithCp(objectKey, filePath string, partSize int64, options []Option, cpFilePath string, routines int, uRange *unpackedRange) error {
 	tempFilePath := filePath + TempFileSuffix
 	listener := getProgressListener(options)
 
-	// LOAD CP数据
+	payerOptions := []Option{}
+	payer := getPayer(options)
+	if payer != "" {
+		payerOptions = append(payerOptions, RequestPayer(PayerType(payer)))
+	}
+
+	// Load checkpoint data.
 	dcp := downloadCheckpoint{}
 	err := dcp.load(cpFilePath)
 	if err != nil {
 		os.Remove(cpFilePath)
 	}
 
-	// LOAD出错或数据无效重新初始化下载
-	valid, err := dcp.isValid(&bucket, objectKey)
+	// Get the object detailed meta.
+	meta, err := bucket.GetObjectDetailedMeta(objectKey, payerOptions...)
+	if err != nil {
+		return err
+	}
+
+	// Load error or data invalid. Re-initialize the download.
+	valid, err := dcp.isValid(meta, uRange)
 	if err != nil || !valid {
-		if err = dcp.prepare(&bucket, objectKey, filePath, partSize); err != nil {
+		if err = dcp.prepare(meta, &bucket, objectKey, filePath, partSize, uRange); err != nil {
 			return err
 		}
 		os.Remove(cpFilePath)
 	}
 
-	// 如果文件不存在则创建，存在不清空，下载分片会重写文件内容
+	// Create the file if not exists. Otherwise the parts download will overwrite it.
 	fd, err := os.OpenFile(tempFilePath, os.O_WRONLY|os.O_CREATE, FilePermMode)
 	if err != nil {
 		return err
 	}
 	fd.Close()
 
-	// 未完成的分片
+	// Unfinished parts
 	parts := dcp.todoParts()
 	jobs := make(chan downloadPart, len(parts))
 	results := make(chan downloadPart, len(parts))
@@ -425,22 +520,23 @@ func (bucket Bucket) downloadFileWithCp(objectKey, filePath string, partSize int
 	event := newProgressEvent(TransferStartedEvent, completedBytes, dcp.ObjStat.Size)
 	publishProgress(listener, event)
 
-	// 启动工作协程
-	arg := downloadWorkerArg{&bucket, objectKey, tempFilePath, options, downloadPartHooker}
+	// Start the download workers routine
+	arg := downloadWorkerArg{&bucket, objectKey, tempFilePath, options, downloadPartHooker, dcp.enableCRC}
 	for w := 1; w <= routines; w++ {
 		go downloadWorker(w, arg, jobs, results, failed, die)
 	}
 
-	// 并发下载分片
+	// Concurrently downloads parts
 	go downloadScheduler(jobs, parts)
 
-	// 等待分片下载完成
+	// Wait for the parts download finished
 	completed := 0
 	for completed < len(parts) {
 		select {
 		case part := <-results:
 			completed++
 			dcp.PartStat[part.Index] = true
+			dcp.Parts[part.Index].CRC64 = part.CRC64
 			dcp.dump(cpFilePath)
 			completedBytes += (part.End - part.Start + 1)
 			event = newProgressEvent(TransferDataEvent, completedBytes, dcp.ObjStat.Size)
@@ -460,5 +556,13 @@ func (bucket Bucket) downloadFileWithCp(objectKey, filePath string, partSize int
 	event = newProgressEvent(TransferCompletedEvent, completedBytes, dcp.ObjStat.Size)
 	publishProgress(listener, event)
 
+	if dcp.enableCRC {
+		actualCRC := combineCRCInParts(dcp.Parts)
+		err = checkDownloadCRC(actualCRC, dcp.CRC)
+		if err != nil {
+			return err
+		}
+	}
+
 	return dcp.complete(cpFilePath, tempFilePath)
 }
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/error.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/error.go
index 5c06df92b..6d7b4e0fa 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/error.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/error.go
@@ -10,28 +10,33 @@ import (
 // ServiceError contains fields of the error response from Oss Service REST API.
 type ServiceError struct {
 	XMLName    xml.Name `xml:"Error"`
-	Code       string   `xml:"Code"`      // OSS返回给用户的错误码
-	Message    string   `xml:"Message"`   // OSS给出的详细错误信息
-	RequestID  string   `xml:"RequestId"` // 用于唯一标识该次请求的UUID
-	HostID     string   `xml:"HostId"`    // 用于标识访问的OSS集群
-	RawMessage string   // OSS返回的原始消息内容
-	StatusCode int      // HTTP状态码
+	Code       string   `xml:"Code"`      // The error code returned from OSS to the caller
+	Message    string   `xml:"Message"`   // The detail error message from OSS
+	RequestID  string   `xml:"RequestId"` // The UUID used to uniquely identify the request
+	HostID     string   `xml:"HostId"`    // The OSS server cluster's Id
+	Endpoint   string   `xml:"Endpoint"`
+	RawMessage string   // The raw messages from OSS
+	StatusCode int      // HTTP status code
 }
 
-// Implement interface error
+// Error implements interface error
 func (e ServiceError) Error() string {
-	return fmt.Sprintf("oss: service returned error: StatusCode=%d, ErrorCode=%s, ErrorMessage=%s, RequestId=%s",
-		e.StatusCode, e.Code, e.Message, e.RequestID)
+	if e.Endpoint == "" {
+		return fmt.Sprintf("oss: service returned error: StatusCode=%d, ErrorCode=%s, ErrorMessage=\"%s\", RequestId=%s",
+			e.StatusCode, e.Code, e.Message, e.RequestID)
+	}
+	return fmt.Sprintf("oss: service returned error: StatusCode=%d, ErrorCode=%s, ErrorMessage=\"%s\", RequestId=%s, Endpoint=%s",
+		e.StatusCode, e.Code, e.Message, e.RequestID, e.Endpoint)
 }
 
 // UnexpectedStatusCodeError is returned when a storage service responds with neither an error
 // nor with an HTTP status code indicating success.
 type UnexpectedStatusCodeError struct {
-	allowed []int // 预期OSS返回HTTP状态码
-	got     int   // OSS实际返回HTTP状态码
+	allowed []int // The expected HTTP stats code returned from OSS
+	got     int   // The actual HTTP status code from OSS
 }
 
-// Implement interface error
+// Error implements interface error
 func (e UnexpectedStatusCodeError) Error() string {
 	s := func(i int) string { return fmt.Sprintf("%d %s", i, http.StatusText(i)) }
 
@@ -62,18 +67,25 @@ func checkRespCode(respCode int, allowed []int) error {
 
 // CRCCheckError is returned when crc check is inconsistent between client and server
 type CRCCheckError struct {
-	clientCRC uint64 // 客户端计算的CRC64值
-	serverCRC uint64 // 服务端计算的CRC64值
-	operation string // 上传操作，如PutObject/AppendObject/UploadPart等
-	requestID string // 本次操作的RequestID
+	clientCRC uint64 // Calculated CRC64 in client
+	serverCRC uint64 // Calculated CRC64 in server
+	operation string // Upload operations such as PutObject/AppendObject/UploadPart, etc
+	requestID string // The request id of this operation
 }
 
-// Implement interface error
+// Error implements interface error
 func (e CRCCheckError) Error() string {
 	return fmt.Sprintf("oss: the crc of %s is inconsistent, client %d but server %d; request id is %s",
 		e.operation, e.clientCRC, e.serverCRC, e.requestID)
 }
 
+func checkDownloadCRC(clientCRC, serverCRC uint64) error {
+	if clientCRC == serverCRC {
+		return nil
+	}
+	return CRCCheckError{clientCRC, serverCRC, "DownloadFile", ""}
+}
+
 func checkCRC(resp *Response, operation string) error {
 	if resp.Headers.Get(HTTPHeaderOssCRC64) == "" || resp.ClientCRC == resp.ServerCRC {
 		return nil
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/mime.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/mime.go
index e2ed9ce10..11485973d 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/mime.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/mime.go
@@ -235,7 +235,7 @@ var extToMimeType = map[string]string{
 }
 
 // TypeByExtension returns the MIME type associated with the file extension ext.
-// 获取文件类型，选项ContentType使用
+// gets the file's MIME type for HTTP header Content-Type
 func TypeByExtension(filePath string) string {
 	typ := mime.TypeByExtension(path.Ext(filePath))
 	if typ == "" {
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/model.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/model.go
index 7c71b0181..51f1c31e3 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/model.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/model.go
@@ -6,7 +6,7 @@ import (
 	"net/http"
 )
 
-// Response Http response from oss
+// Response defines HTTP response from OSS
 type Response struct {
 	StatusCode int
 	Headers    http.Header
@@ -15,38 +15,46 @@ type Response struct {
 	ServerCRC  uint64
 }
 
-// PutObjectRequest The request of DoPutObject
+func (r *Response) Read(p []byte) (n int, err error) {
+	return r.Body.Read(p)
+}
+
+func (r *Response) Close() error {
+	return r.Body.Close()
+}
+
+// PutObjectRequest is the request of DoPutObject
 type PutObjectRequest struct {
 	ObjectKey string
 	Reader    io.Reader
 }
 
-// GetObjectRequest The request of DoGetObject
+// GetObjectRequest is the request of DoGetObject
 type GetObjectRequest struct {
 	ObjectKey string
 }
 
-// GetObjectResult The result of DoGetObject
+// GetObjectResult is the result of DoGetObject
 type GetObjectResult struct {
 	Response  *Response
 	ClientCRC hash.Hash64
 	ServerCRC uint64
 }
 
-// AppendObjectRequest  The requtest of DoAppendObject
+// AppendObjectRequest is the requtest of DoAppendObject
 type AppendObjectRequest struct {
 	ObjectKey string
 	Reader    io.Reader
 	Position  int64
 }
 
-// AppendObjectResult The result of DoAppendObject
+// AppendObjectResult is the result of DoAppendObject
 type AppendObjectResult struct {
 	NextPosition int64
 	CRC          uint64
 }
 
-// UploadPartRequest The request of DoUploadPart
+// UploadPartRequest is the request of DoUploadPart
 type UploadPartRequest struct {
 	InitResult *InitiateMultipartUploadResult
 	Reader     io.Reader
@@ -54,7 +62,7 @@ type UploadPartRequest struct {
 	PartNumber int
 }
 
-// UploadPartResult The result of DoUploadPart
+// UploadPartResult is the result of DoUploadPart
 type UploadPartResult struct {
 	Part UploadPart
 }
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/multicopy.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/multicopy.go
index a33b48870..e2597c24e 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/multicopy.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/multicopy.go
@@ -5,22 +5,22 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/ioutil"
+	"net/http"
 	"os"
-	"path/filepath"
 	"strconv"
 )
 
+// CopyFile is multipart copy object
 //
-// CopyFile 分片复制文件
+// srcBucketName    source bucket name
+// srcObjectKey    source object name
+// destObjectKey    target object name in the form of bucketname.objectkey
+// partSize    the part size in byte.
+// options    object's contraints. Check out function InitiateMultipartUpload.
 //
-// srcBucketName  源Bucket名称。
-// srcObjectKey   源Object名称。
-// destObjectKey   目标Object名称。目标Bucket名称为Bucket.BucketName。
-// partSize   复制文件片的大小，字节数。比如100 * 1024为每片100KB。
-// options    Object的属性限制项。详见InitiateMultipartUpload。
-//
-// error 操作成功error为nil，非nil为错误信息。
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) CopyFile(srcBucketName, srcObjectKey, destObjectKey string, partSize int64, options ...Option) error {
 	destBucketName := bucket.BucketName
@@ -28,25 +28,33 @@ func (bucket Bucket) CopyFile(srcBucketName, srcObjectKey, destObjectKey string,
 		return errors.New("oss: part size invalid range (1024KB, 5GB]")
 	}
 
-	cpConf, err := getCpConfig(options, filepath.Base(destObjectKey))
-	if err != nil {
-		return err
-	}
-
+	cpConf := getCpConfig(options)
 	routines := getRoutines(options)
 
-	if cpConf.IsEnable {
-		return bucket.copyFileWithCp(srcBucketName, srcObjectKey, destBucketName, destObjectKey,
-			partSize, options, cpConf.FilePath, routines)
+	if cpConf != nil && cpConf.IsEnable {
+		cpFilePath := getCopyCpFilePath(cpConf, srcBucketName, srcObjectKey, destBucketName, destObjectKey)
+		if cpFilePath != "" {
+			return bucket.copyFileWithCp(srcBucketName, srcObjectKey, destBucketName, destObjectKey, partSize, options, cpFilePath, routines)
+		}
 	}
 
 	return bucket.copyFile(srcBucketName, srcObjectKey, destBucketName, destObjectKey,
 		partSize, options, routines)
 }
 
-// ----- 并发无断点的下载  -----
+func getCopyCpFilePath(cpConf *cpConfig, srcBucket, srcObject, destBucket, destObject string) string {
+	if cpConf.FilePath == "" && cpConf.DirPath != "" {
+		dest := fmt.Sprintf("oss://%v/%v", destBucket, destObject)
+		src := fmt.Sprintf("oss://%v/%v", srcBucket, srcObject)
+		cpFileName := getCpFileName(src, dest)
+		cpConf.FilePath = cpConf.DirPath + string(os.PathSeparator) + cpFileName
+	}
+	return cpConf.FilePath
+}
 
-// 工作协程参数
+// ----- Concurrently copy without checkpoint ---------
+
+// copyWorkerArg defines the copy worker arguments
 type copyWorkerArg struct {
 	bucket        *Bucket
 	imur          InitiateMultipartUploadResult
@@ -56,7 +64,7 @@ type copyWorkerArg struct {
 	hook          copyPartHook
 }
 
-// Hook用于测试
+// copyPartHook is the hook for testing purpose
 type copyPartHook func(part copyPart) error
 
 var copyPartHooker copyPartHook = defaultCopyPartHook
@@ -65,7 +73,7 @@ func defaultCopyPartHook(part copyPart) error {
 	return nil
 }
 
-// 工作协程
+// copyWorker copies worker
 func copyWorker(id int, arg copyWorkerArg, jobs <-chan copyPart, results chan<- UploadPart, failed chan<- error, die <-chan bool) {
 	for chunk := range jobs {
 		if err := arg.hook(chunk); err != nil {
@@ -88,7 +96,7 @@ func copyWorker(id int, arg copyWorkerArg, jobs <-chan copyPart, results chan<-
 	}
 }
 
-// 调度协程
+// copyScheduler
 func copyScheduler(jobs chan copyPart, parts []copyPart) {
 	for _, part := range parts {
 		jobs <- part
@@ -96,26 +104,16 @@ func copyScheduler(jobs chan copyPart, parts []copyPart) {
 	close(jobs)
 }
 
-// 分片
+// copyPart structure
 type copyPart struct {
-	Number int   // 片序号[1, 10000]
-	Start  int64 // 片起始位置
-	End    int64 // 片结束位置
+	Number int   // Part number (from 1 to 10,000)
+	Start  int64 // The start index in the source file.
+	End    int64 // The end index in the source file
 }
 
-// 文件分片
-func getCopyParts(bucket *Bucket, objectKey string, partSize int64) ([]copyPart, error) {
-	meta, err := bucket.GetObjectDetailedMeta(objectKey)
-	if err != nil {
-		return nil, err
-	}
-
+// getCopyParts calculates copy parts
+func getCopyParts(objectSize, partSize int64) []copyPart {
 	parts := []copyPart{}
-	objectSize, err := strconv.ParseInt(meta.Get(HTTPHeaderContentLength), 10, 0)
-	if err != nil {
-		return nil, err
-	}
-
 	part := copyPart{}
 	i := 0
 	for offset := int64(0); offset < objectSize; offset += partSize {
@@ -125,10 +123,10 @@ func getCopyParts(bucket *Bucket, objectKey string, partSize int64) ([]copyPart,
 		parts = append(parts, part)
 		i++
 	}
-	return parts, nil
+	return parts
 }
 
-// 获取源文件大小
+// getSrcObjectBytes gets the source file size
 func getSrcObjectBytes(parts []copyPart) int64 {
 	var ob int64
 	for _, part := range parts {
@@ -137,20 +135,32 @@ func getSrcObjectBytes(parts []copyPart) int64 {
 	return ob
 }
 
-// 并发无断点续传的下载
+// copyFile is a concurrently copy without checkpoint
 func (bucket Bucket) copyFile(srcBucketName, srcObjectKey, destBucketName, destObjectKey string,
 	partSize int64, options []Option, routines int) error {
 	descBucket, err := bucket.Client.Bucket(destBucketName)
 	srcBucket, err := bucket.Client.Bucket(srcBucketName)
 	listener := getProgressListener(options)
 
-	// 分割文件
-	parts, err := getCopyParts(srcBucket, srcObjectKey, partSize)
+	payerOptions := []Option{}
+	payer := getPayer(options)
+	if payer != "" {
+		payerOptions = append(payerOptions, RequestPayer(PayerType(payer)))
+	}
+
+	meta, err := srcBucket.GetObjectDetailedMeta(srcObjectKey, payerOptions...)
 	if err != nil {
 		return err
 	}
 
-	// 初始化上传任务
+	objectSize, err := strconv.ParseInt(meta.Get(HTTPHeaderContentLength), 10, 0)
+	if err != nil {
+		return err
+	}
+
+	// Get copy parts
+	parts := getCopyParts(objectSize, partSize)
+	// Initialize the multipart upload
 	imur, err := descBucket.InitiateMultipartUpload(destObjectKey, options...)
 	if err != nil {
 		return err
@@ -166,16 +176,16 @@ func (bucket Bucket) copyFile(srcBucketName, srcObjectKey, destBucketName, destO
 	event := newProgressEvent(TransferStartedEvent, 0, totalBytes)
 	publishProgress(listener, event)
 
-	// 启动工作协程
-	arg := copyWorkerArg{descBucket, imur, srcBucketName, srcObjectKey, options, copyPartHooker}
+	// Start to copy workers
+	arg := copyWorkerArg{descBucket, imur, srcBucketName, srcObjectKey, payerOptions, copyPartHooker}
 	for w := 1; w <= routines; w++ {
 		go copyWorker(w, arg, jobs, results, failed, die)
 	}
 
-	// 并发上传分片
+	// Start the scheduler
 	go copyScheduler(jobs, parts)
 
-	// 等待分片下载完成
+	// Wait for the parts finished.
 	completed := 0
 	ups := make([]UploadPart, len(parts))
 	for completed < len(parts) {
@@ -188,7 +198,7 @@ func (bucket Bucket) copyFile(srcBucketName, srcObjectKey, destBucketName, destO
 			publishProgress(listener, event)
 		case err := <-failed:
 			close(die)
-			descBucket.AbortMultipartUpload(imur)
+			descBucket.AbortMultipartUpload(imur, payerOptions...)
 			event = newProgressEvent(TransferFailedEvent, completedBytes, totalBytes)
 			publishProgress(listener, event)
 			return err
@@ -202,36 +212,36 @@ func (bucket Bucket) copyFile(srcBucketName, srcObjectKey, destBucketName, destO
 	event = newProgressEvent(TransferCompletedEvent, completedBytes, totalBytes)
 	publishProgress(listener, event)
 
-	// 提交任务
-	_, err = descBucket.CompleteMultipartUpload(imur, ups)
+	// Complete the multipart upload
+	_, err = descBucket.CompleteMultipartUpload(imur, ups, payerOptions...)
 	if err != nil {
-		bucket.AbortMultipartUpload(imur)
+		bucket.AbortMultipartUpload(imur, payerOptions...)
 		return err
 	}
 	return nil
 }
 
-// ----- 并发有断点的下载  -----
+// ----- Concurrently copy with checkpoint  -----
 
 const copyCpMagic = "84F1F18C-FF1D-403B-A1D8-9DEB5F65910A"
 
 type copyCheckpoint struct {
-	Magic          string       // magic
-	MD5            string       // cp内容的MD5
-	SrcBucketName  string       // 源Bucket
-	SrcObjectKey   string       // 源Object
-	DestBucketName string       // 目标Bucket
-	DestObjectKey  string       // 目标Bucket
-	CopyID         string       // copy id
-	ObjStat        objectStat   // 文件状态
-	Parts          []copyPart   // 全部分片
-	CopyParts      []UploadPart // 分片上传成功后的返回值
-	PartStat       []bool       // 分片下载是否完成
+	Magic          string       // Magic
+	MD5            string       // CP content MD5
+	SrcBucketName  string       // Source bucket
+	SrcObjectKey   string       // Source object
+	DestBucketName string       // Target bucket
+	DestObjectKey  string       // Target object
+	CopyID         string       // Copy ID
+	ObjStat        objectStat   // Object stat
+	Parts          []copyPart   // Copy parts
+	CopyParts      []UploadPart // The uploaded parts
+	PartStat       []bool       // The part status
 }
 
-// CP数据是否有效，CP有效且Object没有更新时有效
-func (cp copyCheckpoint) isValid(bucket *Bucket, objectKey string) (bool, error) {
-	// 比较CP的Magic及MD5
+// isValid checks if the data is valid which means CP is valid and object is not updated.
+func (cp copyCheckpoint) isValid(meta http.Header) (bool, error) {
+	// Compare CP's magic number and the MD5.
 	cpb := cp
 	cpb.MD5 = ""
 	js, _ := json.Marshal(cpb)
@@ -242,18 +252,12 @@ func (cp copyCheckpoint) isValid(bucket *Bucket, objectKey string) (bool, error)
 		return false, nil
 	}
 
-	// 确认object没有更新
-	meta, err := bucket.GetObjectDetailedMeta(objectKey)
-	if err != nil {
-		return false, err
-	}
-
 	objectSize, err := strconv.ParseInt(meta.Get(HTTPHeaderContentLength), 10, 0)
 	if err != nil {
 		return false, err
 	}
 
-	// 比较Object的大小/最后修改时间/etag
+	// Compare the object size and last modified time and etag.
 	if cp.ObjStat.Size != objectSize ||
 		cp.ObjStat.LastModified != meta.Get(HTTPHeaderLastModified) ||
 		cp.ObjStat.Etag != meta.Get(HTTPHeaderEtag) {
@@ -263,7 +267,7 @@ func (cp copyCheckpoint) isValid(bucket *Bucket, objectKey string) (bool, error)
 	return true, nil
 }
 
-// 从文件中load
+// load loads from the checkpoint file
 func (cp *copyCheckpoint) load(filePath string) error {
 	contents, err := ioutil.ReadFile(filePath)
 	if err != nil {
@@ -274,17 +278,17 @@ func (cp *copyCheckpoint) load(filePath string) error {
 	return err
 }
 
-// 更新分片状态
+// update updates the parts status
 func (cp *copyCheckpoint) update(part UploadPart) {
 	cp.CopyParts[part.PartNumber-1] = part
 	cp.PartStat[part.PartNumber-1] = true
 }
 
-// dump到文件
+// dump dumps the CP to the file
 func (cp *copyCheckpoint) dump(filePath string) error {
 	bcp := *cp
 
-	// 计算MD5
+	// Calculate MD5
 	bcp.MD5 = ""
 	js, err := json.Marshal(bcp)
 	if err != nil {
@@ -294,17 +298,17 @@ func (cp *copyCheckpoint) dump(filePath string) error {
 	b64 := base64.StdEncoding.EncodeToString(sum[:])
 	bcp.MD5 = b64
 
-	// 序列化
+	// Serialization
 	js, err = json.Marshal(bcp)
 	if err != nil {
 		return err
 	}
 
-	// dump
+	// Dump
 	return ioutil.WriteFile(filePath, js, FilePermMode)
 }
 
-// 未完成的分片
+// todoParts returns unfinished parts
 func (cp copyCheckpoint) todoParts() []copyPart {
 	dps := []copyPart{}
 	for i, ps := range cp.PartStat {
@@ -315,7 +319,7 @@ func (cp copyCheckpoint) todoParts() []copyPart {
 	return dps
 }
 
-// 完成的字节数
+// getCompletedBytes returns finished bytes count
 func (cp copyCheckpoint) getCompletedBytes() int64 {
 	var completedBytes int64
 	for i, part := range cp.Parts {
@@ -326,22 +330,16 @@ func (cp copyCheckpoint) getCompletedBytes() int64 {
 	return completedBytes
 }
 
-// 初始化下载任务
-func (cp *copyCheckpoint) prepare(srcBucket *Bucket, srcObjectKey string, destBucket *Bucket, destObjectKey string,
+// prepare initializes the multipart upload
+func (cp *copyCheckpoint) prepare(meta http.Header, srcBucket *Bucket, srcObjectKey string, destBucket *Bucket, destObjectKey string,
 	partSize int64, options []Option) error {
-	// cp
+	// CP
 	cp.Magic = copyCpMagic
 	cp.SrcBucketName = srcBucket.BucketName
 	cp.SrcObjectKey = srcObjectKey
 	cp.DestBucketName = destBucket.BucketName
 	cp.DestObjectKey = destObjectKey
 
-	// object
-	meta, err := srcBucket.GetObjectDetailedMeta(srcObjectKey)
-	if err != nil {
-		return err
-	}
-
 	objectSize, err := strconv.ParseInt(meta.Get(HTTPHeaderContentLength), 10, 0)
 	if err != nil {
 		return err
@@ -351,18 +349,15 @@ func (cp *copyCheckpoint) prepare(srcBucket *Bucket, srcObjectKey string, destBu
 	cp.ObjStat.LastModified = meta.Get(HTTPHeaderLastModified)
 	cp.ObjStat.Etag = meta.Get(HTTPHeaderEtag)
 
-	// parts
-	cp.Parts, err = getCopyParts(srcBucket, srcObjectKey, partSize)
-	if err != nil {
-		return err
-	}
+	// Parts
+	cp.Parts = getCopyParts(objectSize, partSize)
 	cp.PartStat = make([]bool, len(cp.Parts))
 	for i := range cp.PartStat {
 		cp.PartStat[i] = false
 	}
 	cp.CopyParts = make([]UploadPart, len(cp.Parts))
 
-	// init copy
+	// Init copy
 	imur, err := destBucket.InitiateMultipartUpload(destObjectKey, options...)
 	if err != nil {
 		return err
@@ -372,10 +367,10 @@ func (cp *copyCheckpoint) prepare(srcBucket *Bucket, srcObjectKey string, destBu
 	return nil
 }
 
-func (cp *copyCheckpoint) complete(bucket *Bucket, parts []UploadPart, cpFilePath string) error {
+func (cp *copyCheckpoint) complete(bucket *Bucket, parts []UploadPart, cpFilePath string, options []Option) error {
 	imur := InitiateMultipartUploadResult{Bucket: cp.DestBucketName,
 		Key: cp.DestObjectKey, UploadID: cp.CopyID}
-	_, err := bucket.CompleteMultipartUpload(imur, parts)
+	_, err := bucket.CompleteMultipartUpload(imur, parts, options...)
 	if err != nil {
 		return err
 	}
@@ -383,30 +378,42 @@ func (cp *copyCheckpoint) complete(bucket *Bucket, parts []UploadPart, cpFilePat
 	return err
 }
 
-// 并发带断点的下载
+// copyFileWithCp is concurrently copy with checkpoint
 func (bucket Bucket) copyFileWithCp(srcBucketName, srcObjectKey, destBucketName, destObjectKey string,
 	partSize int64, options []Option, cpFilePath string, routines int) error {
 	descBucket, err := bucket.Client.Bucket(destBucketName)
 	srcBucket, err := bucket.Client.Bucket(srcBucketName)
 	listener := getProgressListener(options)
 
-	// LOAD CP数据
+	payerOptions := []Option{}
+	payer := getPayer(options)
+	if payer != "" {
+		payerOptions = append(payerOptions, RequestPayer(PayerType(payer)))
+	}
+
+	// Load CP data
 	ccp := copyCheckpoint{}
 	err = ccp.load(cpFilePath)
 	if err != nil {
 		os.Remove(cpFilePath)
 	}
 
-	// LOAD出错或数据无效重新初始化下载
-	valid, err := ccp.isValid(srcBucket, srcObjectKey)
+	// Make sure the object is not updated.
+	meta, err := srcBucket.GetObjectDetailedMeta(srcObjectKey, payerOptions...)
+	if err != nil {
+		return err
+	}
+
+	// Load error or the CP data is invalid---reinitialize
+	valid, err := ccp.isValid(meta)
 	if err != nil || !valid {
-		if err = ccp.prepare(srcBucket, srcObjectKey, descBucket, destObjectKey, partSize, options); err != nil {
+		if err = ccp.prepare(meta, srcBucket, srcObjectKey, descBucket, destObjectKey, partSize, options); err != nil {
 			return err
 		}
 		os.Remove(cpFilePath)
 	}
 
-	// 未完成的分片
+	// Unfinished parts
 	parts := ccp.todoParts()
 	imur := InitiateMultipartUploadResult{
 		Bucket:   destBucketName,
@@ -422,16 +429,16 @@ func (bucket Bucket) copyFileWithCp(srcBucketName, srcObjectKey, destBucketName,
 	event := newProgressEvent(TransferStartedEvent, completedBytes, ccp.ObjStat.Size)
 	publishProgress(listener, event)
 
-	// 启动工作协程
-	arg := copyWorkerArg{descBucket, imur, srcBucketName, srcObjectKey, options, copyPartHooker}
+	// Start the worker coroutines
+	arg := copyWorkerArg{descBucket, imur, srcBucketName, srcObjectKey, payerOptions, copyPartHooker}
 	for w := 1; w <= routines; w++ {
 		go copyWorker(w, arg, jobs, results, failed, die)
 	}
 
-	// 并发下载分片
+	// Start the scheduler
 	go copyScheduler(jobs, parts)
 
-	// 等待分片下载完成
+	// Wait for the parts completed.
 	completed := 0
 	for completed < len(parts) {
 		select {
@@ -457,5 +464,5 @@ func (bucket Bucket) copyFileWithCp(srcBucketName, srcObjectKey, destBucketName,
 	event = newProgressEvent(TransferCompletedEvent, completedBytes, ccp.ObjStat.Size)
 	publishProgress(listener, event)
 
-	return ccp.complete(descBucket, ccp.CopyParts, cpFilePath)
+	return ccp.complete(descBucket, ccp.CopyParts, cpFilePath, payerOptions)
 }
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/multipart.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/multipart.go
index d06c79160..b5a3a05b5 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/multipart.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/multipart.go
@@ -5,26 +5,28 @@ import (
 	"encoding/xml"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
 	"sort"
 	"strconv"
 )
 
+// InitiateMultipartUpload initializes multipart upload
 //
-// InitiateMultipartUpload 初始化分片上传任务。
+// objectKey    object name
+// options    the object constricts for upload. The valid options are CacheControl, ContentDisposition, ContentEncoding, Expires,
+//            ServerSideEncryption, Meta, check out the following link:
+//            https://help.aliyun.com/document_detail/oss/api-reference/multipart-upload/InitiateMultipartUpload.html
 //
-// objectKey  Object名称。
-// options    上传时可以指定Object的属性，可选属性有CacheControl、ContentDisposition、ContentEncoding、Expires、
-// ServerSideEncryption、Meta，具体含义请参考
-// https://help.aliyun.com/document_detail/oss/api-reference/multipart-upload/InitiateMultipartUpload.html
-//
-// InitiateMultipartUploadResult 初始化后操作成功的返回值，用于后面的UploadPartFromFile、UploadPartCopy等操作。error为nil时有效。
-// error  操作成功error为nil，非nil为错误信息。
+// InitiateMultipartUploadResult    the return value of the InitiateMultipartUpload, which is used for calls later on such as UploadPartFromFile,UploadPartCopy.
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) InitiateMultipartUpload(objectKey string, options ...Option) (InitiateMultipartUploadResult, error) {
 	var imur InitiateMultipartUploadResult
 	opts := addContentType(options, objectKey)
-	resp, err := bucket.do("POST", objectKey, "uploads", "uploads", opts, nil, nil)
+	params := map[string]interface{}{}
+	params["uploads"] = nil
+	resp, err := bucket.do("POST", objectKey, params, opts, nil, nil)
 	if err != nil {
 		return imur, err
 	}
@@ -34,23 +36,20 @@ func (bucket Bucket) InitiateMultipartUpload(objectKey string, options ...Option
 	return imur, err
 }
 
+// UploadPart uploads parts
 //
-// UploadPart 上传分片。
+// After initializing a Multipart Upload, the upload Id and object key could be used for uploading the parts.
+// Each part has its part number (ranges from 1 to 10,000). And for each upload Id, the part number identifies the position of the part in the whole file.
+// And thus with the same part number and upload Id, another part upload will overwrite the data.
+// Except the last one, minimal part size is 100KB. There's no limit on the last part size.
 //
-// 初始化一个Multipart Upload之后，可以根据指定的Object名和Upload ID来分片（Part）上传数据。
-// 每一个上传的Part都有一个标识它的号码（part number，范围是1~10000）。对于同一个Upload ID，
-// 该号码不但唯一标识这一片数据，也标识了这片数据在整个文件内的相对位置。如果您用同一个part号码，上传了新的数据，
-// 那么OSS上已有的这个号码的Part数据将被覆盖。除了最后一片Part以外，其他的part最小为100KB；
-// 最后一片Part没有大小限制。
+// imur    the returned value of InitiateMultipartUpload.
+// reader    io.Reader the reader for the part's data.
+// size    the part size.
+// partNumber    the part number (ranges from 1 to 10,000). Invalid part number will lead to InvalidArgument error.
 //
-// imur        InitiateMultipartUpload成功后的返回值。
-// reader      io.Reader 需要分片上传的reader。
-// size        本次上传片Part的大小。
-// partNumber  本次上传片(Part)的编号，范围是1~10000。如果超出范围，OSS将返回InvalidArgument错误。
-//
-// UploadPart 上传成功的返回值，两个成员PartNumber、ETag。PartNumber片编号，即传入参数partNumber；
-// ETag及上传数据的MD5。error为nil时有效。
-// error 操作成功error为nil，非nil为错误信息。
+// UploadPart    the return value of the upload part. It consists of PartNumber and ETag. It's valid when error is nil.
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) UploadPart(imur InitiateMultipartUploadResult, reader io.Reader,
 	partSize int64, partNumber int, options ...Option) (UploadPart, error) {
@@ -66,18 +65,16 @@ func (bucket Bucket) UploadPart(imur InitiateMultipartUploadResult, reader io.Re
 	return result.Part, err
 }
 
+// UploadPartFromFile uploads part from the file.
 //
-// UploadPartFromFile 上传分片。
+// imur    the return value of a successful InitiateMultipartUpload.
+// filePath    the local file path to upload.
+// startPosition    the start position in the local file.
+// partSize    the part size.
+// partNumber    the part number (from 1 to 10,000)
 //
-// imur           InitiateMultipartUpload成功后的返回值。
-// filePath       需要分片上传的本地文件。
-// startPosition  本次上传文件片的起始位置。
-// partSize       本次上传文件片的大小。
-// partNumber     本次上传文件片的编号，范围是1~10000。
-//
-// UploadPart 上传成功的返回值，两个成员PartNumber、ETag。PartNumber片编号，传入参数partNumber；
-// ETag上传数据的MD5。error为nil时有效。
-// error 操作成功error为nil，非nil为错误信息。
+// UploadPart    the return value consists of PartNumber and ETag.
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) UploadPartFromFile(imur InitiateMultipartUploadResult, filePath string,
 	startPosition, partSize int64, partNumber int, options ...Option) (UploadPart, error) {
@@ -101,19 +98,20 @@ func (bucket Bucket) UploadPartFromFile(imur InitiateMultipartUploadResult, file
 	return result.Part, err
 }
 
+// DoUploadPart does the actual part upload.
 //
-// DoUploadPart 上传分片。
+// request    part upload request
 //
-// request 上传分片请求。
-//
-// UploadPartResult 上传分片请求返回值。
-// error  操作无错误为nil，非nil为错误信息。
+// UploadPartResult    the result of uploading part.
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) DoUploadPart(request *UploadPartRequest, options []Option) (*UploadPartResult, error) {
 	listener := getProgressListener(options)
-	params := "partNumber=" + strconv.Itoa(request.PartNumber) + "&uploadId=" + request.InitResult.UploadID
-	opts := []Option{ContentLength(request.PartSize)}
-	resp, err := bucket.do("PUT", request.InitResult.Key, params, params, opts,
+	options = append(options, ContentLength(request.PartSize))
+	params := map[string]interface{}{}
+	params["partNumber"] = strconv.Itoa(request.PartNumber)
+	params["uploadId"] = request.InitResult.UploadID
+	resp, err := bucket.do("PUT", request.InitResult.Key, params, options,
 		&io.LimitedReader{R: request.Reader, N: request.PartSize}, listener)
 	if err != nil {
 		return &UploadPartResult{}, err
@@ -135,32 +133,32 @@ func (bucket Bucket) DoUploadPart(request *UploadPartRequest, options []Option)
 	return &UploadPartResult{part}, nil
 }
 
+// UploadPartCopy uploads part copy
 //
-// UploadPartCopy 拷贝分片。
+// imur    the return value of InitiateMultipartUpload
+// copySrc    source Object name
+// startPosition    the part's start index in the source file
+// partSize    the part size
+// partNumber    the part number, ranges from 1 to 10,000. If it exceeds the range OSS returns InvalidArgument error.
+// options    the constraints of source object for the copy. The copy happens only when these contraints are met. Otherwise it returns error.
+//            CopySourceIfNoneMatch, CopySourceIfModifiedSince  CopySourceIfUnmodifiedSince, check out the following link for the detail
+//            https://help.aliyun.com/document_detail/oss/api-reference/multipart-upload/UploadPartCopy.html
 //
-// imur           InitiateMultipartUpload成功后的返回值。
-// copySrc        源Object名称。
-// startPosition  本次拷贝片(Part)在源Object的起始位置。
-// partSize       本次拷贝片的大小。
-// partNumber     本次拷贝片的编号，范围是1~10000。如果超出范围，OSS将返回InvalidArgument错误。
-// options        copy时源Object的限制条件，满足限制条件时copy，不满足时返回错误。可选条件有CopySourceIfMatch、
-// CopySourceIfNoneMatch、CopySourceIfModifiedSince  CopySourceIfUnmodifiedSince，具体含义请参看
-// https://help.aliyun.com/document_detail/oss/api-reference/multipart-upload/UploadPartCopy.html
-//
-// UploadPart 上传成功的返回值，两个成员PartNumber、ETag。PartNumber片(Part)编号，即传入参数partNumber；
-// ETag及上传数据的MD5。error为nil时有效。
-// error 操作成功error为nil，非nil为错误信息。
+// UploadPart    the return value consists of PartNumber and ETag.
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) UploadPartCopy(imur InitiateMultipartUploadResult, srcBucketName, srcObjectKey string,
 	startPosition, partSize int64, partNumber int, options ...Option) (UploadPart, error) {
 	var out UploadPartCopyResult
 	var part UploadPart
 
-	opts := []Option{CopySource(srcBucketName, srcObjectKey),
+	opts := []Option{CopySource(srcBucketName, url.QueryEscape(srcObjectKey)),
 		CopySourceRange(startPosition, partSize)}
 	opts = append(opts, options...)
-	params := "partNumber=" + strconv.Itoa(partNumber) + "&uploadId=" + imur.UploadID
-	resp, err := bucket.do("PUT", imur.Key, params, params, opts, nil, nil)
+	params := map[string]interface{}{}
+	params["partNumber"] = strconv.Itoa(partNumber)
+	params["uploadId"] = imur.UploadID
+	resp, err := bucket.do("PUT", imur.Key, params, opts, nil, nil)
 	if err != nil {
 		return part, err
 	}
@@ -176,17 +174,16 @@ func (bucket Bucket) UploadPartCopy(imur InitiateMultipartUploadResult, srcBucke
 	return part, nil
 }
 
+// CompleteMultipartUpload completes the multipart upload.
 //
-// CompleteMultipartUpload 提交分片上传任务。
+// imur    the return value of InitiateMultipartUpload.
+// parts    the array of return value of UploadPart/UploadPartFromFile/UploadPartCopy.
 //
-// imur   InitiateMultipartUpload的返回值。
-// parts  UploadPart/UploadPartFromFile/UploadPartCopy返回值组成的数组。
-//
-// CompleteMultipartUploadResponse  操作成功后的返回值。error为nil时有效。
-// error  操作成功error为nil，非nil为错误信息。
+// CompleteMultipartUploadResponse    the return value when the call succeeds. Only valid when the error is nil.
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) CompleteMultipartUpload(imur InitiateMultipartUploadResult,
-	parts []UploadPart) (CompleteMultipartUploadResult, error) {
+	parts []UploadPart, options ...Option) (CompleteMultipartUploadResult, error) {
 	var out CompleteMultipartUploadResult
 
 	sort.Sort(uploadParts(parts))
@@ -199,8 +196,9 @@ func (bucket Bucket) CompleteMultipartUpload(imur InitiateMultipartUploadResult,
 	buffer := new(bytes.Buffer)
 	buffer.Write(bs)
 
-	params := "uploadId=" + imur.UploadID
-	resp, err := bucket.do("POST", imur.Key, params, params, nil, buffer, nil)
+	params := map[string]interface{}{}
+	params["uploadId"] = imur.UploadID
+	resp, err := bucket.do("POST", imur.Key, params, options, buffer, nil)
 	if err != nil {
 		return out, err
 	}
@@ -210,16 +208,16 @@ func (bucket Bucket) CompleteMultipartUpload(imur InitiateMultipartUploadResult,
 	return out, err
 }
 
+// AbortMultipartUpload aborts the multipart upload.
 //
-// AbortMultipartUpload 取消分片上传任务。
+// imur    the return value of InitiateMultipartUpload.
 //
-// imur  InitiateMultipartUpload的返回值。
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
-// error  操作成功error为nil，非nil为错误信息。
-//
-func (bucket Bucket) AbortMultipartUpload(imur InitiateMultipartUploadResult) error {
-	params := "uploadId=" + imur.UploadID
-	resp, err := bucket.do("DELETE", imur.Key, params, params, nil, nil, nil)
+func (bucket Bucket) AbortMultipartUpload(imur InitiateMultipartUploadResult, options ...Option) error {
+	params := map[string]interface{}{}
+	params["uploadId"] = imur.UploadID
+	resp, err := bucket.do("DELETE", imur.Key, params, options, nil, nil)
 	if err != nil {
 		return err
 	}
@@ -227,46 +225,57 @@ func (bucket Bucket) AbortMultipartUpload(imur InitiateMultipartUploadResult) er
 	return checkRespCode(resp.StatusCode, []int{http.StatusNoContent})
 }
 
+// ListUploadedParts lists the uploaded parts.
 //
-// ListUploadedParts 列出指定上传任务已经上传的分片。
+// imur    the return value of InitiateMultipartUpload.
 //
-// imur  InitiateMultipartUpload的返回值。
+// ListUploadedPartsResponse    the return value if it succeeds, only valid when error is nil.
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
-// ListUploadedPartsResponse  操作成功后的返回值，成员UploadedParts已经上传/拷贝的片。error为nil时该返回值有效。
-// error  操作成功error为nil，非nil为错误信息。
-//
-func (bucket Bucket) ListUploadedParts(imur InitiateMultipartUploadResult) (ListUploadedPartsResult, error) {
+func (bucket Bucket) ListUploadedParts(imur InitiateMultipartUploadResult, options ...Option) (ListUploadedPartsResult, error) {
 	var out ListUploadedPartsResult
-	params := "uploadId=" + imur.UploadID
-	resp, err := bucket.do("GET", imur.Key, params, params, nil, nil, nil)
+	options = append(options, EncodingType("url"))
+
+	params := map[string]interface{}{}
+	params, err := getRawParams(options)
+	if err != nil {
+		return out, err
+	}
+
+	params["uploadId"] = imur.UploadID
+	resp, err := bucket.do("GET", imur.Key, params, nil, nil, nil)
 	if err != nil {
 		return out, err
 	}
 	defer resp.Body.Close()
 
 	err = xmlUnmarshal(resp.Body, &out)
+	if err != nil {
+		return out, err
+	}
+	err = decodeListUploadedPartsResult(&out)
 	return out, err
 }
 
+// ListMultipartUploads lists all ongoing multipart upload tasks
 //
-// ListMultipartUploads 列出所有未上传完整的multipart任务列表。
+// options    listObject's filter. Prefix specifies the returned object's prefix; KeyMarker specifies the returned object's start point in lexicographic order;
+//            MaxKeys specifies the max entries to return; Delimiter is the character for grouping object keys.
 //
-// options  ListObject的筛选行为。Prefix返回object的前缀，KeyMarker返回object的起始位置，MaxUploads最大数目默认1000，
-// Delimiter用于对Object名字进行分组的字符，所有名字包含指定的前缀且第一次出现delimiter字符之间的object。
-//
-// ListMultipartUploadResponse  操作成功后的返回值，error为nil时该返回值有效。
-// error  操作成功error为nil，非nil为错误信息。
+// ListMultipartUploadResponse    the return value if it succeeds, only valid when error is nil.
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) ListMultipartUploads(options ...Option) (ListMultipartUploadResult, error) {
 	var out ListMultipartUploadResult
 
 	options = append(options, EncodingType("url"))
-	params, err := handleParams(options)
+	params, err := getRawParams(options)
 	if err != nil {
 		return out, err
 	}
+	params["uploads"] = nil
 
-	resp, err := bucket.do("GET", "", "uploads&"+params, "uploads", nil, nil, nil)
+	resp, err := bucket.do("GET", "", params, options, nil, nil)
 	if err != nil {
 		return out, err
 	}
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/option.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/option.go
index 8ad932a87..5952f8ae3 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/option.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/option.go
@@ -1,21 +1,19 @@
 package oss
 
 import (
-	"bytes"
 	"fmt"
 	"net/http"
-	"net/url"
-	"sort"
 	"strconv"
+	"strings"
 	"time"
 )
 
 type optionType string
 
 const (
-	optionParam optionType = "HTTPParameter" // URL参数
-	optionHTTP  optionType = "HTTPHeader"    // HTTP头
-	optionArg   optionType = "FuncArgument"  // 函数参数
+	optionParam optionType = "HTTPParameter" // URL parameter
+	optionHTTP  optionType = "HTTPHeader"    // HTTP header
+	optionArg   optionType = "FuncArgument"  // Function argument
 )
 
 const (
@@ -24,6 +22,7 @@ const (
 	checkpointConfig   = "x-cp-config"
 	initCRC64          = "init-crc64"
 	progressListener   = "x-progress-listener"
+	storageClass       = "storage-class"
 )
 
 type (
@@ -32,7 +31,7 @@ type (
 		Type  optionType
 	}
 
-	// Option http option
+	// Option HTTP option
 	Option func(map[string]optionValue) error
 )
 
@@ -66,6 +65,11 @@ func ContentEncoding(value string) Option {
 	return setHeader(HTTPHeaderContentEncoding, value)
 }
 
+// ContentLanguage is an option to set Content-Language header
+func ContentLanguage(value string) Option {
+	return setHeader(HTTPHeaderContentLanguage, value)
+}
+
 // ContentMD5 is an option to set Content-MD5 header
 func ContentMD5(value string) Option {
 	return setHeader(HTTPHeaderContentMD5, value)
@@ -86,6 +90,11 @@ func Range(start, end int64) Option {
 	return setHeader(HTTPHeaderRange, fmt.Sprintf("bytes=%d-%d", start, end))
 }
 
+// NormalizedRange is an option to set Range header, such as 1024-2048 or 1024- or -2048
+func NormalizedRange(nr string) Option {
+	return setHeader(HTTPHeaderRange, fmt.Sprintf("bytes=%s", strings.TrimSpace(nr)))
+}
+
 // AcceptEncoding is an option to set Accept-Encoding header
 func AcceptEncoding(value string) Option {
 	return setHeader(HTTPHeaderAcceptEncoding, value)
@@ -153,16 +162,46 @@ func ServerSideEncryption(value string) Option {
 	return setHeader(HTTPHeaderOssServerSideEncryption, value)
 }
 
+// ServerSideEncryptionKeyID is an option to set X-Oss-Server-Side-Encryption-Key-Id header
+func ServerSideEncryptionKeyID(value string) Option {
+	return setHeader(HTTPHeaderOssServerSideEncryptionKeyID, value)
+}
+
 // ObjectACL is an option to set X-Oss-Object-Acl header
 func ObjectACL(acl ACLType) Option {
 	return setHeader(HTTPHeaderOssObjectACL, string(acl))
 }
 
+// symlinkTarget is an option to set X-Oss-Symlink-Target
+func symlinkTarget(targetObjectKey string) Option {
+	return setHeader(HTTPHeaderOssSymlinkTarget, targetObjectKey)
+}
+
 // Origin is an option to set Origin header
 func Origin(value string) Option {
 	return setHeader(HTTPHeaderOrigin, value)
 }
 
+// ObjectStorageClass is an option to set the storage class of object
+func ObjectStorageClass(storageClass StorageClassType) Option {
+	return setHeader(HTTPHeaderOssStorageClass, string(storageClass))
+}
+
+// Callback is an option to set callback values
+func Callback(callback string) Option {
+	return setHeader(HTTPHeaderOssCallback, callback)
+}
+
+// CallbackVar is an option to set callback user defined values
+func CallbackVar(callbackVar string) Option {
+	return setHeader(HTTPHeaderOssCallbackVar, callbackVar)
+}
+
+// RequestPayer is an option to set payer who pay for the request
+func RequestPayer(payerType PayerType) Option {
+	return setHeader(HTTPHeaderOSSRequester, string(payerType))
+}
+
 // Delimiter is an option to set delimiler parameter
 func Delimiter(value string) Option {
 	return addParam("delimiter", value)
@@ -203,28 +242,49 @@ func UploadIDMarker(value string) Option {
 	return addParam("upload-id-marker", value)
 }
 
-// DeleteObjectsQuiet DeleteObjects详细(verbose)模式或简单(quiet)模式，默认详细模式。
+// MaxParts is an option to set max-parts parameter
+func MaxParts(value int) Option {
+	return addParam("max-parts", strconv.Itoa(value))
+}
+
+// PartNumberMarker is an option to set part-number-marker parameter
+func PartNumberMarker(value int) Option {
+	return addParam("part-number-marker", strconv.Itoa(value))
+}
+
+// DeleteObjectsQuiet false:DeleteObjects in verbose mode; true:DeleteObjects in quite mode. Default is false.
 func DeleteObjectsQuiet(isQuiet bool) Option {
 	return addArg(deleteObjectsQuiet, isQuiet)
 }
 
-// 断点续传配置，包括是否启用、cp文件
+// StorageClass bucket storage class
+func StorageClass(value StorageClassType) Option {
+	return addArg(storageClass, value)
+}
+
+// Checkpoint configuration
 type cpConfig struct {
 	IsEnable bool
 	FilePath string
+	DirPath  string
 }
 
-// Checkpoint DownloadFile/UploadFile是否开启checkpoint及checkpoint文件路径
+// Checkpoint sets the isEnable flag and checkpoint file path for DownloadFile/UploadFile.
 func Checkpoint(isEnable bool, filePath string) Option {
-	return addArg(checkpointConfig, &cpConfig{isEnable, filePath})
+	return addArg(checkpointConfig, &cpConfig{IsEnable: isEnable, FilePath: filePath})
 }
 
-// Routines DownloadFile/UploadFile并发数
+// CheckpointDir sets the isEnable flag and checkpoint dir path for DownloadFile/UploadFile.
+func CheckpointDir(isEnable bool, dirPath string) Option {
+	return addArg(checkpointConfig, &cpConfig{IsEnable: isEnable, DirPath: dirPath})
+}
+
+// Routines DownloadFile/UploadFile routine count
 func Routines(n int) Option {
 	return addArg(routineNum, n)
 }
 
-// InitCRC AppendObject CRC的校验的初始值
+// InitCRC Init AppendObject CRC
 func InitCRC(initCRC uint64) Option {
 	return addArg(initCRC64, initCRC)
 }
@@ -234,6 +294,41 @@ func Progress(listener ProgressListener) Option {
 	return addArg(progressListener, listener)
 }
 
+// ResponseContentType is an option to set response-content-type param
+func ResponseContentType(value string) Option {
+	return addParam("response-content-type", value)
+}
+
+// ResponseContentLanguage is an option to set response-content-language param
+func ResponseContentLanguage(value string) Option {
+	return addParam("response-content-language", value)
+}
+
+// ResponseExpires is an option to set response-expires param
+func ResponseExpires(value string) Option {
+	return addParam("response-expires", value)
+}
+
+// ResponseCacheControl is an option to set response-cache-control param
+func ResponseCacheControl(value string) Option {
+	return addParam("response-cache-control", value)
+}
+
+// ResponseContentDisposition is an option to set response-content-disposition param
+func ResponseContentDisposition(value string) Option {
+	return addParam("response-content-disposition", value)
+}
+
+// ResponseContentEncoding is an option to set response-content-encoding param
+func ResponseContentEncoding(value string) Option {
+	return addParam("response-content-encoding", value)
+}
+
+// Process is an option to set x-oss-process param
+func Process(value string) Option {
+	return addParam("x-oss-process", value)
+}
+
 func setHeader(key string, value interface{}) Option {
 	return func(params map[string]optionValue) error {
 		if value == nil {
@@ -282,40 +377,27 @@ func handleOptions(headers map[string]string, options []Option) error {
 	return nil
 }
 
-func handleParams(options []Option) (string, error) {
-	// option
+func getRawParams(options []Option) (map[string]interface{}, error) {
+	// Option
 	params := map[string]optionValue{}
 	for _, option := range options {
 		if option != nil {
 			if err := option(params); err != nil {
-				return "", err
+				return nil, err
 			}
 		}
 	}
 
-	// sort
-	var buf bytes.Buffer
-	keys := make([]string, 0, len(params))
+	paramsm := map[string]interface{}{}
+	// Serialize
 	for k, v := range params {
 		if v.Type == optionParam {
-			keys = append(keys, k)
+			vs := params[k]
+			paramsm[k] = vs.Value.(string)
 		}
 	}
-	sort.Strings(keys)
 
-	// serialize
-	for _, k := range keys {
-		vs := params[k]
-		prefix := url.QueryEscape(k) + "="
-
-		if buf.Len() > 0 {
-			buf.WriteByte('&')
-		}
-		buf.WriteString(prefix)
-		buf.WriteString(url.QueryEscape(vs.Value.(string)))
-	}
-
-	return buf.String(), nil
+	return paramsm, nil
 }
 
 func findOption(options []Option, param string, defaultVal interface{}) (interface{}, error) {
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/progress.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/progress.go
index 0ea897f03..b38d803fe 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/progress.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/progress.go
@@ -2,7 +2,7 @@ package oss
 
 import "io"
 
-// ProgressEventType transfer progress event type
+// ProgressEventType defines transfer progress event type
 type ProgressEventType int
 
 const (
@@ -16,19 +16,19 @@ const (
 	TransferFailedEvent
 )
 
-// ProgressEvent progress event
+// ProgressEvent defines progress event
 type ProgressEvent struct {
 	ConsumedBytes int64
 	TotalBytes    int64
 	EventType     ProgressEventType
 }
 
-// ProgressListener listen progress change
+// ProgressListener listens progress change
 type ProgressListener interface {
 	ProgressChanged(event *ProgressEvent)
 }
 
-// -------------------- private --------------------
+// -------------------- Private --------------------
 
 func newProgressEvent(eventType ProgressEventType, consumed, total int64) *ProgressEvent {
 	return &ProgressEvent{
@@ -62,7 +62,7 @@ type teeReader struct {
 // corresponding writes to w.  There is no internal buffering -
 // the write must complete before the read completes.
 // Any error encountered while writing is reported as a read error.
-func TeeReader(reader io.Reader, writer io.Writer, totalBytes int64, listener ProgressListener, tracker *readerTracker) io.Reader {
+func TeeReader(reader io.Reader, writer io.Writer, totalBytes int64, listener ProgressListener, tracker *readerTracker) io.ReadCloser {
 	return &teeReader{
 		reader:        reader,
 		writer:        writer,
@@ -76,7 +76,7 @@ func TeeReader(reader io.Reader, writer io.Writer, totalBytes int64, listener Pr
 func (t *teeReader) Read(p []byte) (n int, err error) {
 	n, err = t.reader.Read(p)
 
-	// read encountered error
+	// Read encountered error
 	if err != nil && err != io.EOF {
 		event := newProgressEvent(TransferFailedEvent, t.consumedBytes, t.totalBytes)
 		publishProgress(t.listener, event)
@@ -84,18 +84,18 @@ func (t *teeReader) Read(p []byte) (n int, err error) {
 
 	if n > 0 {
 		t.consumedBytes += int64(n)
-		// crc
+		// CRC
 		if t.writer != nil {
 			if n, err := t.writer.Write(p[:n]); err != nil {
 				return n, err
 			}
 		}
-		// progress
+		// Progress
 		if t.listener != nil {
 			event := newProgressEvent(TransferDataEvent, t.consumedBytes, t.totalBytes)
 			publishProgress(t.listener, event)
 		}
-		// track
+		// Track
 		if t.tracker != nil {
 			t.tracker.completedBytes = t.consumedBytes
 		}
@@ -103,3 +103,10 @@ func (t *teeReader) Read(p []byte) (n int, err error) {
 
 	return
 }
+
+func (t *teeReader) Close() error {
+	if rc, ok := t.reader.(io.ReadCloser); ok {
+		return rc.Close()
+	}
+	return nil
+}
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/transport_1_6.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/transport_1_6.go
new file mode 100644
index 000000000..e6de4cdd2
--- /dev/null
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/transport_1_6.go
@@ -0,0 +1,26 @@
+// +build !go1.7
+
+package oss
+
+import (
+	"net"
+	"net/http"
+)
+
+func newTransport(conn *Conn, config *Config) *http.Transport {
+	httpTimeOut := conn.config.HTTPTimeout
+	httpMaxConns := conn.config.HTTPMaxConns
+	// New Transport
+	transport := &http.Transport{
+		Dial: func(netw, addr string) (net.Conn, error) {
+			conn, err := net.DialTimeout(netw, addr, httpTimeOut.ConnectTimeout)
+			if err != nil {
+				return nil, err
+			}
+			return newTimeoutConn(conn, httpTimeOut.ReadWriteTimeout, httpTimeOut.LongTimeout), nil
+		},
+		MaxIdleConnsPerHost:   httpMaxConns.MaxIdleConnsPerHost,
+		ResponseHeaderTimeout: httpTimeOut.HeaderTimeout,
+	}
+	return transport
+}
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/transport_1_7.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/transport_1_7.go
new file mode 100644
index 000000000..006ea47a0
--- /dev/null
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/transport_1_7.go
@@ -0,0 +1,28 @@
+// +build go1.7
+
+package oss
+
+import (
+	"net"
+	"net/http"
+)
+
+func newTransport(conn *Conn, config *Config) *http.Transport {
+	httpTimeOut := conn.config.HTTPTimeout
+	httpMaxConns := conn.config.HTTPMaxConns
+	// New Transport
+	transport := &http.Transport{
+		Dial: func(netw, addr string) (net.Conn, error) {
+			conn, err := net.DialTimeout(netw, addr, httpTimeOut.ConnectTimeout)
+			if err != nil {
+				return nil, err
+			}
+			return newTimeoutConn(conn, httpTimeOut.ReadWriteTimeout, httpTimeOut.LongTimeout), nil
+		},
+		MaxIdleConns:          httpMaxConns.MaxIdleConns,
+		MaxIdleConnsPerHost:   httpMaxConns.MaxIdleConnsPerHost,
+		IdleConnTimeout:       httpTimeOut.IdleConnTimeout,
+		ResponseHeaderTimeout: httpTimeOut.HeaderTimeout,
+	}
+	return transport
+}
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/type.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/type.go
index b60564538..794f28231 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/type.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/type.go
@@ -6,53 +6,54 @@ import (
 	"time"
 )
 
-// ListBucketsResult ListBuckets请求返回的结果
+// ListBucketsResult defines the result object from ListBuckets request
 type ListBucketsResult struct {
 	XMLName     xml.Name           `xml:"ListAllMyBucketsResult"`
-	Prefix      string             `xml:"Prefix"`         // 本次查询结果的前缀
-	Marker      string             `xml:"Marker"`         // 标明查询的起点，未全部返回时有此节点
-	MaxKeys     int                `xml:"MaxKeys"`        // 返回结果的最大数目，未全部返回时有此节点
-	IsTruncated bool               `xml:"IsTruncated"`    // 所有的结果是否已经全部返回
-	NextMarker  string             `xml:"NextMarker"`     // 表示下一次查询的起点
-	Owner       Owner              `xml:"Owner"`          // 拥有者信息
-	Buckets     []BucketProperties `xml:"Buckets>Bucket"` // Bucket列表
+	Prefix      string             `xml:"Prefix"`         // The prefix in this query
+	Marker      string             `xml:"Marker"`         // The marker filter
+	MaxKeys     int                `xml:"MaxKeys"`        // The max entry count to return. This information is returned when IsTruncated is true.
+	IsTruncated bool               `xml:"IsTruncated"`    // Flag true means there's remaining buckets to return.
+	NextMarker  string             `xml:"NextMarker"`     // The marker filter for the next list call
+	Owner       Owner              `xml:"Owner"`          // The owner information
+	Buckets     []BucketProperties `xml:"Buckets>Bucket"` // The bucket list
 }
 
-// BucketProperties Bucket信息
+// BucketProperties defines bucket properties
 type BucketProperties struct {
 	XMLName      xml.Name  `xml:"Bucket"`
-	Name         string    `xml:"Name"`         // Bucket名称
-	Location     string    `xml:"Location"`     // Bucket所在的数据中心
-	CreationDate time.Time `xml:"CreationDate"` // Bucket创建时间
+	Name         string    `xml:"Name"`         // Bucket name
+	Location     string    `xml:"Location"`     // Bucket datacenter
+	CreationDate time.Time `xml:"CreationDate"` // Bucket create time
+	StorageClass string    `xml:"StorageClass"` // Bucket storage class
 }
 
-// GetBucketACLResult GetBucketACL请求返回的结果
+// GetBucketACLResult defines GetBucketACL request's result
 type GetBucketACLResult struct {
 	XMLName xml.Name `xml:"AccessControlPolicy"`
-	ACL     string   `xml:"AccessControlList>Grant"` // Bucket权限
-	Owner   Owner    `xml:"Owner"`                   // Bucket拥有者信息
+	ACL     string   `xml:"AccessControlList>Grant"` // Bucket ACL
+	Owner   Owner    `xml:"Owner"`                   // Bucket owner
 }
 
-// LifecycleConfiguration Bucket的Lifecycle配置
+// LifecycleConfiguration is the Bucket Lifecycle configuration
 type LifecycleConfiguration struct {
 	XMLName xml.Name        `xml:"LifecycleConfiguration"`
 	Rules   []LifecycleRule `xml:"Rule"`
 }
 
-// LifecycleRule Lifecycle规则
+// LifecycleRule defines Lifecycle rules
 type LifecycleRule struct {
 	XMLName    xml.Name            `xml:"Rule"`
-	ID         string              `xml:"ID"`         // 规则唯一的ID
-	Prefix     string              `xml:"Prefix"`     // 规则所适用Object的前缀
-	Status     string              `xml:"Status"`     // 规则是否生效
-	Expiration LifecycleExpiration `xml:"Expiration"` // 规则的过期属性
+	ID         string              `xml:"ID"`         // The rule ID
+	Prefix     string              `xml:"Prefix"`     // The object key prefix
+	Status     string              `xml:"Status"`     // The rule status (enabled or not)
+	Expiration LifecycleExpiration `xml:"Expiration"` // The expiration property
 }
 
-// LifecycleExpiration 规则的过期属性
+// LifecycleExpiration defines the rule's expiration property
 type LifecycleExpiration struct {
 	XMLName xml.Name  `xml:"Expiration"`
-	Days    int       `xml:"Days,omitempty"` // 最后修改时间过后多少天生效
-	Date    time.Time `xml:"Date,omitempty"` // 指定规则何时生效
+	Days    int       `xml:"Days,omitempty"` // Relative expiration time: The expiration time in days after the last modified time
+	Date    time.Time `xml:"Date,omitempty"` // Absolute expiration time: The expiration time in date.
 }
 
 type lifecycleXML struct {
@@ -93,7 +94,7 @@ func convLifecycleRule(rules []LifecycleRule) []lifecycleRule {
 	return rs
 }
 
-// BuildLifecycleRuleByDays 指定过期天数构建Lifecycle规则
+// BuildLifecycleRuleByDays builds a lifecycle rule with specified expiration days
 func BuildLifecycleRuleByDays(id, prefix string, status bool, days int) LifecycleRule {
 	var statusStr = "Enabled"
 	if !status {
@@ -103,7 +104,7 @@ func BuildLifecycleRuleByDays(id, prefix string, status bool, days int) Lifecycl
 		Expiration: LifecycleExpiration{Days: days}}
 }
 
-// BuildLifecycleRuleByDate 指定过期时间构建Lifecycle规则
+// BuildLifecycleRuleByDate builds a lifecycle rule with specified expiration time.
 func BuildLifecycleRuleByDate(id, prefix string, status bool, year, month, day int) LifecycleRule {
 	var statusStr = "Enabled"
 	if !status {
@@ -114,171 +115,172 @@ func BuildLifecycleRuleByDate(id, prefix string, status bool, year, month, day i
 		Expiration: LifecycleExpiration{Date: date}}
 }
 
-// GetBucketLifecycleResult GetBucketLifecycle请求请求结果
+// GetBucketLifecycleResult defines GetBucketLifecycle's result object
 type GetBucketLifecycleResult LifecycleConfiguration
 
-// RefererXML Referer配置
+// RefererXML defines Referer configuration
 type RefererXML struct {
 	XMLName           xml.Name `xml:"RefererConfiguration"`
-	AllowEmptyReferer bool     `xml:"AllowEmptyReferer"`   // 是否允许referer字段为空的请求访问
-	RefererList       []string `xml:"RefererList>Referer"` // referer访问白名单
+	AllowEmptyReferer bool     `xml:"AllowEmptyReferer"`   // Allow empty referrer
+	RefererList       []string `xml:"RefererList>Referer"` // Referer whitelist
 }
 
-// GetBucketRefererResult GetBucketReferer请教返回结果
+// GetBucketRefererResult defines result object for GetBucketReferer request
 type GetBucketRefererResult RefererXML
 
-// LoggingXML Logging配置
+// LoggingXML defines logging configuration
 type LoggingXML struct {
 	XMLName        xml.Name       `xml:"BucketLoggingStatus"`
-	LoggingEnabled LoggingEnabled `xml:"LoggingEnabled"` // 访问日志信息容器
+	LoggingEnabled LoggingEnabled `xml:"LoggingEnabled"` // The logging configuration information
 }
 
 type loggingXMLEmpty struct {
 	XMLName xml.Name `xml:"BucketLoggingStatus"`
 }
 
-// LoggingEnabled 访问日志信息容器
+// LoggingEnabled defines the logging configuration information
 type LoggingEnabled struct {
 	XMLName      xml.Name `xml:"LoggingEnabled"`
-	TargetBucket string   `xml:"TargetBucket"` //存放访问日志的Bucket
-	TargetPrefix string   `xml:"TargetPrefix"` //保存访问日志的文件前缀
+	TargetBucket string   `xml:"TargetBucket"` // The bucket name for storing the log files
+	TargetPrefix string   `xml:"TargetPrefix"` // The log file prefix
 }
 
-// GetBucketLoggingResult GetBucketLogging请求返回结果
+// GetBucketLoggingResult defines the result from GetBucketLogging request
 type GetBucketLoggingResult LoggingXML
 
-// WebsiteXML Website配置
+// WebsiteXML defines Website configuration
 type WebsiteXML struct {
 	XMLName       xml.Name      `xml:"WebsiteConfiguration"`
-	IndexDocument IndexDocument `xml:"IndexDocument"` // 目录URL时添加的索引文件
-	ErrorDocument ErrorDocument `xml:"ErrorDocument"` // 404错误时使用的文件
+	IndexDocument IndexDocument `xml:"IndexDocument"` // The index page
+	ErrorDocument ErrorDocument `xml:"ErrorDocument"` // The error page
 }
 
-// IndexDocument 目录URL时添加的索引文件
+// IndexDocument defines the index page info
 type IndexDocument struct {
 	XMLName xml.Name `xml:"IndexDocument"`
-	Suffix  string   `xml:"Suffix"` // 目录URL时添加的索引文件名
+	Suffix  string   `xml:"Suffix"` // The file name for the index page
 }
 
-// ErrorDocument 404错误时使用的文件
+// ErrorDocument defines the 404 error page info
 type ErrorDocument struct {
 	XMLName xml.Name `xml:"ErrorDocument"`
-	Key     string   `xml:"Key"` // 404错误时使用的文件名
+	Key     string   `xml:"Key"` // 404 error file name
 }
 
-// GetBucketWebsiteResult GetBucketWebsite请求返回结果
+// GetBucketWebsiteResult defines the result from GetBucketWebsite request.
 type GetBucketWebsiteResult WebsiteXML
 
-// CORSXML CORS配置
+// CORSXML defines CORS configuration
 type CORSXML struct {
 	XMLName   xml.Name   `xml:"CORSConfiguration"`
-	CORSRules []CORSRule `xml:"CORSRule"` // CORS规则列表
+	CORSRules []CORSRule `xml:"CORSRule"` // CORS rules
 }
 
-// CORSRule CORS规则
+// CORSRule defines CORS rules
 type CORSRule struct {
 	XMLName       xml.Name `xml:"CORSRule"`
-	AllowedOrigin []string `xml:"AllowedOrigin"` // 允许的来源，默认通配符"*"
-	AllowedMethod []string `xml:"AllowedMethod"` // 允许的方法
-	AllowedHeader []string `xml:"AllowedHeader"` // 允许的请求头
-	ExposeHeader  []string `xml:"ExposeHeader"`  // 允许的响应头
-	MaxAgeSeconds int      `xml:"MaxAgeSeconds"` // 最大的缓存时间
+	AllowedOrigin []string `xml:"AllowedOrigin"` // Allowed origins. By default it's wildcard '*'
+	AllowedMethod []string `xml:"AllowedMethod"` // Allowed methods
+	AllowedHeader []string `xml:"AllowedHeader"` // Allowed headers
+	ExposeHeader  []string `xml:"ExposeHeader"`  // Allowed response headers
+	MaxAgeSeconds int      `xml:"MaxAgeSeconds"` // Max cache ages in seconds
 }
 
-// GetBucketCORSResult GetBucketCORS请求返回的结果
+// GetBucketCORSResult defines the result from GetBucketCORS request.
 type GetBucketCORSResult CORSXML
 
-// GetBucketInfoResult GetBucketInfo请求返回结果
+// GetBucketInfoResult defines the result from GetBucketInfo request.
 type GetBucketInfoResult struct {
-	XMLName        xml.Name `xml:"BucketInfo"`
-	BucketInfo     BucketInfo   `xml:"Bucket"`
+	XMLName    xml.Name   `xml:"BucketInfo"`
+	BucketInfo BucketInfo `xml:"Bucket"`
 }
 
-// BucketInfo Bucket信息
+// BucketInfo defines Bucket information
 type BucketInfo struct {
 	XMLName          xml.Name  `xml:"Bucket"`
-	Name             string    `xml:"Name"`                    // Bucket名称
-	Location         string    `xml:"Location"`                // Bucket所在的数据中心
-	CreationDate     time.Time `xml:"CreationDate"`            // Bucket创建时间
-	ExtranetEndpoint string    `xml:"ExtranetEndpoint"`        // Bucket访问的外网域名 
-	IntranetEndpoint string    `xml:"IntranetEndpoint"`        // Bucket访问的内网域名
-	ACL              string    `xml:"AccessControlList>Grant"` // Bucket权限
-	Owner            Owner     `xml:"Owner"`                   // Bucket拥有者信息
+	Name             string    `xml:"Name"`                    // Bucket name
+	Location         string    `xml:"Location"`                // Bucket datacenter
+	CreationDate     time.Time `xml:"CreationDate"`            // Bucket creation time
+	ExtranetEndpoint string    `xml:"ExtranetEndpoint"`        // Bucket external endpoint
+	IntranetEndpoint string    `xml:"IntranetEndpoint"`        // Bucket internal endpoint
+	ACL              string    `xml:"AccessControlList>Grant"` // Bucket ACL
+	Owner            Owner     `xml:"Owner"`                   // Bucket owner
+	StorageClass     string    `xml:"StorageClass"`            // Bucket storage class
 }
 
-// ListObjectsResult ListObjects请求返回结果
+// ListObjectsResult defines the result from ListObjects request
 type ListObjectsResult struct {
 	XMLName        xml.Name           `xml:"ListBucketResult"`
-	Prefix         string             `xml:"Prefix"`                // 本次查询结果的开始前缀
-	Marker         string             `xml:"Marker"`                // 这次查询的起点
-	MaxKeys        int                `xml:"MaxKeys"`               // 请求返回结果的最大数目
-	Delimiter      string             `xml:"Delimiter"`             // 对Object名字进行分组的字符
-	IsTruncated    bool               `xml:"IsTruncated"`           // 是否所有的结果都已经返回
-	NextMarker     string             `xml:"NextMarker"`            // 下一次查询的起点
-	Objects        []ObjectProperties `xml:"Contents"`              // Object类别
-	CommonPrefixes []string           `xml:"CommonPrefixes>Prefix"` // 以delimiter结尾并有共同前缀的Object的集合
+	Prefix         string             `xml:"Prefix"`                // The object prefix
+	Marker         string             `xml:"Marker"`                // The marker filter.
+	MaxKeys        int                `xml:"MaxKeys"`               // Max keys to return
+	Delimiter      string             `xml:"Delimiter"`             // The delimiter for grouping objects' name
+	IsTruncated    bool               `xml:"IsTruncated"`           // Flag indicates if all results are returned (when it's false)
+	NextMarker     string             `xml:"NextMarker"`            // The start point of the next query
+	Objects        []ObjectProperties `xml:"Contents"`              // Object list
+	CommonPrefixes []string           `xml:"CommonPrefixes>Prefix"` // You can think of commonprefixes as "folders" whose names end with the delimiter
 }
 
-// ObjectProperties Objecct属性
+// ObjectProperties defines Objecct properties
 type ObjectProperties struct {
 	XMLName      xml.Name  `xml:"Contents"`
-	Key          string    `xml:"Key"`          // Object的Key
-	Type         string    `xml:"Type"`         // Object Type
-	Size         int64     `xml:"Size"`         // Object的长度字节数
-	ETag         string    `xml:"ETag"`         // 标示Object的内容
-	Owner        Owner     `xml:"Owner"`        // 保存Object拥有者信息的容器
-	LastModified time.Time `xml:"LastModified"` // Object最后修改时间
-	StorageClass string    `xml:"StorageClass"` // Object的存储类型，目前只能是Standard
+	Key          string    `xml:"Key"`          // Object key
+	Type         string    `xml:"Type"`         // Object type
+	Size         int64     `xml:"Size"`         // Object size
+	ETag         string    `xml:"ETag"`         // Object ETag
+	Owner        Owner     `xml:"Owner"`        // Object owner information
+	LastModified time.Time `xml:"LastModified"` // Object last modified time
+	StorageClass string    `xml:"StorageClass"` // Object storage class (Standard, IA, Archive)
 }
 
-// Owner Bucket/Object的owner
+// Owner defines Bucket/Object's owner
 type Owner struct {
 	XMLName     xml.Name `xml:"Owner"`
-	ID          string   `xml:"ID"`          // 用户ID
-	DisplayName string   `xml:"DisplayName"` // Owner名字
+	ID          string   `xml:"ID"`          // Owner ID
+	DisplayName string   `xml:"DisplayName"` // Owner's display name
 }
 
-// CopyObjectResult CopyObject请求返回的结果
+// CopyObjectResult defines result object of CopyObject
 type CopyObjectResult struct {
 	XMLName      xml.Name  `xml:"CopyObjectResult"`
-	LastModified time.Time `xml:"LastModified"` // 新Object最后更新时间
-	ETag         string    `xml:"ETag"`         // 新Object的ETag值
+	LastModified time.Time `xml:"LastModified"` // New object's last modified time.
+	ETag         string    `xml:"ETag"`         // New object's ETag
 }
 
-// GetObjectACLResult GetObjectACL请求返回的结果
+// GetObjectACLResult defines result of GetObjectACL request
 type GetObjectACLResult GetBucketACLResult
 
 type deleteXML struct {
 	XMLName xml.Name       `xml:"Delete"`
-	Objects []DeleteObject `xml:"Object"` // 删除的所有Object
-	Quiet   bool           `xml:"Quiet"`  // 安静响应模式
+	Objects []DeleteObject `xml:"Object"` // Objects to delete
+	Quiet   bool           `xml:"Quiet"`  // Flag of quiet mode.
 }
 
-// DeleteObject 删除的Object
+// DeleteObject defines the struct for deleting object
 type DeleteObject struct {
 	XMLName xml.Name `xml:"Object"`
-	Key     string   `xml:"Key"` // Object名称
+	Key     string   `xml:"Key"` // Object name
 }
 
-// DeleteObjectsResult DeleteObjects请求返回结果
+// DeleteObjectsResult defines result of DeleteObjects request
 type DeleteObjectsResult struct {
 	XMLName        xml.Name `xml:"DeleteResult"`
-	DeletedObjects []string `xml:"Deleted>Key"` // 删除的Object列表
+	DeletedObjects []string `xml:"Deleted>Key"` // Deleted object list
 }
 
-// InitiateMultipartUploadResult InitiateMultipartUpload请求返回结果
+// InitiateMultipartUploadResult defines result of InitiateMultipartUpload request
 type InitiateMultipartUploadResult struct {
 	XMLName  xml.Name `xml:"InitiateMultipartUploadResult"`
-	Bucket   string   `xml:"Bucket"`   // Bucket名称
-	Key      string   `xml:"Key"`      // 上传Object名称
-	UploadID string   `xml:"UploadId"` // 生成的UploadId
+	Bucket   string   `xml:"Bucket"`   // Bucket name
+	Key      string   `xml:"Key"`      // Object name to upload
+	UploadID string   `xml:"UploadId"` // Generated UploadId
 }
 
-// UploadPart 上传/拷贝的分片
+// UploadPart defines the upload/copy part
 type UploadPart struct {
 	XMLName    xml.Name `xml:"Part"`
-	PartNumber int      `xml:"PartNumber"` // Part编号
-	ETag       string   `xml:"ETag"`       // ETag缓存码
+	PartNumber int      `xml:"PartNumber"` // Part number
+	ETag       string   `xml:"ETag"`       // ETag value of the part's data
 }
 
 type uploadParts []UploadPart
@@ -295,10 +297,10 @@ func (slice uploadParts) Swap(i, j int) {
 	slice[i], slice[j] = slice[j], slice[i]
 }
 
-// UploadPartCopyResult 拷贝分片请求返回的结果
+// UploadPartCopyResult defines result object of multipart copy request.
 type UploadPartCopyResult struct {
 	XMLName      xml.Name  `xml:"CopyPartResult"`
-	LastModified time.Time `xml:"LastModified"` // 最后修改时间
+	LastModified time.Time `xml:"LastModified"` // Last modified time
 	ETag         string    `xml:"ETag"`         // ETag
 }
 
@@ -307,61 +309,69 @@ type completeMultipartUploadXML struct {
 	Part    []UploadPart `xml:"Part"`
 }
 
-// CompleteMultipartUploadResult 提交分片上传任务返回结果
+// CompleteMultipartUploadResult defines result object of CompleteMultipartUploadRequest
 type CompleteMultipartUploadResult struct {
 	XMLName  xml.Name `xml:"CompleteMultipartUploadResult"`
-	Location string   `xml:"Location"` // Object的URL
-	Bucket   string   `xml:"Bucket"`   // Bucket名称
-	ETag     string   `xml:"ETag"`     // Object的ETag
-	Key      string   `xml:"Key"`      // Object的名字
+	Location string   `xml:"Location"` // Object URL
+	Bucket   string   `xml:"Bucket"`   // Bucket name
+	ETag     string   `xml:"ETag"`     // Object ETag
+	Key      string   `xml:"Key"`      // Object name
 }
 
-// ListUploadedPartsResult ListUploadedParts请求返回结果
+// ListUploadedPartsResult defines result object of ListUploadedParts
 type ListUploadedPartsResult struct {
 	XMLName              xml.Name       `xml:"ListPartsResult"`
-	Bucket               string         `xml:"Bucket"`               // Bucket名称
-	Key                  string         `xml:"Key"`                  // Object名称
-	UploadID             string         `xml:"UploadId"`             // 上传Id
-	NextPartNumberMarker string         `xml:"NextPartNumberMarker"` // 下一个Part的位置
-	MaxParts             int            `xml:"MaxParts"`             // 最大Part个数
-	IsTruncated          bool           `xml:"IsTruncated"`          // 是否完全上传完成
-	UploadedParts        []UploadedPart `xml:"Part"`                 // 已完成的Part
+	Bucket               string         `xml:"Bucket"`               // Bucket name
+	Key                  string         `xml:"Key"`                  // Object name
+	UploadID             string         `xml:"UploadId"`             // Upload ID
+	NextPartNumberMarker string         `xml:"NextPartNumberMarker"` // Next part number
+	MaxParts             int            `xml:"MaxParts"`             // Max parts count
+	IsTruncated          bool           `xml:"IsTruncated"`          // Flag indicates all entries returned.false: all entries returned.
+	UploadedParts        []UploadedPart `xml:"Part"`                 // Uploaded parts
 }
 
-// UploadedPart 该任务已经上传的分片
+// UploadedPart defines uploaded part
 type UploadedPart struct {
 	XMLName      xml.Name  `xml:"Part"`
-	PartNumber   int       `xml:"PartNumber"`   // Part编号
-	LastModified time.Time `xml:"LastModified"` // 最后一次修改时间
-	ETag         string    `xml:"ETag"`         // ETag缓存码
-	Size         int       `xml:"Size"`         // Part大小
+	PartNumber   int       `xml:"PartNumber"`   // Part number
+	LastModified time.Time `xml:"LastModified"` // Last modified time
+	ETag         string    `xml:"ETag"`         // ETag cache
+	Size         int       `xml:"Size"`         // Part size
 }
 
-// ListMultipartUploadResult ListMultipartUpload请求返回结果
+// ListMultipartUploadResult defines result object of ListMultipartUpload
 type ListMultipartUploadResult struct {
 	XMLName            xml.Name            `xml:"ListMultipartUploadsResult"`
-	Bucket             string              `xml:"Bucket"`                // Bucket名称
-	Delimiter          string              `xml:"Delimiter"`             // 分组分割符
-	Prefix             string              `xml:"Prefix"`                // 筛选前缀
-	KeyMarker          string              `xml:"KeyMarker"`             // 起始Object位置
-	UploadIDMarker     string              `xml:"UploadIdMarker"`        // 起始UploadId位置
-	NextKeyMarker      string              `xml:"NextKeyMarker"`         // 如果没有全部返回，标明接下去的KeyMarker位置
-	NextUploadIDMarker string              `xml:"NextUploadIdMarker"`    // 如果没有全部返回，标明接下去的UploadId位置
-	MaxUploads         int                 `xml:"MaxUploads"`            // 返回最大Upload数目
-	IsTruncated        bool                `xml:"IsTruncated"`           // 是否完全返回
-	Uploads            []UncompletedUpload `xml:"Upload"`                // 未完成上传的MultipartUpload
-	CommonPrefixes     []string            `xml:"CommonPrefixes>Prefix"` // 所有名字包含指定的前缀且第一次出现delimiter字符之间的object作为一组的分组结果
+	Bucket             string              `xml:"Bucket"`                // Bucket name
+	Delimiter          string              `xml:"Delimiter"`             // Delimiter for grouping object.
+	Prefix             string              `xml:"Prefix"`                // Object prefix
+	KeyMarker          string              `xml:"KeyMarker"`             // Object key marker
+	UploadIDMarker     string              `xml:"UploadIdMarker"`        // UploadId marker
+	NextKeyMarker      string              `xml:"NextKeyMarker"`         // Next key marker, if not all entries returned.
+	NextUploadIDMarker string              `xml:"NextUploadIdMarker"`    // Next uploadId marker, if not all entries returned.
+	MaxUploads         int                 `xml:"MaxUploads"`            // Max uploads to return
+	IsTruncated        bool                `xml:"IsTruncated"`           // Flag indicates all entries are returned.
+	Uploads            []UncompletedUpload `xml:"Upload"`                // Ongoing uploads (not completed, not aborted)
+	CommonPrefixes     []string            `xml:"CommonPrefixes>Prefix"` // Common prefixes list.
 }
 
-// UncompletedUpload 未完成的Upload任务
+// UncompletedUpload structure wraps an uncompleted upload task
 type UncompletedUpload struct {
 	XMLName   xml.Name  `xml:"Upload"`
-	Key       string    `xml:"Key"`       // Object名称
-	UploadID  string    `xml:"UploadId"`  // 对应UploadId
-	Initiated time.Time `xml:"Initiated"` // 初始化时间，格式2012-02-23T04:18:23.000Z
+	Key       string    `xml:"Key"`       // Object name
+	UploadID  string    `xml:"UploadId"`  // The UploadId
+	Initiated time.Time `xml:"Initiated"` // Initialization time in the format such as 2012-02-23T04:18:23.000Z
 }
 
-// 解析URL编码
+// ProcessObjectResult defines result object of ProcessObject
+type ProcessObjectResult struct {
+	Bucket   string `json:"bucket"`
+	FileSize int    `json:"fileSize"`
+	Object   string `json:"object"`
+	Status   string `json:"status"`
+}
+
+// decodeDeleteObjectsResult decodes deleting objects result in URL encoding
 func decodeDeleteObjectsResult(result *DeleteObjectsResult) error {
 	var err error
 	for i := 0; i < len(result.DeletedObjects); i++ {
@@ -373,7 +383,7 @@ func decodeDeleteObjectsResult(result *DeleteObjectsResult) error {
 	return nil
 }
 
-// 解析URL编码
+// decodeListObjectsResult decodes list objects result in URL encoding
 func decodeListObjectsResult(result *ListObjectsResult) error {
 	var err error
 	result.Prefix, err = url.QueryUnescape(result.Prefix)
@@ -407,7 +417,17 @@ func decodeListObjectsResult(result *ListObjectsResult) error {
 	return nil
 }
 
-// 解析URL编码
+// decodeListUploadedPartsResult decodes
+func decodeListUploadedPartsResult(result *ListUploadedPartsResult) error {
+	var err error
+	result.Key, err = url.QueryUnescape(result.Key)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// decodeListMultipartUploadResult decodes list multipart upload result in URL encoding
 func decodeListMultipartUploadResult(result *ListMultipartUploadResult) error {
 	var err error
 	result.Prefix, err = url.QueryUnescape(result.Prefix)
@@ -440,3 +460,9 @@ func decodeListMultipartUploadResult(result *ListMultipartUploadResult) error {
 	}
 	return nil
 }
+
+// createBucketConfiguration defines the configuration for creating a bucket.
+type createBucketConfiguration struct {
+	XMLName      xml.Name         `xml:"CreateBucketConfiguration"`
+	StorageClass StorageClassType `xml:"StorageClass,omitempty"`
+}
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/upload.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/upload.go
index 049ed82d9..80371447d 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/upload.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/upload.go
@@ -3,61 +3,79 @@ package oss
 import (
 	"crypto/md5"
 	"encoding/base64"
+	"encoding/hex"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"os"
+	"path/filepath"
 	"time"
 )
 
+// UploadFile is multipart file upload.
 //
-// UploadFile 分片上传文件
+// objectKey    the object name.
+// filePath    the local file path to upload.
+// partSize    the part size in byte.
+// options    the options for uploading object.
 //
-// objectKey  object名称。
-// filePath   本地文件。需要上传的文件。
-// partSize   本次上传文件片的大小，字节数。比如100 * 1024为每片100KB。
-// options    上传Object时可以指定Object的属性。详见InitiateMultipartUpload。
-//
-// error 操作成功为nil，非nil为错误信息。
+// error    it's nil if the operation succeeds, otherwise it's an error object.
 //
 func (bucket Bucket) UploadFile(objectKey, filePath string, partSize int64, options ...Option) error {
 	if partSize < MinPartSize || partSize > MaxPartSize {
-		return errors.New("oss: part size invalid range (1024KB, 5GB]")
-	}
-
-	cpConf, err := getCpConfig(options, filePath)
-	if err != nil {
-		return err
+		return errors.New("oss: part size invalid range (100KB, 5GB]")
 	}
 
+	cpConf := getCpConfig(options)
 	routines := getRoutines(options)
 
-	if cpConf.IsEnable {
-		return bucket.uploadFileWithCp(objectKey, filePath, partSize, options, cpConf.FilePath, routines)
+	if cpConf != nil && cpConf.IsEnable {
+		cpFilePath := getUploadCpFilePath(cpConf, filePath, bucket.BucketName, objectKey)
+		if cpFilePath != "" {
+			return bucket.uploadFileWithCp(objectKey, filePath, partSize, options, cpFilePath, routines)
+		}
 	}
 
 	return bucket.uploadFile(objectKey, filePath, partSize, options, routines)
 }
 
-// ----- 并发无断点的上传  -----
-
-// 获取Checkpoint配置
-func getCpConfig(options []Option, filePath string) (*cpConfig, error) {
-	cpc := &cpConfig{}
-	cpcOpt, err := findOption(options, checkpointConfig, nil)
-	if err != nil || cpcOpt == nil {
-		return cpc, err
+func getUploadCpFilePath(cpConf *cpConfig, srcFile, destBucket, destObject string) string {
+	if cpConf.FilePath == "" && cpConf.DirPath != "" {
+		dest := fmt.Sprintf("oss://%v/%v", destBucket, destObject)
+		absPath, _ := filepath.Abs(srcFile)
+		cpFileName := getCpFileName(absPath, dest)
+		cpConf.FilePath = cpConf.DirPath + string(os.PathSeparator) + cpFileName
 	}
-
-	cpc = cpcOpt.(*cpConfig)
-	if cpc.IsEnable && cpc.FilePath == "" {
-		cpc.FilePath = filePath + CheckpointFileSuffix
-	}
-
-	return cpc, nil
+	return cpConf.FilePath
 }
 
-// 获取并发数，默认并发数1
+// ----- concurrent upload without checkpoint  -----
+
+// getCpConfig gets checkpoint configuration
+func getCpConfig(options []Option) *cpConfig {
+	cpcOpt, err := findOption(options, checkpointConfig, nil)
+	if err != nil || cpcOpt == nil {
+		return nil
+	}
+
+	return cpcOpt.(*cpConfig)
+}
+
+// getCpFileName return the name of the checkpoint file
+func getCpFileName(src, dest string) string {
+	md5Ctx := md5.New()
+	md5Ctx.Write([]byte(src))
+	srcCheckSum := hex.EncodeToString(md5Ctx.Sum(nil))
+
+	md5Ctx.Reset()
+	md5Ctx.Write([]byte(dest))
+	destCheckSum := hex.EncodeToString(md5Ctx.Sum(nil))
+
+	return fmt.Sprintf("%v-%v.cp", srcCheckSum, destCheckSum)
+}
+
+// getRoutines gets the routine count. by default it's 1.
 func getRoutines(options []Option) int {
 	rtnOpt, err := findOption(options, routineNum, nil)
 	if err != nil || rtnOpt == nil {
@@ -74,7 +92,17 @@ func getRoutines(options []Option) int {
 	return rs
 }
 
-// 获取进度回调
+// getPayer return the payer of the request
+func getPayer(options []Option) string {
+	payerOpt, err := findOption(options, HTTPHeaderOSSRequester, nil)
+	if err != nil || payerOpt == nil {
+		return ""
+	}
+
+	return payerOpt.(string)
+}
+
+// getProgressListener gets the progress callback
 func getProgressListener(options []Option) ProgressListener {
 	isSet, listener, _ := isOptionSet(options, progressListener)
 	if !isSet {
@@ -83,7 +111,7 @@ func getProgressListener(options []Option) ProgressListener {
 	return listener.(ProgressListener)
 }
 
-// 测试使用
+// uploadPartHook is for testing usage
 type uploadPartHook func(id int, chunk FileChunk) error
 
 var uploadPartHooker uploadPartHook = defaultUploadPart
@@ -92,22 +120,23 @@ func defaultUploadPart(id int, chunk FileChunk) error {
 	return nil
 }
 
-// 工作协程参数
+// workerArg defines worker argument structure
 type workerArg struct {
 	bucket   *Bucket
 	filePath string
 	imur     InitiateMultipartUploadResult
+	options  []Option
 	hook     uploadPartHook
 }
 
-// 工作协程
+// worker is the worker coroutine function
 func worker(id int, arg workerArg, jobs <-chan FileChunk, results chan<- UploadPart, failed chan<- error, die <-chan bool) {
 	for chunk := range jobs {
 		if err := arg.hook(id, chunk); err != nil {
 			failed <- err
 			break
 		}
-		part, err := arg.bucket.UploadPartFromFile(arg.imur, arg.filePath, chunk.Offset, chunk.Size, chunk.Number)
+		part, err := arg.bucket.UploadPartFromFile(arg.imur, arg.filePath, chunk.Offset, chunk.Size, chunk.Number, arg.options...)
 		if err != nil {
 			failed <- err
 			break
@@ -121,7 +150,7 @@ func worker(id int, arg workerArg, jobs <-chan FileChunk, results chan<- UploadP
 	}
 }
 
-// 调度协程
+// scheduler function
 func scheduler(jobs chan FileChunk, chunks []FileChunk) {
 	for _, chunk := range chunks {
 		jobs <- chunk
@@ -137,7 +166,7 @@ func getTotalBytes(chunks []FileChunk) int64 {
 	return tb
 }
 
-// 并发上传，不带断点续传功能
+// uploadFile is a concurrent upload, without checkpoint
 func (bucket Bucket) uploadFile(objectKey, filePath string, partSize int64, options []Option, routines int) error {
 	listener := getProgressListener(options)
 
@@ -146,7 +175,13 @@ func (bucket Bucket) uploadFile(objectKey, filePath string, partSize int64, opti
 		return err
 	}
 
-	// 初始化上传任务
+	payerOptions := []Option{}
+	payer := getPayer(options)
+	if payer != "" {
+		payerOptions = append(payerOptions, RequestPayer(PayerType(payer)))
+	}
+
+	// Initialize the multipart upload
 	imur, err := bucket.InitiateMultipartUpload(objectKey, options...)
 	if err != nil {
 		return err
@@ -162,16 +197,16 @@ func (bucket Bucket) uploadFile(objectKey, filePath string, partSize int64, opti
 	event := newProgressEvent(TransferStartedEvent, 0, totalBytes)
 	publishProgress(listener, event)
 
-	// 启动工作协程
-	arg := workerArg{&bucket, filePath, imur, uploadPartHooker}
+	// Start the worker coroutine
+	arg := workerArg{&bucket, filePath, imur, payerOptions, uploadPartHooker}
 	for w := 1; w <= routines; w++ {
 		go worker(w, arg, jobs, results, failed, die)
 	}
 
-	// 并发上传分片
+	// Schedule the jobs
 	go scheduler(jobs, chunks)
 
-	// 等待分配分片上传完成
+	// Waiting for the upload finished
 	completed := 0
 	parts := make([]UploadPart, len(chunks))
 	for completed < len(chunks) {
@@ -186,7 +221,7 @@ func (bucket Bucket) uploadFile(objectKey, filePath string, partSize int64, opti
 			close(die)
 			event = newProgressEvent(TransferFailedEvent, completedBytes, totalBytes)
 			publishProgress(listener, event)
-			bucket.AbortMultipartUpload(imur)
+			bucket.AbortMultipartUpload(imur, payerOptions...)
 			return err
 		}
 
@@ -198,43 +233,43 @@ func (bucket Bucket) uploadFile(objectKey, filePath string, partSize int64, opti
 	event = newProgressEvent(TransferStartedEvent, completedBytes, totalBytes)
 	publishProgress(listener, event)
 
-	// 提交任务
-	_, err = bucket.CompleteMultipartUpload(imur, parts)
+	// Complete the multpart upload
+	_, err = bucket.CompleteMultipartUpload(imur, parts, payerOptions...)
 	if err != nil {
-		bucket.AbortMultipartUpload(imur)
+		bucket.AbortMultipartUpload(imur, payerOptions...)
 		return err
 	}
 	return nil
 }
 
-// ----- 并发带断点的上传  -----
+// ----- concurrent upload with checkpoint  -----
 const uploadCpMagic = "FE8BB4EA-B593-4FAC-AD7A-2459A36E2E62"
 
 type uploadCheckpoint struct {
-	Magic     string   // magic
-	MD5       string   // cp内容的MD5
-	FilePath  string   // 本地文件
-	FileStat  cpStat   // 文件状态
-	ObjectKey string   // key
-	UploadID  string   // upload id
-	Parts     []cpPart // 本地文件的全部分片
+	Magic     string   // Magic
+	MD5       string   // Checkpoint file content's MD5
+	FilePath  string   // Local file path
+	FileStat  cpStat   // File state
+	ObjectKey string   // Key
+	UploadID  string   // Upload ID
+	Parts     []cpPart // All parts of the local file
 }
 
 type cpStat struct {
-	Size         int64     // 文件大小
-	LastModified time.Time // 本地文件最后修改时间
-	MD5          string    // 本地文件MD5
+	Size         int64     // File size
+	LastModified time.Time // File's last modified time
+	MD5          string    // Local file's MD5
 }
 
 type cpPart struct {
-	Chunk       FileChunk  // 分片
-	Part        UploadPart // 上传完成的分片
-	IsCompleted bool       // upload是否完成
+	Chunk       FileChunk  // File chunk
+	Part        UploadPart // Uploaded part
+	IsCompleted bool       // Upload complete flag
 }
 
-// CP数据是否有效，CP有效且文件没有更新时有效
+// isValid checks if the uploaded data is valid---it's valid when the file is not updated and the checkpoint data is valid.
 func (cp uploadCheckpoint) isValid(filePath string) (bool, error) {
-	// 比较CP的Magic及MD5
+	// Compare the CP's magic number and MD5.
 	cpb := cp
 	cpb.MD5 = ""
 	js, _ := json.Marshal(cpb)
@@ -245,7 +280,7 @@ func (cp uploadCheckpoint) isValid(filePath string) (bool, error) {
 		return false, nil
 	}
 
-	// 确认本地文件是否更新
+	// Make sure if the local file is updated.
 	fd, err := os.Open(filePath)
 	if err != nil {
 		return false, err
@@ -262,7 +297,7 @@ func (cp uploadCheckpoint) isValid(filePath string) (bool, error) {
 		return false, err
 	}
 
-	// 比较文件大小/文件最后更新时间/文件MD5
+	// Compare the file size, file's last modified time and file's MD5
 	if cp.FileStat.Size != st.Size() ||
 		cp.FileStat.LastModified != st.ModTime() ||
 		cp.FileStat.MD5 != md {
@@ -272,7 +307,7 @@ func (cp uploadCheckpoint) isValid(filePath string) (bool, error) {
 	return true, nil
 }
 
-// 从文件中load
+// load loads from the file
 func (cp *uploadCheckpoint) load(filePath string) error {
 	contents, err := ioutil.ReadFile(filePath)
 	if err != nil {
@@ -283,11 +318,11 @@ func (cp *uploadCheckpoint) load(filePath string) error {
 	return err
 }
 
-// dump到文件
+// dump dumps to the local file
 func (cp *uploadCheckpoint) dump(filePath string) error {
 	bcp := *cp
 
-	// 计算MD5
+	// Calculate MD5
 	bcp.MD5 = ""
 	js, err := json.Marshal(bcp)
 	if err != nil {
@@ -297,23 +332,23 @@ func (cp *uploadCheckpoint) dump(filePath string) error {
 	b64 := base64.StdEncoding.EncodeToString(sum[:])
 	bcp.MD5 = b64
 
-	// 序列化
+	// Serialization
 	js, err = json.Marshal(bcp)
 	if err != nil {
 		return err
 	}
 
-	// dump
+	// Dump
 	return ioutil.WriteFile(filePath, js, FilePermMode)
 }
 
-// 更新分片状态
+// updatePart updates the part status
 func (cp *uploadCheckpoint) updatePart(part UploadPart) {
 	cp.Parts[part.PartNumber-1].Part = part
 	cp.Parts[part.PartNumber-1].IsCompleted = true
 }
 
-// 未完成的分片
+// todoParts returns unfinished parts
 func (cp *uploadCheckpoint) todoParts() []FileChunk {
 	fcs := []FileChunk{}
 	for _, part := range cp.Parts {
@@ -324,7 +359,7 @@ func (cp *uploadCheckpoint) todoParts() []FileChunk {
 	return fcs
 }
 
-// 所有的分片
+// allParts returns all parts
 func (cp *uploadCheckpoint) allParts() []UploadPart {
 	ps := []UploadPart{}
 	for _, part := range cp.Parts {
@@ -333,7 +368,7 @@ func (cp *uploadCheckpoint) allParts() []UploadPart {
 	return ps
 }
 
-// 完成的字节数
+// getCompletedBytes returns completed bytes count
 func (cp *uploadCheckpoint) getCompletedBytes() int64 {
 	var completedBytes int64
 	for _, part := range cp.Parts {
@@ -344,19 +379,19 @@ func (cp *uploadCheckpoint) getCompletedBytes() int64 {
 	return completedBytes
 }
 
-// 计算文件文件MD5
+// calcFileMD5 calculates the MD5 for the specified local file
 func calcFileMD5(filePath string) (string, error) {
 	return "", nil
 }
 
-// 初始化分片上传
+// prepare initializes the multipart upload
 func prepare(cp *uploadCheckpoint, objectKey, filePath string, partSize int64, bucket *Bucket, options []Option) error {
-	// cp
+	// CP
 	cp.Magic = uploadCpMagic
 	cp.FilePath = filePath
 	cp.ObjectKey = objectKey
 
-	// localfile
+	// Local file
 	fd, err := os.Open(filePath)
 	if err != nil {
 		return err
@@ -375,7 +410,7 @@ func prepare(cp *uploadCheckpoint, objectKey, filePath string, partSize int64, b
 	}
 	cp.FileStat.MD5 = md
 
-	// chunks
+	// Chunks
 	parts, err := SplitFileByPartSize(filePath, partSize)
 	if err != nil {
 		return err
@@ -387,7 +422,7 @@ func prepare(cp *uploadCheckpoint, objectKey, filePath string, partSize int64, b
 		cp.Parts[i].IsCompleted = false
 	}
 
-	// init load
+	// Init load
 	imur, err := bucket.InitiateMultipartUpload(objectKey, options...)
 	if err != nil {
 		return err
@@ -397,11 +432,11 @@ func prepare(cp *uploadCheckpoint, objectKey, filePath string, partSize int64, b
 	return nil
 }
 
-// 提交分片上传，删除CP文件
-func complete(cp *uploadCheckpoint, bucket *Bucket, parts []UploadPart, cpFilePath string) error {
+// complete completes the multipart upload and deletes the local CP files
+func complete(cp *uploadCheckpoint, bucket *Bucket, parts []UploadPart, cpFilePath string, options []Option) error {
 	imur := InitiateMultipartUploadResult{Bucket: bucket.BucketName,
 		Key: cp.ObjectKey, UploadID: cp.UploadID}
-	_, err := bucket.CompleteMultipartUpload(imur, parts)
+	_, err := bucket.CompleteMultipartUpload(imur, parts, options...)
 	if err != nil {
 		return err
 	}
@@ -409,18 +444,24 @@ func complete(cp *uploadCheckpoint, bucket *Bucket, parts []UploadPart, cpFilePa
 	return err
 }
 
-// 并发带断点的上传
+// uploadFileWithCp handles concurrent upload with checkpoint
 func (bucket Bucket) uploadFileWithCp(objectKey, filePath string, partSize int64, options []Option, cpFilePath string, routines int) error {
 	listener := getProgressListener(options)
 
-	// LOAD CP数据
+	payerOptions := []Option{}
+	payer := getPayer(options)
+	if payer != "" {
+		payerOptions = append(payerOptions, RequestPayer(PayerType(payer)))
+	}
+
+	// Load CP data
 	ucp := uploadCheckpoint{}
 	err := ucp.load(cpFilePath)
 	if err != nil {
 		os.Remove(cpFilePath)
 	}
 
-	// LOAD出错或数据无效重新初始化上传
+	// Load error or the CP data is invalid.
 	valid, err := ucp.isValid(filePath)
 	if err != nil || !valid {
 		if err = prepare(&ucp, objectKey, filePath, partSize, &bucket, options); err != nil {
@@ -444,16 +485,16 @@ func (bucket Bucket) uploadFileWithCp(objectKey, filePath string, partSize int64
 	event := newProgressEvent(TransferStartedEvent, completedBytes, ucp.FileStat.Size)
 	publishProgress(listener, event)
 
-	// 启动工作协程
-	arg := workerArg{&bucket, filePath, imur, uploadPartHooker}
+	// Start the workers
+	arg := workerArg{&bucket, filePath, imur, payerOptions, uploadPartHooker}
 	for w := 1; w <= routines; w++ {
 		go worker(w, arg, jobs, results, failed, die)
 	}
 
-	// 并发上传分片
+	// Schedule jobs
 	go scheduler(jobs, chunks)
 
-	// 等待分配分片上传完成
+	// Waiting for the job finished
 	completed := 0
 	for completed < len(chunks) {
 		select {
@@ -479,7 +520,7 @@ func (bucket Bucket) uploadFileWithCp(objectKey, filePath string, partSize int64
 	event = newProgressEvent(TransferCompletedEvent, completedBytes, ucp.FileStat.Size)
 	publishProgress(listener, event)
 
-	// 提交分片上传
-	err = complete(&ucp, &bucket, ucp.allParts(), cpFilePath)
+	// Complete the multipart upload
+	err = complete(&ucp, &bucket, ucp.allParts(), cpFilePath, payerOptions)
 	return err
 }
diff --git a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/utils.go b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/utils.go
index b4d8e1694..c0e7b2b1b 100644
--- a/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/utils.go
+++ b/vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/utils.go
@@ -9,25 +9,27 @@ import (
 	"os"
 	"os/exec"
 	"runtime"
+	"strconv"
+	"strings"
 	"time"
 )
 
-// Get User Agent
-// Go sdk相关信息，包括sdk版本，操作系统类型，GO版本
-var userAgent = func() string {
+// userAgent gets user agent
+// It has the SDK version information, OS information and GO version
+func userAgent() string {
 	sys := getSysInfo()
 	return fmt.Sprintf("aliyun-sdk-go/%s (%s/%s/%s;%s)", Version, sys.name,
 		sys.release, sys.machine, runtime.Version())
-}()
-
-type sysInfo struct {
-	name    string // 操作系统名称windows/Linux
-	release string // 操作系统版本 2.6.32-220.23.2.ali1089.el5.x86_64等
-	machine string // 机器类型amd64/x86_64
 }
 
-// Get　system info
-// 获取操作系统信息、机器类型
+type sysInfo struct {
+	name    string // OS name such as windows/Linux
+	release string // OS version 2.6.32-220.23.2.ali1089.el5.x86_64 etc
+	machine string // CPU type amd64/x86_64
+}
+
+// getSysInfo gets system info
+// gets the OS information and CPU type
 func getSysInfo() sysInfo {
 	name := runtime.GOOS
 	release := "-"
@@ -44,8 +46,106 @@ func getSysInfo() sysInfo {
 	return sysInfo{name: name, release: release, machine: machine}
 }
 
+// unpackedRange
+type unpackedRange struct {
+	hasStart bool  // Flag indicates if the start point is specified
+	hasEnd   bool  // Flag indicates if the end point is specified
+	start    int64 // Start point
+	end      int64 // End point
+}
+
+// invalidRangeError returns invalid range error
+func invalidRangeError(r string) error {
+	return fmt.Errorf("InvalidRange %s", r)
+}
+
+// parseRange parse various styles of range such as bytes=M-N
+func parseRange(normalizedRange string) (*unpackedRange, error) {
+	var err error
+	hasStart := false
+	hasEnd := false
+	var start int64
+	var end int64
+
+	// Bytes==M-N or ranges=M-N
+	nrSlice := strings.Split(normalizedRange, "=")
+	if len(nrSlice) != 2 || nrSlice[0] != "bytes" {
+		return nil, invalidRangeError(normalizedRange)
+	}
+
+	// Bytes=M-N,X-Y
+	rSlice := strings.Split(nrSlice[1], ",")
+	rStr := rSlice[0]
+
+	if strings.HasSuffix(rStr, "-") { // M-
+		startStr := rStr[:len(rStr)-1]
+		start, err = strconv.ParseInt(startStr, 10, 64)
+		if err != nil {
+			return nil, invalidRangeError(normalizedRange)
+		}
+		hasStart = true
+	} else if strings.HasPrefix(rStr, "-") { // -N
+		len := rStr[1:]
+		end, err = strconv.ParseInt(len, 10, 64)
+		if err != nil {
+			return nil, invalidRangeError(normalizedRange)
+		}
+		if end == 0 { // -0
+			return nil, invalidRangeError(normalizedRange)
+		}
+		hasEnd = true
+	} else { // M-N
+		valSlice := strings.Split(rStr, "-")
+		if len(valSlice) != 2 {
+			return nil, invalidRangeError(normalizedRange)
+		}
+		start, err = strconv.ParseInt(valSlice[0], 10, 64)
+		if err != nil {
+			return nil, invalidRangeError(normalizedRange)
+		}
+		hasStart = true
+		end, err = strconv.ParseInt(valSlice[1], 10, 64)
+		if err != nil {
+			return nil, invalidRangeError(normalizedRange)
+		}
+		hasEnd = true
+	}
+
+	return &unpackedRange{hasStart, hasEnd, start, end}, nil
+}
+
+// adjustRange returns adjusted range, adjust the range according to the length of the file
+func adjustRange(ur *unpackedRange, size int64) (start, end int64) {
+	if ur == nil {
+		return 0, size
+	}
+
+	if ur.hasStart && ur.hasEnd {
+		start = ur.start
+		end = ur.end + 1
+		if ur.start < 0 || ur.start >= size || ur.end > size || ur.start > ur.end {
+			start = 0
+			end = size
+		}
+	} else if ur.hasStart {
+		start = ur.start
+		end = size
+		if ur.start < 0 || ur.start >= size {
+			start = 0
+		}
+	} else if ur.hasEnd {
+		start = size - ur.end
+		end = size
+		if ur.end < 0 || ur.end > size {
+			start = 0
+			end = size
+		}
+	}
+	return
+}
+
 // GetNowSec returns Unix time, the number of seconds elapsed since January 1, 1970 UTC.
-// 获取当前时间，从UTC开始的秒数。
+// gets the current time in Unix time, in seconds.
 func GetNowSec() int64 {
 	return time.Now().Unix()
 }
@@ -54,25 +154,25 @@ func GetNowSec() int64 {
 // since January 1, 1970 UTC. The result is undefined if the Unix time
 // in nanoseconds cannot be represented by an int64. Note that this
 // means the result of calling UnixNano on the zero Time is undefined.
-// 获取当前时间，从UTC开始的纳秒。
+// gets the current time in Unix time, in nanoseconds.
 func GetNowNanoSec() int64 {
 	return time.Now().UnixNano()
 }
 
-// GetNowGMT 获取当前时间，格式形如"Mon, 02 Jan 2006 15:04:05 GMT"，HTTP中使用的时间格式
+// GetNowGMT gets the current time in GMT format.
 func GetNowGMT() string {
 	return time.Now().UTC().Format(http.TimeFormat)
 }
 
-// FileChunk 文件片定义
+// FileChunk is the file chunk definition
 type FileChunk struct {
-	Number int   // 块序号
-	Offset int64 // 块在文件中的偏移量
-	Size   int64 // 块大小
+	Number int   // Chunk number
+	Offset int64 // Chunk offset
+	Size   int64 // Chunk size.
 }
 
-// SplitFileByPartNum Split big file to part by the num of part
-// 按指定的块数分割文件。返回值FileChunk为分割结果，error为nil时有效。
+// SplitFileByPartNum splits big file into parts by the num of parts.
+// Split the file with specified parts count, returns the split result when error is nil.
 func SplitFileByPartNum(fileName string, chunkNum int) ([]FileChunk, error) {
 	if chunkNum <= 0 || chunkNum > 10000 {
 		return nil, errors.New("chunkNum invalid")
@@ -110,8 +210,8 @@ func SplitFileByPartNum(fileName string, chunkNum int) ([]FileChunk, error) {
 	return chunks, nil
 }
 
-// SplitFileByPartSize Split big file to part by the size of part
-// 按块大小分割文件。返回值FileChunk为分割结果，error为nil时有效。
+// SplitFileByPartSize splits big file into parts by the size of parts.
+// Splits the file by the part size. Returns the FileChunk when error is nil.
 func SplitFileByPartSize(fileName string, chunkSize int64) ([]FileChunk, error) {
 	if chunkSize <= 0 {
 		return nil, errors.New("chunkSize invalid")
@@ -129,7 +229,7 @@ func SplitFileByPartSize(fileName string, chunkSize int64) ([]FileChunk, error)
 	}
 	var chunkN = stat.Size() / chunkSize
 	if chunkN >= 10000 {
-		return nil, errors.New("Too many parts, please increase part size.")
+		return nil, errors.New("Too many parts, please increase part size")
 	}
 
 	var chunks []FileChunk
@@ -151,7 +251,7 @@ func SplitFileByPartSize(fileName string, chunkSize int64) ([]FileChunk, error)
 	return chunks, nil
 }
 
-// GetPartEnd 计算结束位置
+// GetPartEnd calculates the end position
 func GetPartEnd(begin int64, total int64, per int64) int64 {
 	if begin+per > total {
 		return total - 1
@@ -159,7 +259,7 @@ func GetPartEnd(begin int64, total int64, per int64) int64 {
 	return begin + per - 1
 }
 
-// crcTable returns the Table constructed from the specified polynomial
+// crcTable returns the table constructed from the specified polynomial
 var crcTable = func() *crc64.Table {
 	return crc64.MakeTable(crc64.ECMA)
 }
diff --git a/vendor/github.com/antchfx/xpath/.travis.yml b/vendor/github.com/antchfx/xpath/.travis.yml
index 126848c8e..6b63957a8 100644
--- a/vendor/github.com/antchfx/xpath/.travis.yml
+++ b/vendor/github.com/antchfx/xpath/.travis.yml
@@ -2,8 +2,8 @@ language: go
 
 go:
   - 1.6
-  - 1.7
-  - 1.8
+  - 1.9
+  - '1.10'
 
 install:
   - go get github.com/mattn/goveralls
diff --git a/vendor/github.com/antchfx/xpath/README.md b/vendor/github.com/antchfx/xpath/README.md
index 41bf8c6ff..414114dc0 100644
--- a/vendor/github.com/antchfx/xpath/README.md
+++ b/vendor/github.com/antchfx/xpath/README.md
@@ -7,9 +7,17 @@ XPath
 
 XPath is Go package provides selecting nodes from XML, HTML or other documents using XPath expression.
 
-[XQuery](https://github.com/antchfx/xquery) : lets you extract data from HTML/XML documents using XPath package.
+Implementation
+===
 
-### Features
+- [htmlquery](https://github.com/antchfx/htmlquery) - an XPath query package for HTML document
+
+- [xmlquery](https://github.com/antchfx/xmlquery) - an XPath query package for XML document.
+
+- [jsonquery](https://github.com/antchfx/jsonquery) - an XPath query package for JSON document
+
+Supported Features
+===
 
 #### The basic XPath patterns.
 
@@ -45,7 +53,10 @@ XPath is Go package provides selecting nodes from XML, HTML or other documents u
 
 - `//b` : Returns elements in the entire document matching b.
 
-- `a|b` : All nodes matching a or b.
+- `a|b` : All nodes matching a or b, union operation(not boolean or).
+
+- `(a, b, c)` : Evaluates each of its operands and concatenates the resulting sequences, in order, into a single result sequence
+
 
 #### Node Axes 
 
@@ -97,23 +108,60 @@ XPath is Go package provides selecting nodes from XML, HTML or other documents u
     * a div b	Divide
     * a mod b	Floating point mod, like Java.
 
+- `a or b` : Boolean `or` operation.
+
+- `a and b` : Boolean `and` operation.
+
 - `(expr)` : Parenthesized expressions.
 
-- `fun(arg1, ..., argn)` : Function calls.
+- `fun(arg1, ..., argn)` : Function calls:
 
-    * position()
-    * last()
-    * count( node-set )
-    * name()
-    * starts-with( string, string )
-    * normalize-space( string )
-    * substring( string , start [, length] )
-    * not( expression )
-    * string-length( [string] )
-    * contains( string, string )
-    * sum( node-set )
-    * concat( string1 , string2 [, stringn]* )
+| Function | Supported |
+| --- | --- |
+`boolean()`| ✓ |
+`ceiling()`| ✓ |
+`choose()`| ✗ |
+`concat()`| ✓ |
+`contains()`| ✓ |
+`count()`| ✓ |
+`current()`| ✗ |
+`document()`| ✗ |
+`element-available()`| ✗ |
+`ends-with()`| ✓ |
+`false()`| ✓ |
+`floor()`| ✓ |
+`format-number()`| ✗ |
+`function-available()`| ✗ |
+`generate-id()`| ✗ |
+`id()`| ✗ |
+`key()`| ✗ |
+`lang()`| ✗ |
+`last()`| ✓ |
+`local-name()`| ✓ |
+`name()`| ✓ |
+`namespace-uri()`| ✓ |
+`normalize-space()`| ✓ |
+`not()`| ✓ |
+`number()`| ✓ |
+`position()`| ✓ |
+`round()`| ✓ |
+`starts-with()`| ✓ |
+`string()`| ✓ |
+`string-length()`| ✓ |
+`substring()`| ✓ |
+`substring-after()`| ✓ |
+`substring-before()`| ✓ |
+`sum()`| ✓ |
+`system-property()`| ✗ |
+`translate()`| ✓ |
+`true()`| ✓ |
+`unparsed-entity-url()` | ✗ |
 
-- `a or b` : Boolean or.
+Changelogs
+===
 
-- `a and b` : Boolean and.
\ No newline at end of file
+2019-01-29
+-  improvement `normalize-space` function. [#32](https://github.com/antchfx/xpath/issues/32)
+
+2018-12-07
+-  supports XPath 2.0 Sequence expressions. [#30](https://github.com/antchfx/xpath/pull/30) by [@minherz](https://github.com/minherz).
\ No newline at end of file
diff --git a/vendor/github.com/antchfx/xpath/build.go b/vendor/github.com/antchfx/xpath/build.go
index 544e0d49c..74f266b0d 100644
--- a/vendor/github.com/antchfx/xpath/build.go
+++ b/vendor/github.com/antchfx/xpath/build.go
@@ -23,9 +23,12 @@ type builder struct {
 func axisPredicate(root *axisNode) func(NodeNavigator) bool {
 	// get current axix node type.
 	typ := ElementNode
-	if root.AxeType == "attribute" {
+	switch root.AxeType {
+	case "attribute":
 		typ = AttributeNode
-	} else {
+	case "self", "parent":
+		typ = allNode
+	default:
 		switch root.Prop {
 		case "comment":
 			typ = CommentNode
@@ -34,12 +37,17 @@ func axisPredicate(root *axisNode) func(NodeNavigator) bool {
 			//	case "processing-instruction":
 		//	typ = ProcessingInstructionNode
 		case "node":
-			typ = ElementNode
+			typ = allNode
 		}
 	}
+	nametest := root.LocalName != "" || root.Prefix != ""
 	predicate := func(n NodeNavigator) bool {
-		if typ == n.NodeType() || typ == TextNode {
-			if root.LocalName == "" || (root.LocalName == n.LocalName() && root.Prefix == n.Prefix()) {
+		if typ == n.NodeType() || typ == allNode || typ == TextNode {
+			if nametest {
+				if root.LocalName == n.LocalName() && root.Prefix == n.Prefix() {
+					return true
+				}
+			} else {
 				return true
 			}
 		}
@@ -61,18 +69,16 @@ func (b *builder) processAxisNode(root *axisNode) (query, error) {
 	if root.Input == nil {
 		qyInput = &contextQuery{}
 	} else {
-		if b.flag&filterFlag == 0 {
-			if root.AxeType == "child" && (root.Input.Type() == nodeAxis) {
-				if input := root.Input.(*axisNode); input.AxeType == "descendant-or-self" {
-					var qyGrandInput query
-					if input.Input != nil {
-						qyGrandInput, _ = b.processNode(input.Input)
-					} else {
-						qyGrandInput = &contextQuery{}
-					}
-					qyOutput = &descendantQuery{Input: qyGrandInput, Predicate: predicate, Self: true}
-					return qyOutput, nil
+		if root.AxeType == "child" && (root.Input.Type() == nodeAxis) {
+			if input := root.Input.(*axisNode); input.AxeType == "descendant-or-self" {
+				var qyGrandInput query
+				if input.Input != nil {
+					qyGrandInput, _ = b.processNode(input.Input)
+				} else {
+					qyGrandInput = &contextQuery{}
 				}
+				qyOutput = &descendantQuery{Input: qyGrandInput, Predicate: predicate, Self: true}
+				return qyOutput, nil
 			}
 		}
 		qyInput, err = b.processNode(root.Input)
@@ -157,6 +163,16 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 			return nil, err
 		}
 		qyOutput = &functionQuery{Input: b.firstInput, Func: startwithFunc(arg1, arg2)}
+	case "ends-with":
+		arg1, err := b.processNode(root.Args[0])
+		if err != nil {
+			return nil, err
+		}
+		arg2, err := b.processNode(root.Args[1])
+		if err != nil {
+			return nil, err
+		}
+		qyOutput = &functionQuery{Input: b.firstInput, Func: endwithFunc(arg1, arg2)}
 	case "contains":
 		arg1, err := b.processNode(root.Args[0])
 		if err != nil {
@@ -189,6 +205,25 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 			}
 		}
 		qyOutput = &functionQuery{Input: b.firstInput, Func: substringFunc(arg1, arg2, arg3)}
+	case "substring-before", "substring-after":
+		//substring-xxxx( haystack, needle )
+		if len(root.Args) != 2 {
+			return nil, errors.New("xpath: substring-before function must have two parameters")
+		}
+		var (
+			arg1, arg2 query
+			err        error
+		)
+		if arg1, err = b.processNode(root.Args[0]); err != nil {
+			return nil, err
+		}
+		if arg2, err = b.processNode(root.Args[1]); err != nil {
+			return nil, err
+		}
+		qyOutput = &functionQuery{
+			Input: b.firstInput,
+			Func:  substringIndFunc(arg1, arg2, root.FuncName == "substring-after"),
+		}
 	case "string-length":
 		// string-length( [string] )
 		if len(root.Args) < 1 {
@@ -208,6 +243,25 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 			return nil, err
 		}
 		qyOutput = &functionQuery{Input: argQuery, Func: normalizespaceFunc}
+	case "translate":
+		//translate( string , string, string )
+		if len(root.Args) != 3 {
+			return nil, errors.New("xpath: translate function must have three parameters")
+		}
+		var (
+			arg1, arg2, arg3 query
+			err              error
+		)
+		if arg1, err = b.processNode(root.Args[0]); err != nil {
+			return nil, err
+		}
+		if arg2, err = b.processNode(root.Args[1]); err != nil {
+			return nil, err
+		}
+		if arg3, err = b.processNode(root.Args[2]); err != nil {
+			return nil, err
+		}
+		qyOutput = &functionQuery{Input: b.firstInput, Func: translateFunc(arg1, arg2, arg3)}
 	case "not":
 		if len(root.Args) == 0 {
 			return nil, errors.New("xpath: not function must have at least one parameter")
@@ -217,12 +271,62 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 			return nil, err
 		}
 		qyOutput = &functionQuery{Input: argQuery, Func: notFunc}
-	case "name":
-		qyOutput = &functionQuery{Input: b.firstInput, Func: nameFunc}
+	case "name", "local-name", "namespace-uri":
+		inp := b.firstInput
+		if len(root.Args) > 1 {
+			return nil, fmt.Errorf("xpath: %s function must have at most one parameter", root.FuncName)
+		}
+		if len(root.Args) == 1 {
+			argQuery, err := b.processNode(root.Args[0])
+			if err != nil {
+				return nil, err
+			}
+			inp = argQuery
+		}
+		f := &functionQuery{Input: inp}
+		switch root.FuncName {
+		case "name":
+			f.Func = nameFunc
+		case "local-name":
+			f.Func = localNameFunc
+		case "namespace-uri":
+			f.Func = namespaceFunc
+		}
+		qyOutput = f
+	case "true", "false":
+		val := root.FuncName == "true"
+		qyOutput = &functionQuery{
+			Input: b.firstInput,
+			Func: func(_ query, _ iterator) interface{} {
+				return val
+			},
+		}
 	case "last":
 		qyOutput = &functionQuery{Input: b.firstInput, Func: lastFunc}
 	case "position":
 		qyOutput = &functionQuery{Input: b.firstInput, Func: positionFunc}
+	case "boolean", "number", "string":
+		inp := b.firstInput
+		if len(root.Args) > 1 {
+			return nil, fmt.Errorf("xpath: %s function must have at most one parameter", root.FuncName)
+		}
+		if len(root.Args) == 1 {
+			argQuery, err := b.processNode(root.Args[0])
+			if err != nil {
+				return nil, err
+			}
+			inp = argQuery
+		}
+		f := &functionQuery{Input: inp}
+		switch root.FuncName {
+		case "boolean":
+			f.Func = booleanFunc
+		case "string":
+			f.Func = stringFunc
+		case "number":
+			f.Func = numberFunc
+		}
+		qyOutput = f
 	case "count":
 		//if b.firstInput == nil {
 		//	return nil, errors.New("xpath: expression must evaluate to node-set")
@@ -244,6 +348,24 @@ func (b *builder) processFunctionNode(root *functionNode) (query, error) {
 			return nil, err
 		}
 		qyOutput = &functionQuery{Input: argQuery, Func: sumFunc}
+	case "ceiling", "floor", "round":
+		if len(root.Args) == 0 {
+			return nil, fmt.Errorf("xpath: ceiling(node-sets) function must with have parameters node-sets")
+		}
+		argQuery, err := b.processNode(root.Args[0])
+		if err != nil {
+			return nil, err
+		}
+		f := &functionQuery{Input: argQuery}
+		switch root.FuncName {
+		case "ceiling":
+			f.Func = ceilingFunc
+		case "floor":
+			f.Func = floorFunc
+		case "round":
+			f.Func = roundFunc
+		}
+		qyOutput = f
 	case "concat":
 		if len(root.Args) < 2 {
 			return nil, fmt.Errorf("xpath: concat() must have at least two arguments")
@@ -304,12 +426,14 @@ func (b *builder) processOperatorNode(root *operatorNode) (query, error) {
 			exprFunc = neFunc
 		}
 		qyOutput = &logicalQuery{Left: left, Right: right, Do: exprFunc}
-	case "or", "and", "|":
+	case "or", "and":
 		isOr := false
-		if root.Op == "or" || root.Op == "|" {
+		if root.Op == "or" {
 			isOr = true
 		}
 		qyOutput = &booleanQuery{Left: left, Right: right, IsOr: isOr}
+	case "|":
+		qyOutput = &unionQuery{Left: left, Right: right}
 	}
 	return qyOutput, nil
 }
diff --git a/vendor/github.com/antchfx/xpath/func.go b/vendor/github.com/antchfx/xpath/func.go
index e28563401..3c0fde9f9 100644
--- a/vendor/github.com/antchfx/xpath/func.go
+++ b/vendor/github.com/antchfx/xpath/func.go
@@ -2,6 +2,9 @@ package xpath
 
 import (
 	"errors"
+	"fmt"
+	"math"
+	"regexp"
 	"strconv"
 	"strings"
 )
@@ -80,16 +83,146 @@ func sumFunc(q query, t iterator) interface{} {
 	case float64:
 		sum = typ
 	case string:
-		if v, err := strconv.ParseFloat(typ, 64); err != nil {
-			sum = v
+		v, err := strconv.ParseFloat(typ, 64)
+		if err != nil {
+			panic(errors.New("sum() function argument type must be a node-set or number"))
 		}
+		sum = v
 	}
 	return sum
 }
 
+func asNumber(t iterator, o interface{}) float64 {
+	switch typ := o.(type) {
+	case query:
+		node := typ.Select(t)
+		if node == nil {
+			return float64(0)
+		}
+		if v, err := strconv.ParseFloat(node.Value(), 64); err == nil {
+			return v
+		}
+	case float64:
+		return typ
+	case string:
+		v, err := strconv.ParseFloat(typ, 64)
+		if err != nil {
+			panic(errors.New("ceiling() function argument type must be a node-set or number"))
+		}
+		return v
+	}
+	return 0
+}
+
+// ceilingFunc is a XPath Node Set functions ceiling(node-set).
+func ceilingFunc(q query, t iterator) interface{} {
+	val := asNumber(t, q.Evaluate(t))
+	return math.Ceil(val)
+}
+
+// floorFunc is a XPath Node Set functions floor(node-set).
+func floorFunc(q query, t iterator) interface{} {
+	val := asNumber(t, q.Evaluate(t))
+	return math.Floor(val)
+}
+
+// roundFunc is a XPath Node Set functions round(node-set).
+func roundFunc(q query, t iterator) interface{} {
+	val := asNumber(t, q.Evaluate(t))
+	//return math.Round(val)
+	return round(val)
+}
+
 // nameFunc is a XPath functions name([node-set]).
 func nameFunc(q query, t iterator) interface{} {
-	return t.Current().LocalName()
+	v := q.Select(t)
+	if v == nil {
+		return ""
+	}
+	ns := v.Prefix()
+	if ns == "" {
+		return v.LocalName()
+	}
+	return ns + ":" + v.LocalName()
+}
+
+// localNameFunc is a XPath functions local-name([node-set]).
+func localNameFunc(q query, t iterator) interface{} {
+	v := q.Select(t)
+	if v == nil {
+		return ""
+	}
+	return v.LocalName()
+}
+
+// namespaceFunc is a XPath functions namespace-uri([node-set]).
+func namespaceFunc(q query, t iterator) interface{} {
+	v := q.Select(t)
+	if v == nil {
+		return ""
+	}
+	return v.Prefix()
+}
+
+func asBool(t iterator, v interface{}) bool {
+	switch v := v.(type) {
+	case nil:
+		return false
+	case *NodeIterator:
+		return v.MoveNext()
+	case bool:
+		return bool(v)
+	case float64:
+		return v != 0
+	case string:
+		return v != ""
+	case query:
+		return v.Select(t) != nil
+	default:
+		panic(fmt.Errorf("unexpected type: %T", v))
+	}
+}
+
+func asString(t iterator, v interface{}) string {
+	switch v := v.(type) {
+	case nil:
+		return ""
+	case bool:
+		if v {
+			return "true"
+		}
+		return "false"
+	case float64:
+		return strconv.FormatFloat(v, 'g', -1, 64)
+	case string:
+		return v
+	case query:
+		node := v.Select(t)
+		if node == nil {
+			return ""
+		}
+		return node.Value()
+	default:
+		panic(fmt.Errorf("unexpected type: %T", v))
+	}
+}
+
+// booleanFunc is a XPath functions boolean([node-set]).
+func booleanFunc(q query, t iterator) interface{} {
+	v := q.Evaluate(t)
+	return asBool(t, v)
+}
+
+// numberFunc is a XPath functions number([node-set]).
+func numberFunc(q query, t iterator) interface{} {
+	v := q.Evaluate(t)
+	return asNumber(t, v)
+}
+
+// stringFunc is a XPath functions string([node-set]).
+func stringFunc(q query, t iterator) interface{} {
+	v := q.Evaluate(t)
+	return asString(t, v)
 }
 
 // startwithFunc is a XPath functions starts-with(string, string).
@@ -119,6 +252,33 @@ func startwithFunc(arg1, arg2 query) func(query, iterator) interface{} {
 	}
 }
 
+// endwithFunc is a XPath functions ends-with(string, string).
+func endwithFunc(arg1, arg2 query) func(query, iterator) interface{} {
+	return func(q query, t iterator) interface{} {
+		var (
+			m, n string
+			ok   bool
+		)
+		switch typ := arg1.Evaluate(t).(type) {
+		case string:
+			m = typ
+		case query:
+			node := typ.Select(t)
+			if node == nil {
+				return false
+			}
+			m = node.Value()
+		default:
+			panic(errors.New("ends-with() function argument type must be string"))
+		}
+		n, ok = arg2.Evaluate(t).(string)
+		if !ok {
+			panic(errors.New("ends-with() function argument type must be string"))
+		}
+		return strings.HasSuffix(m, n)
+	}
+}
+
 // containsFunc is a XPath functions contains(string or @attr, string).
 func containsFunc(arg1, arg2 query) func(query, iterator) interface{} {
 	return func(q query, t iterator) interface{} {
@@ -149,6 +309,11 @@ func containsFunc(arg1, arg2 query) func(query, iterator) interface{} {
 	}
 }
 
+var (
+	regnewline  = regexp.MustCompile(`[\r\n\t]`)
+	regseqspace = regexp.MustCompile(`\s{2,}`)
+)
+
 // normalizespaceFunc is XPath functions normalize-space(string?)
 func normalizespaceFunc(q query, t iterator) interface{} {
 	var m string
@@ -158,11 +323,14 @@ func normalizespaceFunc(q query, t iterator) interface{} {
 	case query:
 		node := typ.Select(t)
 		if node == nil {
-			return false
+			return ""
 		}
 		m = node.Value()
 	}
-	return strings.TrimSpace(m)
+	m = strings.TrimSpace(m)
+	m = regnewline.ReplaceAllString(m, " ")
+	m = regseqspace.ReplaceAllString(m, " ")
+	return m
 }
 
 // substringFunc is XPath functions substring function returns a part of a given string.
@@ -175,7 +343,7 @@ func substringFunc(arg1, arg2, arg3 query) func(query, iterator) interface{} {
 		case query:
 			node := typ.Select(t)
 			if node == nil {
-				return false
+				return ""
 			}
 			m = node.Value()
 		}
@@ -185,7 +353,10 @@ func substringFunc(arg1, arg2, arg3 query) func(query, iterator) interface{} {
 
 		if start, ok = arg2.Evaluate(t).(float64); !ok {
 			panic(errors.New("substring() function first argument type must be int"))
+		} else if start < 1 {
+			panic(errors.New("substring() function first argument type must be >= 1"))
 		}
+		start--
 		if arg3 != nil {
 			if length, ok = arg3.Evaluate(t).(float64); !ok {
 				panic(errors.New("substring() function second argument type must be int"))
@@ -201,6 +372,46 @@ func substringFunc(arg1, arg2, arg3 query) func(query, iterator) interface{} {
 	}
 }
 
+// substringIndFunc is XPath functions substring-before/substring-after function returns a part of a given string.
+func substringIndFunc(arg1, arg2 query, after bool) func(query, iterator) interface{} {
+	return func(q query, t iterator) interface{} {
+		var str string
+		switch v := arg1.Evaluate(t).(type) {
+		case string:
+			str = v
+		case query:
+			node := v.Select(t)
+			if node == nil {
+				return ""
+			}
+			str = node.Value()
+		}
+		var word string
+		switch v := arg2.Evaluate(t).(type) {
+		case string:
+			word = v
+		case query:
+			node := v.Select(t)
+			if node == nil {
+				return ""
+			}
+			word = node.Value()
+		}
+		if word == "" {
+			return ""
+		}
+
+		i := strings.Index(str, word)
+		if i < 0 {
+			return ""
+		}
+		if after {
+			return str[i+len(word):]
+		}
+		return str[:i]
+	}
+}
+
 // stringLengthFunc is XPATH string-length( [string] ) function that returns a number
 // equal to the number of characters in a given string.
 func stringLengthFunc(arg1 query) func(query, iterator) interface{} {
@@ -219,6 +430,25 @@ func stringLengthFunc(arg1 query) func(query, iterator) interface{} {
 	}
 }
 
+// translateFunc is XPath functions translate() function returns a replaced string.
+func translateFunc(arg1, arg2, arg3 query) func(query, iterator) interface{} {
+	return func(q query, t iterator) interface{} {
+		str := asString(t, arg1.Evaluate(t))
+		src := asString(t, arg2.Evaluate(t))
+		dst := asString(t, arg3.Evaluate(t))
+
+		var replace []string
+		for i, s := range src {
+			d := ""
+			if i < len(dst) {
+				d = string(dst[i])
+			}
+			replace = append(replace, string(s), d)
+		}
+		return strings.NewReplacer(replace...).Replace(str)
+	}
+}
+
 // notFunc is XPATH functions not(expression) function operation.
 func notFunc(q query, t iterator) interface{} {
 	switch v := q.Evaluate(t).(type) {
diff --git a/vendor/github.com/antchfx/xpath/func_go110.go b/vendor/github.com/antchfx/xpath/func_go110.go
new file mode 100644
index 000000000..500880fac
--- /dev/null
+++ b/vendor/github.com/antchfx/xpath/func_go110.go
@@ -0,0 +1,9 @@
+// +build go1.10
+
+package xpath
+
+import "math"
+
+func round(f float64) int {
+	return int(math.Round(f))
+}
diff --git a/vendor/github.com/antchfx/xpath/func_pre_go110.go b/vendor/github.com/antchfx/xpath/func_pre_go110.go
new file mode 100644
index 000000000..043616b30
--- /dev/null
+++ b/vendor/github.com/antchfx/xpath/func_pre_go110.go
@@ -0,0 +1,15 @@
+// +build !go1.10
+
+package xpath
+
+import "math"
+
+// math.Round() is supported by Go 1.10+,
+// This method just compatible for version <1.10.
+// https://github.com/golang/go/issues/20100
+func round(f float64) int {
+	if math.Abs(f) < 0.5 {
+		return 0
+	}
+	return int(f + math.Copysign(0.5, f))
+}
diff --git a/vendor/github.com/antchfx/xpath/parse.go b/vendor/github.com/antchfx/xpath/parse.go
index 6103131cb..fb9abe312 100644
--- a/vendor/github.com/antchfx/xpath/parse.go
+++ b/vendor/github.com/antchfx/xpath/parse.go
@@ -42,7 +42,7 @@ const (
 	itemString                     // Quoted string constant
 	itemNumber                     // Number constant
 	itemAxe                        // Axe (like child::)
-	itemEof                        // END
+	itemEOF                        // END
 )
 
 // A node is an XPath node in the parse tree.
@@ -389,7 +389,7 @@ Loop:
 }
 
 // Step	::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
-func (p *parser) parseStep(n node) node {
+func (p *parser) parseStep(n node) (opnd node) {
 	axeTyp := "child" // default axes value.
 	if p.r.typ == itemDot || p.r.typ == itemDotDot {
 		if p.r.typ == itemDot {
@@ -398,23 +398,45 @@ func (p *parser) parseStep(n node) node {
 			axeTyp = "parent"
 		}
 		p.next()
-		return newAxisNode(axeTyp, "", "", "", n)
+		opnd = newAxisNode(axeTyp, "", "", "", n)
+		if p.r.typ != itemLBracket {
+			return opnd
+		}
+	} else {
+		switch p.r.typ {
+		case itemAt:
+			p.next()
+			axeTyp = "attribute"
+		case itemAxe:
+			axeTyp = p.r.name
+			p.next()
+		case itemLParens:
+			return p.parseSequence(n)
+		}
+		opnd = p.parseNodeTest(n, axeTyp)
 	}
-	switch p.r.typ {
-	case itemAt:
-		p.next()
-		axeTyp = "attribute"
-	case itemAxe:
-		axeTyp = p.r.name
-		p.next()
-	}
-	opnd := p.parseNodeTest(n, axeTyp)
 	for p.r.typ == itemLBracket {
 		opnd = newFilterNode(opnd, p.parsePredicate(opnd))
 	}
 	return opnd
 }
 
+// Expr ::= '(' Step ("," Step)* ')'
+func (p *parser) parseSequence(n node) (opnd node) {
+	p.skipItem(itemLParens)
+	opnd = p.parseStep(n)
+	for {
+		if p.r.typ != itemComma {
+			break
+		}
+		p.next()
+		opnd2 := p.parseStep(n)
+		opnd = newOperatorNode("|", opnd, opnd2)
+	}
+	p.skipItem(itemRParens)
+	return opnd
+}
+
 // 	NodeTest ::= NameTest | nodeType '(' ')' | 'processing-instruction' '(' Literal ')'
 func (p *parser) parseNodeTest(n node, axeTyp string) (opnd node) {
 	switch p.r.typ {
@@ -628,7 +650,7 @@ func (s *scanner) nextChar() bool {
 		return false
 	}
 	s.curr = rune(s.text[s.pos])
-	s.pos += 1
+	s.pos++
 	return true
 }
 
@@ -636,7 +658,7 @@ func (s *scanner) nextItem() bool {
 	s.skipSpace()
 	switch s.curr {
 	case 0:
-		s.typ = itemEof
+		s.typ = itemEOF
 		return false
 	case ',', '@', '(', ')', '|', '*', '[', ']', '+', '-', '=', '#', '$':
 		s.typ = asItemType(s.curr)
diff --git a/vendor/github.com/antchfx/xpath/query.go b/vendor/github.com/antchfx/xpath/query.go
index b076973c8..9735ef096 100644
--- a/vendor/github.com/antchfx/xpath/query.go
+++ b/vendor/github.com/antchfx/xpath/query.go
@@ -71,7 +71,7 @@ func (a *ancestorQuery) Select(t iterator) NodeNavigator {
 				}
 				for node.MoveToParent() {
 					if !a.Predicate(node) {
-						break
+						continue
 					}
 					return node
 				}
@@ -707,16 +707,79 @@ func (b *booleanQuery) Select(t iterator) NodeNavigator {
 
 func (b *booleanQuery) Evaluate(t iterator) interface{} {
 	m := b.Left.Evaluate(t)
-	if m.(bool) == b.IsOr {
-		return m
+	left := asBool(t, m)
+	if b.IsOr && left {
+		return true
+	} else if !b.IsOr && !left {
+		return false
 	}
-	return b.Right.Evaluate(t)
+	m = b.Right.Evaluate(t)
+	return asBool(t, m)
 }
 
 func (b *booleanQuery) Clone() query {
 	return &booleanQuery{IsOr: b.IsOr, Left: b.Left.Clone(), Right: b.Right.Clone()}
 }
 
+type unionQuery struct {
+	Left, Right query
+	iterator    func() NodeNavigator
+}
+
+func (u *unionQuery) Select(t iterator) NodeNavigator {
+	if u.iterator == nil {
+		var list []NodeNavigator
+		var i int
+		root := t.Current().Copy()
+		for {
+			node := u.Left.Select(t)
+			if node == nil {
+				break
+			}
+			node = node.Copy()
+			list = append(list, node)
+		}
+		t.Current().MoveTo(root)
+		for {
+			node := u.Right.Select(t)
+			if node == nil {
+				break
+			}
+			node = node.Copy()
+			var exists bool
+			for _, x := range list {
+				if reflect.DeepEqual(x, node) {
+					exists = true
+					break
+				}
+			}
+			if !exists {
+				list = append(list, node)
+			}
+		}
+		u.iterator = func() NodeNavigator {
+			if i >= len(list) {
+				return nil
+			}
+			node := list[i]
+			i++
+			return node
+		}
+	}
+	return u.iterator()
+}
+
+func (u *unionQuery) Evaluate(t iterator) interface{} {
+	u.iterator = nil
+	u.Left.Evaluate(t)
+	u.Right.Evaluate(t)
+	return u
+}
+
+func (u *unionQuery) Clone() query {
+	return &unionQuery{Left: u.Left.Clone(), Right: u.Right.Clone()}
+}
+
 func getNodePosition(q query) int {
 	type Position interface {
 		position() int
diff --git a/vendor/github.com/antchfx/xpath/xpath.go b/vendor/github.com/antchfx/xpath/xpath.go
index 4460c3777..7e3f52c38 100644
--- a/vendor/github.com/antchfx/xpath/xpath.go
+++ b/vendor/github.com/antchfx/xpath/xpath.go
@@ -22,6 +22,9 @@ const (
 
 	// CommentNode is a comment node, such as <!-- my comment -->
 	CommentNode
+
+	// allNode is any types of node, used by xpath package only to predicate match.
+	allNode
 )
 
 // NodeNavigator provides cursor model for navigating XML data.
diff --git a/vendor/github.com/antchfx/xquery/xml/node.go b/vendor/github.com/antchfx/xquery/xml/node.go
index 064d1cdd8..19c4653ea 100644
--- a/vendor/github.com/antchfx/xquery/xml/node.go
+++ b/vendor/github.com/antchfx/xquery/xml/node.go
@@ -66,10 +66,15 @@ func (n *Node) InnerText() string {
 
 func outputXML(buf *bytes.Buffer, n *Node) {
 	if n.Type == TextNode || n.Type == CommentNode {
-		buf.WriteString(strings.TrimSpace(n.Data))
+		xml.EscapeText(buf, []byte(strings.TrimSpace(n.Data)))
 		return
 	}
-	buf.WriteString("<" + n.Data)
+	if n.Type == DeclarationNode {
+		buf.WriteString("<?" + n.Data)
+	} else {
+		buf.WriteString("<" + n.Data)
+	}
+
 	for _, attr := range n.Attr {
 		if attr.Name.Space != "" {
 			buf.WriteString(fmt.Sprintf(` %s:%s="%s"`, attr.Name.Space, attr.Name.Local, attr.Value))
@@ -77,11 +82,17 @@ func outputXML(buf *bytes.Buffer, n *Node) {
 			buf.WriteString(fmt.Sprintf(` %s="%s"`, attr.Name.Local, attr.Value))
 		}
 	}
-	buf.WriteString(">")
+	if n.Type == DeclarationNode {
+		buf.WriteString("?>")
+	} else {
+		buf.WriteString(">")
+	}
 	for child := n.FirstChild; child != nil; child = child.NextSibling {
 		outputXML(buf, child)
 	}
-	buf.WriteString(fmt.Sprintf("</%s>", n.Data))
+	if n.Type != DeclarationNode {
+		buf.WriteString(fmt.Sprintf("</%s>", n.Data))
+	}
 }
 
 // OutputXML returns the text that including tags name.
@@ -128,6 +139,9 @@ func addChild(parent, n *Node) {
 }
 
 func addSibling(sibling, n *Node) {
+	for t := sibling.NextSibling; t != nil; t = t.NextSibling {
+		sibling = t
+	}
 	n.Parent = sibling.Parent
 	sibling.NextSibling = n
 	n.PrevSibling = sibling
@@ -245,8 +259,3 @@ quit:
 func Parse(r io.Reader) (*Node, error) {
 	return parse(r)
 }
-
-// ParseXML returns the parse tree for the XML from the given Reader.Deprecated.
-func ParseXML(r io.Reader) (*Node, error) {
-	return parse(r)
-}
diff --git a/vendor/github.com/apparentlymart/go-textseg/LICENSE b/vendor/github.com/apparentlymart/go-textseg/LICENSE
new file mode 100644
index 000000000..684b03b4a
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/LICENSE
@@ -0,0 +1,95 @@
+Copyright (c) 2017 Martin Atkins
+
+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.
+
+---------
+
+Unicode table generation programs are under a separate copyright and license:
+
+Copyright (c) 2014 Couchbase, Inc.
+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.
+
+---------
+
+Grapheme break data is provided as part of the Unicode character database,
+copright 2016 Unicode, Inc, which is provided with the following license:
+
+Unicode Data Files include all data files under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/,
+http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
+http://www.unicode.org/utility/trac/browser/.
+
+Unicode Data Files do not include PDF online code charts under the
+directory http://www.unicode.org/Public/.
+
+Software includes any source code published in the Unicode Standard
+or under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/,
+http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
+http://www.unicode.org/utility/trac/browser/.
+
+NOTICE TO USER: Carefully read the following legal agreement.
+BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
+DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
+YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT.
+IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
+THE DATA FILES OR SOFTWARE.
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2017 Unicode, Inc. All rights reserved.
+Distributed under the Terms of Use in http://www.unicode.org/copyright.html.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Unicode data files and any associated documentation
+(the "Data Files") or Unicode software and any associated documentation
+(the "Software") to deal in the Data Files or Software
+without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, and/or sell copies of
+the Data Files or Software, and to permit persons to whom the Data Files
+or Software are furnished to do so, provided that either
+(a) this copyright and permission notice appear with all copies
+of the Data Files or Software, or
+(b) this copyright and permission notice appear in associated
+Documentation.
+
+THE DATA FILES AND SOFTWARE ARE 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 OF THIRD PARTY RIGHTS.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale,
+use or other dealings in these Data Files or Software without prior
+written authorization of the copyright holder.
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go b/vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go
new file mode 100644
index 000000000..5752e9ef8
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go
@@ -0,0 +1,30 @@
+package textseg
+
+import (
+	"bufio"
+	"bytes"
+)
+
+// AllTokens is a utility that uses a bufio.SplitFunc to produce a slice of
+// all of the recognized tokens in the given buffer.
+func AllTokens(buf []byte, splitFunc bufio.SplitFunc) ([][]byte, error) {
+	scanner := bufio.NewScanner(bytes.NewReader(buf))
+	scanner.Split(splitFunc)
+	var ret [][]byte
+	for scanner.Scan() {
+		ret = append(ret, scanner.Bytes())
+	}
+	return ret, scanner.Err()
+}
+
+// TokenCount is a utility that uses a bufio.SplitFunc to count the number of
+// recognized tokens in the given buffer.
+func TokenCount(buf []byte, splitFunc bufio.SplitFunc) (int, error) {
+	scanner := bufio.NewScanner(bytes.NewReader(buf))
+	scanner.Split(splitFunc)
+	var ret int
+	for scanner.Scan() {
+		ret++
+	}
+	return ret, scanner.Err()
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/generate.go b/vendor/github.com/apparentlymart/go-textseg/textseg/generate.go
new file mode 100644
index 000000000..81f3a7471
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/generate.go
@@ -0,0 +1,7 @@
+package textseg
+
+//go:generate go run make_tables.go -output tables.go
+//go:generate go run make_test_tables.go -output tables_test.go
+//go:generate ruby unicode2ragel.rb --url=http://www.unicode.org/Public/9.0.0/ucd/auxiliary/GraphemeBreakProperty.txt -m GraphemeCluster -p "Prepend,CR,LF,Control,Extend,Regional_Indicator,SpacingMark,L,V,T,LV,LVT,E_Base,E_Modifier,ZWJ,Glue_After_Zwj,E_Base_GAZ" -o grapheme_clusters_table.rl
+//go:generate ragel -Z grapheme_clusters.rl
+//go:generate gofmt -w grapheme_clusters.go
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go
new file mode 100644
index 000000000..012bc690a
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go
@@ -0,0 +1,5276 @@
+
+// line 1 "grapheme_clusters.rl"
+package textseg
+
+import (
+    "errors"
+    "unicode/utf8"
+)
+
+// Generated from grapheme_clusters.rl. DO NOT EDIT
+
+// line 13 "grapheme_clusters.go"
+var _graphclust_actions []byte = []byte{
+	0, 1, 0, 1, 4, 1, 9, 1, 10, 
+	1, 11, 1, 12, 1, 13, 1, 14, 
+	1, 15, 1, 16, 1, 17, 1, 18, 
+	1, 19, 1, 20, 1, 21, 2, 1, 
+	7, 2, 1, 8, 2, 2, 3, 2, 
+	5, 1, 3, 0, 1, 8, 3, 5, 
+	0, 1, 3, 5, 1, 6, 
+}
+
+var _graphclust_key_offsets []int16 = []int16{
+	0, 0, 1, 3, 5, 7, 10, 15, 
+	17, 20, 28, 31, 33, 35, 37, 67, 
+	75, 77, 81, 84, 89, 94, 104, 116, 
+	122, 127, 137, 140, 147, 151, 159, 169, 
+	173, 181, 183, 191, 194, 196, 201, 203, 
+	210, 212, 220, 221, 242, 246, 252, 257, 
+	259, 263, 267, 269, 273, 275, 278, 282, 
+	284, 291, 293, 297, 301, 305, 307, 309, 
+	318, 322, 327, 329, 335, 337, 338, 340, 
+	341, 343, 345, 347, 349, 364, 368, 370, 
+	372, 377, 381, 385, 387, 389, 393, 397, 
+	399, 403, 410, 415, 419, 422, 423, 427, 
+	434, 439, 440, 441, 443, 452, 454, 477, 
+	481, 483, 487, 491, 492, 496, 500, 503, 
+	505, 510, 523, 525, 527, 529, 531, 535, 
+	539, 541, 543, 545, 549, 553, 557, 559, 
+	561, 563, 565, 566, 568, 574, 580, 586, 
+	588, 592, 596, 601, 604, 614, 616, 618, 
+	621, 623, 625, 627, 629, 632, 637, 639, 
+	642, 650, 653, 655, 657, 659, 690, 698, 
+	700, 704, 711, 723, 730, 744, 750, 768, 
+	779, 785, 797, 800, 809, 814, 824, 830, 
+	844, 850, 862, 874, 878, 880, 886, 888, 
+	895, 898, 906, 907, 928, 937, 945, 951, 
+	953, 957, 961, 966, 972, 974, 977, 990, 
+	995, 1009, 1011, 1020, 1027, 1038, 1048, 1056, 
+	1067, 1071, 1076, 1078, 1080, 1082, 1083, 1085, 
+	1087, 1089, 1091, 1106, 1110, 1112, 1114, 1122, 
+	1130, 1132, 1136, 1147, 1150, 1160, 1164, 1171, 
+	1179, 1185, 1188, 1189, 1193, 1200, 1205, 1206, 
+	1207, 1209, 1218, 1220, 1243, 1248, 1250, 1259, 
+	1264, 1265, 1274, 1280, 1290, 1295, 1302, 1316, 
+	1320, 1325, 1336, 1339, 1349, 1353, 1362, 1364, 
+	1372, 1379, 1385, 1392, 1396, 1398, 1400, 1402, 
+	1403, 1405, 1411, 1419, 1425, 1427, 1431, 1435, 
+	1440, 1443, 1453, 1455, 1457, 1458, 1460, 1461, 
+	1467, 1469, 1471, 1471, 1472, 1473, 1474, 1480, 
+	1482, 1484, 1484, 1490, 1492, 1497, 1502, 1504, 
+	1506, 1508, 1511, 1516, 1518, 1521, 1529, 1532, 
+	1534, 1536, 1538, 1568, 1576, 1578, 1582, 1585, 
+	1590, 1595, 1605, 1617, 1623, 1628, 1638, 1641, 
+	1648, 1652, 1660, 1670, 1674, 1682, 1684, 1692, 
+	1695, 1697, 1702, 1704, 1711, 1713, 1721, 1722, 
+	1743, 1747, 1753, 1758, 1760, 1764, 1768, 1770, 
+	1774, 1776, 1779, 1783, 1785, 1792, 1794, 1798, 
+	1802, 1806, 1808, 1810, 1819, 1823, 1828, 1830, 
+	1836, 1838, 1839, 1841, 1842, 1844, 1846, 1848, 
+	1850, 1865, 1869, 1871, 1873, 1878, 1882, 1886, 
+	1888, 1890, 1894, 1898, 1900, 1904, 1911, 1916, 
+	1920, 1923, 1924, 1928, 1935, 1940, 1941, 1942, 
+	1944, 1953, 1955, 1978, 1982, 1984, 1988, 1992, 
+	1993, 1997, 2001, 2004, 2006, 2011, 2024, 2026, 
+	2028, 2030, 2032, 2036, 2040, 2042, 2044, 2046, 
+	2050, 2054, 2058, 2060, 2062, 2064, 2066, 2067, 
+	2069, 2075, 2081, 2087, 2089, 2093, 2097, 2102, 
+	2105, 2115, 2117, 2119, 2122, 2124, 2126, 2128, 
+	2130, 2133, 2138, 2140, 2143, 2151, 2154, 2156, 
+	2158, 2160, 2191, 2199, 2201, 2205, 2212, 2224, 
+	2231, 2245, 2251, 2269, 2280, 2286, 2298, 2301, 
+	2310, 2315, 2325, 2331, 2345, 2351, 2363, 2375, 
+	2379, 2381, 2387, 2389, 2396, 2399, 2407, 2408, 
+	2429, 2438, 2446, 2452, 2454, 2458, 2462, 2467, 
+	2473, 2475, 2478, 2491, 2496, 2510, 2512, 2521, 
+	2528, 2539, 2549, 2557, 2568, 2572, 2577, 2579, 
+	2581, 2583, 2584, 2586, 2588, 2590, 2592, 2607, 
+	2611, 2613, 2615, 2623, 2631, 2633, 2637, 2648, 
+	2651, 2661, 2665, 2672, 2680, 2686, 2689, 2690, 
+	2694, 2701, 2706, 2707, 2708, 2710, 2719, 2721, 
+	2744, 2749, 2751, 2760, 2765, 2766, 2775, 2781, 
+	2791, 2796, 2803, 2817, 2821, 2826, 2837, 2840, 
+	2850, 2854, 2863, 2865, 2873, 2880, 2886, 2893, 
+	2897, 2899, 2901, 2903, 2904, 2906, 2912, 2920, 
+	2926, 2928, 2932, 2936, 2941, 2944, 2954, 2956, 
+	2958, 2959, 2961, 2962, 2968, 2970, 2972, 2972, 
+	2973, 2974, 2975, 2981, 2983, 2985, 2985, 2991, 
+	2993, 2997, 3003, 3006, 3009, 3013, 3016, 3019, 
+	3026, 3028, 3052, 3054, 3078, 3080, 3082, 3105, 
+	3107, 3109, 3110, 3112, 3114, 3116, 3122, 3124, 
+	3156, 3160, 3165, 3188, 3190, 3192, 3194, 3196, 
+	3199, 3201, 3203, 3207, 3207, 3263, 3319, 3350, 
+	3355, 3359, 3366, 3374, 3378, 3381, 3384, 3390, 
+	3392, 3412, 3418, 3423, 3425, 3427, 3430, 3432, 
+	3434, 3438, 3494, 3550, 3581, 3586, 3594, 3598, 
+	3600, 3605, 3611, 3615, 3618, 3624, 3627, 3631, 
+	3634, 3638, 3651, 3655, 3662, 3663, 3665, 3668, 
+	3678, 3698, 3705, 3709, 3716, 3726, 3733, 3736, 
+	3751, 3753, 3756, 3761, 3763, 3766, 3769, 3773, 
+	3776, 3779, 3786, 3788, 3790, 3792, 3794, 3797, 
+	3802, 3804, 3807, 3815, 3818, 3820, 3822, 3824, 
+	3854, 3862, 3864, 3868, 3871, 3876, 3881, 3891, 
+	3903, 3909, 3914, 3924, 3927, 3934, 3938, 3946, 
+	3956, 3960, 3968, 3970, 3978, 3981, 3983, 3988, 
+	3990, 3997, 3999, 4007, 4008, 4029, 4033, 4039, 
+	4044, 4046, 4050, 4054, 4056, 4060, 4062, 4065, 
+	4069, 4071, 4078, 4080, 4084, 4088, 4092, 4094, 
+	4096, 4105, 4109, 4114, 4116, 4122, 4124, 4125, 
+	4127, 4128, 4130, 4132, 4134, 4136, 4151, 4155, 
+	4157, 4159, 4164, 4168, 4172, 4174, 4176, 4180, 
+	4184, 4186, 4190, 4197, 4202, 4206, 4209, 4210, 
+	4214, 4221, 4226, 4227, 4228, 4230, 4239, 4241, 
+	4264, 4268, 4270, 4274, 4278, 4279, 4283, 4287, 
+	4290, 4292, 4297, 4310, 4312, 4314, 4316, 4318, 
+	4322, 4326, 4328, 4330, 4332, 4336, 4340, 4344, 
+	4346, 4348, 4350, 4352, 4353, 4355, 4361, 4367, 
+	4373, 4375, 4379, 4383, 4388, 4391, 4401, 4403, 
+	4405, 4408, 4410, 4412, 4414, 4416, 4419, 4424, 
+	4426, 4429, 4437, 4440, 4442, 4444, 4446, 4477, 
+	4485, 4487, 4491, 4498, 4510, 4517, 4531, 4537, 
+	4555, 4566, 4572, 4584, 4587, 4596, 4601, 4611, 
+	4617, 4631, 4637, 4649, 4661, 4665, 4667, 4673, 
+	4675, 4682, 4685, 4693, 4694, 4715, 4724, 4732, 
+	4738, 4740, 4744, 4748, 4753, 4759, 4761, 4764, 
+	4777, 4782, 4796, 4798, 4807, 4814, 4825, 4835, 
+	4843, 4854, 4858, 4863, 4865, 4867, 4869, 4870, 
+	4872, 4874, 4876, 4878, 4893, 4897, 4899, 4901, 
+	4909, 4917, 4919, 4923, 4934, 4937, 4947, 4951, 
+	4958, 4966, 4972, 4975, 4976, 4980, 4987, 4992, 
+	4993, 4994, 4996, 5005, 5007, 5030, 5035, 5037, 
+	5046, 5051, 5052, 5061, 5067, 5077, 5082, 5089, 
+	5103, 5107, 5112, 5123, 5126, 5136, 5140, 5149, 
+	5151, 5159, 5166, 5172, 5179, 5183, 5185, 5187, 
+	5189, 5190, 5192, 5198, 5206, 5212, 5214, 5218, 
+	5222, 5227, 5230, 5240, 5242, 5244, 5245, 5247, 
+	5248, 5254, 5256, 5258, 5258, 5259, 5260, 5261, 
+	5267, 5269, 5271, 5271, 5277, 5301, 5303, 5327, 
+	5329, 5331, 5354, 5356, 5358, 5359, 5361, 5363, 
+	5365, 5371, 5373, 5405, 5409, 5414, 5437, 5439, 
+	5441, 5443, 5445, 5448, 5450, 5452, 5456, 5456, 
+	5512, 5568, 5599, 5604, 5607, 5614, 5626, 5628, 
+	5630, 5632, 5635, 5640, 5642, 5645, 5653, 5656, 
+	5658, 5660, 5662, 5692, 5700, 5702, 5706, 5709, 
+	5714, 5719, 5729, 5741, 5747, 5752, 5762, 5765, 
+	5772, 5776, 5784, 5794, 5798, 5806, 5808, 5816, 
+	5819, 5821, 5826, 5828, 5835, 5837, 5845, 5846, 
+	5867, 5871, 5877, 5882, 5884, 5888, 5892, 5894, 
+	5898, 5900, 5903, 5907, 5909, 5916, 5918, 5922, 
+	5926, 5930, 5932, 5934, 5943, 5947, 5952, 5954, 
+	5956, 5958, 5959, 5961, 5963, 5965, 5967, 5982, 
+	5986, 5988, 5990, 5995, 5999, 6003, 6005, 6007, 
+	6011, 6015, 6017, 6021, 6028, 6033, 6037, 6040, 
+	6041, 6045, 6051, 6056, 6057, 6058, 6060, 6069, 
+	6071, 6094, 6098, 6100, 6104, 6108, 6109, 6113, 
+	6117, 6120, 6122, 6127, 6140, 6142, 6144, 6146, 
+	6148, 6152, 6156, 6158, 6160, 6162, 6166, 6170, 
+	6174, 6176, 6178, 6180, 6182, 6183, 6185, 6191, 
+	6197, 6203, 6205, 6209, 6213, 6218, 6221, 6231, 
+	6233, 6235, 6236, 6242, 6244, 6246, 6246, 6252, 
+	6253, 6260, 6263, 6265, 6267, 6269, 6271, 6274, 
+	6279, 6281, 6284, 6292, 6295, 6297, 6299, 6301, 
+	6332, 6340, 6342, 6346, 6353, 6365, 6372, 6386, 
+	6392, 6410, 6421, 6427, 6439, 6442, 6451, 6456, 
+	6466, 6472, 6486, 6492, 6504, 6516, 6520, 6522, 
+	6528, 6530, 6537, 6540, 6548, 6549, 6570, 6579, 
+	6587, 6593, 6595, 6599, 6603, 6608, 6614, 6616, 
+	6619, 6632, 6637, 6651, 6653, 6662, 6669, 6680, 
+	6690, 6698, 6709, 6713, 6718, 6720, 6722, 6724, 
+	6725, 6727, 6729, 6731, 6733, 6748, 6752, 6754, 
+	6756, 6764, 6772, 6774, 6778, 6789, 6792, 6802, 
+	6806, 6813, 6821, 6827, 6830, 6831, 6835, 6842, 
+	6847, 6848, 6849, 6851, 6860, 6862, 6885, 6890, 
+	6892, 6901, 6906, 6907, 6916, 6922, 6932, 6937, 
+	6944, 6958, 6962, 6967, 6978, 6981, 6991, 6995, 
+	7004, 7006, 7014, 7021, 7027, 7034, 7038, 7040, 
+	7042, 7044, 7045, 7047, 7053, 7061, 7067, 7069, 
+	7073, 7077, 7082, 7085, 7095, 7097, 7099, 7100, 
+	7102, 7103, 7109, 7111, 7113, 7113, 7114, 7115, 
+	7121, 7124, 7126, 7128, 7130, 7133, 7138, 7140, 
+	7143, 7151, 7154, 7156, 7158, 7160, 7191, 7199, 
+	7201, 7205, 7212, 7214, 7216, 7218, 7221, 7226, 
+	7228, 7231, 7239, 7242, 7244, 7246, 7248, 7278, 
+	7286, 7288, 7292, 7295, 7300, 7305, 7315, 7327, 
+	7333, 7338, 7348, 7351, 7358, 7362, 7370, 7380, 
+	7384, 7392, 7394, 7402, 7405, 7407, 7412, 7414, 
+	7421, 7423, 7431, 7432, 7453, 7457, 7463, 7468, 
+	7470, 7474, 7478, 7480, 7484, 7486, 7489, 7493, 
+	7495, 7502, 7504, 7508, 7512, 7516, 7518, 7520, 
+	7529, 7533, 7538, 7540, 7546, 7548, 7549, 7551, 
+	7552, 7554, 7556, 7558, 7560, 7575, 7579, 7581, 
+	7583, 7588, 7592, 7596, 7598, 7600, 7604, 7608, 
+	7610, 7614, 7621, 7626, 7630, 7633, 7634, 7638, 
+	7645, 7650, 7651, 7652, 7654, 7663, 7665, 7688, 
+	7692, 7694, 7698, 7702, 7703, 7707, 7711, 7714, 
+	7716, 7721, 7734, 7736, 7738, 7740, 7742, 7746, 
+	7750, 7752, 7754, 7756, 7760, 7764, 7768, 7770, 
+	7772, 7774, 7776, 7777, 7779, 7785, 7791, 7797, 
+	7799, 7803, 7807, 7812, 7815, 7825, 7827, 7829, 
+	7832, 7834, 7835, 7836, 7837, 7843, 7845, 7847, 
+	7847, 7853, 7865, 7872, 7886, 7892, 7910, 7921, 
+	7927, 7939, 7942, 7951, 7956, 7966, 7972, 7986, 
+	7992, 8004, 8016, 8020, 8022, 8028, 8030, 8037, 
+	8040, 8048, 8049, 8070, 8079, 8087, 8093, 8095, 
+	8099, 8103, 8108, 8114, 8116, 8119, 8132, 8137, 
+	8151, 8153, 8162, 8169, 8180, 8190, 8198, 8209, 
+	8213, 8218, 8220, 8222, 8224, 8225, 8227, 8229, 
+	8231, 8233, 8248, 8252, 8254, 8256, 8264, 8272, 
+	8274, 8278, 8289, 8292, 8302, 8306, 8313, 8321, 
+	8327, 8330, 8331, 8335, 8342, 8347, 8348, 8349, 
+	8351, 8360, 8362, 8385, 8390, 8392, 8401, 8406, 
+	8407, 8416, 8422, 8432, 8437, 8444, 8458, 8462, 
+	8467, 8478, 8481, 8491, 8495, 8504, 8506, 8514, 
+	8521, 8527, 8534, 8538, 8540, 8542, 8544, 8545, 
+	8547, 8553, 8561, 8567, 8569, 8573, 8577, 8582, 
+	8585, 8595, 8597, 8599, 8600, 8602, 8603, 8609, 
+	8611, 8613, 8613, 8616, 8622, 8624, 8644, 8650, 
+	8655, 8657, 8659, 8662, 8664, 8666, 8670, 8726, 
+	8782, 8817, 8822, 8830, 8832, 8832, 8834, 8838, 
+	8841, 8848, 8854, 8858, 8861, 8867, 8870, 8876, 
+	8879, 8885, 8898, 8902, 8904, 8906, 8908, 8911, 
+	8916, 8918, 8921, 8929, 8932, 8934, 8936, 8938, 
+	8968, 8976, 8978, 8982, 8985, 8990, 8995, 9005, 
+	9017, 9023, 9028, 9038, 9041, 9048, 9052, 9060, 
+	9070, 9074, 9082, 9084, 9092, 9095, 9097, 9102, 
+	9104, 9111, 9113, 9121, 9122, 9143, 9147, 9153, 
+	9158, 9160, 9164, 9168, 9170, 9174, 9176, 9179, 
+	9183, 9185, 9192, 9194, 9198, 9202, 9206, 9208, 
+	9210, 9219, 9223, 9228, 9230, 9236, 9238, 9239, 
+	9241, 9242, 9244, 9246, 9248, 9250, 9265, 9269, 
+	9271, 9273, 9278, 9282, 9286, 9288, 9290, 9294, 
+	9298, 9300, 9304, 9311, 9316, 9320, 9323, 9324, 
+	9328, 9335, 9340, 9341, 9342, 9344, 9353, 9355, 
+	9378, 9382, 9384, 9388, 9392, 9393, 9397, 9401, 
+	9404, 9406, 9411, 9424, 9426, 9428, 9430, 9432, 
+	9436, 9440, 9442, 9444, 9446, 9450, 9454, 9458, 
+	9460, 9462, 9464, 9466, 9467, 9469, 9475, 9481, 
+	9487, 9489, 9493, 9497, 9502, 9505, 9515, 9517, 
+	9519, 9522, 9524, 9526, 9528, 9530, 9533, 9538, 
+	9540, 9543, 9551, 9554, 9556, 9558, 9560, 9591, 
+	9599, 9601, 9605, 9612, 9624, 9631, 9645, 9651, 
+	9669, 9680, 9686, 9698, 9701, 9710, 9715, 9725, 
+	9731, 9745, 9751, 9763, 9775, 9779, 9781, 9787, 
+	9789, 9796, 9799, 9807, 9808, 9829, 9838, 9846, 
+	9852, 9854, 9858, 9862, 9867, 9873, 9875, 9878, 
+	9891, 9896, 9910, 9912, 9921, 9928, 9939, 9949, 
+	9957, 9968, 9972, 9977, 9979, 9981, 9983, 9984, 
+	9986, 9988, 9990, 9992, 10007, 10011, 10013, 10015, 
+	10023, 10031, 10033, 10037, 10048, 10051, 10061, 10065, 
+	10072, 10080, 10086, 10089, 10090, 10094, 10101, 10106, 
+	10107, 10108, 10110, 10119, 10121, 10144, 10149, 10151, 
+	10160, 10165, 10166, 10175, 10181, 10191, 10196, 10203, 
+	10217, 10221, 10226, 10237, 10240, 10250, 10254, 10263, 
+	10265, 10273, 10280, 10286, 10293, 10297, 10299, 10301, 
+	10303, 10304, 10306, 10312, 10320, 10326, 10328, 10332, 
+	10336, 10341, 10344, 10354, 10356, 10358, 10359, 10361, 
+	10362, 10368, 10370, 10372, 10372, 10373, 10374, 10375, 
+	10381, 10383, 10385, 10385, 10391, 10398, 10399, 10401, 
+	10404, 10414, 10434, 10441, 10445, 10452, 10462, 10469, 
+	10472, 10487, 10489, 10492, 10501, 10505, 10509, 10538, 
+	10558, 10578, 10598, 10620, 10640, 10660, 10680, 10703, 
+	10724, 10745, 10766, 10786, 10809, 10829, 10849, 10869, 
+	10890, 10911, 10932, 10952, 10972, 10992, 11012, 11032, 
+	11052, 11072, 11092, 11112, 
+}
+
+var _graphclust_trans_keys []byte = []byte{
+	10, 128, 255, 176, 255, 131, 137, 191, 
+	145, 189, 135, 129, 130, 132, 133, 144, 
+	154, 176, 139, 159, 150, 156, 159, 164, 
+	167, 168, 170, 173, 145, 176, 255, 139, 
+	255, 166, 176, 171, 179, 160, 161, 163, 
+	164, 165, 167, 169, 171, 173, 174, 175, 
+	176, 177, 179, 180, 181, 182, 183, 184, 
+	185, 186, 187, 188, 189, 190, 191, 166, 
+	170, 172, 178, 150, 153, 155, 163, 165, 
+	167, 169, 173, 153, 155, 148, 161, 163, 
+	255, 189, 132, 185, 144, 152, 161, 164, 
+	255, 188, 129, 131, 190, 255, 133, 134, 
+	137, 138, 142, 150, 152, 161, 164, 255, 
+	131, 134, 137, 138, 142, 144, 146, 175, 
+	178, 180, 182, 255, 134, 138, 142, 161, 
+	164, 255, 188, 129, 131, 190, 191, 128, 
+	132, 135, 136, 139, 141, 150, 151, 162, 
+	163, 130, 190, 191, 151, 128, 130, 134, 
+	136, 138, 141, 128, 131, 190, 255, 133, 
+	137, 142, 148, 151, 161, 164, 255, 128, 
+	132, 134, 136, 138, 141, 149, 150, 162, 
+	163, 129, 131, 190, 255, 133, 137, 142, 
+	150, 152, 161, 164, 255, 130, 131, 138, 
+	150, 143, 148, 152, 159, 178, 179, 177, 
+	179, 186, 135, 142, 177, 179, 185, 187, 
+	188, 136, 141, 181, 183, 185, 152, 153, 
+	190, 191, 177, 191, 128, 132, 134, 135, 
+	141, 151, 153, 188, 134, 128, 129, 130, 
+	141, 156, 157, 158, 159, 160, 162, 164, 
+	168, 169, 170, 172, 173, 174, 175, 176, 
+	179, 183, 173, 183, 185, 190, 150, 153, 
+	158, 160, 177, 180, 130, 141, 157, 132, 
+	134, 157, 159, 146, 148, 178, 180, 146, 
+	147, 178, 179, 180, 255, 148, 156, 158, 
+	255, 139, 141, 169, 133, 134, 160, 171, 
+	176, 187, 151, 155, 160, 162, 191, 149, 
+	158, 165, 188, 176, 190, 128, 132, 180, 
+	255, 133, 170, 180, 255, 128, 130, 161, 
+	173, 166, 179, 164, 183, 173, 144, 146, 
+	148, 168, 178, 180, 184, 185, 128, 181, 
+	187, 191, 128, 131, 179, 181, 183, 140, 
+	141, 128, 131, 157, 179, 181, 183, 144, 
+	176, 164, 175, 177, 191, 160, 191, 128, 
+	130, 170, 175, 153, 154, 153, 154, 155, 
+	160, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 175, 175, 178, 180, 189, 
+	158, 159, 176, 177, 130, 134, 139, 163, 
+	167, 128, 129, 180, 255, 134, 159, 178, 
+	255, 166, 173, 135, 147, 128, 131, 179, 
+	255, 129, 164, 166, 255, 169, 182, 131, 
+	188, 140, 141, 176, 178, 180, 183, 184, 
+	190, 191, 129, 171, 175, 181, 182, 163, 
+	170, 172, 173, 172, 184, 190, 158, 128, 
+	143, 160, 175, 144, 145, 150, 155, 157, 
+	158, 159, 135, 139, 141, 168, 171, 189, 
+	160, 182, 186, 191, 129, 131, 133, 134, 
+	140, 143, 184, 186, 165, 166, 128, 129, 
+	130, 132, 133, 134, 135, 136, 139, 140, 
+	141, 144, 145, 146, 147, 150, 151, 152, 
+	153, 154, 156, 176, 178, 128, 130, 184, 
+	255, 135, 190, 131, 175, 187, 255, 128, 
+	130, 167, 180, 179, 128, 130, 179, 255, 
+	129, 137, 141, 255, 190, 172, 183, 159, 
+	170, 188, 128, 131, 190, 191, 151, 128, 
+	132, 135, 136, 139, 141, 162, 163, 166, 
+	172, 176, 180, 181, 191, 128, 134, 176, 
+	255, 132, 255, 175, 181, 184, 255, 129, 
+	155, 158, 255, 129, 255, 171, 183, 157, 
+	171, 175, 182, 184, 191, 146, 167, 169, 
+	182, 171, 172, 189, 190, 176, 180, 176, 
+	182, 145, 190, 143, 146, 178, 157, 158, 
+	133, 134, 137, 168, 169, 170, 165, 169, 
+	173, 178, 187, 255, 131, 132, 140, 169, 
+	174, 255, 130, 132, 128, 182, 187, 255, 
+	173, 180, 182, 255, 132, 155, 159, 161, 
+	175, 128, 163, 165, 128, 134, 136, 152, 
+	155, 161, 163, 164, 166, 170, 144, 150, 
+	132, 138, 145, 146, 151, 166, 169, 0, 
+	127, 176, 255, 131, 137, 191, 145, 189, 
+	135, 129, 130, 132, 133, 144, 154, 176, 
+	139, 159, 150, 156, 159, 164, 167, 168, 
+	170, 173, 145, 176, 255, 139, 255, 166, 
+	176, 171, 179, 160, 161, 163, 164, 165, 
+	166, 167, 169, 171, 172, 173, 174, 175, 
+	176, 177, 178, 179, 180, 181, 182, 183, 
+	184, 185, 186, 187, 188, 189, 190, 191, 
+	168, 170, 150, 153, 155, 163, 165, 167, 
+	169, 173, 153, 155, 148, 161, 163, 255, 
+	131, 187, 189, 132, 185, 190, 255, 141, 
+	144, 129, 136, 145, 151, 152, 161, 162, 
+	163, 164, 255, 129, 188, 190, 130, 131, 
+	191, 255, 141, 151, 129, 132, 133, 134, 
+	137, 138, 142, 161, 162, 163, 164, 255, 
+	131, 188, 129, 130, 190, 255, 145, 181, 
+	129, 130, 131, 134, 135, 136, 137, 138, 
+	139, 141, 142, 175, 176, 177, 178, 255, 
+	134, 138, 141, 129, 136, 142, 161, 162, 
+	163, 164, 255, 129, 188, 130, 131, 190, 
+	191, 128, 141, 129, 132, 135, 136, 139, 
+	140, 150, 151, 162, 163, 130, 190, 191, 
+	128, 141, 151, 129, 130, 134, 136, 138, 
+	140, 128, 129, 131, 190, 255, 133, 137, 
+	129, 132, 142, 148, 151, 161, 164, 255, 
+	129, 188, 190, 191, 130, 131, 130, 134, 
+	128, 132, 135, 136, 138, 139, 140, 141, 
+	149, 150, 162, 163, 129, 190, 130, 131, 
+	191, 255, 133, 137, 141, 151, 129, 132, 
+	142, 161, 162, 163, 164, 255, 138, 143, 
+	150, 159, 144, 145, 146, 148, 152, 158, 
+	178, 179, 177, 179, 180, 186, 135, 142, 
+	177, 179, 180, 185, 187, 188, 136, 141, 
+	181, 183, 185, 152, 153, 190, 191, 191, 
+	177, 190, 128, 132, 134, 135, 141, 151, 
+	153, 188, 134, 128, 129, 130, 141, 156, 
+	157, 158, 159, 160, 162, 164, 168, 169, 
+	170, 172, 173, 174, 175, 176, 179, 183, 
+	177, 173, 183, 185, 186, 187, 188, 189, 
+	190, 150, 151, 152, 153, 158, 160, 177, 
+	180, 130, 132, 141, 157, 133, 134, 157, 
+	159, 146, 148, 178, 180, 146, 147, 178, 
+	179, 182, 180, 189, 190, 255, 134, 157, 
+	137, 147, 148, 255, 139, 141, 169, 133, 
+	134, 178, 160, 162, 163, 166, 167, 168, 
+	169, 171, 176, 184, 185, 187, 155, 151, 
+	152, 153, 154, 150, 160, 162, 191, 149, 
+	151, 152, 158, 165, 172, 173, 178, 179, 
+	188, 176, 190, 132, 181, 187, 128, 131, 
+	180, 188, 189, 255, 130, 133, 170, 171, 
+	179, 180, 255, 130, 161, 170, 128, 129, 
+	162, 165, 166, 167, 168, 173, 167, 173, 
+	166, 169, 170, 174, 175, 177, 178, 179, 
+	164, 171, 172, 179, 180, 181, 182, 183, 
+	161, 173, 180, 144, 146, 148, 168, 178, 
+	179, 184, 185, 128, 181, 187, 191, 128, 
+	131, 179, 181, 183, 140, 141, 144, 176, 
+	175, 177, 191, 160, 191, 128, 130, 170, 
+	175, 153, 154, 153, 154, 155, 160, 162, 
+	163, 164, 165, 166, 167, 168, 169, 170, 
+	171, 175, 175, 178, 180, 189, 158, 159, 
+	176, 177, 130, 134, 139, 167, 163, 164, 
+	165, 166, 132, 133, 134, 159, 160, 177, 
+	178, 255, 166, 173, 135, 145, 146, 147, 
+	131, 179, 188, 128, 130, 180, 181, 182, 
+	185, 186, 255, 165, 129, 255, 169, 174, 
+	175, 176, 177, 178, 179, 180, 181, 182, 
+	131, 140, 141, 188, 176, 178, 180, 183, 
+	184, 190, 191, 129, 171, 181, 182, 172, 
+	173, 174, 175, 165, 168, 172, 173, 163, 
+	170, 172, 184, 190, 158, 128, 143, 160, 
+	175, 144, 145, 150, 155, 157, 158, 159, 
+	135, 139, 141, 168, 171, 189, 160, 182, 
+	186, 191, 129, 131, 133, 134, 140, 143, 
+	184, 186, 165, 166, 128, 129, 130, 132, 
+	133, 134, 135, 136, 139, 140, 141, 144, 
+	145, 146, 147, 150, 151, 152, 153, 154, 
+	156, 176, 178, 129, 128, 130, 184, 255, 
+	135, 190, 130, 131, 175, 176, 178, 183, 
+	184, 187, 255, 172, 128, 130, 167, 180, 
+	179, 130, 128, 129, 179, 181, 182, 190, 
+	191, 255, 129, 137, 138, 140, 141, 255, 
+	180, 190, 172, 174, 175, 177, 178, 181, 
+	182, 183, 159, 160, 162, 163, 170, 188, 
+	190, 191, 128, 129, 130, 131, 128, 151, 
+	129, 132, 135, 136, 139, 141, 162, 163, 
+	166, 172, 176, 180, 181, 183, 184, 191, 
+	133, 128, 129, 130, 134, 176, 185, 189, 
+	177, 178, 179, 186, 187, 190, 191, 255, 
+	129, 132, 255, 175, 190, 176, 177, 178, 
+	181, 184, 187, 188, 255, 129, 155, 158, 
+	255, 189, 176, 178, 179, 186, 187, 190, 
+	191, 255, 129, 255, 172, 182, 171, 173, 
+	174, 175, 176, 183, 166, 157, 159, 160, 
+	161, 162, 171, 175, 190, 176, 182, 184, 
+	191, 169, 177, 180, 146, 167, 170, 182, 
+	171, 172, 189, 190, 176, 180, 176, 182, 
+	143, 146, 178, 157, 158, 133, 134, 137, 
+	168, 169, 170, 166, 173, 165, 169, 174, 
+	178, 187, 255, 131, 132, 140, 169, 174, 
+	255, 130, 132, 128, 182, 187, 255, 173, 
+	180, 182, 255, 132, 155, 159, 161, 175, 
+	128, 163, 165, 128, 134, 136, 152, 155, 
+	161, 163, 164, 166, 170, 144, 150, 132, 
+	138, 143, 187, 191, 160, 128, 129, 132, 
+	135, 133, 134, 160, 255, 192, 255, 139, 
+	168, 160, 128, 129, 132, 135, 133, 134, 
+	160, 255, 192, 255, 144, 145, 150, 155, 
+	157, 158, 128, 191, 173, 128, 159, 160, 
+	191, 156, 128, 133, 134, 191, 0, 127, 
+	176, 255, 131, 137, 191, 145, 189, 135, 
+	129, 130, 132, 133, 144, 154, 176, 139, 
+	159, 150, 156, 159, 164, 167, 168, 170, 
+	173, 145, 176, 255, 139, 255, 166, 176, 
+	171, 179, 160, 161, 163, 164, 165, 167, 
+	169, 171, 173, 174, 175, 176, 177, 179, 
+	180, 181, 182, 183, 184, 185, 186, 187, 
+	188, 189, 190, 191, 166, 170, 172, 178, 
+	150, 153, 155, 163, 165, 167, 169, 173, 
+	153, 155, 148, 161, 163, 255, 189, 132, 
+	185, 144, 152, 161, 164, 255, 188, 129, 
+	131, 190, 255, 133, 134, 137, 138, 142, 
+	150, 152, 161, 164, 255, 131, 134, 137, 
+	138, 142, 144, 146, 175, 178, 180, 182, 
+	255, 134, 138, 142, 161, 164, 255, 188, 
+	129, 131, 190, 191, 128, 132, 135, 136, 
+	139, 141, 150, 151, 162, 163, 130, 190, 
+	191, 151, 128, 130, 134, 136, 138, 141, 
+	128, 131, 190, 255, 133, 137, 142, 148, 
+	151, 161, 164, 255, 128, 132, 134, 136, 
+	138, 141, 149, 150, 162, 163, 129, 131, 
+	190, 255, 133, 137, 142, 150, 152, 161, 
+	164, 255, 130, 131, 138, 150, 143, 148, 
+	152, 159, 178, 179, 177, 179, 186, 135, 
+	142, 177, 179, 185, 187, 188, 136, 141, 
+	181, 183, 185, 152, 153, 190, 191, 177, 
+	191, 128, 132, 134, 135, 141, 151, 153, 
+	188, 134, 128, 129, 130, 141, 156, 157, 
+	158, 159, 160, 162, 164, 168, 169, 170, 
+	172, 173, 174, 175, 176, 179, 183, 173, 
+	183, 185, 190, 150, 153, 158, 160, 177, 
+	180, 130, 141, 157, 132, 134, 157, 159, 
+	146, 148, 178, 180, 146, 147, 178, 179, 
+	180, 255, 148, 156, 158, 255, 139, 141, 
+	169, 133, 134, 160, 171, 176, 187, 151, 
+	155, 160, 162, 191, 149, 158, 165, 188, 
+	176, 190, 128, 132, 180, 255, 133, 170, 
+	180, 255, 128, 130, 161, 173, 166, 179, 
+	164, 183, 173, 144, 146, 148, 168, 178, 
+	180, 184, 185, 128, 181, 187, 191, 128, 
+	131, 179, 181, 183, 140, 141, 128, 131, 
+	157, 179, 181, 183, 144, 176, 164, 175, 
+	177, 191, 160, 191, 128, 130, 170, 175, 
+	153, 154, 153, 154, 155, 160, 162, 163, 
+	164, 165, 166, 167, 168, 169, 170, 171, 
+	175, 175, 178, 180, 189, 158, 159, 176, 
+	177, 130, 134, 139, 163, 167, 128, 129, 
+	180, 255, 134, 159, 178, 255, 166, 173, 
+	135, 147, 128, 131, 179, 255, 129, 164, 
+	166, 255, 169, 182, 131, 188, 140, 141, 
+	176, 178, 180, 183, 184, 190, 191, 129, 
+	171, 175, 181, 182, 163, 170, 172, 173, 
+	172, 184, 190, 158, 128, 143, 160, 175, 
+	144, 145, 150, 155, 157, 158, 159, 135, 
+	139, 141, 168, 171, 189, 160, 182, 186, 
+	191, 129, 131, 133, 134, 140, 143, 184, 
+	186, 165, 166, 128, 129, 130, 132, 133, 
+	134, 135, 136, 139, 140, 141, 144, 145, 
+	146, 147, 150, 151, 152, 153, 154, 156, 
+	176, 178, 128, 130, 184, 255, 135, 190, 
+	131, 175, 187, 255, 128, 130, 167, 180, 
+	179, 128, 130, 179, 255, 129, 137, 141, 
+	255, 190, 172, 183, 159, 170, 188, 128, 
+	131, 190, 191, 151, 128, 132, 135, 136, 
+	139, 141, 162, 163, 166, 172, 176, 180, 
+	181, 191, 128, 134, 176, 255, 132, 255, 
+	175, 181, 184, 255, 129, 155, 158, 255, 
+	129, 255, 171, 183, 157, 171, 175, 182, 
+	184, 191, 146, 167, 169, 182, 171, 172, 
+	189, 190, 176, 180, 176, 182, 145, 190, 
+	143, 146, 178, 157, 158, 133, 134, 137, 
+	168, 169, 170, 165, 169, 173, 178, 187, 
+	255, 131, 132, 140, 169, 174, 255, 130, 
+	132, 128, 182, 187, 255, 173, 180, 182, 
+	255, 132, 155, 159, 161, 175, 128, 163, 
+	165, 128, 134, 136, 152, 155, 161, 163, 
+	164, 166, 170, 144, 150, 132, 138, 145, 
+	146, 151, 166, 169, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 166, 167, 169, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	187, 188, 189, 190, 191, 168, 170, 150, 
+	153, 155, 163, 165, 167, 169, 173, 153, 
+	155, 148, 161, 163, 255, 131, 187, 189, 
+	132, 185, 190, 255, 141, 144, 129, 136, 
+	145, 151, 152, 161, 162, 163, 164, 255, 
+	129, 188, 190, 130, 131, 191, 255, 141, 
+	151, 129, 132, 133, 134, 137, 138, 142, 
+	161, 162, 163, 164, 255, 131, 188, 129, 
+	130, 190, 255, 145, 181, 129, 130, 131, 
+	134, 135, 136, 137, 138, 139, 141, 142, 
+	175, 176, 177, 178, 255, 134, 138, 141, 
+	129, 136, 142, 161, 162, 163, 164, 255, 
+	129, 188, 130, 131, 190, 191, 128, 141, 
+	129, 132, 135, 136, 139, 140, 150, 151, 
+	162, 163, 130, 190, 191, 128, 141, 151, 
+	129, 130, 134, 136, 138, 140, 128, 129, 
+	131, 190, 255, 133, 137, 129, 132, 142, 
+	148, 151, 161, 164, 255, 129, 188, 190, 
+	191, 130, 131, 130, 134, 128, 132, 135, 
+	136, 138, 139, 140, 141, 149, 150, 162, 
+	163, 129, 190, 130, 131, 191, 255, 133, 
+	137, 141, 151, 129, 132, 142, 161, 162, 
+	163, 164, 255, 138, 143, 150, 159, 144, 
+	145, 146, 148, 152, 158, 178, 179, 177, 
+	179, 180, 186, 135, 142, 177, 179, 180, 
+	185, 187, 188, 136, 141, 181, 183, 185, 
+	152, 153, 190, 191, 191, 177, 190, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 177, 173, 183, 
+	185, 186, 187, 188, 189, 190, 150, 151, 
+	152, 153, 158, 160, 177, 180, 130, 132, 
+	141, 157, 133, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 182, 180, 
+	189, 190, 255, 134, 157, 137, 147, 148, 
+	255, 139, 141, 169, 133, 134, 178, 160, 
+	162, 163, 166, 167, 168, 169, 171, 176, 
+	184, 185, 187, 155, 151, 152, 153, 154, 
+	150, 160, 162, 191, 149, 151, 152, 158, 
+	165, 172, 173, 178, 179, 188, 176, 190, 
+	132, 181, 187, 128, 131, 180, 188, 189, 
+	255, 130, 133, 170, 171, 179, 180, 255, 
+	130, 161, 170, 128, 129, 162, 165, 166, 
+	167, 168, 173, 167, 173, 166, 169, 170, 
+	174, 175, 177, 178, 179, 164, 171, 172, 
+	179, 180, 181, 182, 183, 161, 173, 180, 
+	144, 146, 148, 168, 178, 179, 184, 185, 
+	128, 181, 187, 191, 128, 131, 179, 181, 
+	183, 140, 141, 144, 176, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 167, 163, 164, 165, 166, 132, 
+	133, 134, 159, 160, 177, 178, 255, 166, 
+	173, 135, 145, 146, 147, 131, 179, 188, 
+	128, 130, 180, 181, 182, 185, 186, 255, 
+	165, 129, 255, 169, 174, 175, 176, 177, 
+	178, 179, 180, 181, 182, 131, 140, 141, 
+	188, 176, 178, 180, 183, 184, 190, 191, 
+	129, 171, 181, 182, 172, 173, 174, 175, 
+	165, 168, 172, 173, 163, 170, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	129, 128, 130, 184, 255, 135, 190, 130, 
+	131, 175, 176, 178, 183, 184, 187, 255, 
+	172, 128, 130, 167, 180, 179, 130, 128, 
+	129, 179, 181, 182, 190, 191, 255, 129, 
+	137, 138, 140, 141, 255, 180, 190, 172, 
+	174, 175, 177, 178, 181, 182, 183, 159, 
+	160, 162, 163, 170, 188, 190, 191, 128, 
+	129, 130, 131, 128, 151, 129, 132, 135, 
+	136, 139, 141, 162, 163, 166, 172, 176, 
+	180, 181, 183, 184, 191, 133, 128, 129, 
+	130, 134, 176, 185, 189, 177, 178, 179, 
+	186, 187, 190, 191, 255, 129, 132, 255, 
+	175, 190, 176, 177, 178, 181, 184, 187, 
+	188, 255, 129, 155, 158, 255, 189, 176, 
+	178, 179, 186, 187, 190, 191, 255, 129, 
+	255, 172, 182, 171, 173, 174, 175, 176, 
+	183, 166, 157, 159, 160, 161, 162, 171, 
+	175, 190, 176, 182, 184, 191, 169, 177, 
+	180, 146, 167, 170, 182, 171, 172, 189, 
+	190, 176, 180, 176, 182, 143, 146, 178, 
+	157, 158, 133, 134, 137, 168, 169, 170, 
+	166, 173, 165, 169, 174, 178, 187, 255, 
+	131, 132, 140, 169, 174, 255, 130, 132, 
+	128, 182, 187, 255, 173, 180, 182, 255, 
+	132, 155, 159, 161, 175, 128, 163, 165, 
+	128, 134, 136, 152, 155, 161, 163, 164, 
+	166, 170, 144, 150, 132, 138, 143, 187, 
+	191, 160, 128, 129, 132, 135, 133, 134, 
+	160, 255, 192, 255, 139, 168, 160, 128, 
+	129, 132, 135, 133, 134, 160, 255, 192, 
+	255, 144, 145, 150, 155, 157, 158, 128, 
+	191, 160, 172, 174, 191, 128, 133, 134, 
+	155, 157, 191, 157, 128, 191, 143, 128, 
+	191, 163, 181, 128, 191, 162, 128, 191, 
+	142, 128, 191, 132, 133, 134, 135, 160, 
+	128, 191, 128, 255, 128, 129, 130, 132, 
+	133, 134, 141, 156, 157, 158, 159, 160, 
+	162, 164, 168, 169, 170, 172, 173, 174, 
+	175, 176, 179, 183, 160, 255, 128, 129, 
+	130, 133, 134, 135, 141, 156, 157, 158, 
+	159, 160, 162, 164, 168, 169, 170, 172, 
+	173, 174, 175, 176, 179, 183, 160, 255, 
+	168, 255, 128, 129, 130, 134, 135, 141, 
+	156, 157, 158, 159, 160, 162, 164, 168, 
+	169, 170, 172, 173, 174, 175, 176, 179, 
+	183, 168, 255, 192, 255, 159, 139, 187, 
+	158, 159, 176, 255, 135, 138, 139, 187, 
+	188, 255, 168, 255, 153, 154, 155, 160, 
+	162, 163, 164, 165, 166, 167, 168, 169, 
+	170, 171, 175, 177, 178, 179, 180, 181, 
+	182, 184, 185, 186, 187, 188, 189, 191, 
+	176, 190, 192, 255, 135, 147, 160, 188, 
+	128, 156, 184, 129, 255, 128, 129, 130, 
+	133, 134, 141, 156, 157, 158, 159, 160, 
+	162, 164, 168, 169, 170, 172, 173, 174, 
+	175, 176, 179, 183, 158, 159, 135, 255, 
+	148, 176, 140, 168, 132, 160, 188, 152, 
+	180, 144, 172, 136, 164, 192, 255, 129, 
+	130, 131, 132, 133, 134, 136, 137, 138, 
+	139, 140, 141, 143, 144, 145, 146, 147, 
+	148, 150, 151, 152, 153, 154, 155, 157, 
+	158, 159, 160, 161, 162, 164, 165, 166, 
+	167, 168, 169, 171, 172, 173, 174, 175, 
+	176, 178, 179, 180, 181, 182, 183, 185, 
+	186, 187, 188, 189, 190, 128, 191, 129, 
+	130, 131, 132, 133, 134, 136, 137, 138, 
+	139, 140, 141, 143, 144, 145, 146, 147, 
+	148, 150, 151, 152, 153, 154, 155, 157, 
+	158, 159, 160, 161, 162, 164, 165, 166, 
+	167, 168, 169, 171, 172, 173, 174, 175, 
+	176, 178, 179, 180, 181, 182, 183, 185, 
+	186, 187, 188, 189, 190, 128, 191, 129, 
+	130, 131, 132, 133, 134, 136, 137, 138, 
+	139, 140, 141, 143, 144, 145, 146, 147, 
+	148, 150, 151, 152, 153, 154, 155, 157, 
+	158, 159, 128, 156, 160, 255, 136, 164, 
+	175, 176, 255, 128, 141, 143, 191, 128, 
+	129, 152, 155, 156, 130, 191, 140, 141, 
+	128, 138, 144, 167, 175, 191, 128, 159, 
+	176, 191, 157, 128, 191, 185, 128, 191, 
+	128, 137, 138, 141, 142, 191, 128, 191, 
+	165, 177, 178, 179, 180, 181, 182, 184, 
+	185, 186, 187, 188, 189, 191, 128, 175, 
+	176, 190, 192, 255, 128, 159, 160, 188, 
+	189, 191, 128, 156, 184, 129, 255, 148, 
+	176, 140, 168, 132, 160, 188, 152, 180, 
+	144, 172, 136, 164, 192, 255, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 128, 156, 160, 255, 136, 164, 175, 
+	176, 255, 135, 138, 139, 187, 188, 191, 
+	192, 255, 187, 191, 128, 190, 128, 190, 
+	188, 128, 175, 190, 191, 145, 155, 157, 
+	159, 128, 191, 130, 135, 128, 191, 189, 
+	128, 191, 128, 129, 130, 131, 132, 191, 
+	178, 128, 191, 128, 159, 164, 191, 133, 
+	128, 191, 128, 178, 187, 191, 135, 142, 
+	143, 145, 146, 149, 150, 153, 154, 155, 
+	164, 128, 191, 128, 165, 166, 191, 144, 
+	145, 150, 155, 157, 158, 159, 135, 166, 
+	191, 133, 128, 191, 128, 130, 131, 132, 
+	133, 137, 138, 139, 140, 191, 174, 188, 
+	128, 129, 130, 131, 132, 133, 134, 144, 
+	145, 165, 166, 169, 170, 175, 176, 184, 
+	185, 191, 128, 132, 170, 129, 135, 136, 
+	191, 181, 186, 128, 191, 144, 128, 148, 
+	149, 150, 151, 191, 128, 132, 133, 135, 
+	136, 138, 139, 143, 144, 191, 163, 128, 
+	179, 180, 182, 183, 191, 128, 129, 191, 
+	166, 176, 191, 128, 151, 152, 158, 159, 
+	178, 179, 185, 186, 187, 188, 190, 128, 
+	191, 160, 128, 191, 128, 129, 135, 132, 
+	134, 128, 175, 157, 128, 191, 143, 128, 
+	191, 163, 181, 128, 191, 162, 128, 191, 
+	142, 128, 191, 132, 133, 134, 135, 160, 
+	128, 191, 0, 127, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 167, 169, 171, 
+	173, 174, 175, 176, 177, 179, 180, 181, 
+	182, 183, 184, 185, 186, 187, 188, 189, 
+	190, 191, 166, 170, 172, 178, 150, 153, 
+	155, 163, 165, 167, 169, 173, 153, 155, 
+	148, 161, 163, 255, 189, 132, 185, 144, 
+	152, 161, 164, 255, 188, 129, 131, 190, 
+	255, 133, 134, 137, 138, 142, 150, 152, 
+	161, 164, 255, 131, 134, 137, 138, 142, 
+	144, 146, 175, 178, 180, 182, 255, 134, 
+	138, 142, 161, 164, 255, 188, 129, 131, 
+	190, 191, 128, 132, 135, 136, 139, 141, 
+	150, 151, 162, 163, 130, 190, 191, 151, 
+	128, 130, 134, 136, 138, 141, 128, 131, 
+	190, 255, 133, 137, 142, 148, 151, 161, 
+	164, 255, 128, 132, 134, 136, 138, 141, 
+	149, 150, 162, 163, 129, 131, 190, 255, 
+	133, 137, 142, 150, 152, 161, 164, 255, 
+	130, 131, 138, 150, 143, 148, 152, 159, 
+	178, 179, 177, 179, 186, 135, 142, 177, 
+	179, 185, 187, 188, 136, 141, 181, 183, 
+	185, 152, 153, 190, 191, 177, 191, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 173, 183, 185, 
+	190, 150, 153, 158, 160, 177, 180, 130, 
+	141, 157, 132, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 180, 255, 
+	148, 156, 158, 255, 139, 141, 169, 133, 
+	134, 160, 171, 176, 187, 151, 155, 160, 
+	162, 191, 149, 158, 165, 188, 176, 190, 
+	128, 132, 180, 255, 133, 170, 180, 255, 
+	128, 130, 161, 173, 166, 179, 164, 183, 
+	173, 144, 146, 148, 168, 178, 180, 184, 
+	185, 128, 181, 187, 191, 128, 131, 179, 
+	181, 183, 140, 141, 128, 131, 157, 179, 
+	181, 183, 144, 176, 164, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 163, 167, 128, 129, 180, 255, 
+	134, 159, 178, 255, 166, 173, 135, 147, 
+	128, 131, 179, 255, 129, 164, 166, 255, 
+	169, 182, 131, 188, 140, 141, 176, 178, 
+	180, 183, 184, 190, 191, 129, 171, 175, 
+	181, 182, 163, 170, 172, 173, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	128, 130, 184, 255, 135, 190, 131, 175, 
+	187, 255, 128, 130, 167, 180, 179, 128, 
+	130, 179, 255, 129, 137, 141, 255, 190, 
+	172, 183, 159, 170, 188, 128, 131, 190, 
+	191, 151, 128, 132, 135, 136, 139, 141, 
+	162, 163, 166, 172, 176, 180, 181, 191, 
+	128, 134, 176, 255, 132, 255, 175, 181, 
+	184, 255, 129, 155, 158, 255, 129, 255, 
+	171, 183, 157, 171, 175, 182, 184, 191, 
+	146, 167, 169, 182, 171, 172, 189, 190, 
+	176, 180, 176, 182, 145, 190, 143, 146, 
+	178, 157, 158, 133, 134, 137, 168, 169, 
+	170, 165, 169, 173, 178, 187, 255, 131, 
+	132, 140, 169, 174, 255, 130, 132, 128, 
+	182, 187, 255, 173, 180, 182, 255, 132, 
+	155, 159, 161, 175, 128, 163, 165, 128, 
+	134, 136, 152, 155, 161, 163, 164, 166, 
+	170, 144, 150, 132, 138, 145, 146, 151, 
+	166, 169, 128, 255, 176, 255, 131, 137, 
+	191, 145, 189, 135, 129, 130, 132, 133, 
+	144, 154, 176, 139, 159, 150, 156, 159, 
+	164, 167, 168, 170, 173, 145, 176, 255, 
+	139, 255, 166, 176, 171, 179, 160, 161, 
+	163, 164, 165, 166, 167, 169, 171, 172, 
+	173, 174, 175, 176, 177, 178, 179, 180, 
+	181, 182, 183, 184, 185, 186, 187, 188, 
+	189, 190, 191, 168, 170, 150, 153, 155, 
+	163, 165, 167, 169, 173, 153, 155, 148, 
+	161, 163, 255, 131, 187, 189, 132, 185, 
+	190, 255, 141, 144, 129, 136, 145, 151, 
+	152, 161, 162, 163, 164, 255, 129, 188, 
+	190, 130, 131, 191, 255, 141, 151, 129, 
+	132, 133, 134, 137, 138, 142, 161, 162, 
+	163, 164, 255, 131, 188, 129, 130, 190, 
+	255, 145, 181, 129, 130, 131, 134, 135, 
+	136, 137, 138, 139, 141, 142, 175, 176, 
+	177, 178, 255, 134, 138, 141, 129, 136, 
+	142, 161, 162, 163, 164, 255, 129, 188, 
+	130, 131, 190, 191, 128, 141, 129, 132, 
+	135, 136, 139, 140, 150, 151, 162, 163, 
+	130, 190, 191, 128, 141, 151, 129, 130, 
+	134, 136, 138, 140, 128, 129, 131, 190, 
+	255, 133, 137, 129, 132, 142, 148, 151, 
+	161, 164, 255, 129, 188, 190, 191, 130, 
+	131, 130, 134, 128, 132, 135, 136, 138, 
+	139, 140, 141, 149, 150, 162, 163, 129, 
+	190, 130, 131, 191, 255, 133, 137, 141, 
+	151, 129, 132, 142, 161, 162, 163, 164, 
+	255, 138, 143, 150, 159, 144, 145, 146, 
+	148, 152, 158, 178, 179, 177, 179, 180, 
+	186, 135, 142, 177, 179, 180, 185, 187, 
+	188, 136, 141, 181, 183, 185, 152, 153, 
+	190, 191, 191, 177, 190, 128, 132, 134, 
+	135, 141, 151, 153, 188, 134, 128, 129, 
+	130, 141, 156, 157, 158, 159, 160, 162, 
+	164, 168, 169, 170, 172, 173, 174, 175, 
+	176, 179, 183, 177, 173, 183, 185, 186, 
+	187, 188, 189, 190, 150, 151, 152, 153, 
+	158, 160, 177, 180, 130, 132, 141, 157, 
+	133, 134, 157, 159, 146, 148, 178, 180, 
+	146, 147, 178, 179, 182, 180, 189, 190, 
+	255, 134, 157, 137, 147, 148, 255, 139, 
+	141, 169, 133, 134, 178, 160, 162, 163, 
+	166, 167, 168, 169, 171, 176, 184, 185, 
+	187, 155, 151, 152, 153, 154, 150, 160, 
+	162, 191, 149, 151, 152, 158, 165, 172, 
+	173, 178, 179, 188, 176, 190, 132, 181, 
+	187, 128, 131, 180, 188, 189, 255, 130, 
+	133, 170, 171, 179, 180, 255, 130, 161, 
+	170, 128, 129, 162, 165, 166, 167, 168, 
+	173, 167, 173, 166, 169, 170, 174, 175, 
+	177, 178, 179, 164, 171, 172, 179, 180, 
+	181, 182, 183, 161, 173, 180, 144, 146, 
+	148, 168, 178, 179, 184, 185, 128, 181, 
+	187, 191, 128, 131, 179, 181, 183, 140, 
+	141, 144, 176, 175, 177, 191, 160, 191, 
+	128, 130, 170, 175, 153, 154, 153, 154, 
+	155, 160, 162, 163, 164, 165, 166, 167, 
+	168, 169, 170, 171, 175, 175, 178, 180, 
+	189, 158, 159, 176, 177, 130, 134, 139, 
+	167, 163, 164, 165, 166, 132, 133, 134, 
+	159, 160, 177, 178, 255, 166, 173, 135, 
+	145, 146, 147, 131, 179, 188, 128, 130, 
+	180, 181, 182, 185, 186, 255, 165, 129, 
+	255, 169, 174, 175, 176, 177, 178, 179, 
+	180, 181, 182, 131, 140, 141, 188, 176, 
+	178, 180, 183, 184, 190, 191, 129, 171, 
+	181, 182, 172, 173, 174, 175, 165, 168, 
+	172, 173, 163, 170, 172, 184, 190, 158, 
+	128, 143, 160, 175, 144, 145, 150, 155, 
+	157, 158, 159, 135, 139, 141, 168, 171, 
+	189, 160, 182, 186, 191, 129, 131, 133, 
+	134, 140, 143, 184, 186, 165, 166, 128, 
+	129, 130, 132, 133, 134, 135, 136, 139, 
+	140, 141, 144, 145, 146, 147, 150, 151, 
+	152, 153, 154, 156, 176, 178, 129, 128, 
+	130, 184, 255, 135, 190, 130, 131, 175, 
+	176, 178, 183, 184, 187, 255, 172, 128, 
+	130, 167, 180, 179, 130, 128, 129, 179, 
+	181, 182, 190, 191, 255, 129, 137, 138, 
+	140, 141, 255, 180, 190, 172, 174, 175, 
+	177, 178, 181, 182, 183, 159, 160, 162, 
+	163, 170, 188, 190, 191, 128, 129, 130, 
+	131, 128, 151, 129, 132, 135, 136, 139, 
+	141, 162, 163, 166, 172, 176, 180, 181, 
+	183, 184, 191, 133, 128, 129, 130, 134, 
+	176, 185, 189, 177, 178, 179, 186, 187, 
+	190, 191, 255, 129, 132, 255, 175, 190, 
+	176, 177, 178, 181, 184, 187, 188, 255, 
+	129, 155, 158, 255, 189, 176, 178, 179, 
+	186, 187, 190, 191, 255, 129, 255, 172, 
+	182, 171, 173, 174, 175, 176, 183, 166, 
+	157, 159, 160, 161, 162, 171, 175, 190, 
+	176, 182, 184, 191, 169, 177, 180, 146, 
+	167, 170, 182, 171, 172, 189, 190, 176, 
+	180, 176, 182, 143, 146, 178, 157, 158, 
+	133, 134, 137, 168, 169, 170, 166, 173, 
+	165, 169, 174, 178, 187, 255, 131, 132, 
+	140, 169, 174, 255, 130, 132, 128, 182, 
+	187, 255, 173, 180, 182, 255, 132, 155, 
+	159, 161, 175, 128, 163, 165, 128, 134, 
+	136, 152, 155, 161, 163, 164, 166, 170, 
+	144, 150, 132, 138, 143, 187, 191, 160, 
+	128, 129, 132, 135, 133, 134, 160, 255, 
+	192, 255, 139, 168, 160, 128, 129, 132, 
+	135, 133, 134, 160, 255, 192, 255, 144, 
+	145, 150, 155, 157, 158, 128, 129, 130, 
+	132, 133, 134, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 160, 255, 128, 
+	129, 130, 133, 134, 135, 141, 156, 157, 
+	158, 159, 160, 162, 164, 168, 169, 170, 
+	172, 173, 174, 175, 176, 179, 183, 160, 
+	255, 168, 255, 128, 129, 130, 134, 135, 
+	141, 156, 157, 158, 159, 160, 162, 164, 
+	168, 169, 170, 172, 173, 174, 175, 176, 
+	179, 183, 168, 255, 192, 255, 159, 139, 
+	187, 158, 159, 176, 255, 135, 138, 139, 
+	187, 188, 255, 168, 255, 153, 154, 155, 
+	160, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 175, 177, 178, 179, 180, 
+	181, 182, 184, 185, 186, 187, 188, 189, 
+	191, 176, 190, 192, 255, 135, 147, 160, 
+	188, 128, 156, 184, 129, 255, 128, 129, 
+	130, 133, 134, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 158, 159, 135, 
+	255, 148, 176, 140, 168, 132, 160, 188, 
+	152, 180, 144, 172, 136, 164, 192, 255, 
+	129, 130, 131, 132, 133, 134, 136, 137, 
+	138, 139, 140, 141, 143, 144, 145, 146, 
+	147, 148, 150, 151, 152, 153, 154, 155, 
+	157, 158, 159, 160, 161, 162, 164, 165, 
+	166, 167, 168, 169, 171, 172, 173, 174, 
+	175, 176, 178, 179, 180, 181, 182, 183, 
+	185, 186, 187, 188, 189, 190, 128, 191, 
+	129, 130, 131, 132, 133, 134, 136, 137, 
+	138, 139, 140, 141, 143, 144, 145, 146, 
+	147, 148, 150, 151, 152, 153, 154, 155, 
+	157, 158, 159, 160, 161, 162, 164, 165, 
+	166, 167, 168, 169, 171, 172, 173, 174, 
+	175, 176, 178, 179, 180, 181, 182, 183, 
+	185, 186, 187, 188, 189, 190, 128, 191, 
+	129, 130, 131, 132, 133, 134, 136, 137, 
+	138, 139, 140, 141, 143, 144, 145, 146, 
+	147, 148, 150, 151, 152, 153, 154, 155, 
+	157, 158, 159, 128, 156, 160, 255, 136, 
+	164, 175, 176, 255, 142, 128, 191, 128, 
+	129, 152, 155, 156, 130, 191, 139, 141, 
+	128, 140, 142, 143, 144, 167, 168, 174, 
+	175, 191, 128, 255, 176, 255, 131, 137, 
+	191, 145, 189, 135, 129, 130, 132, 133, 
+	144, 154, 176, 139, 159, 150, 156, 159, 
+	164, 167, 168, 170, 173, 145, 176, 255, 
+	139, 255, 166, 176, 171, 179, 160, 161, 
+	163, 164, 165, 167, 169, 171, 173, 174, 
+	175, 176, 177, 179, 180, 181, 182, 183, 
+	184, 185, 186, 187, 188, 189, 190, 191, 
+	166, 170, 172, 178, 150, 153, 155, 163, 
+	165, 167, 169, 173, 153, 155, 148, 161, 
+	163, 255, 189, 132, 185, 144, 152, 161, 
+	164, 255, 188, 129, 131, 190, 255, 133, 
+	134, 137, 138, 142, 150, 152, 161, 164, 
+	255, 131, 134, 137, 138, 142, 144, 146, 
+	175, 178, 180, 182, 255, 134, 138, 142, 
+	161, 164, 255, 188, 129, 131, 190, 191, 
+	128, 132, 135, 136, 139, 141, 150, 151, 
+	162, 163, 130, 190, 191, 151, 128, 130, 
+	134, 136, 138, 141, 128, 131, 190, 255, 
+	133, 137, 142, 148, 151, 161, 164, 255, 
+	128, 132, 134, 136, 138, 141, 149, 150, 
+	162, 163, 129, 131, 190, 255, 133, 137, 
+	142, 150, 152, 161, 164, 255, 130, 131, 
+	138, 150, 143, 148, 152, 159, 178, 179, 
+	177, 179, 186, 135, 142, 177, 179, 185, 
+	187, 188, 136, 141, 181, 183, 185, 152, 
+	153, 190, 191, 177, 191, 128, 132, 134, 
+	135, 141, 151, 153, 188, 134, 128, 129, 
+	130, 141, 156, 157, 158, 159, 160, 162, 
+	164, 168, 169, 170, 172, 173, 174, 175, 
+	176, 179, 183, 173, 183, 185, 190, 150, 
+	153, 158, 160, 177, 180, 130, 141, 157, 
+	132, 134, 157, 159, 146, 148, 178, 180, 
+	146, 147, 178, 179, 180, 255, 148, 156, 
+	158, 255, 139, 141, 169, 133, 134, 160, 
+	171, 176, 187, 151, 155, 160, 162, 191, 
+	149, 158, 165, 188, 176, 190, 128, 132, 
+	180, 255, 133, 170, 180, 255, 128, 130, 
+	161, 173, 166, 179, 164, 183, 173, 144, 
+	146, 148, 168, 178, 180, 184, 185, 128, 
+	181, 187, 191, 128, 131, 179, 181, 183, 
+	140, 141, 144, 176, 175, 177, 191, 160, 
+	191, 128, 130, 170, 175, 153, 154, 153, 
+	154, 155, 160, 162, 163, 164, 165, 166, 
+	167, 168, 169, 170, 171, 175, 175, 178, 
+	180, 189, 158, 159, 176, 177, 130, 134, 
+	139, 163, 167, 128, 129, 180, 255, 134, 
+	159, 178, 255, 166, 173, 135, 147, 128, 
+	131, 179, 255, 129, 164, 166, 255, 169, 
+	182, 131, 188, 140, 141, 176, 178, 180, 
+	183, 184, 190, 191, 129, 171, 175, 181, 
+	182, 163, 170, 172, 173, 172, 184, 190, 
+	158, 128, 143, 160, 175, 144, 145, 150, 
+	155, 157, 158, 135, 139, 141, 168, 171, 
+	189, 160, 182, 186, 191, 129, 131, 133, 
+	134, 140, 143, 184, 186, 165, 166, 128, 
+	129, 130, 132, 133, 134, 135, 136, 139, 
+	140, 141, 144, 145, 146, 147, 150, 151, 
+	152, 153, 154, 156, 176, 178, 128, 130, 
+	184, 255, 135, 190, 131, 175, 187, 255, 
+	128, 130, 167, 180, 179, 128, 130, 179, 
+	255, 129, 137, 141, 255, 190, 172, 183, 
+	159, 170, 188, 128, 131, 190, 191, 151, 
+	128, 132, 135, 136, 139, 141, 162, 163, 
+	166, 172, 176, 180, 181, 191, 128, 134, 
+	176, 255, 132, 255, 175, 181, 184, 255, 
+	129, 155, 158, 255, 129, 255, 171, 183, 
+	157, 171, 175, 182, 184, 191, 146, 167, 
+	169, 182, 171, 172, 189, 190, 176, 180, 
+	176, 182, 145, 190, 143, 146, 178, 157, 
+	158, 133, 134, 137, 168, 169, 170, 165, 
+	169, 173, 178, 187, 255, 131, 132, 140, 
+	169, 174, 255, 130, 132, 128, 182, 187, 
+	255, 173, 180, 182, 255, 132, 155, 159, 
+	161, 175, 128, 163, 165, 128, 134, 136, 
+	152, 155, 161, 163, 164, 166, 170, 144, 
+	150, 132, 138, 160, 128, 129, 132, 135, 
+	133, 134, 160, 255, 192, 255, 128, 131, 
+	157, 179, 181, 183, 164, 144, 145, 150, 
+	155, 157, 158, 159, 145, 146, 151, 166, 
+	169, 128, 255, 176, 255, 131, 137, 191, 
+	145, 189, 135, 129, 130, 132, 133, 144, 
+	154, 176, 139, 159, 150, 156, 159, 164, 
+	167, 168, 170, 173, 145, 176, 255, 139, 
+	255, 166, 176, 171, 179, 160, 161, 163, 
+	164, 165, 166, 167, 169, 171, 172, 173, 
+	174, 175, 176, 177, 178, 179, 180, 181, 
+	182, 183, 184, 185, 186, 187, 188, 189, 
+	190, 191, 168, 170, 150, 153, 155, 163, 
+	165, 167, 169, 173, 153, 155, 148, 161, 
+	163, 255, 131, 187, 189, 132, 185, 190, 
+	255, 141, 144, 129, 136, 145, 151, 152, 
+	161, 162, 163, 164, 255, 129, 188, 190, 
+	130, 131, 191, 255, 141, 151, 129, 132, 
+	133, 134, 137, 138, 142, 161, 162, 163, 
+	164, 255, 131, 188, 129, 130, 190, 255, 
+	145, 181, 129, 130, 131, 134, 135, 136, 
+	137, 138, 139, 141, 142, 175, 176, 177, 
+	178, 255, 134, 138, 141, 129, 136, 142, 
+	161, 162, 163, 164, 255, 129, 188, 130, 
+	131, 190, 191, 128, 141, 129, 132, 135, 
+	136, 139, 140, 150, 151, 162, 163, 130, 
+	190, 191, 128, 141, 151, 129, 130, 134, 
+	136, 138, 140, 128, 129, 131, 190, 255, 
+	133, 137, 129, 132, 142, 148, 151, 161, 
+	164, 255, 129, 188, 190, 191, 130, 131, 
+	130, 134, 128, 132, 135, 136, 138, 139, 
+	140, 141, 149, 150, 162, 163, 129, 190, 
+	130, 131, 191, 255, 133, 137, 141, 151, 
+	129, 132, 142, 161, 162, 163, 164, 255, 
+	138, 143, 150, 159, 144, 145, 146, 148, 
+	152, 158, 178, 179, 177, 179, 180, 186, 
+	135, 142, 177, 179, 180, 185, 187, 188, 
+	136, 141, 181, 183, 185, 152, 153, 190, 
+	191, 191, 177, 190, 128, 132, 134, 135, 
+	141, 151, 153, 188, 134, 128, 129, 130, 
+	141, 156, 157, 158, 159, 160, 162, 164, 
+	168, 169, 170, 172, 173, 174, 175, 176, 
+	179, 183, 177, 173, 183, 185, 186, 187, 
+	188, 189, 190, 150, 151, 152, 153, 158, 
+	160, 177, 180, 130, 132, 141, 157, 133, 
+	134, 157, 159, 146, 148, 178, 180, 146, 
+	147, 178, 179, 182, 180, 189, 190, 255, 
+	134, 157, 137, 147, 148, 255, 139, 141, 
+	169, 133, 134, 178, 160, 162, 163, 166, 
+	167, 168, 169, 171, 176, 184, 185, 187, 
+	155, 151, 152, 153, 154, 150, 160, 162, 
+	191, 149, 151, 152, 158, 165, 172, 173, 
+	178, 179, 188, 176, 190, 132, 181, 187, 
+	128, 131, 180, 188, 189, 255, 130, 133, 
+	170, 171, 179, 180, 255, 130, 161, 170, 
+	128, 129, 162, 165, 166, 167, 168, 173, 
+	167, 173, 166, 169, 170, 174, 175, 177, 
+	178, 179, 164, 171, 172, 179, 180, 181, 
+	182, 183, 161, 173, 180, 144, 146, 148, 
+	168, 178, 179, 184, 185, 128, 181, 187, 
+	191, 128, 131, 179, 181, 183, 140, 141, 
+	144, 176, 175, 177, 191, 160, 191, 128, 
+	130, 170, 175, 153, 154, 153, 154, 155, 
+	160, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 175, 175, 178, 180, 189, 
+	158, 159, 176, 177, 130, 134, 139, 167, 
+	163, 164, 165, 166, 132, 133, 134, 159, 
+	160, 177, 178, 255, 166, 173, 135, 145, 
+	146, 147, 131, 179, 188, 128, 130, 180, 
+	181, 182, 185, 186, 255, 165, 129, 255, 
+	169, 174, 175, 176, 177, 178, 179, 180, 
+	181, 182, 131, 140, 141, 188, 176, 178, 
+	180, 183, 184, 190, 191, 129, 171, 181, 
+	182, 172, 173, 174, 175, 165, 168, 172, 
+	173, 163, 170, 172, 184, 190, 158, 128, 
+	143, 160, 175, 144, 145, 150, 155, 157, 
+	158, 159, 135, 139, 141, 168, 171, 189, 
+	160, 182, 186, 191, 129, 131, 133, 134, 
+	140, 143, 184, 186, 165, 166, 128, 129, 
+	130, 132, 133, 134, 135, 136, 139, 140, 
+	141, 144, 145, 146, 147, 150, 151, 152, 
+	153, 154, 156, 176, 178, 129, 128, 130, 
+	184, 255, 135, 190, 130, 131, 175, 176, 
+	178, 183, 184, 187, 255, 172, 128, 130, 
+	167, 180, 179, 130, 128, 129, 179, 181, 
+	182, 190, 191, 255, 129, 137, 138, 140, 
+	141, 255, 180, 190, 172, 174, 175, 177, 
+	178, 181, 182, 183, 159, 160, 162, 163, 
+	170, 188, 190, 191, 128, 129, 130, 131, 
+	128, 151, 129, 132, 135, 136, 139, 141, 
+	162, 163, 166, 172, 176, 180, 181, 183, 
+	184, 191, 133, 128, 129, 130, 134, 176, 
+	185, 189, 177, 178, 179, 186, 187, 190, 
+	191, 255, 129, 132, 255, 175, 190, 176, 
+	177, 178, 181, 184, 187, 188, 255, 129, 
+	155, 158, 255, 189, 176, 178, 179, 186, 
+	187, 190, 191, 255, 129, 255, 172, 182, 
+	171, 173, 174, 175, 176, 183, 166, 157, 
+	159, 160, 161, 162, 171, 175, 190, 176, 
+	182, 184, 191, 169, 177, 180, 146, 167, 
+	170, 182, 171, 172, 189, 190, 176, 180, 
+	176, 182, 143, 146, 178, 157, 158, 133, 
+	134, 137, 168, 169, 170, 166, 173, 165, 
+	169, 174, 178, 187, 255, 131, 132, 140, 
+	169, 174, 255, 130, 132, 128, 182, 187, 
+	255, 173, 180, 182, 255, 132, 155, 159, 
+	161, 175, 128, 163, 165, 128, 134, 136, 
+	152, 155, 161, 163, 164, 166, 170, 144, 
+	150, 132, 138, 143, 187, 191, 160, 128, 
+	129, 132, 135, 133, 134, 160, 255, 192, 
+	255, 139, 168, 128, 159, 160, 175, 176, 
+	191, 157, 128, 191, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 166, 167, 169, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	187, 188, 189, 190, 191, 168, 170, 150, 
+	153, 155, 163, 165, 167, 169, 173, 153, 
+	155, 148, 161, 163, 255, 131, 187, 189, 
+	132, 185, 190, 255, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 167, 169, 171, 
+	173, 174, 175, 176, 177, 179, 180, 181, 
+	182, 183, 184, 185, 186, 187, 188, 189, 
+	190, 191, 166, 170, 172, 178, 150, 153, 
+	155, 163, 165, 167, 169, 173, 153, 155, 
+	148, 161, 163, 255, 189, 132, 185, 144, 
+	152, 161, 164, 255, 188, 129, 131, 190, 
+	255, 133, 134, 137, 138, 142, 150, 152, 
+	161, 164, 255, 131, 134, 137, 138, 142, 
+	144, 146, 175, 178, 180, 182, 255, 134, 
+	138, 142, 161, 164, 255, 188, 129, 131, 
+	190, 191, 128, 132, 135, 136, 139, 141, 
+	150, 151, 162, 163, 130, 190, 191, 151, 
+	128, 130, 134, 136, 138, 141, 128, 131, 
+	190, 255, 133, 137, 142, 148, 151, 161, 
+	164, 255, 128, 132, 134, 136, 138, 141, 
+	149, 150, 162, 163, 129, 131, 190, 255, 
+	133, 137, 142, 150, 152, 161, 164, 255, 
+	130, 131, 138, 150, 143, 148, 152, 159, 
+	178, 179, 177, 179, 186, 135, 142, 177, 
+	179, 185, 187, 188, 136, 141, 181, 183, 
+	185, 152, 153, 190, 191, 177, 191, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 173, 183, 185, 
+	190, 150, 153, 158, 160, 177, 180, 130, 
+	141, 157, 132, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 180, 255, 
+	148, 156, 158, 255, 139, 141, 169, 133, 
+	134, 160, 171, 176, 187, 151, 155, 160, 
+	162, 191, 149, 158, 165, 188, 176, 190, 
+	128, 132, 180, 255, 133, 170, 180, 255, 
+	128, 130, 161, 173, 166, 179, 164, 183, 
+	173, 144, 146, 148, 168, 178, 180, 184, 
+	185, 128, 181, 187, 191, 128, 131, 179, 
+	181, 183, 140, 141, 128, 131, 157, 179, 
+	181, 183, 144, 176, 164, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 163, 167, 128, 129, 180, 255, 
+	134, 159, 178, 255, 166, 173, 135, 147, 
+	128, 131, 179, 255, 129, 164, 166, 255, 
+	169, 182, 131, 188, 140, 141, 176, 178, 
+	180, 183, 184, 190, 191, 129, 171, 175, 
+	181, 182, 163, 170, 172, 173, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	128, 130, 184, 255, 135, 190, 131, 175, 
+	187, 255, 128, 130, 167, 180, 179, 128, 
+	130, 179, 255, 129, 137, 141, 255, 190, 
+	172, 183, 159, 170, 188, 128, 131, 190, 
+	191, 151, 128, 132, 135, 136, 139, 141, 
+	162, 163, 166, 172, 176, 180, 181, 191, 
+	128, 134, 176, 255, 132, 255, 175, 181, 
+	184, 255, 129, 155, 158, 255, 129, 255, 
+	171, 183, 157, 171, 175, 182, 184, 191, 
+	146, 167, 169, 182, 171, 172, 189, 190, 
+	176, 180, 176, 182, 145, 190, 143, 146, 
+	178, 157, 158, 133, 134, 137, 168, 169, 
+	170, 165, 169, 173, 178, 187, 255, 131, 
+	132, 140, 169, 174, 255, 130, 132, 128, 
+	182, 187, 255, 173, 180, 182, 255, 132, 
+	155, 159, 161, 175, 128, 163, 165, 128, 
+	134, 136, 152, 155, 161, 163, 164, 166, 
+	170, 144, 150, 132, 138, 145, 146, 151, 
+	166, 169, 139, 168, 160, 128, 129, 132, 
+	135, 133, 134, 160, 255, 192, 255, 144, 
+	145, 150, 155, 157, 158, 141, 144, 129, 
+	136, 145, 151, 152, 161, 162, 163, 164, 
+	255, 129, 188, 190, 130, 131, 191, 255, 
+	141, 151, 129, 132, 133, 134, 137, 138, 
+	142, 161, 162, 163, 164, 255, 131, 188, 
+	129, 130, 190, 255, 145, 181, 129, 130, 
+	131, 134, 135, 136, 137, 138, 139, 141, 
+	142, 175, 176, 177, 178, 255, 134, 138, 
+	141, 129, 136, 142, 161, 162, 163, 164, 
+	255, 129, 188, 130, 131, 190, 191, 128, 
+	141, 129, 132, 135, 136, 139, 140, 150, 
+	151, 162, 163, 130, 190, 191, 128, 141, 
+	151, 129, 130, 134, 136, 138, 140, 128, 
+	129, 131, 190, 255, 133, 137, 129, 132, 
+	142, 148, 151, 161, 164, 255, 129, 188, 
+	190, 191, 130, 131, 130, 134, 128, 132, 
+	135, 136, 138, 139, 140, 141, 149, 150, 
+	162, 163, 129, 190, 130, 131, 191, 255, 
+	133, 137, 141, 151, 129, 132, 142, 161, 
+	162, 163, 164, 255, 138, 143, 150, 159, 
+	144, 145, 146, 148, 152, 158, 178, 179, 
+	177, 179, 180, 186, 135, 142, 177, 179, 
+	180, 185, 187, 188, 136, 141, 181, 183, 
+	185, 152, 153, 190, 191, 191, 177, 190, 
+	128, 132, 134, 135, 141, 151, 153, 188, 
+	134, 128, 129, 130, 141, 156, 157, 158, 
+	159, 160, 162, 164, 168, 169, 170, 172, 
+	173, 174, 175, 176, 179, 183, 177, 173, 
+	183, 185, 186, 187, 188, 189, 190, 150, 
+	151, 152, 153, 158, 160, 177, 180, 130, 
+	132, 141, 157, 133, 134, 157, 159, 146, 
+	148, 178, 180, 146, 147, 178, 179, 182, 
+	180, 189, 190, 255, 134, 157, 137, 147, 
+	148, 255, 139, 141, 169, 133, 134, 178, 
+	160, 162, 163, 166, 167, 168, 169, 171, 
+	176, 184, 185, 187, 155, 151, 152, 153, 
+	154, 150, 160, 162, 191, 149, 151, 152, 
+	158, 165, 172, 173, 178, 179, 188, 176, 
+	190, 132, 181, 187, 128, 131, 180, 188, 
+	189, 255, 130, 133, 170, 171, 179, 180, 
+	255, 130, 161, 170, 128, 129, 162, 165, 
+	166, 167, 168, 173, 167, 173, 166, 169, 
+	170, 174, 175, 177, 178, 179, 164, 171, 
+	172, 179, 180, 181, 182, 183, 161, 173, 
+	180, 144, 146, 148, 168, 178, 179, 184, 
+	185, 128, 181, 187, 191, 128, 131, 179, 
+	181, 183, 140, 141, 144, 176, 175, 177, 
+	191, 160, 191, 128, 130, 170, 175, 153, 
+	154, 153, 154, 155, 160, 162, 163, 164, 
+	165, 166, 167, 168, 169, 170, 171, 175, 
+	175, 178, 180, 189, 158, 159, 176, 177, 
+	130, 134, 139, 167, 163, 164, 165, 166, 
+	132, 133, 134, 159, 160, 177, 178, 255, 
+	166, 173, 135, 145, 146, 147, 131, 179, 
+	188, 128, 130, 180, 181, 182, 185, 186, 
+	255, 165, 129, 255, 169, 174, 175, 176, 
+	177, 178, 179, 180, 181, 182, 131, 140, 
+	141, 188, 176, 178, 180, 183, 184, 190, 
+	191, 129, 171, 181, 182, 172, 173, 174, 
+	175, 165, 168, 172, 173, 163, 170, 172, 
+	184, 190, 158, 128, 143, 160, 175, 144, 
+	145, 150, 155, 157, 158, 159, 135, 139, 
+	141, 168, 171, 189, 160, 182, 186, 191, 
+	129, 131, 133, 134, 140, 143, 184, 186, 
+	165, 166, 128, 129, 130, 132, 133, 134, 
+	135, 136, 139, 140, 141, 144, 145, 146, 
+	147, 150, 151, 152, 153, 154, 156, 176, 
+	178, 129, 128, 130, 184, 255, 135, 190, 
+	130, 131, 175, 176, 178, 183, 184, 187, 
+	255, 172, 128, 130, 167, 180, 179, 130, 
+	128, 129, 179, 181, 182, 190, 191, 255, 
+	129, 137, 138, 140, 141, 255, 180, 190, 
+	172, 174, 175, 177, 178, 181, 182, 183, 
+	159, 160, 162, 163, 170, 188, 190, 191, 
+	128, 129, 130, 131, 128, 151, 129, 132, 
+	135, 136, 139, 141, 162, 163, 166, 172, 
+	176, 180, 181, 183, 184, 191, 133, 128, 
+	129, 130, 134, 176, 185, 189, 177, 178, 
+	179, 186, 187, 190, 191, 255, 129, 132, 
+	255, 175, 190, 176, 177, 178, 181, 184, 
+	187, 188, 255, 129, 155, 158, 255, 189, 
+	176, 178, 179, 186, 187, 190, 191, 255, 
+	129, 255, 172, 182, 171, 173, 174, 175, 
+	176, 183, 166, 157, 159, 160, 161, 162, 
+	171, 175, 190, 176, 182, 184, 191, 169, 
+	177, 180, 146, 167, 170, 182, 171, 172, 
+	189, 190, 176, 180, 176, 182, 143, 146, 
+	178, 157, 158, 133, 134, 137, 168, 169, 
+	170, 166, 173, 165, 169, 174, 178, 187, 
+	255, 131, 132, 140, 169, 174, 255, 130, 
+	132, 128, 182, 187, 255, 173, 180, 182, 
+	255, 132, 155, 159, 161, 175, 128, 163, 
+	165, 128, 134, 136, 152, 155, 161, 163, 
+	164, 166, 170, 144, 150, 132, 138, 143, 
+	187, 191, 160, 128, 129, 132, 135, 133, 
+	134, 160, 255, 192, 255, 185, 128, 191, 
+	128, 137, 138, 141, 142, 191, 128, 191, 
+	165, 177, 178, 179, 180, 181, 182, 184, 
+	185, 186, 187, 188, 189, 191, 128, 175, 
+	176, 190, 192, 255, 128, 159, 160, 188, 
+	189, 191, 128, 156, 184, 129, 255, 148, 
+	176, 140, 168, 132, 160, 188, 152, 180, 
+	144, 172, 136, 164, 192, 255, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 191, 128, 156, 161, 190, 192, 
+	255, 136, 164, 175, 176, 255, 135, 138, 
+	139, 187, 188, 191, 192, 255, 0, 127, 
+	192, 255, 187, 191, 128, 190, 191, 128, 
+	190, 188, 128, 175, 176, 189, 190, 191, 
+	145, 155, 157, 159, 128, 191, 130, 135, 
+	128, 191, 189, 128, 191, 128, 129, 130, 
+	131, 132, 191, 178, 128, 191, 128, 159, 
+	160, 163, 164, 191, 133, 128, 191, 128, 
+	178, 179, 186, 187, 191, 135, 142, 143, 
+	145, 146, 149, 150, 153, 154, 155, 164, 
+	128, 191, 128, 165, 166, 191, 128, 255, 
+	176, 255, 131, 137, 191, 145, 189, 135, 
+	129, 130, 132, 133, 144, 154, 176, 139, 
+	159, 150, 156, 159, 164, 167, 168, 170, 
+	173, 145, 176, 255, 139, 255, 166, 176, 
+	171, 179, 160, 161, 163, 164, 165, 167, 
+	169, 171, 173, 174, 175, 176, 177, 179, 
+	180, 181, 182, 183, 184, 185, 186, 187, 
+	188, 189, 190, 191, 166, 170, 172, 178, 
+	150, 153, 155, 163, 165, 167, 169, 173, 
+	153, 155, 148, 161, 163, 255, 189, 132, 
+	185, 144, 152, 161, 164, 255, 188, 129, 
+	131, 190, 255, 133, 134, 137, 138, 142, 
+	150, 152, 161, 164, 255, 131, 134, 137, 
+	138, 142, 144, 146, 175, 178, 180, 182, 
+	255, 134, 138, 142, 161, 164, 255, 188, 
+	129, 131, 190, 191, 128, 132, 135, 136, 
+	139, 141, 150, 151, 162, 163, 130, 190, 
+	191, 151, 128, 130, 134, 136, 138, 141, 
+	128, 131, 190, 255, 133, 137, 142, 148, 
+	151, 161, 164, 255, 128, 132, 134, 136, 
+	138, 141, 149, 150, 162, 163, 129, 131, 
+	190, 255, 133, 137, 142, 150, 152, 161, 
+	164, 255, 130, 131, 138, 150, 143, 148, 
+	152, 159, 178, 179, 177, 179, 186, 135, 
+	142, 177, 179, 185, 187, 188, 136, 141, 
+	181, 183, 185, 152, 153, 190, 191, 177, 
+	191, 128, 132, 134, 135, 141, 151, 153, 
+	188, 134, 128, 129, 130, 141, 156, 157, 
+	158, 159, 160, 162, 164, 168, 169, 170, 
+	172, 173, 174, 175, 176, 179, 183, 173, 
+	183, 185, 190, 150, 153, 158, 160, 177, 
+	180, 130, 141, 157, 132, 134, 157, 159, 
+	146, 148, 178, 180, 146, 147, 178, 179, 
+	180, 255, 148, 156, 158, 255, 139, 141, 
+	169, 133, 134, 160, 171, 176, 187, 151, 
+	155, 160, 162, 191, 149, 158, 165, 188, 
+	176, 190, 128, 132, 180, 255, 133, 170, 
+	180, 255, 128, 130, 161, 173, 166, 179, 
+	164, 183, 173, 144, 146, 148, 168, 178, 
+	180, 184, 185, 128, 181, 187, 191, 128, 
+	131, 179, 181, 183, 140, 141, 128, 131, 
+	157, 179, 181, 183, 144, 176, 164, 175, 
+	177, 191, 160, 191, 128, 130, 170, 175, 
+	153, 154, 153, 154, 155, 160, 162, 163, 
+	164, 165, 166, 167, 168, 169, 170, 171, 
+	175, 175, 178, 180, 189, 158, 159, 176, 
+	177, 130, 134, 139, 163, 167, 128, 129, 
+	180, 255, 134, 159, 178, 255, 166, 173, 
+	135, 147, 128, 131, 179, 255, 129, 164, 
+	166, 255, 169, 182, 131, 188, 140, 141, 
+	176, 178, 180, 183, 184, 190, 191, 129, 
+	171, 175, 181, 182, 163, 170, 172, 173, 
+	172, 184, 190, 158, 128, 143, 160, 175, 
+	144, 145, 150, 155, 157, 158, 159, 135, 
+	139, 141, 168, 171, 189, 160, 182, 186, 
+	191, 129, 131, 133, 134, 140, 143, 184, 
+	186, 165, 166, 128, 129, 130, 132, 133, 
+	134, 135, 136, 139, 140, 141, 144, 145, 
+	146, 147, 150, 151, 152, 153, 154, 156, 
+	176, 178, 128, 130, 184, 255, 135, 190, 
+	131, 175, 187, 255, 128, 130, 167, 180, 
+	179, 128, 130, 179, 255, 129, 137, 141, 
+	255, 190, 172, 183, 159, 170, 188, 128, 
+	131, 190, 191, 151, 128, 132, 135, 136, 
+	139, 141, 162, 163, 166, 172, 176, 180, 
+	181, 191, 128, 134, 176, 255, 132, 255, 
+	175, 181, 184, 255, 129, 155, 158, 255, 
+	129, 255, 171, 183, 157, 171, 175, 182, 
+	184, 191, 146, 167, 169, 182, 171, 172, 
+	189, 190, 176, 180, 176, 182, 145, 190, 
+	143, 146, 178, 157, 158, 133, 134, 137, 
+	168, 169, 170, 165, 169, 173, 178, 187, 
+	255, 131, 132, 140, 169, 174, 255, 130, 
+	132, 128, 182, 187, 255, 173, 180, 182, 
+	255, 132, 155, 159, 161, 175, 128, 163, 
+	165, 128, 134, 136, 152, 155, 161, 163, 
+	164, 166, 170, 144, 150, 132, 138, 145, 
+	146, 151, 166, 169, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 166, 167, 169, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	187, 188, 189, 190, 191, 168, 170, 150, 
+	153, 155, 163, 165, 167, 169, 173, 153, 
+	155, 148, 161, 163, 255, 131, 187, 189, 
+	132, 185, 190, 255, 141, 144, 129, 136, 
+	145, 151, 152, 161, 162, 163, 164, 255, 
+	129, 188, 190, 130, 131, 191, 255, 141, 
+	151, 129, 132, 133, 134, 137, 138, 142, 
+	161, 162, 163, 164, 255, 131, 188, 129, 
+	130, 190, 255, 145, 181, 129, 130, 131, 
+	134, 135, 136, 137, 138, 139, 141, 142, 
+	175, 176, 177, 178, 255, 134, 138, 141, 
+	129, 136, 142, 161, 162, 163, 164, 255, 
+	129, 188, 130, 131, 190, 191, 128, 141, 
+	129, 132, 135, 136, 139, 140, 150, 151, 
+	162, 163, 130, 190, 191, 128, 141, 151, 
+	129, 130, 134, 136, 138, 140, 128, 129, 
+	131, 190, 255, 133, 137, 129, 132, 142, 
+	148, 151, 161, 164, 255, 129, 188, 190, 
+	191, 130, 131, 130, 134, 128, 132, 135, 
+	136, 138, 139, 140, 141, 149, 150, 162, 
+	163, 129, 190, 130, 131, 191, 255, 133, 
+	137, 141, 151, 129, 132, 142, 161, 162, 
+	163, 164, 255, 138, 143, 150, 159, 144, 
+	145, 146, 148, 152, 158, 178, 179, 177, 
+	179, 180, 186, 135, 142, 177, 179, 180, 
+	185, 187, 188, 136, 141, 181, 183, 185, 
+	152, 153, 190, 191, 191, 177, 190, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 177, 173, 183, 
+	185, 186, 187, 188, 189, 190, 150, 151, 
+	152, 153, 158, 160, 177, 180, 130, 132, 
+	141, 157, 133, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 182, 180, 
+	189, 190, 255, 134, 157, 137, 147, 148, 
+	255, 139, 141, 169, 133, 134, 178, 160, 
+	162, 163, 166, 167, 168, 169, 171, 176, 
+	184, 185, 187, 155, 151, 152, 153, 154, 
+	150, 160, 162, 191, 149, 151, 152, 158, 
+	165, 172, 173, 178, 179, 188, 176, 190, 
+	132, 181, 187, 128, 131, 180, 188, 189, 
+	255, 130, 133, 170, 171, 179, 180, 255, 
+	130, 161, 170, 128, 129, 162, 165, 166, 
+	167, 168, 173, 167, 173, 166, 169, 170, 
+	174, 175, 177, 178, 179, 164, 171, 172, 
+	179, 180, 181, 182, 183, 161, 173, 180, 
+	144, 146, 148, 168, 178, 179, 184, 185, 
+	128, 181, 187, 191, 128, 131, 179, 181, 
+	183, 140, 141, 144, 176, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 167, 163, 164, 165, 166, 132, 
+	133, 134, 159, 160, 177, 178, 255, 166, 
+	173, 135, 145, 146, 147, 131, 179, 188, 
+	128, 130, 180, 181, 182, 185, 186, 255, 
+	165, 129, 255, 169, 174, 175, 176, 177, 
+	178, 179, 180, 181, 182, 131, 140, 141, 
+	188, 176, 178, 180, 183, 184, 190, 191, 
+	129, 171, 181, 182, 172, 173, 174, 175, 
+	165, 168, 172, 173, 163, 170, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	129, 128, 130, 184, 255, 135, 190, 130, 
+	131, 175, 176, 178, 183, 184, 187, 255, 
+	172, 128, 130, 167, 180, 179, 130, 128, 
+	129, 179, 181, 182, 190, 191, 255, 129, 
+	137, 138, 140, 141, 255, 180, 190, 172, 
+	174, 175, 177, 178, 181, 182, 183, 159, 
+	160, 162, 163, 170, 188, 190, 191, 128, 
+	129, 130, 131, 128, 151, 129, 132, 135, 
+	136, 139, 141, 162, 163, 166, 172, 176, 
+	180, 181, 183, 184, 191, 133, 128, 129, 
+	130, 134, 176, 185, 189, 177, 178, 179, 
+	186, 187, 190, 191, 255, 129, 132, 255, 
+	175, 190, 176, 177, 178, 181, 184, 187, 
+	188, 255, 129, 155, 158, 255, 189, 176, 
+	178, 179, 186, 187, 190, 191, 255, 129, 
+	255, 172, 182, 171, 173, 174, 175, 176, 
+	183, 166, 157, 159, 160, 161, 162, 171, 
+	175, 190, 176, 182, 184, 191, 169, 177, 
+	180, 146, 167, 170, 182, 171, 172, 189, 
+	190, 176, 180, 176, 182, 143, 146, 178, 
+	157, 158, 133, 134, 137, 168, 169, 170, 
+	166, 173, 165, 169, 174, 178, 187, 255, 
+	131, 132, 140, 169, 174, 255, 130, 132, 
+	128, 182, 187, 255, 173, 180, 182, 255, 
+	132, 155, 159, 161, 175, 128, 163, 165, 
+	128, 134, 136, 152, 155, 161, 163, 164, 
+	166, 170, 144, 150, 132, 138, 143, 187, 
+	191, 160, 128, 129, 132, 135, 133, 134, 
+	160, 255, 192, 255, 139, 168, 160, 128, 
+	129, 132, 135, 133, 134, 160, 255, 192, 
+	255, 144, 145, 150, 155, 157, 158, 144, 
+	145, 150, 155, 157, 158, 159, 135, 166, 
+	191, 133, 128, 191, 128, 130, 131, 132, 
+	133, 137, 138, 139, 140, 191, 174, 188, 
+	128, 129, 130, 131, 132, 133, 134, 144, 
+	145, 165, 166, 169, 170, 175, 176, 184, 
+	185, 191, 128, 132, 170, 129, 135, 136, 
+	191, 181, 186, 128, 191, 144, 128, 148, 
+	149, 150, 151, 191, 128, 132, 133, 135, 
+	136, 138, 139, 143, 144, 191, 163, 128, 
+	179, 180, 182, 183, 191, 128, 129, 191, 
+	166, 176, 191, 128, 151, 152, 158, 159, 
+	178, 179, 185, 186, 187, 188, 190, 128, 
+	191, 160, 128, 191, 128, 130, 131, 135, 
+	191, 129, 134, 136, 190, 128, 159, 160, 
+	191, 128, 175, 176, 255, 10, 13, 127, 
+	194, 216, 219, 220, 224, 225, 226, 234, 
+	235, 236, 237, 239, 240, 243, 0, 31, 
+	128, 191, 192, 223, 227, 238, 241, 247, 
+	248, 255, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 239, 240, 243, 204, 205, 
+	210, 214, 215, 216, 217, 219, 220, 221, 
+	222, 223, 224, 225, 226, 227, 234, 239, 
+	240, 243, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 239, 240, 243, 194, 216, 
+	219, 220, 224, 225, 226, 234, 235, 236, 
+	237, 239, 240, 243, 32, 126, 192, 223, 
+	227, 238, 241, 247, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 235, 236, 237, 239, 240, 243, 204, 
+	205, 210, 214, 215, 216, 217, 219, 220, 
+	221, 222, 223, 224, 225, 226, 227, 234, 
+	237, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 237, 239, 240, 
+	243, 204, 205, 210, 214, 215, 216, 217, 
+	219, 220, 221, 222, 223, 224, 225, 226, 
+	227, 234, 237, 239, 240, 243, 204, 205, 
+	210, 214, 215, 216, 217, 219, 220, 221, 
+	222, 223, 224, 225, 226, 227, 234, 239, 
+	240, 243, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 235, 236, 237, 239, 240, 
+	243, 204, 205, 210, 214, 215, 216, 217, 
+	219, 220, 221, 222, 223, 224, 225, 226, 
+	227, 234, 239, 240, 243, 204, 205, 210, 
+	214, 215, 216, 217, 219, 220, 221, 222, 
+	223, 224, 225, 226, 227, 234, 239, 240, 
+	243, 204, 205, 210, 214, 215, 216, 217, 
+	219, 220, 221, 222, 223, 224, 225, 226, 
+	227, 234, 239, 240, 243, 204, 205, 210, 
+	214, 215, 216, 217, 219, 220, 221, 222, 
+	223, 224, 225, 226, 227, 234, 237, 239, 
+	240, 243, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 237, 239, 240, 243, 204, 
+	205, 210, 214, 215, 216, 217, 219, 220, 
+	221, 222, 223, 224, 225, 226, 227, 234, 
+	237, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 
+}
+
+var _graphclust_single_lengths []byte = []byte{
+	0, 1, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 26, 0, 
+	0, 0, 1, 1, 1, 0, 0, 2, 
+	1, 0, 1, 1, 0, 2, 0, 0, 
+	2, 0, 2, 1, 0, 1, 0, 3, 
+	0, 0, 1, 21, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 1, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 1, 
+	0, 5, 2, 6, 0, 1, 0, 1, 
+	0, 2, 0, 0, 15, 0, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 0, 
+	2, 1, 1, 0, 3, 1, 0, 7, 
+	5, 1, 1, 0, 1, 0, 23, 0, 
+	0, 0, 0, 1, 0, 0, 1, 0, 
+	1, 1, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 4, 0, 0, 
+	0, 0, 1, 0, 6, 0, 0, 0, 
+	0, 0, 1, 3, 0, 0, 0, 3, 
+	0, 0, 0, 0, 1, 1, 0, 1, 
+	0, 1, 0, 0, 0, 29, 0, 0, 
+	0, 3, 2, 3, 2, 2, 2, 3, 
+	2, 2, 3, 3, 1, 2, 4, 2, 
+	2, 4, 4, 2, 0, 2, 0, 3, 
+	1, 0, 1, 21, 1, 0, 4, 0, 
+	0, 0, 1, 2, 0, 1, 1, 1, 
+	4, 0, 3, 1, 3, 2, 0, 3, 
+	0, 5, 2, 0, 0, 1, 0, 2, 
+	0, 0, 15, 0, 0, 0, 4, 0, 
+	0, 0, 3, 1, 0, 4, 1, 4, 
+	4, 3, 1, 0, 7, 5, 1, 1, 
+	0, 1, 0, 23, 1, 0, 1, 1, 
+	1, 1, 0, 2, 1, 3, 2, 0, 
+	1, 3, 1, 2, 0, 1, 0, 2, 
+	1, 2, 3, 4, 0, 0, 0, 1, 
+	0, 6, 2, 0, 0, 0, 0, 1, 
+	3, 0, 0, 0, 1, 0, 1, 4, 
+	0, 0, 0, 1, 1, 1, 4, 0, 
+	0, 0, 6, 0, 1, 1, 0, 0, 
+	0, 1, 1, 0, 1, 0, 1, 0, 
+	0, 0, 26, 0, 0, 0, 1, 1, 
+	1, 0, 0, 2, 1, 0, 1, 1, 
+	0, 2, 0, 0, 2, 0, 2, 1, 
+	0, 1, 0, 3, 0, 0, 1, 21, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 3, 0, 0, 0, 
+	0, 0, 0, 1, 0, 5, 2, 6, 
+	0, 1, 0, 1, 0, 2, 0, 0, 
+	15, 0, 0, 0, 3, 0, 0, 0, 
+	0, 0, 0, 0, 2, 1, 1, 0, 
+	3, 1, 0, 7, 5, 1, 1, 0, 
+	1, 0, 23, 0, 0, 0, 0, 1, 
+	0, 0, 1, 0, 1, 1, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 4, 0, 0, 0, 0, 1, 0, 
+	6, 0, 0, 0, 0, 0, 1, 3, 
+	0, 0, 0, 3, 0, 0, 0, 0, 
+	1, 1, 0, 1, 0, 1, 0, 0, 
+	0, 29, 0, 0, 0, 3, 2, 3, 
+	2, 2, 2, 3, 2, 2, 3, 3, 
+	1, 2, 4, 2, 2, 4, 4, 2, 
+	0, 2, 0, 3, 1, 0, 1, 21, 
+	1, 0, 4, 0, 0, 0, 1, 2, 
+	0, 1, 1, 1, 4, 0, 3, 1, 
+	3, 2, 0, 3, 0, 5, 2, 0, 
+	0, 1, 0, 2, 0, 0, 15, 0, 
+	0, 0, 4, 0, 0, 0, 3, 1, 
+	0, 4, 1, 4, 4, 3, 1, 0, 
+	7, 5, 1, 1, 0, 1, 0, 23, 
+	1, 0, 1, 1, 1, 1, 0, 2, 
+	1, 3, 2, 0, 1, 3, 1, 2, 
+	0, 1, 0, 2, 1, 2, 3, 4, 
+	0, 0, 0, 1, 0, 6, 2, 0, 
+	0, 0, 0, 1, 3, 0, 0, 0, 
+	1, 0, 1, 4, 0, 0, 0, 1, 
+	1, 1, 4, 0, 0, 0, 6, 0, 
+	0, 0, 1, 1, 2, 1, 1, 5, 
+	0, 24, 0, 24, 0, 0, 23, 0, 
+	0, 1, 0, 2, 0, 0, 0, 28, 
+	0, 3, 23, 2, 0, 2, 2, 3, 
+	2, 2, 2, 0, 54, 54, 27, 1, 
+	0, 5, 2, 0, 1, 1, 0, 0, 
+	14, 0, 3, 2, 2, 3, 2, 2, 
+	2, 54, 54, 27, 1, 0, 2, 0, 
+	1, 4, 2, 1, 0, 1, 0, 1, 
+	0, 11, 0, 7, 1, 0, 1, 0, 
+	2, 3, 2, 1, 0, 1, 1, 3, 
+	0, 1, 3, 0, 1, 1, 2, 1, 
+	1, 5, 0, 0, 0, 0, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 26, 
+	0, 0, 0, 1, 1, 1, 0, 0, 
+	2, 1, 0, 1, 1, 0, 2, 0, 
+	0, 2, 0, 2, 1, 0, 1, 0, 
+	3, 0, 0, 1, 21, 0, 0, 3, 
+	0, 0, 0, 0, 0, 0, 1, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	1, 0, 5, 2, 6, 0, 1, 0, 
+	1, 0, 2, 0, 0, 15, 0, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	0, 2, 1, 1, 0, 3, 1, 0, 
+	7, 5, 1, 1, 0, 1, 0, 23, 
+	0, 0, 0, 0, 1, 0, 0, 1, 
+	0, 1, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 4, 0, 
+	0, 0, 0, 1, 0, 6, 0, 0, 
+	0, 0, 0, 1, 3, 0, 0, 0, 
+	3, 0, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 29, 0, 
+	0, 0, 3, 2, 3, 2, 2, 2, 
+	3, 2, 2, 3, 3, 1, 2, 4, 
+	2, 2, 4, 4, 2, 0, 2, 0, 
+	3, 1, 0, 1, 21, 1, 0, 4, 
+	0, 0, 0, 1, 2, 0, 1, 1, 
+	1, 4, 0, 3, 1, 3, 2, 0, 
+	3, 0, 5, 2, 0, 0, 1, 0, 
+	2, 0, 0, 15, 0, 0, 0, 4, 
+	0, 0, 0, 3, 1, 0, 4, 1, 
+	4, 4, 3, 1, 0, 7, 5, 1, 
+	1, 0, 1, 0, 23, 1, 0, 1, 
+	1, 1, 1, 0, 2, 1, 3, 2, 
+	0, 1, 3, 1, 2, 0, 1, 0, 
+	2, 1, 2, 3, 4, 0, 0, 0, 
+	1, 0, 6, 2, 0, 0, 0, 0, 
+	1, 3, 0, 0, 0, 1, 0, 1, 
+	4, 0, 0, 0, 1, 1, 1, 4, 
+	0, 0, 0, 6, 24, 0, 24, 0, 
+	0, 23, 0, 0, 1, 0, 2, 0, 
+	0, 0, 28, 0, 3, 23, 2, 0, 
+	2, 2, 3, 2, 2, 2, 0, 54, 
+	54, 27, 1, 1, 5, 2, 0, 0, 
+	0, 1, 1, 0, 1, 0, 1, 0, 
+	0, 0, 26, 0, 0, 0, 1, 1, 
+	1, 0, 0, 2, 1, 0, 1, 1, 
+	0, 2, 0, 0, 2, 0, 2, 1, 
+	0, 1, 0, 3, 0, 0, 1, 21, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 3, 0, 0, 0, 
+	0, 0, 0, 1, 0, 5, 2, 0, 
+	0, 1, 0, 2, 0, 0, 15, 0, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 0, 2, 1, 1, 0, 3, 1, 
+	0, 6, 5, 1, 1, 0, 1, 0, 
+	23, 0, 0, 0, 0, 1, 0, 0, 
+	1, 0, 1, 1, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 4, 
+	0, 0, 0, 0, 1, 0, 6, 0, 
+	0, 0, 0, 0, 1, 3, 0, 0, 
+	0, 1, 4, 0, 0, 0, 6, 1, 
+	7, 3, 0, 0, 0, 0, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 29, 
+	0, 0, 0, 3, 2, 3, 2, 2, 
+	2, 3, 2, 2, 3, 3, 1, 2, 
+	4, 2, 2, 4, 4, 2, 0, 2, 
+	0, 3, 1, 0, 1, 21, 1, 0, 
+	4, 0, 0, 0, 1, 2, 0, 1, 
+	1, 1, 4, 0, 3, 1, 3, 2, 
+	0, 3, 0, 5, 2, 0, 0, 1, 
+	0, 2, 0, 0, 15, 0, 0, 0, 
+	4, 0, 0, 0, 3, 1, 0, 4, 
+	1, 4, 4, 3, 1, 0, 7, 5, 
+	1, 1, 0, 1, 0, 23, 1, 0, 
+	1, 1, 1, 1, 0, 2, 1, 3, 
+	2, 0, 1, 3, 1, 2, 0, 1, 
+	0, 2, 1, 2, 3, 4, 0, 0, 
+	0, 1, 0, 6, 2, 0, 0, 0, 
+	0, 1, 3, 0, 0, 0, 1, 0, 
+	1, 4, 0, 0, 0, 1, 1, 0, 
+	1, 0, 0, 0, 1, 1, 0, 1, 
+	0, 1, 0, 0, 0, 29, 0, 0, 
+	0, 3, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 26, 0, 
+	0, 0, 1, 1, 1, 0, 0, 2, 
+	1, 0, 1, 1, 0, 2, 0, 0, 
+	2, 0, 2, 1, 0, 1, 0, 3, 
+	0, 0, 1, 21, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 1, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 1, 
+	0, 5, 2, 6, 0, 1, 0, 1, 
+	0, 2, 0, 0, 15, 0, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 0, 
+	2, 1, 1, 0, 3, 1, 0, 7, 
+	5, 1, 1, 0, 1, 0, 23, 0, 
+	0, 0, 0, 1, 0, 0, 1, 0, 
+	1, 1, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 4, 0, 0, 
+	0, 0, 1, 0, 6, 0, 0, 0, 
+	0, 0, 1, 3, 0, 0, 0, 3, 
+	0, 1, 1, 1, 4, 0, 0, 0, 
+	6, 2, 3, 2, 2, 2, 3, 2, 
+	2, 3, 3, 1, 2, 4, 2, 2, 
+	4, 4, 2, 0, 2, 0, 3, 1, 
+	0, 1, 21, 1, 0, 4, 0, 0, 
+	0, 1, 2, 0, 1, 1, 1, 4, 
+	0, 3, 1, 3, 2, 0, 3, 0, 
+	5, 2, 0, 0, 1, 0, 2, 0, 
+	0, 15, 0, 0, 0, 4, 0, 0, 
+	0, 3, 1, 0, 4, 1, 4, 4, 
+	3, 1, 0, 7, 5, 1, 1, 0, 
+	1, 0, 23, 1, 0, 1, 1, 1, 
+	1, 0, 2, 1, 3, 2, 0, 1, 
+	3, 1, 2, 0, 1, 0, 2, 1, 
+	2, 3, 4, 0, 0, 0, 1, 0, 
+	6, 2, 0, 0, 0, 0, 1, 3, 
+	0, 0, 0, 1, 0, 1, 4, 0, 
+	0, 0, 1, 0, 0, 14, 0, 3, 
+	2, 2, 3, 2, 2, 2, 54, 54, 
+	29, 1, 0, 0, 0, 0, 2, 1, 
+	1, 4, 2, 1, 0, 1, 0, 1, 
+	0, 11, 0, 0, 0, 0, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 26, 
+	0, 0, 0, 1, 1, 1, 0, 0, 
+	2, 1, 0, 1, 1, 0, 2, 0, 
+	0, 2, 0, 2, 1, 0, 1, 0, 
+	3, 0, 0, 1, 21, 0, 0, 3, 
+	0, 0, 0, 0, 0, 0, 1, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	1, 0, 5, 2, 6, 0, 1, 0, 
+	1, 0, 2, 0, 0, 15, 0, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	0, 2, 1, 1, 0, 3, 1, 0, 
+	7, 5, 1, 1, 0, 1, 0, 23, 
+	0, 0, 0, 0, 1, 0, 0, 1, 
+	0, 1, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 4, 0, 
+	0, 0, 0, 1, 0, 6, 0, 0, 
+	0, 0, 0, 1, 3, 0, 0, 0, 
+	3, 0, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 29, 0, 
+	0, 0, 3, 2, 3, 2, 2, 2, 
+	3, 2, 2, 3, 3, 1, 2, 4, 
+	2, 2, 4, 4, 2, 0, 2, 0, 
+	3, 1, 0, 1, 21, 1, 0, 4, 
+	0, 0, 0, 1, 2, 0, 1, 1, 
+	1, 4, 0, 3, 1, 3, 2, 0, 
+	3, 0, 5, 2, 0, 0, 1, 0, 
+	2, 0, 0, 15, 0, 0, 0, 4, 
+	0, 0, 0, 3, 1, 0, 4, 1, 
+	4, 4, 3, 1, 0, 7, 5, 1, 
+	1, 0, 1, 0, 23, 1, 0, 1, 
+	1, 1, 1, 0, 2, 1, 3, 2, 
+	0, 1, 3, 1, 2, 0, 1, 0, 
+	2, 1, 2, 3, 4, 0, 0, 0, 
+	1, 0, 6, 2, 0, 0, 0, 0, 
+	1, 3, 0, 0, 0, 1, 0, 1, 
+	4, 0, 0, 0, 1, 1, 1, 4, 
+	0, 0, 0, 6, 7, 1, 0, 1, 
+	0, 2, 3, 2, 1, 0, 1, 1, 
+	3, 0, 1, 5, 0, 0, 17, 20, 
+	20, 20, 14, 20, 20, 20, 23, 21, 
+	21, 21, 20, 23, 20, 20, 20, 21, 
+	21, 21, 20, 20, 20, 20, 20, 20, 
+	20, 20, 20, 20, 
+}
+
+var _graphclust_range_lengths []byte = []byte{
+	0, 0, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 2, 4, 
+	1, 2, 1, 2, 2, 5, 6, 2, 
+	2, 5, 1, 3, 2, 3, 5, 2, 
+	3, 1, 3, 1, 1, 2, 1, 2, 
+	1, 4, 0, 0, 2, 3, 1, 1, 
+	2, 2, 1, 2, 1, 1, 2, 1, 
+	2, 1, 2, 2, 2, 1, 1, 4, 
+	2, 0, 0, 0, 1, 0, 1, 0, 
+	1, 0, 1, 1, 0, 2, 1, 1, 
+	1, 2, 2, 1, 1, 2, 2, 1, 
+	1, 3, 2, 2, 0, 0, 2, 0, 
+	0, 0, 0, 1, 4, 1, 0, 2, 
+	1, 2, 2, 0, 2, 2, 1, 1, 
+	2, 6, 1, 1, 1, 1, 2, 2, 
+	1, 1, 1, 2, 2, 0, 1, 1, 
+	1, 1, 0, 1, 0, 3, 3, 1, 
+	2, 2, 2, 0, 5, 1, 1, 0, 
+	1, 1, 1, 1, 1, 2, 1, 1, 
+	4, 1, 1, 1, 1, 1, 4, 1, 
+	2, 2, 5, 2, 6, 2, 8, 4, 
+	2, 5, 0, 3, 2, 4, 1, 6, 
+	2, 4, 4, 1, 1, 2, 1, 2, 
+	1, 4, 0, 0, 4, 4, 1, 1, 
+	2, 2, 2, 2, 1, 1, 6, 2, 
+	5, 1, 3, 3, 4, 4, 4, 4, 
+	2, 0, 0, 1, 1, 0, 1, 0, 
+	1, 1, 0, 2, 1, 1, 2, 4, 
+	1, 2, 4, 1, 5, 0, 3, 2, 
+	1, 0, 0, 2, 0, 0, 0, 0, 
+	1, 4, 1, 0, 2, 1, 4, 2, 
+	0, 4, 3, 4, 2, 2, 6, 2, 
+	2, 4, 1, 4, 2, 4, 1, 3, 
+	3, 2, 2, 0, 1, 1, 1, 0, 
+	1, 0, 3, 3, 1, 2, 2, 2, 
+	0, 5, 1, 1, 0, 1, 0, 1, 
+	1, 1, 0, 0, 0, 0, 1, 1, 
+	1, 0, 0, 1, 2, 2, 1, 1, 
+	1, 1, 2, 1, 1, 4, 1, 1, 
+	1, 1, 2, 4, 1, 2, 1, 2, 
+	2, 5, 6, 2, 2, 5, 1, 3, 
+	2, 3, 5, 2, 3, 1, 3, 1, 
+	1, 2, 1, 2, 1, 4, 0, 0, 
+	2, 3, 1, 1, 2, 2, 1, 2, 
+	1, 1, 2, 1, 2, 1, 2, 2, 
+	2, 1, 1, 4, 2, 0, 0, 0, 
+	1, 0, 1, 0, 1, 0, 1, 1, 
+	0, 2, 1, 1, 1, 2, 2, 1, 
+	1, 2, 2, 1, 1, 3, 2, 2, 
+	0, 0, 2, 0, 0, 0, 0, 1, 
+	4, 1, 0, 2, 1, 2, 2, 0, 
+	2, 2, 1, 1, 2, 6, 1, 1, 
+	1, 1, 2, 2, 1, 1, 1, 2, 
+	2, 0, 1, 1, 1, 1, 0, 1, 
+	0, 3, 3, 1, 2, 2, 2, 0, 
+	5, 1, 1, 0, 1, 1, 1, 1, 
+	1, 2, 1, 1, 4, 1, 1, 1, 
+	1, 1, 4, 1, 2, 2, 5, 2, 
+	6, 2, 8, 4, 2, 5, 0, 3, 
+	2, 4, 1, 6, 2, 4, 4, 1, 
+	1, 2, 1, 2, 1, 4, 0, 0, 
+	4, 4, 1, 1, 2, 2, 2, 2, 
+	1, 1, 6, 2, 5, 1, 3, 3, 
+	4, 4, 4, 4, 2, 0, 0, 1, 
+	1, 0, 1, 0, 1, 1, 0, 2, 
+	1, 1, 2, 4, 1, 2, 4, 1, 
+	5, 0, 3, 2, 1, 0, 0, 2, 
+	0, 0, 0, 0, 1, 4, 1, 0, 
+	2, 1, 4, 2, 0, 4, 3, 4, 
+	2, 2, 6, 2, 2, 4, 1, 4, 
+	2, 4, 1, 3, 3, 2, 2, 0, 
+	1, 1, 1, 0, 1, 0, 3, 3, 
+	1, 2, 2, 2, 0, 5, 1, 1, 
+	0, 1, 0, 1, 1, 1, 0, 0, 
+	0, 0, 1, 1, 1, 0, 0, 1, 
+	2, 3, 1, 1, 1, 1, 1, 1, 
+	1, 0, 1, 0, 1, 1, 0, 1, 
+	1, 0, 1, 0, 1, 3, 1, 2, 
+	2, 1, 0, 0, 1, 0, 0, 0, 
+	0, 0, 1, 0, 1, 1, 2, 2, 
+	2, 1, 3, 2, 1, 1, 3, 1, 
+	3, 3, 1, 0, 0, 0, 0, 0, 
+	1, 1, 1, 2, 2, 4, 1, 1, 
+	2, 1, 1, 1, 3, 1, 2, 1, 
+	2, 1, 2, 0, 0, 1, 1, 5, 
+	9, 2, 1, 3, 5, 3, 1, 6, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 2, 
+	1, 1, 4, 1, 1, 1, 1, 2, 
+	4, 1, 2, 1, 2, 2, 5, 6, 
+	2, 2, 5, 1, 3, 2, 3, 5, 
+	2, 3, 1, 3, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 2, 3, 1, 
+	1, 2, 2, 1, 2, 1, 1, 2, 
+	1, 2, 1, 2, 2, 2, 1, 1, 
+	4, 2, 0, 0, 0, 1, 0, 1, 
+	0, 1, 0, 1, 1, 0, 2, 1, 
+	1, 1, 2, 2, 1, 1, 2, 2, 
+	1, 1, 3, 2, 2, 0, 0, 2, 
+	0, 0, 0, 0, 1, 4, 1, 0, 
+	2, 1, 2, 2, 0, 2, 2, 1, 
+	1, 2, 6, 1, 1, 1, 1, 2, 
+	2, 1, 1, 1, 2, 2, 0, 1, 
+	1, 1, 1, 0, 1, 0, 3, 3, 
+	1, 2, 2, 2, 0, 5, 1, 1, 
+	0, 1, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 1, 4, 
+	1, 2, 2, 5, 2, 6, 2, 8, 
+	4, 2, 5, 0, 3, 2, 4, 1, 
+	6, 2, 4, 4, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 4, 4, 1, 
+	1, 2, 2, 2, 2, 1, 1, 6, 
+	2, 5, 1, 3, 3, 4, 4, 4, 
+	4, 2, 0, 0, 1, 1, 0, 1, 
+	0, 1, 1, 0, 2, 1, 1, 2, 
+	4, 1, 2, 4, 1, 5, 0, 3, 
+	2, 1, 0, 0, 2, 0, 0, 0, 
+	0, 1, 4, 1, 0, 2, 1, 4, 
+	2, 0, 4, 3, 4, 2, 2, 6, 
+	2, 2, 4, 1, 4, 2, 4, 1, 
+	3, 3, 2, 2, 0, 1, 1, 1, 
+	0, 1, 0, 3, 3, 1, 2, 2, 
+	2, 0, 5, 1, 1, 0, 1, 0, 
+	1, 1, 1, 0, 0, 0, 0, 1, 
+	1, 1, 0, 0, 0, 1, 0, 1, 
+	1, 0, 1, 1, 0, 1, 0, 1, 
+	3, 1, 2, 2, 1, 0, 0, 1, 
+	0, 0, 0, 0, 0, 1, 0, 1, 
+	1, 2, 2, 1, 1, 5, 1, 1, 
+	1, 1, 2, 1, 1, 4, 1, 1, 
+	1, 1, 2, 4, 1, 2, 1, 2, 
+	2, 5, 6, 2, 2, 5, 1, 3, 
+	2, 3, 5, 2, 3, 1, 3, 1, 
+	1, 2, 1, 2, 1, 4, 0, 0, 
+	2, 3, 1, 1, 2, 2, 1, 2, 
+	1, 1, 2, 1, 2, 1, 2, 2, 
+	2, 1, 1, 4, 2, 0, 0, 1, 
+	1, 0, 1, 0, 1, 1, 0, 2, 
+	1, 1, 1, 2, 2, 1, 1, 2, 
+	2, 1, 1, 3, 2, 2, 0, 0, 
+	2, 0, 0, 0, 0, 1, 4, 1, 
+	0, 2, 1, 2, 2, 0, 2, 2, 
+	1, 1, 2, 6, 1, 1, 1, 1, 
+	2, 2, 1, 1, 1, 2, 2, 0, 
+	1, 1, 1, 1, 0, 1, 0, 3, 
+	3, 1, 2, 2, 2, 0, 5, 1, 
+	1, 0, 1, 1, 1, 0, 0, 0, 
+	0, 0, 1, 1, 1, 1, 1, 2, 
+	1, 1, 4, 1, 1, 1, 1, 1, 
+	4, 1, 2, 2, 5, 2, 6, 2, 
+	8, 4, 2, 5, 0, 3, 2, 4, 
+	1, 6, 2, 4, 4, 1, 1, 2, 
+	1, 2, 1, 4, 0, 0, 4, 4, 
+	1, 1, 2, 2, 2, 2, 1, 1, 
+	6, 2, 5, 1, 3, 3, 4, 4, 
+	4, 4, 2, 0, 0, 1, 1, 0, 
+	1, 0, 1, 1, 0, 2, 1, 1, 
+	2, 4, 1, 2, 4, 1, 5, 0, 
+	3, 2, 1, 0, 0, 2, 0, 0, 
+	0, 0, 1, 4, 1, 0, 2, 1, 
+	4, 2, 0, 4, 3, 4, 2, 2, 
+	6, 2, 2, 4, 1, 4, 2, 4, 
+	1, 3, 3, 2, 2, 0, 1, 1, 
+	1, 0, 1, 0, 3, 3, 1, 2, 
+	2, 2, 0, 5, 1, 1, 0, 1, 
+	0, 1, 1, 1, 0, 0, 0, 3, 
+	1, 1, 1, 1, 1, 2, 1, 1, 
+	4, 1, 1, 1, 1, 1, 4, 1, 
+	2, 2, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 2, 4, 
+	1, 2, 1, 2, 2, 5, 6, 2, 
+	2, 5, 1, 3, 2, 3, 5, 2, 
+	3, 1, 3, 1, 1, 2, 1, 2, 
+	1, 4, 0, 0, 2, 3, 1, 1, 
+	2, 2, 1, 2, 1, 1, 2, 1, 
+	2, 1, 2, 2, 2, 1, 1, 4, 
+	2, 0, 0, 0, 1, 0, 1, 0, 
+	1, 0, 1, 1, 0, 2, 1, 1, 
+	1, 2, 2, 1, 1, 2, 2, 1, 
+	1, 3, 2, 2, 0, 0, 2, 0, 
+	0, 0, 0, 1, 4, 1, 0, 2, 
+	1, 2, 2, 0, 2, 2, 1, 1, 
+	2, 6, 1, 1, 1, 1, 2, 2, 
+	1, 1, 1, 2, 2, 0, 1, 1, 
+	1, 1, 0, 1, 0, 3, 3, 1, 
+	2, 2, 2, 0, 5, 1, 1, 0, 
+	1, 0, 0, 0, 1, 1, 1, 0, 
+	0, 5, 2, 6, 2, 8, 4, 2, 
+	5, 0, 3, 2, 4, 1, 6, 2, 
+	4, 4, 1, 1, 2, 1, 2, 1, 
+	4, 0, 0, 4, 4, 1, 1, 2, 
+	2, 2, 2, 1, 1, 6, 2, 5, 
+	1, 3, 3, 4, 4, 4, 4, 2, 
+	0, 0, 1, 1, 0, 1, 0, 1, 
+	1, 0, 2, 1, 1, 2, 4, 1, 
+	2, 4, 1, 5, 0, 3, 2, 1, 
+	0, 0, 2, 0, 0, 0, 0, 1, 
+	4, 1, 0, 2, 1, 4, 2, 0, 
+	4, 3, 4, 2, 2, 6, 2, 2, 
+	4, 1, 4, 2, 4, 1, 3, 3, 
+	2, 2, 0, 1, 1, 1, 0, 1, 
+	0, 3, 3, 1, 2, 2, 2, 0, 
+	5, 1, 1, 0, 1, 0, 1, 1, 
+	1, 0, 1, 3, 1, 3, 3, 1, 
+	0, 0, 0, 0, 0, 1, 1, 1, 
+	3, 2, 4, 1, 0, 1, 1, 1, 
+	3, 1, 1, 1, 3, 1, 3, 1, 
+	3, 1, 2, 1, 1, 1, 1, 2, 
+	1, 1, 4, 1, 1, 1, 1, 2, 
+	4, 1, 2, 1, 2, 2, 5, 6, 
+	2, 2, 5, 1, 3, 2, 3, 5, 
+	2, 3, 1, 3, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 2, 3, 1, 
+	1, 2, 2, 1, 2, 1, 1, 2, 
+	1, 2, 1, 2, 2, 2, 1, 1, 
+	4, 2, 0, 0, 0, 1, 0, 1, 
+	0, 1, 0, 1, 1, 0, 2, 1, 
+	1, 1, 2, 2, 1, 1, 2, 2, 
+	1, 1, 3, 2, 2, 0, 0, 2, 
+	0, 0, 0, 0, 1, 4, 1, 0, 
+	2, 1, 2, 2, 0, 2, 2, 1, 
+	1, 2, 6, 1, 1, 1, 1, 2, 
+	2, 1, 1, 1, 2, 2, 0, 1, 
+	1, 1, 1, 0, 1, 0, 3, 3, 
+	1, 2, 2, 2, 0, 5, 1, 1, 
+	0, 1, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 1, 4, 
+	1, 2, 2, 5, 2, 6, 2, 8, 
+	4, 2, 5, 0, 3, 2, 4, 1, 
+	6, 2, 4, 4, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 4, 4, 1, 
+	1, 2, 2, 2, 2, 1, 1, 6, 
+	2, 5, 1, 3, 3, 4, 4, 4, 
+	4, 2, 0, 0, 1, 1, 0, 1, 
+	0, 1, 1, 0, 2, 1, 1, 2, 
+	4, 1, 2, 4, 1, 5, 0, 3, 
+	2, 1, 0, 0, 2, 0, 0, 0, 
+	0, 1, 4, 1, 0, 2, 1, 4, 
+	2, 0, 4, 3, 4, 2, 2, 6, 
+	2, 2, 4, 1, 4, 2, 4, 1, 
+	3, 3, 2, 2, 0, 1, 1, 1, 
+	0, 1, 0, 3, 3, 1, 2, 2, 
+	2, 0, 5, 1, 1, 0, 1, 0, 
+	1, 1, 1, 0, 0, 0, 0, 1, 
+	1, 1, 0, 0, 0, 0, 1, 1, 
+	5, 9, 2, 1, 3, 5, 3, 1, 
+	6, 1, 1, 2, 2, 2, 6, 0, 
+	0, 0, 4, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 
+}
+
+var _graphclust_index_offsets []int16 = []int16{
+	0, 0, 2, 4, 6, 8, 11, 15, 
+	17, 20, 25, 28, 30, 32, 34, 63, 
+	68, 70, 73, 76, 80, 84, 90, 97, 
+	102, 106, 112, 115, 120, 123, 129, 135, 
+	138, 144, 146, 152, 155, 157, 161, 163, 
+	169, 171, 176, 178, 200, 203, 207, 212, 
+	214, 217, 220, 222, 225, 227, 230, 233, 
+	235, 241, 243, 246, 249, 252, 254, 256, 
+	262, 265, 271, 274, 281, 283, 285, 287, 
+	289, 291, 294, 296, 298, 314, 317, 319, 
+	321, 326, 329, 332, 334, 336, 339, 342, 
+	344, 348, 353, 357, 360, 364, 366, 369, 
+	377, 383, 385, 387, 389, 395, 397, 421, 
+	424, 426, 429, 432, 434, 437, 440, 443, 
+	445, 449, 457, 459, 461, 463, 465, 468, 
+	471, 473, 475, 477, 480, 483, 488, 490, 
+	492, 494, 496, 498, 500, 507, 511, 515, 
+	517, 520, 523, 527, 531, 537, 539, 541, 
+	545, 547, 549, 551, 553, 556, 560, 562, 
+	565, 570, 573, 575, 577, 579, 610, 615, 
+	617, 620, 626, 634, 640, 649, 654, 665, 
+	673, 678, 686, 690, 697, 701, 708, 714, 
+	723, 728, 737, 746, 750, 752, 757, 759, 
+	765, 768, 773, 775, 797, 803, 808, 814, 
+	816, 819, 822, 826, 831, 833, 836, 844, 
+	848, 858, 860, 867, 872, 880, 887, 892, 
+	900, 903, 909, 912, 914, 916, 918, 920, 
+	923, 925, 927, 943, 946, 948, 950, 957, 
+	962, 964, 967, 975, 978, 984, 989, 994, 
+	1001, 1007, 1011, 1013, 1016, 1024, 1030, 1032, 
+	1034, 1036, 1042, 1044, 1068, 1072, 1074, 1080, 
+	1084, 1086, 1092, 1096, 1103, 1107, 1113, 1122, 
+	1125, 1129, 1137, 1140, 1147, 1150, 1156, 1158, 
+	1164, 1169, 1174, 1180, 1185, 1187, 1189, 1191, 
+	1193, 1195, 1202, 1208, 1212, 1214, 1217, 1220, 
+	1224, 1228, 1234, 1236, 1238, 1240, 1242, 1244, 
+	1250, 1252, 1254, 1255, 1257, 1259, 1261, 1267, 
+	1269, 1271, 1272, 1279, 1281, 1285, 1289, 1291, 
+	1293, 1295, 1298, 1302, 1304, 1307, 1312, 1315, 
+	1317, 1319, 1321, 1350, 1355, 1357, 1360, 1363, 
+	1367, 1371, 1377, 1384, 1389, 1393, 1399, 1402, 
+	1407, 1410, 1416, 1422, 1425, 1431, 1433, 1439, 
+	1442, 1444, 1448, 1450, 1456, 1458, 1463, 1465, 
+	1487, 1490, 1494, 1499, 1501, 1504, 1507, 1509, 
+	1512, 1514, 1517, 1520, 1522, 1528, 1530, 1533, 
+	1536, 1539, 1541, 1543, 1549, 1552, 1558, 1561, 
+	1568, 1570, 1572, 1574, 1576, 1578, 1581, 1583, 
+	1585, 1601, 1604, 1606, 1608, 1613, 1616, 1619, 
+	1621, 1623, 1626, 1629, 1631, 1635, 1640, 1644, 
+	1647, 1651, 1653, 1656, 1664, 1670, 1672, 1674, 
+	1676, 1682, 1684, 1708, 1711, 1713, 1716, 1719, 
+	1721, 1724, 1727, 1730, 1732, 1736, 1744, 1746, 
+	1748, 1750, 1752, 1755, 1758, 1760, 1762, 1764, 
+	1767, 1770, 1775, 1777, 1779, 1781, 1783, 1785, 
+	1787, 1794, 1798, 1802, 1804, 1807, 1810, 1814, 
+	1818, 1824, 1826, 1828, 1832, 1834, 1836, 1838, 
+	1840, 1843, 1847, 1849, 1852, 1857, 1860, 1862, 
+	1864, 1866, 1897, 1902, 1904, 1907, 1913, 1921, 
+	1927, 1936, 1941, 1952, 1960, 1965, 1973, 1977, 
+	1984, 1988, 1995, 2001, 2010, 2015, 2024, 2033, 
+	2037, 2039, 2044, 2046, 2052, 2055, 2060, 2062, 
+	2084, 2090, 2095, 2101, 2103, 2106, 2109, 2113, 
+	2118, 2120, 2123, 2131, 2135, 2145, 2147, 2154, 
+	2159, 2167, 2174, 2179, 2187, 2190, 2196, 2199, 
+	2201, 2203, 2205, 2207, 2210, 2212, 2214, 2230, 
+	2233, 2235, 2237, 2244, 2249, 2251, 2254, 2262, 
+	2265, 2271, 2276, 2281, 2288, 2294, 2298, 2300, 
+	2303, 2311, 2317, 2319, 2321, 2323, 2329, 2331, 
+	2355, 2359, 2361, 2367, 2371, 2373, 2379, 2383, 
+	2390, 2394, 2400, 2409, 2412, 2416, 2424, 2427, 
+	2434, 2437, 2443, 2445, 2451, 2456, 2461, 2467, 
+	2472, 2474, 2476, 2478, 2480, 2482, 2489, 2495, 
+	2499, 2501, 2504, 2507, 2511, 2515, 2521, 2523, 
+	2525, 2527, 2529, 2531, 2537, 2539, 2541, 2542, 
+	2544, 2546, 2548, 2554, 2556, 2558, 2559, 2566, 
+	2568, 2571, 2575, 2578, 2581, 2585, 2588, 2591, 
+	2598, 2600, 2625, 2627, 2652, 2654, 2656, 2680, 
+	2682, 2684, 2686, 2688, 2691, 2693, 2697, 2699, 
+	2730, 2733, 2738, 2762, 2765, 2767, 2770, 2773, 
+	2777, 2780, 2783, 2787, 2788, 2844, 2900, 2930, 
+	2934, 2937, 2944, 2950, 2953, 2956, 2959, 2963, 
+	2965, 2983, 2987, 2992, 2995, 2998, 3002, 3005, 
+	3008, 3012, 3068, 3124, 3154, 3158, 3163, 3167, 
+	3169, 3173, 3179, 3183, 3186, 3190, 3193, 3196, 
+	3199, 3202, 3215, 3218, 3226, 3228, 3230, 3233, 
+	3239, 3251, 3257, 3261, 3266, 3272, 3277, 3280, 
+	3290, 3292, 3295, 3300, 3302, 3305, 3308, 3312, 
+	3315, 3318, 3325, 3327, 3329, 3331, 3333, 3336, 
+	3340, 3342, 3345, 3350, 3353, 3355, 3357, 3359, 
+	3388, 3393, 3395, 3398, 3401, 3405, 3409, 3415, 
+	3422, 3427, 3431, 3437, 3440, 3445, 3448, 3454, 
+	3460, 3463, 3469, 3471, 3477, 3480, 3482, 3486, 
+	3488, 3494, 3496, 3501, 3503, 3525, 3528, 3532, 
+	3537, 3539, 3542, 3545, 3547, 3550, 3552, 3555, 
+	3558, 3560, 3566, 3568, 3571, 3574, 3577, 3579, 
+	3581, 3587, 3590, 3596, 3599, 3606, 3608, 3610, 
+	3612, 3614, 3616, 3619, 3621, 3623, 3639, 3642, 
+	3644, 3646, 3651, 3654, 3657, 3659, 3661, 3664, 
+	3667, 3669, 3673, 3678, 3682, 3685, 3689, 3691, 
+	3694, 3702, 3708, 3710, 3712, 3714, 3720, 3722, 
+	3746, 3749, 3751, 3754, 3757, 3759, 3762, 3765, 
+	3768, 3770, 3774, 3782, 3784, 3786, 3788, 3790, 
+	3793, 3796, 3798, 3800, 3802, 3805, 3808, 3813, 
+	3815, 3817, 3819, 3821, 3823, 3825, 3832, 3836, 
+	3840, 3842, 3845, 3848, 3852, 3856, 3862, 3864, 
+	3866, 3870, 3872, 3874, 3876, 3878, 3881, 3885, 
+	3887, 3890, 3895, 3898, 3900, 3902, 3904, 3935, 
+	3940, 3942, 3945, 3951, 3959, 3965, 3974, 3979, 
+	3990, 3998, 4003, 4011, 4015, 4022, 4026, 4033, 
+	4039, 4048, 4053, 4062, 4071, 4075, 4077, 4082, 
+	4084, 4090, 4093, 4098, 4100, 4122, 4128, 4133, 
+	4139, 4141, 4144, 4147, 4151, 4156, 4158, 4161, 
+	4169, 4173, 4183, 4185, 4192, 4197, 4205, 4212, 
+	4217, 4225, 4228, 4234, 4237, 4239, 4241, 4243, 
+	4245, 4248, 4250, 4252, 4268, 4271, 4273, 4275, 
+	4282, 4287, 4289, 4292, 4300, 4303, 4309, 4314, 
+	4319, 4326, 4332, 4336, 4338, 4341, 4349, 4355, 
+	4357, 4359, 4361, 4367, 4369, 4393, 4397, 4399, 
+	4405, 4409, 4411, 4417, 4421, 4428, 4432, 4438, 
+	4447, 4450, 4454, 4462, 4465, 4472, 4475, 4481, 
+	4483, 4489, 4494, 4499, 4505, 4510, 4512, 4514, 
+	4516, 4518, 4520, 4527, 4533, 4537, 4539, 4542, 
+	4545, 4549, 4553, 4559, 4561, 4563, 4565, 4567, 
+	4569, 4575, 4577, 4579, 4580, 4582, 4584, 4586, 
+	4592, 4594, 4596, 4597, 4604, 4629, 4631, 4656, 
+	4658, 4660, 4684, 4686, 4688, 4690, 4692, 4695, 
+	4697, 4701, 4703, 4734, 4737, 4742, 4766, 4769, 
+	4771, 4774, 4777, 4781, 4784, 4787, 4791, 4792, 
+	4848, 4904, 4934, 4938, 4941, 4948, 4956, 4958, 
+	4960, 4962, 4965, 4969, 4971, 4974, 4979, 4982, 
+	4984, 4986, 4988, 5017, 5022, 5024, 5027, 5030, 
+	5034, 5038, 5044, 5051, 5056, 5060, 5066, 5069, 
+	5074, 5077, 5083, 5089, 5092, 5098, 5100, 5106, 
+	5109, 5111, 5115, 5117, 5123, 5125, 5130, 5132, 
+	5154, 5157, 5161, 5166, 5168, 5171, 5174, 5176, 
+	5179, 5181, 5184, 5187, 5189, 5195, 5197, 5200, 
+	5203, 5206, 5208, 5210, 5216, 5219, 5225, 5228, 
+	5230, 5232, 5234, 5236, 5239, 5241, 5243, 5259, 
+	5262, 5264, 5266, 5271, 5274, 5277, 5279, 5281, 
+	5284, 5287, 5289, 5293, 5298, 5302, 5305, 5309, 
+	5311, 5314, 5321, 5327, 5329, 5331, 5333, 5339, 
+	5341, 5365, 5368, 5370, 5373, 5376, 5378, 5381, 
+	5384, 5387, 5389, 5393, 5401, 5403, 5405, 5407, 
+	5409, 5412, 5415, 5417, 5419, 5421, 5424, 5427, 
+	5432, 5434, 5436, 5438, 5440, 5442, 5444, 5451, 
+	5455, 5459, 5461, 5464, 5467, 5471, 5475, 5481, 
+	5483, 5485, 5487, 5493, 5495, 5497, 5498, 5505, 
+	5507, 5515, 5519, 5521, 5523, 5525, 5527, 5530, 
+	5534, 5536, 5539, 5544, 5547, 5549, 5551, 5553, 
+	5584, 5589, 5591, 5594, 5600, 5608, 5614, 5623, 
+	5628, 5639, 5647, 5652, 5660, 5664, 5671, 5675, 
+	5682, 5688, 5697, 5702, 5711, 5720, 5724, 5726, 
+	5731, 5733, 5739, 5742, 5747, 5749, 5771, 5777, 
+	5782, 5788, 5790, 5793, 5796, 5800, 5805, 5807, 
+	5810, 5818, 5822, 5832, 5834, 5841, 5846, 5854, 
+	5861, 5866, 5874, 5877, 5883, 5886, 5888, 5890, 
+	5892, 5894, 5897, 5899, 5901, 5917, 5920, 5922, 
+	5924, 5931, 5936, 5938, 5941, 5949, 5952, 5958, 
+	5963, 5968, 5975, 5981, 5985, 5987, 5990, 5998, 
+	6004, 6006, 6008, 6010, 6016, 6018, 6042, 6046, 
+	6048, 6054, 6058, 6060, 6066, 6070, 6077, 6081, 
+	6087, 6096, 6099, 6103, 6111, 6114, 6121, 6124, 
+	6130, 6132, 6138, 6143, 6148, 6154, 6159, 6161, 
+	6163, 6165, 6167, 6169, 6176, 6182, 6186, 6188, 
+	6191, 6194, 6198, 6202, 6208, 6210, 6212, 6214, 
+	6216, 6218, 6224, 6226, 6228, 6229, 6231, 6233, 
+	6237, 6240, 6242, 6244, 6246, 6249, 6253, 6255, 
+	6258, 6263, 6266, 6268, 6270, 6272, 6303, 6308, 
+	6310, 6313, 6319, 6321, 6323, 6325, 6328, 6332, 
+	6334, 6337, 6342, 6345, 6347, 6349, 6351, 6380, 
+	6385, 6387, 6390, 6393, 6397, 6401, 6407, 6414, 
+	6419, 6423, 6429, 6432, 6437, 6440, 6446, 6452, 
+	6455, 6461, 6463, 6469, 6472, 6474, 6478, 6480, 
+	6486, 6488, 6493, 6495, 6517, 6520, 6524, 6529, 
+	6531, 6534, 6537, 6539, 6542, 6544, 6547, 6550, 
+	6552, 6558, 6560, 6563, 6566, 6569, 6571, 6573, 
+	6579, 6582, 6588, 6591, 6598, 6600, 6602, 6604, 
+	6606, 6608, 6611, 6613, 6615, 6631, 6634, 6636, 
+	6638, 6643, 6646, 6649, 6651, 6653, 6656, 6659, 
+	6661, 6665, 6670, 6674, 6677, 6681, 6683, 6686, 
+	6694, 6700, 6702, 6704, 6706, 6712, 6714, 6738, 
+	6741, 6743, 6746, 6749, 6751, 6754, 6757, 6760, 
+	6762, 6766, 6774, 6776, 6778, 6780, 6782, 6785, 
+	6788, 6790, 6792, 6794, 6797, 6800, 6805, 6807, 
+	6809, 6811, 6813, 6815, 6817, 6824, 6828, 6832, 
+	6834, 6837, 6840, 6844, 6848, 6854, 6856, 6858, 
+	6862, 6864, 6866, 6868, 6870, 6876, 6878, 6880, 
+	6881, 6888, 6896, 6902, 6911, 6916, 6927, 6935, 
+	6940, 6948, 6952, 6959, 6963, 6970, 6976, 6985, 
+	6990, 6999, 7008, 7012, 7014, 7019, 7021, 7027, 
+	7030, 7035, 7037, 7059, 7065, 7070, 7076, 7078, 
+	7081, 7084, 7088, 7093, 7095, 7098, 7106, 7110, 
+	7120, 7122, 7129, 7134, 7142, 7149, 7154, 7162, 
+	7165, 7171, 7174, 7176, 7178, 7180, 7182, 7185, 
+	7187, 7189, 7205, 7208, 7210, 7212, 7219, 7224, 
+	7226, 7229, 7237, 7240, 7246, 7251, 7256, 7263, 
+	7269, 7273, 7275, 7278, 7286, 7292, 7294, 7296, 
+	7298, 7304, 7306, 7330, 7334, 7336, 7342, 7346, 
+	7348, 7354, 7358, 7365, 7369, 7375, 7384, 7387, 
+	7391, 7399, 7402, 7409, 7412, 7418, 7420, 7426, 
+	7431, 7436, 7442, 7447, 7449, 7451, 7453, 7455, 
+	7457, 7464, 7470, 7474, 7476, 7479, 7482, 7486, 
+	7490, 7496, 7498, 7500, 7502, 7504, 7506, 7512, 
+	7514, 7516, 7517, 7520, 7524, 7526, 7544, 7548, 
+	7553, 7556, 7559, 7563, 7566, 7569, 7573, 7629, 
+	7685, 7718, 7722, 7727, 7729, 7730, 7732, 7736, 
+	7739, 7744, 7750, 7754, 7757, 7761, 7764, 7768, 
+	7771, 7775, 7788, 7791, 7793, 7795, 7797, 7800, 
+	7804, 7806, 7809, 7814, 7817, 7819, 7821, 7823, 
+	7852, 7857, 7859, 7862, 7865, 7869, 7873, 7879, 
+	7886, 7891, 7895, 7901, 7904, 7909, 7912, 7918, 
+	7924, 7927, 7933, 7935, 7941, 7944, 7946, 7950, 
+	7952, 7958, 7960, 7965, 7967, 7989, 7992, 7996, 
+	8001, 8003, 8006, 8009, 8011, 8014, 8016, 8019, 
+	8022, 8024, 8030, 8032, 8035, 8038, 8041, 8043, 
+	8045, 8051, 8054, 8060, 8063, 8070, 8072, 8074, 
+	8076, 8078, 8080, 8083, 8085, 8087, 8103, 8106, 
+	8108, 8110, 8115, 8118, 8121, 8123, 8125, 8128, 
+	8131, 8133, 8137, 8142, 8146, 8149, 8153, 8155, 
+	8158, 8166, 8172, 8174, 8176, 8178, 8184, 8186, 
+	8210, 8213, 8215, 8218, 8221, 8223, 8226, 8229, 
+	8232, 8234, 8238, 8246, 8248, 8250, 8252, 8254, 
+	8257, 8260, 8262, 8264, 8266, 8269, 8272, 8277, 
+	8279, 8281, 8283, 8285, 8287, 8289, 8296, 8300, 
+	8304, 8306, 8309, 8312, 8316, 8320, 8326, 8328, 
+	8330, 8334, 8336, 8338, 8340, 8342, 8345, 8349, 
+	8351, 8354, 8359, 8362, 8364, 8366, 8368, 8399, 
+	8404, 8406, 8409, 8415, 8423, 8429, 8438, 8443, 
+	8454, 8462, 8467, 8475, 8479, 8486, 8490, 8497, 
+	8503, 8512, 8517, 8526, 8535, 8539, 8541, 8546, 
+	8548, 8554, 8557, 8562, 8564, 8586, 8592, 8597, 
+	8603, 8605, 8608, 8611, 8615, 8620, 8622, 8625, 
+	8633, 8637, 8647, 8649, 8656, 8661, 8669, 8676, 
+	8681, 8689, 8692, 8698, 8701, 8703, 8705, 8707, 
+	8709, 8712, 8714, 8716, 8732, 8735, 8737, 8739, 
+	8746, 8751, 8753, 8756, 8764, 8767, 8773, 8778, 
+	8783, 8790, 8796, 8800, 8802, 8805, 8813, 8819, 
+	8821, 8823, 8825, 8831, 8833, 8857, 8861, 8863, 
+	8869, 8873, 8875, 8881, 8885, 8892, 8896, 8902, 
+	8911, 8914, 8918, 8926, 8929, 8936, 8939, 8945, 
+	8947, 8953, 8958, 8963, 8969, 8974, 8976, 8978, 
+	8980, 8982, 8984, 8991, 8997, 9001, 9003, 9006, 
+	9009, 9013, 9017, 9023, 9025, 9027, 9029, 9031, 
+	9033, 9039, 9041, 9043, 9044, 9046, 9048, 9050, 
+	9056, 9058, 9060, 9061, 9068, 9076, 9078, 9080, 
+	9083, 9089, 9101, 9107, 9111, 9116, 9122, 9127, 
+	9130, 9140, 9142, 9145, 9153, 9156, 9159, 9183, 
+	9204, 9225, 9246, 9265, 9286, 9307, 9328, 9352, 
+	9374, 9396, 9418, 9439, 9463, 9484, 9505, 9526, 
+	9548, 9570, 9592, 9613, 9634, 9655, 9676, 9697, 
+	9718, 9739, 9760, 9781, 
+}
+
+var _graphclust_indicies []int16 = []int16{
+	0, 1, 3, 2, 2, 3, 3, 2, 
+	3, 3, 2, 3, 3, 3, 2, 3, 
+	2, 3, 3, 2, 3, 3, 3, 3, 
+	2, 3, 3, 2, 2, 3, 3, 2, 
+	3, 2, 4, 5, 6, 7, 8, 10, 
+	11, 12, 14, 15, 16, 17, 18, 19, 
+	20, 21, 22, 23, 24, 25, 26, 27, 
+	28, 29, 30, 31, 9, 13, 2, 3, 
+	3, 3, 3, 2, 3, 2, 3, 3, 
+	2, 2, 2, 3, 2, 2, 2, 3, 
+	3, 3, 3, 2, 2, 2, 2, 2, 
+	2, 3, 2, 2, 2, 2, 2, 2, 
+	3, 2, 2, 2, 2, 3, 3, 3, 
+	3, 2, 3, 3, 3, 3, 3, 2, 
+	3, 3, 2, 3, 3, 3, 3, 2, 
+	3, 3, 2, 2, 2, 2, 2, 2, 
+	3, 3, 3, 3, 3, 3, 2, 3, 
+	3, 2, 2, 2, 2, 2, 2, 3, 
+	3, 2, 3, 3, 3, 3, 3, 2, 
+	3, 3, 2, 3, 2, 3, 3, 3, 
+	2, 3, 2, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 3, 3, 3, 2, 
+	3, 2, 32, 33, 34, 35, 36, 37, 
+	38, 39, 40, 41, 42, 43, 44, 45, 
+	46, 47, 48, 49, 50, 51, 52, 2, 
+	3, 3, 2, 3, 3, 3, 2, 3, 
+	3, 3, 3, 2, 3, 2, 3, 3, 
+	2, 3, 3, 2, 3, 2, 2, 2, 
+	3, 3, 2, 3, 3, 2, 3, 3, 
+	2, 3, 2, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 3, 2, 2, 2, 
+	3, 3, 3, 2, 3, 2, 3, 2, 
+	3, 3, 3, 3, 3, 2, 3, 3, 
+	2, 53, 54, 55, 56, 57, 2, 3, 
+	58, 2, 53, 54, 59, 55, 56, 57, 
+	2, 3, 2, 3, 2, 3, 2, 3, 
+	2, 3, 2, 60, 61, 2, 3, 2, 
+	3, 2, 62, 63, 64, 65, 66, 67, 
+	68, 69, 70, 71, 72, 73, 74, 75, 
+	76, 2, 3, 3, 2, 3, 2, 3, 
+	2, 3, 3, 3, 3, 2, 3, 3, 
+	2, 2, 2, 3, 3, 2, 3, 2, 
+	3, 3, 2, 2, 2, 3, 3, 2, 
+	3, 3, 3, 2, 3, 3, 3, 3, 
+	2, 3, 3, 3, 2, 3, 3, 2, 
+	77, 78, 63, 2, 3, 2, 3, 3, 
+	2, 79, 80, 81, 82, 83, 84, 85, 
+	2, 86, 87, 88, 89, 90, 2, 3, 
+	2, 3, 2, 3, 2, 3, 3, 3, 
+	3, 3, 2, 3, 2, 91, 92, 93, 
+	94, 95, 96, 97, 98, 99, 100, 101, 
+	102, 103, 104, 105, 106, 107, 104, 108, 
+	109, 110, 111, 112, 2, 3, 3, 2, 
+	2, 3, 2, 2, 3, 3, 3, 2, 
+	3, 2, 3, 3, 2, 2, 2, 3, 
+	3, 3, 2, 3, 2, 3, 3, 3, 
+	2, 3, 3, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 2, 3, 2, 2, 
+	3, 3, 3, 2, 2, 2, 3, 2, 
+	3, 3, 2, 3, 2, 3, 3, 2, 
+	3, 3, 2, 113, 114, 115, 116, 2, 
+	3, 2, 3, 2, 3, 2, 3, 2, 
+	117, 2, 3, 2, 118, 119, 120, 121, 
+	122, 123, 2, 3, 3, 3, 2, 2, 
+	2, 2, 3, 3, 2, 3, 3, 2, 
+	2, 2, 3, 3, 3, 3, 2, 124, 
+	125, 126, 2, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 2, 127, 128, 129, 
+	2, 130, 2, 2, 130, 2, 130, 130, 
+	2, 130, 130, 2, 130, 130, 130, 2, 
+	130, 2, 130, 130, 2, 130, 130, 130, 
+	130, 2, 130, 130, 2, 2, 130, 130, 
+	2, 130, 2, 131, 132, 133, 134, 135, 
+	136, 137, 139, 140, 141, 142, 143, 144, 
+	145, 146, 147, 148, 149, 150, 22, 151, 
+	152, 153, 154, 155, 156, 157, 158, 159, 
+	138, 2, 130, 130, 130, 130, 2, 130, 
+	2, 130, 130, 2, 3, 3, 2, 2, 
+	3, 130, 130, 2, 130, 130, 2, 130, 
+	2, 3, 130, 130, 130, 3, 3, 2, 
+	130, 130, 130, 2, 2, 2, 130, 2, 
+	3, 3, 130, 130, 3, 2, 130, 130, 
+	130, 2, 130, 2, 130, 2, 130, 2, 
+	3, 2, 2, 130, 130, 2, 130, 2, 
+	3, 130, 130, 3, 130, 2, 3, 130, 
+	130, 3, 3, 130, 130, 2, 130, 130, 
+	3, 2, 130, 130, 130, 3, 3, 3, 
+	2, 130, 3, 130, 2, 2, 2, 3, 
+	2, 2, 2, 130, 130, 130, 3, 130, 
+	3, 2, 130, 130, 3, 3, 3, 130, 
+	130, 130, 2, 130, 130, 3, 3, 2, 
+	2, 2, 130, 130, 130, 2, 130, 2, 
+	3, 130, 130, 130, 130, 3, 130, 3, 
+	3, 2, 130, 3, 130, 2, 130, 2, 
+	130, 3, 130, 130, 2, 130, 2, 130, 
+	130, 130, 130, 3, 2, 3, 130, 2, 
+	130, 130, 130, 130, 2, 130, 2, 160, 
+	161, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 172, 173, 174, 175, 176, 
+	177, 178, 179, 180, 2, 3, 130, 130, 
+	3, 130, 2, 3, 130, 130, 130, 2, 
+	130, 3, 130, 130, 130, 2, 130, 2, 
+	130, 130, 2, 130, 130, 2, 3, 130, 
+	3, 2, 130, 130, 130, 2, 3, 130, 
+	2, 130, 130, 2, 130, 130, 3, 130, 
+	3, 3, 130, 2, 130, 130, 3, 2, 
+	130, 130, 130, 130, 3, 130, 130, 3, 
+	130, 2, 130, 2, 3, 3, 3, 130, 
+	130, 3, 2, 130, 2, 130, 2, 3, 
+	3, 3, 3, 130, 130, 3, 130, 2, 
+	3, 130, 130, 3, 130, 3, 2, 3, 
+	130, 3, 130, 2, 3, 130, 130, 130, 
+	130, 3, 130, 2, 130, 130, 2, 181, 
+	182, 183, 184, 185, 2, 130, 58, 2, 
+	130, 2, 130, 2, 130, 2, 130, 2, 
+	186, 187, 2, 130, 2, 130, 2, 188, 
+	189, 190, 191, 66, 192, 193, 194, 195, 
+	196, 197, 198, 199, 200, 201, 2, 130, 
+	130, 2, 130, 2, 130, 2, 130, 130, 
+	130, 3, 3, 130, 2, 130, 2, 130, 
+	2, 3, 130, 2, 130, 3, 2, 3, 
+	130, 130, 130, 3, 130, 3, 2, 130, 
+	2, 3, 130, 3, 130, 3, 130, 2, 
+	130, 130, 3, 130, 2, 130, 130, 130, 
+	130, 2, 130, 3, 3, 130, 130, 3, 
+	2, 130, 130, 3, 130, 3, 2, 202, 
+	203, 189, 2, 130, 2, 130, 130, 2, 
+	204, 205, 206, 207, 208, 209, 210, 2, 
+	211, 212, 213, 214, 215, 2, 130, 2, 
+	130, 2, 130, 2, 130, 130, 130, 130, 
+	130, 2, 130, 2, 216, 217, 218, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	228, 229, 230, 231, 232, 233, 234, 235, 
+	236, 237, 238, 2, 130, 3, 130, 2, 
+	2, 130, 3, 2, 3, 3, 2, 130, 
+	3, 130, 130, 2, 130, 2, 3, 130, 
+	3, 130, 3, 2, 2, 130, 2, 3, 
+	130, 130, 3, 130, 3, 130, 2, 130, 
+	3, 130, 2, 130, 130, 3, 130, 3, 
+	2, 130, 130, 3, 3, 3, 3, 130, 
+	130, 2, 3, 130, 2, 3, 3, 130, 
+	2, 130, 3, 130, 3, 130, 3, 130, 
+	2, 3, 2, 130, 130, 3, 3, 130, 
+	3, 130, 2, 2, 2, 130, 130, 3, 
+	130, 3, 130, 2, 2, 130, 3, 3, 
+	130, 3, 130, 2, 3, 130, 3, 130, 
+	2, 3, 3, 130, 130, 2, 3, 3, 
+	3, 130, 130, 2, 239, 240, 115, 241, 
+	2, 130, 2, 130, 2, 130, 2, 242, 
+	2, 130, 2, 243, 244, 245, 246, 247, 
+	248, 2, 3, 3, 130, 130, 130, 2, 
+	2, 2, 2, 130, 130, 2, 130, 130, 
+	2, 2, 2, 130, 130, 130, 130, 2, 
+	249, 250, 251, 2, 130, 130, 130, 130, 
+	130, 2, 130, 2, 130, 2, 252, 2, 
+	3, 2, 253, 2, 254, 255, 256, 258, 
+	257, 2, 130, 2, 2, 130, 130, 3, 
+	2, 3, 2, 259, 2, 260, 261, 262, 
+	264, 263, 2, 3, 2, 2, 3, 3, 
+	79, 80, 81, 82, 83, 84, 2, 3, 
+	1, 265, 265, 3, 1, 265, 266, 3, 
+	1, 267, 268, 267, 268, 268, 267, 268, 
+	268, 267, 268, 268, 268, 267, 268, 267, 
+	268, 268, 267, 268, 268, 268, 268, 267, 
+	268, 268, 267, 267, 268, 268, 267, 268, 
+	267, 269, 270, 271, 272, 273, 275, 276, 
+	277, 279, 280, 281, 282, 283, 284, 285, 
+	286, 287, 288, 289, 290, 291, 292, 293, 
+	294, 295, 296, 274, 278, 267, 268, 268, 
+	268, 268, 267, 268, 267, 268, 268, 267, 
+	267, 267, 268, 267, 267, 267, 268, 268, 
+	268, 268, 267, 267, 267, 267, 267, 267, 
+	268, 267, 267, 267, 267, 267, 267, 268, 
+	267, 267, 267, 267, 268, 268, 268, 268, 
+	267, 268, 268, 268, 268, 268, 267, 268, 
+	268, 267, 268, 268, 268, 268, 267, 268, 
+	268, 267, 267, 267, 267, 267, 267, 268, 
+	268, 268, 268, 268, 268, 267, 268, 268, 
+	267, 267, 267, 267, 267, 267, 268, 268, 
+	267, 268, 268, 268, 268, 268, 267, 268, 
+	268, 267, 268, 267, 268, 268, 268, 267, 
+	268, 267, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 268, 268, 268, 267, 268, 
+	267, 297, 298, 299, 300, 301, 302, 303, 
+	304, 305, 306, 307, 308, 309, 310, 311, 
+	312, 313, 314, 315, 316, 317, 267, 268, 
+	268, 267, 268, 268, 268, 267, 268, 268, 
+	268, 268, 267, 268, 267, 268, 268, 267, 
+	268, 268, 267, 268, 267, 267, 267, 268, 
+	268, 267, 268, 268, 267, 268, 268, 267, 
+	268, 267, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 268, 267, 267, 267, 268, 
+	268, 268, 267, 268, 267, 268, 267, 268, 
+	268, 268, 268, 268, 267, 268, 268, 267, 
+	318, 319, 320, 321, 322, 267, 268, 323, 
+	267, 318, 319, 324, 320, 321, 322, 267, 
+	268, 267, 268, 267, 268, 267, 268, 267, 
+	268, 267, 325, 326, 267, 268, 267, 268, 
+	267, 327, 328, 329, 330, 331, 332, 333, 
+	334, 335, 336, 337, 338, 339, 340, 341, 
+	267, 268, 268, 267, 268, 267, 268, 267, 
+	268, 268, 268, 268, 267, 268, 268, 267, 
+	267, 267, 268, 268, 267, 268, 267, 268, 
+	268, 267, 267, 267, 268, 268, 267, 268, 
+	268, 268, 267, 268, 268, 268, 268, 267, 
+	268, 268, 268, 267, 268, 268, 267, 342, 
+	343, 328, 267, 268, 267, 268, 268, 267, 
+	344, 345, 346, 347, 348, 349, 350, 267, 
+	351, 352, 353, 354, 355, 267, 268, 267, 
+	268, 267, 268, 267, 268, 268, 268, 268, 
+	268, 267, 268, 267, 356, 357, 358, 359, 
+	360, 361, 362, 363, 364, 365, 366, 367, 
+	368, 369, 370, 371, 372, 369, 373, 374, 
+	375, 376, 377, 267, 268, 268, 267, 267, 
+	268, 267, 267, 268, 268, 268, 267, 268, 
+	267, 268, 268, 267, 267, 267, 268, 268, 
+	268, 267, 268, 267, 268, 268, 268, 267, 
+	268, 268, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 267, 268, 267, 267, 268, 
+	268, 268, 267, 267, 267, 268, 267, 268, 
+	268, 267, 268, 267, 268, 268, 267, 268, 
+	268, 267, 378, 379, 380, 381, 267, 268, 
+	267, 268, 267, 268, 267, 268, 267, 382, 
+	267, 268, 267, 383, 384, 385, 386, 387, 
+	388, 267, 268, 268, 268, 267, 267, 267, 
+	267, 268, 268, 267, 268, 268, 267, 267, 
+	267, 268, 268, 268, 268, 267, 389, 390, 
+	391, 267, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 267, 392, 393, 394, 267, 
+	395, 267, 395, 267, 267, 395, 395, 267, 
+	395, 395, 267, 395, 395, 395, 267, 395, 
+	267, 395, 395, 267, 395, 395, 395, 395, 
+	267, 395, 395, 267, 267, 395, 395, 267, 
+	395, 267, 396, 397, 398, 399, 400, 401, 
+	402, 404, 405, 406, 407, 408, 409, 410, 
+	411, 412, 413, 414, 415, 287, 416, 417, 
+	418, 419, 420, 421, 422, 423, 424, 403, 
+	267, 395, 395, 395, 395, 267, 395, 267, 
+	395, 395, 267, 268, 268, 267, 267, 268, 
+	395, 395, 267, 395, 395, 267, 395, 267, 
+	268, 395, 395, 395, 268, 268, 267, 395, 
+	395, 395, 267, 267, 267, 395, 267, 268, 
+	268, 395, 395, 268, 267, 395, 395, 395, 
+	267, 395, 267, 395, 267, 395, 267, 268, 
+	267, 267, 395, 395, 267, 395, 267, 268, 
+	395, 395, 268, 395, 267, 268, 395, 395, 
+	268, 268, 395, 395, 267, 395, 395, 268, 
+	267, 395, 395, 395, 268, 268, 268, 267, 
+	395, 268, 395, 267, 267, 267, 268, 267, 
+	267, 267, 395, 395, 395, 268, 395, 268, 
+	267, 395, 395, 268, 268, 268, 395, 395, 
+	395, 267, 395, 395, 268, 268, 267, 267, 
+	267, 395, 395, 395, 267, 395, 267, 268, 
+	395, 395, 395, 395, 268, 395, 268, 268, 
+	267, 395, 268, 395, 267, 395, 267, 395, 
+	268, 395, 395, 267, 395, 267, 395, 395, 
+	395, 395, 268, 267, 268, 395, 267, 395, 
+	395, 395, 395, 267, 395, 267, 425, 426, 
+	427, 428, 429, 430, 431, 432, 433, 434, 
+	435, 436, 437, 438, 439, 440, 441, 442, 
+	443, 444, 445, 267, 268, 395, 395, 268, 
+	395, 267, 268, 395, 395, 395, 267, 395, 
+	268, 395, 395, 395, 267, 395, 267, 395, 
+	395, 267, 395, 395, 267, 268, 395, 268, 
+	267, 395, 395, 395, 267, 268, 395, 267, 
+	395, 395, 267, 395, 395, 268, 395, 268, 
+	268, 395, 267, 395, 395, 268, 267, 395, 
+	395, 395, 395, 268, 395, 395, 268, 395, 
+	267, 395, 267, 268, 268, 268, 395, 395, 
+	268, 267, 395, 267, 395, 267, 268, 268, 
+	268, 268, 395, 395, 268, 395, 267, 268, 
+	395, 395, 268, 395, 268, 267, 268, 395, 
+	268, 395, 267, 268, 395, 395, 395, 395, 
+	268, 395, 267, 395, 395, 267, 446, 447, 
+	448, 449, 450, 267, 395, 323, 267, 395, 
+	267, 395, 267, 395, 267, 395, 267, 451, 
+	452, 267, 395, 267, 395, 267, 453, 454, 
+	455, 456, 331, 457, 458, 459, 460, 461, 
+	462, 463, 464, 465, 466, 267, 395, 395, 
+	267, 395, 267, 395, 267, 395, 395, 395, 
+	268, 268, 395, 267, 395, 267, 395, 267, 
+	268, 395, 267, 395, 268, 267, 268, 395, 
+	395, 395, 268, 395, 268, 267, 395, 267, 
+	268, 395, 268, 395, 268, 395, 267, 395, 
+	395, 268, 395, 267, 395, 395, 395, 395, 
+	267, 395, 268, 268, 395, 395, 268, 267, 
+	395, 395, 268, 395, 268, 267, 467, 468, 
+	454, 267, 395, 267, 395, 395, 267, 469, 
+	470, 471, 472, 473, 474, 475, 267, 476, 
+	477, 478, 479, 480, 267, 395, 267, 395, 
+	267, 395, 267, 395, 395, 395, 395, 395, 
+	267, 395, 267, 481, 482, 483, 484, 485, 
+	486, 487, 488, 489, 490, 491, 492, 493, 
+	494, 495, 496, 497, 498, 499, 500, 501, 
+	502, 503, 267, 395, 268, 395, 267, 267, 
+	395, 268, 267, 268, 268, 267, 395, 268, 
+	395, 395, 267, 395, 267, 268, 395, 268, 
+	395, 268, 267, 267, 395, 267, 268, 395, 
+	395, 268, 395, 268, 395, 267, 395, 268, 
+	395, 267, 395, 395, 268, 395, 268, 267, 
+	395, 395, 268, 268, 268, 268, 395, 395, 
+	267, 268, 395, 267, 268, 268, 395, 267, 
+	395, 268, 395, 268, 395, 268, 395, 267, 
+	268, 267, 395, 395, 268, 268, 395, 268, 
+	395, 267, 267, 267, 395, 395, 268, 395, 
+	268, 395, 267, 267, 395, 268, 268, 395, 
+	268, 395, 267, 268, 395, 268, 395, 267, 
+	268, 268, 395, 395, 267, 268, 268, 268, 
+	395, 395, 267, 504, 505, 380, 506, 267, 
+	395, 267, 395, 267, 395, 267, 507, 267, 
+	395, 267, 508, 509, 510, 511, 512, 513, 
+	267, 268, 268, 395, 395, 395, 267, 267, 
+	267, 267, 395, 395, 267, 395, 395, 267, 
+	267, 267, 395, 395, 395, 395, 267, 514, 
+	515, 516, 267, 395, 395, 395, 395, 395, 
+	267, 395, 267, 395, 267, 517, 267, 268, 
+	267, 518, 267, 519, 520, 521, 523, 522, 
+	267, 395, 267, 267, 395, 395, 268, 267, 
+	268, 267, 524, 267, 525, 526, 527, 529, 
+	528, 267, 268, 267, 267, 268, 268, 344, 
+	345, 346, 347, 348, 349, 267, 268, 267, 
+	268, 268, 267, 266, 268, 268, 267, 266, 
+	268, 267, 266, 268, 267, 531, 532, 530, 
+	267, 266, 268, 267, 266, 268, 267, 533, 
+	534, 535, 536, 537, 530, 267, 538, 267, 
+	297, 298, 299, 533, 534, 539, 300, 301, 
+	302, 303, 304, 305, 306, 307, 308, 309, 
+	310, 311, 312, 313, 314, 315, 316, 317, 
+	267, 540, 538, 297, 298, 299, 541, 535, 
+	536, 300, 301, 302, 303, 304, 305, 306, 
+	307, 308, 309, 310, 311, 312, 313, 314, 
+	315, 316, 317, 267, 540, 267, 542, 540, 
+	297, 298, 299, 543, 536, 300, 301, 302, 
+	303, 304, 305, 306, 307, 308, 309, 310, 
+	311, 312, 313, 314, 315, 316, 317, 267, 
+	542, 267, 267, 542, 544, 267, 542, 267, 
+	545, 546, 267, 540, 267, 267, 542, 267, 
+	540, 267, 540, 327, 328, 329, 330, 331, 
+	332, 333, 547, 335, 336, 337, 338, 339, 
+	340, 341, 549, 550, 551, 552, 553, 554, 
+	549, 550, 551, 552, 553, 554, 549, 548, 
+	555, 267, 268, 538, 267, 556, 556, 556, 
+	542, 267, 297, 298, 299, 541, 539, 300, 
+	301, 302, 303, 304, 305, 306, 307, 308, 
+	309, 310, 311, 312, 313, 314, 315, 316, 
+	317, 267, 545, 557, 267, 267, 540, 556, 
+	556, 542, 556, 556, 542, 556, 556, 556, 
+	542, 556, 556, 542, 556, 556, 542, 556, 
+	556, 267, 542, 542, 551, 552, 553, 554, 
+	548, 549, 551, 552, 553, 554, 548, 549, 
+	551, 552, 553, 554, 548, 549, 551, 552, 
+	553, 554, 548, 549, 551, 552, 553, 554, 
+	548, 549, 551, 552, 553, 554, 548, 549, 
+	551, 552, 553, 554, 548, 549, 551, 552, 
+	553, 554, 548, 549, 551, 552, 553, 554, 
+	548, 549, 550, 555, 552, 553, 554, 548, 
+	549, 550, 552, 553, 554, 548, 549, 550, 
+	552, 553, 554, 548, 549, 550, 552, 553, 
+	554, 548, 549, 550, 552, 553, 554, 548, 
+	549, 550, 552, 553, 554, 548, 549, 550, 
+	552, 553, 554, 548, 549, 550, 552, 553, 
+	554, 548, 549, 550, 552, 553, 554, 548, 
+	549, 550, 551, 555, 553, 554, 548, 549, 
+	550, 551, 553, 554, 548, 549, 550, 551, 
+	553, 554, 548, 549, 550, 551, 553, 554, 
+	548, 549, 550, 551, 553, 558, 557, 552, 
+	267, 555, 556, 267, 540, 542, 268, 268, 
+	267, 559, 560, 561, 562, 563, 530, 267, 
+	268, 323, 268, 268, 268, 267, 268, 268, 
+	267, 395, 268, 267, 395, 268, 267, 268, 
+	395, 268, 267, 530, 267, 564, 566, 567, 
+	568, 569, 570, 571, 566, 567, 568, 569, 
+	570, 571, 566, 530, 565, 555, 267, 268, 
+	538, 268, 267, 540, 540, 540, 542, 267, 
+	540, 540, 542, 540, 540, 542, 540, 540, 
+	540, 542, 540, 540, 542, 540, 540, 542, 
+	540, 540, 267, 542, 568, 569, 570, 571, 
+	565, 566, 568, 569, 570, 571, 565, 566, 
+	568, 569, 570, 571, 565, 566, 568, 569, 
+	570, 571, 565, 566, 568, 569, 570, 571, 
+	565, 566, 568, 569, 570, 571, 565, 566, 
+	568, 569, 570, 571, 565, 566, 568, 569, 
+	570, 571, 565, 566, 568, 569, 570, 571, 
+	565, 566, 567, 555, 569, 570, 571, 565, 
+	566, 567, 569, 570, 571, 565, 566, 567, 
+	569, 570, 571, 565, 566, 567, 569, 570, 
+	571, 565, 566, 567, 569, 570, 571, 565, 
+	566, 567, 569, 570, 571, 565, 566, 567, 
+	569, 570, 571, 565, 566, 567, 569, 570, 
+	571, 565, 566, 567, 569, 570, 571, 565, 
+	566, 567, 568, 555, 570, 571, 565, 566, 
+	567, 568, 570, 571, 565, 566, 567, 568, 
+	570, 571, 565, 566, 567, 568, 570, 571, 
+	565, 566, 567, 568, 570, 572, 573, 569, 
+	267, 555, 540, 268, 540, 542, 268, 542, 
+	268, 267, 540, 574, 575, 530, 267, 268, 
+	267, 268, 268, 268, 267, 577, 578, 579, 
+	580, 576, 267, 581, 582, 530, 267, 266, 
+	268, 267, 268, 266, 268, 267, 583, 530, 
+	267, 268, 268, 267, 584, 530, 267, 268, 
+	268, 267, 585, 586, 587, 588, 589, 590, 
+	591, 592, 593, 594, 595, 530, 267, 268, 
+	596, 267, 344, 345, 346, 347, 348, 349, 
+	597, 267, 598, 267, 268, 267, 395, 268, 
+	267, 268, 395, 268, 395, 268, 267, 395, 
+	395, 268, 395, 268, 395, 268, 395, 268, 
+	395, 268, 267, 268, 268, 395, 395, 268, 
+	267, 395, 395, 268, 267, 395, 268, 395, 
+	268, 267, 268, 395, 268, 395, 268, 267, 
+	395, 268, 395, 268, 267, 395, 268, 267, 
+	395, 395, 268, 268, 395, 268, 395, 268, 
+	395, 267, 576, 267, 599, 576, 267, 322, 
+	530, 600, 530, 267, 268, 267, 266, 3, 
+	1, 266, 3, 1, 602, 603, 601, 1, 
+	266, 3, 1, 266, 3, 1, 604, 605, 
+	606, 607, 608, 601, 1, 609, 610, 612, 
+	611, 611, 612, 612, 611, 612, 612, 611, 
+	612, 612, 612, 611, 612, 611, 612, 612, 
+	611, 612, 612, 612, 612, 611, 612, 612, 
+	611, 611, 612, 612, 611, 612, 611, 613, 
+	614, 615, 616, 617, 619, 620, 621, 623, 
+	624, 625, 626, 627, 628, 629, 630, 631, 
+	632, 633, 634, 635, 636, 637, 638, 639, 
+	640, 618, 622, 611, 612, 612, 612, 612, 
+	611, 612, 611, 612, 612, 611, 611, 611, 
+	612, 611, 611, 611, 612, 612, 612, 612, 
+	611, 611, 611, 611, 611, 611, 612, 611, 
+	611, 611, 611, 611, 611, 612, 611, 611, 
+	611, 611, 612, 612, 612, 612, 611, 612, 
+	612, 612, 612, 612, 611, 612, 612, 611, 
+	612, 612, 612, 612, 611, 612, 612, 611, 
+	611, 611, 611, 611, 611, 612, 612, 612, 
+	612, 612, 612, 611, 612, 612, 611, 611, 
+	611, 611, 611, 611, 612, 612, 611, 612, 
+	612, 612, 612, 612, 611, 612, 612, 611, 
+	612, 611, 612, 612, 612, 611, 612, 611, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 612, 612, 612, 611, 612, 611, 641, 
+	642, 643, 644, 645, 646, 647, 648, 649, 
+	650, 651, 652, 653, 654, 655, 656, 657, 
+	658, 659, 660, 661, 611, 612, 612, 611, 
+	612, 612, 612, 611, 612, 612, 612, 612, 
+	611, 612, 611, 612, 612, 611, 612, 612, 
+	611, 612, 611, 611, 611, 612, 612, 611, 
+	612, 612, 611, 612, 612, 611, 612, 611, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 612, 611, 611, 611, 612, 612, 612, 
+	611, 612, 611, 612, 611, 612, 612, 612, 
+	612, 612, 611, 612, 612, 611, 662, 663, 
+	664, 665, 666, 611, 612, 667, 611, 662, 
+	663, 668, 664, 665, 666, 611, 612, 611, 
+	612, 611, 612, 611, 612, 611, 612, 611, 
+	669, 670, 611, 612, 611, 612, 611, 671, 
+	672, 673, 674, 675, 676, 677, 678, 679, 
+	680, 681, 682, 683, 684, 685, 611, 612, 
+	612, 611, 612, 611, 612, 611, 612, 612, 
+	612, 612, 611, 612, 612, 611, 611, 611, 
+	612, 612, 611, 612, 611, 612, 612, 611, 
+	611, 611, 612, 612, 611, 612, 612, 612, 
+	611, 612, 612, 612, 612, 611, 612, 612, 
+	612, 611, 612, 612, 611, 686, 687, 672, 
+	611, 612, 611, 612, 612, 611, 688, 689, 
+	690, 691, 692, 693, 694, 611, 695, 696, 
+	697, 698, 699, 611, 612, 611, 612, 611, 
+	612, 611, 612, 612, 612, 612, 612, 611, 
+	612, 611, 700, 701, 702, 703, 704, 705, 
+	706, 707, 708, 709, 710, 711, 712, 713, 
+	714, 715, 716, 713, 717, 718, 719, 720, 
+	721, 611, 612, 612, 611, 611, 612, 611, 
+	611, 612, 612, 612, 611, 612, 611, 612, 
+	612, 611, 611, 611, 612, 612, 612, 611, 
+	612, 611, 612, 612, 612, 611, 612, 612, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 611, 612, 611, 611, 612, 612, 612, 
+	611, 611, 611, 612, 611, 612, 612, 611, 
+	612, 611, 612, 612, 611, 612, 612, 611, 
+	722, 723, 724, 725, 611, 612, 611, 612, 
+	611, 612, 611, 612, 611, 726, 611, 612, 
+	611, 727, 728, 729, 730, 731, 732, 611, 
+	612, 612, 612, 611, 611, 611, 611, 612, 
+	612, 611, 612, 612, 611, 611, 611, 612, 
+	612, 612, 612, 611, 733, 734, 735, 611, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 611, 736, 737, 738, 611, 739, 611, 
+	739, 611, 611, 739, 739, 611, 739, 739, 
+	611, 739, 739, 739, 611, 739, 611, 739, 
+	739, 611, 739, 739, 739, 739, 611, 739, 
+	739, 611, 611, 739, 739, 611, 739, 611, 
+	740, 741, 742, 743, 744, 745, 746, 748, 
+	749, 750, 751, 752, 753, 754, 755, 756, 
+	757, 758, 759, 631, 760, 761, 762, 763, 
+	764, 765, 766, 767, 768, 747, 611, 739, 
+	739, 739, 739, 611, 739, 611, 739, 739, 
+	611, 612, 612, 611, 611, 612, 739, 739, 
+	611, 739, 739, 611, 739, 611, 612, 739, 
+	739, 739, 612, 612, 611, 739, 739, 739, 
+	611, 611, 611, 739, 611, 612, 612, 739, 
+	739, 612, 611, 739, 739, 739, 611, 739, 
+	611, 739, 611, 739, 611, 612, 611, 611, 
+	739, 739, 611, 739, 611, 612, 739, 739, 
+	612, 739, 611, 612, 739, 739, 612, 612, 
+	739, 739, 611, 739, 739, 612, 611, 739, 
+	739, 739, 612, 612, 612, 611, 739, 612, 
+	739, 611, 611, 611, 612, 611, 611, 611, 
+	739, 739, 739, 612, 739, 612, 611, 739, 
+	739, 612, 612, 612, 739, 739, 739, 611, 
+	739, 739, 612, 612, 611, 611, 611, 739, 
+	739, 739, 611, 739, 611, 612, 739, 739, 
+	739, 739, 612, 739, 612, 612, 611, 739, 
+	612, 739, 611, 739, 611, 739, 612, 739, 
+	739, 611, 739, 611, 739, 739, 739, 739, 
+	612, 611, 612, 739, 611, 739, 739, 739, 
+	739, 611, 739, 611, 769, 770, 771, 772, 
+	773, 774, 775, 776, 777, 778, 779, 780, 
+	781, 782, 783, 784, 785, 786, 787, 788, 
+	789, 611, 612, 739, 739, 612, 739, 611, 
+	612, 739, 739, 739, 611, 739, 612, 739, 
+	739, 739, 611, 739, 611, 739, 739, 611, 
+	739, 739, 611, 612, 739, 612, 611, 739, 
+	739, 739, 611, 612, 739, 611, 739, 739, 
+	611, 739, 739, 612, 739, 612, 612, 739, 
+	611, 739, 739, 612, 611, 739, 739, 739, 
+	739, 612, 739, 739, 612, 739, 611, 739, 
+	611, 612, 612, 612, 739, 739, 612, 611, 
+	739, 611, 739, 611, 612, 612, 612, 612, 
+	739, 739, 612, 739, 611, 612, 739, 739, 
+	612, 739, 612, 611, 612, 739, 612, 739, 
+	611, 612, 739, 739, 739, 739, 612, 739, 
+	611, 739, 739, 611, 790, 791, 792, 793, 
+	794, 611, 739, 667, 611, 739, 611, 739, 
+	611, 739, 611, 739, 611, 795, 796, 611, 
+	739, 611, 739, 611, 797, 798, 799, 800, 
+	675, 801, 802, 803, 804, 805, 806, 807, 
+	808, 809, 810, 611, 739, 739, 611, 739, 
+	611, 739, 611, 739, 739, 739, 612, 612, 
+	739, 611, 739, 611, 739, 611, 612, 739, 
+	611, 739, 612, 611, 612, 739, 739, 739, 
+	612, 739, 612, 611, 739, 611, 612, 739, 
+	612, 739, 612, 739, 611, 739, 739, 612, 
+	739, 611, 739, 739, 739, 739, 611, 739, 
+	612, 612, 739, 739, 612, 611, 739, 739, 
+	612, 739, 612, 611, 811, 812, 798, 611, 
+	739, 611, 739, 739, 611, 813, 814, 815, 
+	816, 817, 818, 819, 611, 820, 821, 822, 
+	823, 824, 611, 739, 611, 739, 611, 739, 
+	611, 739, 739, 739, 739, 739, 611, 739, 
+	611, 825, 826, 827, 828, 829, 830, 831, 
+	832, 833, 834, 835, 836, 837, 838, 839, 
+	840, 841, 842, 843, 844, 845, 846, 847, 
+	611, 739, 612, 739, 611, 611, 739, 612, 
+	611, 612, 612, 611, 739, 612, 739, 739, 
+	611, 739, 611, 612, 739, 612, 739, 612, 
+	611, 611, 739, 611, 612, 739, 739, 612, 
+	739, 612, 739, 611, 739, 612, 739, 611, 
+	739, 739, 612, 739, 612, 611, 739, 739, 
+	612, 612, 612, 612, 739, 739, 611, 612, 
+	739, 611, 612, 612, 739, 611, 739, 612, 
+	739, 612, 739, 612, 739, 611, 612, 611, 
+	739, 739, 612, 612, 739, 612, 739, 611, 
+	611, 611, 739, 739, 612, 739, 612, 739, 
+	611, 611, 739, 612, 612, 739, 612, 739, 
+	611, 612, 739, 612, 739, 611, 612, 612, 
+	739, 739, 611, 612, 612, 612, 739, 739, 
+	611, 848, 849, 724, 850, 611, 739, 611, 
+	739, 611, 739, 611, 851, 611, 739, 611, 
+	852, 853, 854, 855, 856, 857, 611, 612, 
+	612, 739, 739, 739, 611, 611, 611, 611, 
+	739, 739, 611, 739, 739, 611, 611, 611, 
+	739, 739, 739, 739, 611, 858, 859, 860, 
+	611, 739, 739, 739, 739, 739, 611, 739, 
+	611, 739, 611, 861, 611, 612, 611, 862, 
+	611, 863, 864, 865, 867, 866, 611, 739, 
+	611, 611, 739, 739, 612, 611, 612, 611, 
+	868, 611, 869, 870, 871, 873, 872, 611, 
+	612, 611, 611, 612, 612, 688, 689, 690, 
+	691, 692, 693, 611, 641, 642, 643, 604, 
+	605, 874, 644, 645, 646, 647, 648, 649, 
+	650, 651, 652, 653, 654, 655, 656, 657, 
+	658, 659, 660, 661, 611, 875, 610, 641, 
+	642, 643, 876, 606, 607, 644, 645, 646, 
+	647, 648, 649, 650, 651, 652, 653, 654, 
+	655, 656, 657, 658, 659, 660, 661, 611, 
+	875, 611, 877, 875, 641, 642, 643, 878, 
+	607, 644, 645, 646, 647, 648, 649, 650, 
+	651, 652, 653, 654, 655, 656, 657, 658, 
+	659, 660, 661, 611, 877, 611, 609, 877, 
+	879, 611, 877, 611, 880, 881, 611, 875, 
+	611, 611, 877, 611, 875, 611, 875, 671, 
+	672, 673, 674, 675, 676, 677, 882, 679, 
+	680, 681, 682, 683, 684, 685, 884, 885, 
+	886, 887, 888, 889, 884, 885, 886, 887, 
+	888, 889, 884, 883, 890, 611, 612, 610, 
+	611, 891, 891, 891, 877, 611, 641, 642, 
+	643, 876, 874, 644, 645, 646, 647, 648, 
+	649, 650, 651, 652, 653, 654, 655, 656, 
+	657, 658, 659, 660, 661, 611, 880, 892, 
+	611, 611, 875, 891, 891, 877, 891, 891, 
+	877, 891, 891, 891, 877, 891, 891, 877, 
+	891, 891, 877, 891, 891, 611, 877, 877, 
+	886, 887, 888, 889, 883, 884, 886, 887, 
+	888, 889, 883, 884, 886, 887, 888, 889, 
+	883, 884, 886, 887, 888, 889, 883, 884, 
+	886, 887, 888, 889, 883, 884, 886, 887, 
+	888, 889, 883, 884, 886, 887, 888, 889, 
+	883, 884, 886, 887, 888, 889, 883, 884, 
+	886, 887, 888, 889, 883, 884, 885, 890, 
+	887, 888, 889, 883, 884, 885, 887, 888, 
+	889, 883, 884, 885, 887, 888, 889, 883, 
+	884, 885, 887, 888, 889, 883, 884, 885, 
+	887, 888, 889, 883, 884, 885, 887, 888, 
+	889, 883, 884, 885, 887, 888, 889, 883, 
+	884, 885, 887, 888, 889, 883, 884, 885, 
+	887, 888, 889, 883, 884, 885, 886, 890, 
+	888, 889, 883, 884, 885, 886, 888, 889, 
+	883, 884, 885, 886, 888, 889, 883, 884, 
+	885, 886, 888, 889, 883, 884, 885, 886, 
+	888, 893, 892, 887, 611, 890, 891, 611, 
+	875, 877, 265, 3, 1, 894, 895, 896, 
+	897, 898, 601, 1, 265, 899, 3, 265, 
+	3, 265, 3, 1, 901, 900, 900, 901, 
+	901, 900, 901, 901, 900, 901, 901, 901, 
+	900, 901, 900, 901, 901, 900, 901, 901, 
+	901, 901, 900, 901, 901, 900, 900, 901, 
+	901, 900, 901, 900, 902, 903, 904, 905, 
+	906, 908, 909, 910, 912, 913, 914, 915, 
+	916, 917, 918, 919, 920, 921, 922, 923, 
+	924, 925, 926, 927, 928, 929, 907, 911, 
+	900, 901, 901, 901, 901, 900, 901, 900, 
+	901, 901, 900, 900, 900, 901, 900, 900, 
+	900, 901, 901, 901, 901, 900, 900, 900, 
+	900, 900, 900, 901, 900, 900, 900, 900, 
+	900, 900, 901, 900, 900, 900, 900, 901, 
+	901, 901, 901, 900, 901, 901, 901, 901, 
+	901, 900, 901, 901, 900, 901, 901, 901, 
+	901, 900, 901, 901, 900, 900, 900, 900, 
+	900, 900, 901, 901, 901, 901, 901, 901, 
+	900, 901, 901, 900, 900, 900, 900, 900, 
+	900, 901, 901, 900, 901, 901, 901, 901, 
+	901, 900, 901, 901, 900, 901, 900, 901, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	901, 900, 901, 900, 930, 931, 932, 933, 
+	934, 935, 936, 937, 938, 939, 940, 941, 
+	942, 943, 944, 945, 946, 947, 948, 949, 
+	950, 900, 901, 901, 900, 901, 901, 901, 
+	900, 901, 901, 901, 901, 900, 901, 900, 
+	901, 901, 900, 901, 901, 900, 901, 900, 
+	900, 900, 901, 901, 900, 901, 901, 900, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	901, 901, 900, 901, 900, 901, 901, 900, 
+	900, 900, 901, 901, 901, 900, 901, 900, 
+	901, 900, 901, 901, 901, 901, 901, 900, 
+	901, 901, 900, 951, 952, 953, 954, 955, 
+	900, 901, 899, 900, 901, 900, 901, 900, 
+	901, 900, 901, 900, 956, 957, 900, 901, 
+	900, 901, 900, 958, 959, 960, 961, 962, 
+	963, 964, 965, 966, 967, 968, 969, 970, 
+	971, 972, 900, 901, 901, 900, 901, 900, 
+	901, 900, 901, 901, 901, 901, 900, 901, 
+	901, 900, 900, 900, 901, 901, 900, 901, 
+	900, 901, 901, 900, 900, 900, 901, 901, 
+	900, 901, 901, 901, 900, 901, 901, 901, 
+	901, 900, 901, 901, 901, 900, 901, 901, 
+	900, 973, 974, 959, 900, 901, 900, 901, 
+	901, 900, 975, 976, 977, 978, 979, 980, 
+	900, 981, 982, 983, 984, 985, 900, 901, 
+	900, 901, 900, 901, 900, 901, 901, 901, 
+	901, 901, 900, 901, 900, 986, 987, 988, 
+	989, 990, 991, 992, 993, 994, 995, 996, 
+	997, 998, 999, 1000, 1001, 1002, 999, 1003, 
+	1004, 1005, 1006, 1007, 900, 901, 901, 900, 
+	900, 901, 900, 900, 901, 901, 901, 900, 
+	901, 900, 901, 901, 900, 900, 900, 901, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	900, 901, 901, 901, 901, 901, 901, 901, 
+	900, 901, 900, 901, 900, 901, 900, 900, 
+	901, 901, 901, 900, 900, 900, 901, 900, 
+	901, 901, 900, 901, 900, 901, 901, 900, 
+	901, 901, 900, 1008, 1009, 1010, 1011, 900, 
+	901, 900, 901, 900, 901, 900, 901, 900, 
+	1012, 900, 901, 900, 1013, 1014, 1015, 1016, 
+	1017, 1018, 900, 901, 901, 901, 900, 900, 
+	900, 900, 901, 901, 900, 901, 901, 900, 
+	900, 900, 901, 901, 901, 901, 900, 1019, 
+	1020, 1021, 900, 901, 901, 901, 901, 901, 
+	900, 901, 900, 901, 900, 1022, 900, 1023, 
+	1024, 1025, 1027, 1026, 900, 901, 900, 900, 
+	901, 901, 951, 952, 1028, 953, 954, 955, 
+	900, 901, 900, 975, 976, 977, 978, 979, 
+	980, 1029, 900, 1030, 1031, 1032, 900, 1033, 
+	900, 1033, 900, 900, 1033, 1033, 900, 1033, 
+	1033, 900, 1033, 1033, 1033, 900, 1033, 900, 
+	1033, 1033, 900, 1033, 1033, 1033, 1033, 900, 
+	1033, 1033, 900, 900, 1033, 1033, 900, 1033, 
+	900, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 
+	1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 
+	1050, 1051, 1052, 1053, 920, 1054, 1055, 1056, 
+	1057, 1058, 1059, 1060, 1061, 1062, 1041, 900, 
+	1033, 1033, 1033, 1033, 900, 1033, 900, 1033, 
+	1033, 900, 901, 901, 900, 900, 901, 1033, 
+	1033, 900, 1033, 1033, 900, 1033, 900, 901, 
+	1033, 1033, 1033, 901, 901, 900, 1033, 1033, 
+	1033, 900, 900, 900, 1033, 900, 901, 901, 
+	1033, 1033, 901, 900, 1033, 1033, 1033, 900, 
+	1033, 900, 1033, 900, 1033, 900, 901, 900, 
+	900, 1033, 1033, 900, 1033, 900, 901, 1033, 
+	1033, 901, 1033, 900, 901, 1033, 1033, 901, 
+	901, 1033, 1033, 900, 1033, 1033, 901, 900, 
+	1033, 1033, 1033, 901, 901, 901, 900, 1033, 
+	901, 1033, 900, 900, 900, 901, 900, 900, 
+	900, 1033, 1033, 1033, 901, 1033, 901, 900, 
+	1033, 1033, 901, 901, 901, 1033, 1033, 1033, 
+	900, 1033, 1033, 901, 901, 900, 900, 900, 
+	1033, 1033, 1033, 900, 1033, 900, 901, 1033, 
+	1033, 1033, 1033, 901, 1033, 901, 901, 900, 
+	1033, 901, 1033, 900, 1033, 900, 1033, 901, 
+	1033, 1033, 900, 1033, 900, 1033, 1033, 1033, 
+	1033, 901, 900, 901, 1033, 900, 1033, 1033, 
+	1033, 1033, 900, 1033, 900, 1063, 1064, 1065, 
+	1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 
+	1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 
+	1082, 1083, 900, 901, 1033, 1033, 901, 1033, 
+	900, 901, 1033, 1033, 1033, 900, 1033, 901, 
+	1033, 1033, 1033, 900, 1033, 900, 1033, 1033, 
+	900, 1033, 1033, 900, 901, 1033, 901, 900, 
+	1033, 1033, 1033, 900, 901, 1033, 900, 1033, 
+	1033, 900, 1033, 1033, 901, 1033, 901, 901, 
+	1033, 900, 1033, 1033, 901, 900, 1033, 1033, 
+	1033, 1033, 901, 1033, 1033, 901, 1033, 900, 
+	1033, 900, 901, 901, 901, 1033, 1033, 901, 
+	900, 1033, 900, 1033, 900, 901, 901, 901, 
+	901, 1033, 1033, 901, 1033, 900, 901, 1033, 
+	1033, 901, 1033, 901, 900, 901, 1033, 901, 
+	1033, 900, 901, 1033, 1033, 1033, 1033, 901, 
+	1033, 900, 1033, 1033, 900, 1084, 1085, 1086, 
+	1087, 1088, 900, 1033, 899, 900, 1033, 900, 
+	1033, 900, 1033, 900, 1033, 900, 1089, 1090, 
+	900, 1033, 900, 1033, 900, 1091, 1092, 1093, 
+	1094, 962, 1095, 1096, 1097, 1098, 1099, 1100, 
+	1101, 1102, 1103, 1104, 900, 1033, 1033, 900, 
+	1033, 900, 1033, 900, 1033, 1033, 1033, 901, 
+	901, 1033, 900, 1033, 900, 1033, 900, 901, 
+	1033, 900, 1033, 901, 900, 901, 1033, 1033, 
+	1033, 901, 1033, 901, 900, 1033, 900, 901, 
+	1033, 901, 1033, 901, 1033, 900, 1033, 1033, 
+	901, 1033, 900, 1033, 1033, 1033, 1033, 900, 
+	1033, 901, 901, 1033, 1033, 901, 900, 1033, 
+	1033, 901, 1033, 901, 900, 1105, 1106, 1092, 
+	900, 1033, 900, 1033, 1033, 900, 1107, 1108, 
+	1109, 1110, 1111, 1112, 1113, 900, 1114, 1115, 
+	1116, 1117, 1118, 900, 1033, 900, 1033, 900, 
+	1033, 900, 1033, 1033, 1033, 1033, 1033, 900, 
+	1033, 900, 1119, 1120, 1121, 1122, 1123, 1124, 
+	1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 
+	1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 
+	1141, 900, 1033, 901, 1033, 900, 900, 1033, 
+	901, 900, 901, 901, 900, 1033, 901, 1033, 
+	1033, 900, 1033, 900, 901, 1033, 901, 1033, 
+	901, 900, 900, 1033, 900, 901, 1033, 1033, 
+	901, 1033, 901, 1033, 900, 1033, 901, 1033, 
+	900, 1033, 1033, 901, 1033, 901, 900, 1033, 
+	1033, 901, 901, 901, 901, 1033, 1033, 900, 
+	901, 1033, 900, 901, 901, 1033, 900, 1033, 
+	901, 1033, 901, 1033, 901, 1033, 900, 901, 
+	900, 1033, 1033, 901, 901, 1033, 901, 1033, 
+	900, 900, 900, 1033, 1033, 901, 1033, 901, 
+	1033, 900, 900, 1033, 901, 901, 1033, 901, 
+	1033, 900, 901, 1033, 901, 1033, 900, 901, 
+	901, 1033, 1033, 900, 901, 901, 901, 1033, 
+	1033, 900, 1142, 1143, 1010, 1144, 900, 1033, 
+	900, 1033, 900, 1033, 900, 1145, 900, 1033, 
+	900, 1146, 1147, 1148, 1149, 1150, 1151, 900, 
+	901, 901, 1033, 1033, 1033, 900, 900, 900, 
+	900, 1033, 1033, 900, 1033, 1033, 900, 900, 
+	900, 1033, 1033, 1033, 1033, 900, 1152, 1153, 
+	1154, 900, 1033, 1033, 1033, 1033, 1033, 900, 
+	1033, 900, 1033, 900, 1155, 900, 901, 900, 
+	1156, 900, 1157, 1158, 1159, 1161, 1160, 900, 
+	1033, 900, 900, 1033, 1033, 901, 900, 901, 
+	900, 3, 265, 3, 1, 1162, 3, 1, 
+	1162, 1163, 1163, 1162, 1162, 1163, 1162, 1162, 
+	1163, 1162, 1162, 1162, 1163, 1162, 1163, 1162, 
+	1162, 1163, 1162, 1162, 1162, 1162, 1163, 1162, 
+	1162, 1163, 1163, 1162, 1162, 1163, 1162, 1163, 
+	1164, 1165, 1166, 1167, 1168, 1169, 1170, 1172, 
+	1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 
+	1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 
+	1189, 1190, 1191, 1192, 1193, 1171, 1163, 1162, 
+	1162, 1162, 1162, 1163, 1162, 1163, 1162, 1162, 
+	1163, 1194, 1194, 1163, 1163, 1194, 1162, 1194, 
+	1163, 1163, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1194, 1163, 1194, 1163, 1194, 1194, 
+	1163, 1194, 1194, 1194, 1194, 1163, 1194, 1194, 
+	1163, 1163, 1194, 1194, 1163, 1194, 1163, 1195, 
+	1196, 1197, 1198, 1199, 1201, 1202, 1203, 1205, 
+	1206, 1207, 1208, 1209, 1210, 1211, 1212, 1184, 
+	1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 
+	1221, 1200, 1204, 1163, 1194, 1194, 1194, 1194, 
+	1163, 1194, 1163, 1194, 1194, 1163, 1163, 1163, 
+	1194, 1163, 1163, 1163, 1194, 1194, 1194, 1194, 
+	1163, 1163, 1163, 1163, 1163, 1163, 1194, 1163, 
+	1163, 1163, 1163, 1163, 1163, 1194, 1163, 1163, 
+	1163, 1163, 1194, 1194, 1194, 1194, 1163, 1194, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1163, 1163, 1163, 1163, 1163, 1194, 1194, 1194, 
+	1194, 1194, 1194, 1163, 1194, 1194, 1163, 1163, 
+	1163, 1163, 1163, 1163, 1194, 1194, 1163, 1194, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1163, 1222, 
+	1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 
+	1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 
+	1239, 1240, 1241, 1242, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1194, 1163, 1194, 1194, 1194, 1194, 
+	1163, 1194, 1163, 1194, 1194, 1163, 1194, 1194, 
+	1163, 1194, 1163, 1163, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1163, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1163, 1163, 1163, 1194, 1194, 1194, 
+	1163, 1194, 1163, 1194, 1163, 1194, 1194, 1194, 
+	1194, 1194, 1163, 1194, 1194, 1163, 1243, 1244, 
+	1245, 1246, 1247, 1163, 1194, 1248, 1163, 1243, 
+	1244, 1249, 1245, 1246, 1247, 1163, 1194, 1163, 
+	1194, 1163, 1194, 1163, 1194, 1163, 1194, 1163, 
+	1250, 1251, 1163, 1194, 1163, 1194, 1163, 1252, 
+	1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, 
+	1261, 1262, 1263, 1264, 1265, 1266, 1163, 1194, 
+	1194, 1163, 1194, 1163, 1194, 1163, 1194, 1194, 
+	1194, 1194, 1163, 1194, 1194, 1163, 1163, 1163, 
+	1194, 1194, 1163, 1194, 1163, 1194, 1194, 1163, 
+	1163, 1163, 1194, 1194, 1163, 1194, 1194, 1194, 
+	1163, 1194, 1194, 1194, 1194, 1163, 1194, 1194, 
+	1194, 1163, 1194, 1194, 1163, 1267, 1268, 1253, 
+	1163, 1194, 1163, 1194, 1194, 1163, 1269, 1270, 
+	1271, 1272, 1273, 1274, 1275, 1163, 1276, 1277, 
+	1278, 1279, 1280, 1163, 1194, 1163, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1194, 1194, 1194, 1163, 
+	1194, 1163, 1281, 1282, 1283, 1284, 1285, 1286, 
+	1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 
+	1295, 1296, 1297, 1294, 1298, 1299, 1300, 1301, 
+	1302, 1163, 1194, 1194, 1163, 1163, 1194, 1163, 
+	1163, 1194, 1194, 1194, 1163, 1194, 1163, 1194, 
+	1194, 1163, 1163, 1163, 1194, 1194, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1194, 1163, 1194, 1194, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1163, 1194, 1163, 1163, 1194, 1194, 1194, 
+	1163, 1163, 1163, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1303, 1304, 1305, 1306, 1163, 1194, 1163, 1194, 
+	1163, 1194, 1163, 1194, 1163, 1307, 1163, 1194, 
+	1163, 1308, 1309, 1310, 1311, 1312, 1313, 1163, 
+	1194, 1194, 1194, 1163, 1163, 1163, 1163, 1194, 
+	1194, 1163, 1194, 1194, 1163, 1163, 1163, 1194, 
+	1194, 1194, 1194, 1163, 1314, 1315, 1316, 1163, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1163, 1317, 1318, 1319, 1163, 1162, 1163, 
+	1194, 1163, 1194, 1163, 1320, 1163, 1321, 1322, 
+	1323, 1325, 1324, 1163, 1194, 1163, 1163, 1194, 
+	1194, 1269, 1270, 1271, 1272, 1273, 1274, 1163, 
+	1162, 1163, 1162, 1162, 1163, 1162, 1163, 1194, 
+	1162, 1162, 1162, 1194, 1194, 1163, 1162, 1162, 
+	1162, 1163, 1163, 1163, 1162, 1163, 1194, 1194, 
+	1162, 1162, 1194, 1163, 1162, 1162, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1162, 1163, 1194, 1163, 
+	1163, 1162, 1162, 1163, 1162, 1163, 1194, 1162, 
+	1162, 1194, 1162, 1163, 1194, 1162, 1162, 1194, 
+	1194, 1162, 1162, 1163, 1162, 1162, 1194, 1163, 
+	1162, 1162, 1162, 1194, 1194, 1194, 1163, 1162, 
+	1194, 1162, 1163, 1163, 1163, 1194, 1163, 1163, 
+	1163, 1162, 1162, 1162, 1194, 1162, 1194, 1163, 
+	1162, 1162, 1194, 1194, 1194, 1162, 1162, 1162, 
+	1163, 1162, 1162, 1194, 1194, 1163, 1163, 1163, 
+	1162, 1162, 1162, 1163, 1162, 1163, 1194, 1162, 
+	1162, 1162, 1162, 1194, 1162, 1194, 1194, 1163, 
+	1162, 1194, 1162, 1163, 1162, 1163, 1162, 1194, 
+	1162, 1162, 1163, 1162, 1163, 1162, 1162, 1162, 
+	1162, 1194, 1163, 1194, 1162, 1163, 1162, 1162, 
+	1162, 1162, 1163, 1162, 1163, 1326, 1327, 1328, 
+	1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 
+	1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 
+	1345, 1346, 1163, 1194, 1162, 1162, 1194, 1162, 
+	1163, 1194, 1162, 1162, 1162, 1163, 1162, 1194, 
+	1162, 1162, 1162, 1163, 1162, 1163, 1162, 1162, 
+	1163, 1162, 1162, 1163, 1194, 1162, 1194, 1163, 
+	1162, 1162, 1162, 1163, 1194, 1162, 1163, 1162, 
+	1162, 1163, 1162, 1162, 1194, 1162, 1194, 1194, 
+	1162, 1163, 1162, 1162, 1194, 1163, 1162, 1162, 
+	1162, 1162, 1194, 1162, 1162, 1194, 1162, 1163, 
+	1162, 1163, 1194, 1194, 1194, 1162, 1162, 1194, 
+	1163, 1162, 1163, 1162, 1163, 1194, 1194, 1194, 
+	1194, 1162, 1162, 1194, 1162, 1163, 1194, 1162, 
+	1162, 1194, 1162, 1194, 1163, 1194, 1162, 1194, 
+	1162, 1163, 1194, 1162, 1162, 1162, 1162, 1194, 
+	1162, 1163, 1162, 1162, 1163, 1347, 1348, 1349, 
+	1350, 1351, 1163, 1162, 1248, 1163, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1162, 1163, 1352, 1353, 
+	1163, 1162, 1163, 1162, 1163, 1354, 1355, 1356, 
+	1357, 1256, 1358, 1359, 1360, 1361, 1362, 1363, 
+	1364, 1365, 1366, 1367, 1163, 1162, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1162, 1162, 1162, 1194, 
+	1194, 1162, 1163, 1162, 1163, 1162, 1163, 1194, 
+	1162, 1163, 1162, 1194, 1163, 1194, 1162, 1162, 
+	1162, 1194, 1162, 1194, 1163, 1162, 1163, 1194, 
+	1162, 1194, 1162, 1194, 1162, 1163, 1162, 1162, 
+	1194, 1162, 1163, 1162, 1162, 1162, 1162, 1163, 
+	1162, 1194, 1194, 1162, 1162, 1194, 1163, 1162, 
+	1162, 1194, 1162, 1194, 1163, 1368, 1369, 1355, 
+	1163, 1162, 1163, 1162, 1162, 1163, 1370, 1371, 
+	1372, 1373, 1374, 1375, 1376, 1163, 1377, 1378, 
+	1379, 1380, 1381, 1163, 1162, 1163, 1162, 1163, 
+	1162, 1163, 1162, 1162, 1162, 1162, 1162, 1163, 
+	1162, 1163, 1382, 1383, 1384, 1385, 1386, 1387, 
+	1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 
+	1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 
+	1404, 1163, 1162, 1194, 1162, 1163, 1163, 1162, 
+	1194, 1163, 1194, 1194, 1163, 1162, 1194, 1162, 
+	1162, 1163, 1162, 1163, 1194, 1162, 1194, 1162, 
+	1194, 1163, 1163, 1162, 1163, 1194, 1162, 1162, 
+	1194, 1162, 1194, 1162, 1163, 1162, 1194, 1162, 
+	1163, 1162, 1162, 1194, 1162, 1194, 1163, 1162, 
+	1162, 1194, 1194, 1194, 1194, 1162, 1162, 1163, 
+	1194, 1162, 1163, 1194, 1194, 1162, 1163, 1162, 
+	1194, 1162, 1194, 1162, 1194, 1162, 1163, 1194, 
+	1163, 1162, 1162, 1194, 1194, 1162, 1194, 1162, 
+	1163, 1163, 1163, 1162, 1162, 1194, 1162, 1194, 
+	1162, 1163, 1163, 1162, 1194, 1194, 1162, 1194, 
+	1162, 1163, 1194, 1162, 1194, 1162, 1163, 1194, 
+	1194, 1162, 1162, 1163, 1194, 1194, 1194, 1162, 
+	1162, 1163, 1405, 1406, 1305, 1407, 1163, 1162, 
+	1163, 1162, 1163, 1162, 1163, 1408, 1163, 1162, 
+	1163, 1409, 1410, 1411, 1412, 1413, 1414, 1163, 
+	1194, 1194, 1162, 1162, 1162, 1163, 1163, 1163, 
+	1163, 1162, 1162, 1163, 1162, 1162, 1163, 1163, 
+	1163, 1162, 1162, 1162, 1162, 1163, 1415, 1416, 
+	1417, 1163, 1162, 1162, 1162, 1162, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1418, 1163, 1194, 1163, 
+	1419, 1163, 1420, 1421, 1422, 1424, 1423, 1163, 
+	1162, 1163, 1163, 1162, 1162, 1162, 3, 1, 
+	3, 1162, 3, 1, 601, 1, 1425, 1427, 
+	1428, 1429, 1430, 1431, 1432, 1427, 1428, 1429, 
+	1430, 1431, 1432, 1427, 601, 1426, 890, 1, 
+	3, 610, 3, 1, 875, 875, 875, 877, 
+	1, 875, 875, 877, 875, 875, 877, 875, 
+	875, 875, 877, 875, 875, 877, 875, 875, 
+	877, 875, 875, 1, 877, 1429, 1430, 1431, 
+	1432, 1426, 1427, 1429, 1430, 1431, 1432, 1426, 
+	1427, 1429, 1430, 1431, 1432, 1426, 1427, 1429, 
+	1430, 1431, 1432, 1426, 1427, 1429, 1430, 1431, 
+	1432, 1426, 1427, 1429, 1430, 1431, 1432, 1426, 
+	1427, 1429, 1430, 1431, 1432, 1426, 1427, 1429, 
+	1430, 1431, 1432, 1426, 1427, 1429, 1430, 1431, 
+	1432, 1426, 1427, 1428, 890, 1430, 1431, 1432, 
+	1426, 1427, 1428, 1430, 1431, 1432, 1426, 1427, 
+	1428, 1430, 1431, 1432, 1426, 1427, 1428, 1430, 
+	1431, 1432, 1426, 1427, 1428, 1430, 1431, 1432, 
+	1426, 1427, 1428, 1430, 1431, 1432, 1426, 1427, 
+	1428, 1430, 1431, 1432, 1426, 1427, 1428, 1430, 
+	1431, 1432, 1426, 1427, 1428, 1430, 1431, 1432, 
+	1426, 1427, 1428, 1429, 890, 1431, 1432, 1426, 
+	1427, 1428, 1429, 1431, 1432, 1426, 1427, 1428, 
+	1429, 1431, 1432, 1426, 1427, 1428, 1429, 1431, 
+	1432, 1426, 1427, 1428, 1429, 1431, 1433, 1434, 
+	1435, 1437, 1430, 1436, 1, 890, 875, 3, 
+	875, 877, 3, 877, 3, 1, 875, 1, 
+	265, 265, 1, 265, 1438, 1439, 601, 1, 
+	265, 3, 1, 3, 3, 265, 3, 1, 
+	1441, 1442, 1443, 1444, 1440, 1, 1445, 1446, 
+	601, 1, 266, 3, 1, 3, 266, 3, 
+	1, 1447, 601, 1, 3, 265, 3, 1, 
+	1448, 601, 1, 3, 265, 3, 1, 1449, 
+	1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 
+	1458, 1459, 601, 1, 3, 1460, 1, 1462, 
+	1461, 1461, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1462, 1461, 1462, 1461, 1462, 1462, 
+	1461, 1462, 1462, 1462, 1462, 1461, 1462, 1462, 
+	1461, 1461, 1462, 1462, 1461, 1462, 1461, 1463, 
+	1464, 1465, 1466, 1467, 1469, 1470, 1471, 1473, 
+	1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, 
+	1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 
+	1490, 1468, 1472, 1461, 1462, 1462, 1462, 1462, 
+	1461, 1462, 1461, 1462, 1462, 1461, 1461, 1461, 
+	1462, 1461, 1461, 1461, 1462, 1462, 1462, 1462, 
+	1461, 1461, 1461, 1461, 1461, 1461, 1462, 1461, 
+	1461, 1461, 1461, 1461, 1461, 1462, 1461, 1461, 
+	1461, 1461, 1462, 1462, 1462, 1462, 1461, 1462, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1461, 1461, 1461, 1461, 1461, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1461, 1462, 1462, 1461, 1461, 
+	1461, 1461, 1461, 1461, 1462, 1462, 1461, 1462, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1461, 1491, 
+	1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 
+	1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 
+	1508, 1509, 1510, 1511, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1462, 1461, 1462, 1462, 1462, 1462, 
+	1461, 1462, 1461, 1462, 1462, 1461, 1462, 1462, 
+	1461, 1462, 1461, 1461, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1461, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1461, 1461, 1461, 1462, 1462, 1462, 
+	1461, 1462, 1461, 1462, 1461, 1462, 1462, 1462, 
+	1462, 1462, 1461, 1462, 1462, 1461, 1512, 1513, 
+	1514, 1515, 1516, 1461, 1462, 1517, 1461, 1512, 
+	1513, 1518, 1514, 1515, 1516, 1461, 1462, 1461, 
+	1462, 1461, 1462, 1461, 1462, 1461, 1462, 1461, 
+	1519, 1520, 1461, 1462, 1461, 1462, 1461, 1521, 
+	1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 
+	1530, 1531, 1532, 1533, 1534, 1535, 1461, 1462, 
+	1462, 1461, 1462, 1461, 1462, 1461, 1462, 1462, 
+	1462, 1462, 1461, 1462, 1462, 1461, 1461, 1461, 
+	1462, 1462, 1461, 1462, 1461, 1462, 1462, 1461, 
+	1461, 1461, 1462, 1462, 1461, 1462, 1462, 1462, 
+	1461, 1462, 1462, 1462, 1462, 1461, 1462, 1462, 
+	1462, 1461, 1462, 1462, 1461, 1536, 1537, 1522, 
+	1461, 1462, 1461, 1462, 1462, 1461, 1538, 1539, 
+	1540, 1541, 1542, 1543, 1544, 1461, 1545, 1546, 
+	1547, 1548, 1549, 1461, 1462, 1461, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1462, 1462, 1462, 1461, 
+	1462, 1461, 1550, 1551, 1552, 1553, 1554, 1555, 
+	1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 
+	1564, 1565, 1566, 1563, 1567, 1568, 1569, 1570, 
+	1571, 1461, 1462, 1462, 1461, 1461, 1462, 1461, 
+	1461, 1462, 1462, 1462, 1461, 1462, 1461, 1462, 
+	1462, 1461, 1461, 1461, 1462, 1462, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1462, 1461, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1461, 1462, 1461, 1461, 1462, 1462, 1462, 
+	1461, 1461, 1461, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1572, 1573, 1574, 1575, 1461, 1462, 1461, 1462, 
+	1461, 1462, 1461, 1462, 1461, 1576, 1461, 1462, 
+	1461, 1577, 1578, 1579, 1580, 1581, 1582, 1461, 
+	1462, 1462, 1462, 1461, 1461, 1461, 1461, 1462, 
+	1462, 1461, 1462, 1462, 1461, 1461, 1461, 1462, 
+	1462, 1462, 1462, 1461, 1583, 1584, 1585, 1461, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1461, 1586, 1587, 1588, 1461, 1589, 1461, 
+	1589, 1461, 1461, 1589, 1589, 1461, 1589, 1589, 
+	1461, 1589, 1589, 1589, 1461, 1589, 1461, 1589, 
+	1589, 1461, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1589, 1461, 1461, 1589, 1589, 1461, 1589, 1461, 
+	1590, 1591, 1592, 1593, 1594, 1595, 1596, 1598, 
+	1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 
+	1607, 1608, 1609, 1481, 1610, 1611, 1612, 1613, 
+	1614, 1615, 1616, 1617, 1618, 1597, 1461, 1589, 
+	1589, 1589, 1589, 1461, 1589, 1461, 1589, 1589, 
+	1461, 1462, 1462, 1461, 1461, 1462, 1589, 1589, 
+	1461, 1589, 1589, 1461, 1589, 1461, 1462, 1589, 
+	1589, 1589, 1462, 1462, 1461, 1589, 1589, 1589, 
+	1461, 1461, 1461, 1589, 1461, 1462, 1462, 1589, 
+	1589, 1462, 1461, 1589, 1589, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1589, 1461, 1462, 1461, 1461, 
+	1589, 1589, 1461, 1589, 1461, 1462, 1589, 1589, 
+	1462, 1589, 1461, 1462, 1589, 1589, 1462, 1462, 
+	1589, 1589, 1461, 1589, 1589, 1462, 1461, 1589, 
+	1589, 1589, 1462, 1462, 1462, 1461, 1589, 1462, 
+	1589, 1461, 1461, 1461, 1462, 1461, 1461, 1461, 
+	1589, 1589, 1589, 1462, 1589, 1462, 1461, 1589, 
+	1589, 1462, 1462, 1462, 1589, 1589, 1589, 1461, 
+	1589, 1589, 1462, 1462, 1461, 1461, 1461, 1589, 
+	1589, 1589, 1461, 1589, 1461, 1462, 1589, 1589, 
+	1589, 1589, 1462, 1589, 1462, 1462, 1461, 1589, 
+	1462, 1589, 1461, 1589, 1461, 1589, 1462, 1589, 
+	1589, 1461, 1589, 1461, 1589, 1589, 1589, 1589, 
+	1462, 1461, 1462, 1589, 1461, 1589, 1589, 1589, 
+	1589, 1461, 1589, 1461, 1619, 1620, 1621, 1622, 
+	1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 
+	1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 
+	1639, 1461, 1462, 1589, 1589, 1462, 1589, 1461, 
+	1462, 1589, 1589, 1589, 1461, 1589, 1462, 1589, 
+	1589, 1589, 1461, 1589, 1461, 1589, 1589, 1461, 
+	1589, 1589, 1461, 1462, 1589, 1462, 1461, 1589, 
+	1589, 1589, 1461, 1462, 1589, 1461, 1589, 1589, 
+	1461, 1589, 1589, 1462, 1589, 1462, 1462, 1589, 
+	1461, 1589, 1589, 1462, 1461, 1589, 1589, 1589, 
+	1589, 1462, 1589, 1589, 1462, 1589, 1461, 1589, 
+	1461, 1462, 1462, 1462, 1589, 1589, 1462, 1461, 
+	1589, 1461, 1589, 1461, 1462, 1462, 1462, 1462, 
+	1589, 1589, 1462, 1589, 1461, 1462, 1589, 1589, 
+	1462, 1589, 1462, 1461, 1462, 1589, 1462, 1589, 
+	1461, 1462, 1589, 1589, 1589, 1589, 1462, 1589, 
+	1461, 1589, 1589, 1461, 1640, 1641, 1642, 1643, 
+	1644, 1461, 1589, 1517, 1461, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1589, 1461, 1645, 1646, 1461, 
+	1589, 1461, 1589, 1461, 1647, 1648, 1649, 1650, 
+	1525, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 
+	1658, 1659, 1660, 1461, 1589, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1589, 1589, 1589, 1462, 1462, 
+	1589, 1461, 1589, 1461, 1589, 1461, 1462, 1589, 
+	1461, 1589, 1462, 1461, 1462, 1589, 1589, 1589, 
+	1462, 1589, 1462, 1461, 1589, 1461, 1462, 1589, 
+	1462, 1589, 1462, 1589, 1461, 1589, 1589, 1462, 
+	1589, 1461, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1462, 1462, 1589, 1589, 1462, 1461, 1589, 1589, 
+	1462, 1589, 1462, 1461, 1661, 1662, 1648, 1461, 
+	1589, 1461, 1589, 1589, 1461, 1663, 1664, 1665, 
+	1666, 1667, 1668, 1669, 1461, 1670, 1671, 1672, 
+	1673, 1674, 1461, 1589, 1461, 1589, 1461, 1589, 
+	1461, 1589, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1461, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 
+	1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 
+	1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 
+	1461, 1589, 1462, 1589, 1461, 1461, 1589, 1462, 
+	1461, 1462, 1462, 1461, 1589, 1462, 1589, 1589, 
+	1461, 1589, 1461, 1462, 1589, 1462, 1589, 1462, 
+	1461, 1461, 1589, 1461, 1462, 1589, 1589, 1462, 
+	1589, 1462, 1589, 1461, 1589, 1462, 1589, 1461, 
+	1589, 1589, 1462, 1589, 1462, 1461, 1589, 1589, 
+	1462, 1462, 1462, 1462, 1589, 1589, 1461, 1462, 
+	1589, 1461, 1462, 1462, 1589, 1461, 1589, 1462, 
+	1589, 1462, 1589, 1462, 1589, 1461, 1462, 1461, 
+	1589, 1589, 1462, 1462, 1589, 1462, 1589, 1461, 
+	1461, 1461, 1589, 1589, 1462, 1589, 1462, 1589, 
+	1461, 1461, 1589, 1462, 1462, 1589, 1462, 1589, 
+	1461, 1462, 1589, 1462, 1589, 1461, 1462, 1462, 
+	1589, 1589, 1461, 1462, 1462, 1462, 1589, 1589, 
+	1461, 1698, 1699, 1574, 1700, 1461, 1589, 1461, 
+	1589, 1461, 1589, 1461, 1701, 1461, 1589, 1461, 
+	1702, 1703, 1704, 1705, 1706, 1707, 1461, 1462, 
+	1462, 1589, 1589, 1589, 1461, 1461, 1461, 1461, 
+	1589, 1589, 1461, 1589, 1589, 1461, 1461, 1461, 
+	1589, 1589, 1589, 1589, 1461, 1708, 1709, 1710, 
+	1461, 1589, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1711, 1461, 1462, 1461, 1712, 
+	1461, 1713, 1714, 1715, 1717, 1716, 1461, 1589, 
+	1461, 1461, 1589, 1589, 1462, 1461, 1462, 1461, 
+	1718, 1461, 1719, 1720, 1721, 1723, 1722, 1461, 
+	1462, 1461, 1461, 1462, 1462, 1538, 1539, 1540, 
+	1541, 1542, 1543, 1461, 1538, 1539, 1540, 1541, 
+	1542, 1543, 1724, 1461, 1725, 1461, 1462, 1461, 
+	1162, 3, 1, 3, 1162, 3, 1162, 3, 
+	1, 1162, 1162, 3, 1162, 3, 1162, 3, 
+	1162, 3, 1162, 3, 1, 3, 3, 1162, 
+	1162, 3, 1, 1162, 1162, 3, 1, 1162, 
+	3, 1162, 3, 1, 3, 1162, 3, 1162, 
+	3, 1, 1162, 3, 1162, 3, 1, 1162, 
+	3, 1, 1162, 1162, 3, 3, 1162, 3, 
+	1162, 3, 1162, 1, 1440, 1, 1726, 1440, 
+	1, 1727, 1435, 1437, 1728, 1437, 601, 1436, 
+	1, 265, 3, 1, 3, 265, 1, 1, 
+	1730, 1729, 1733, 1734, 1735, 1736, 1737, 1738, 
+	1739, 1741, 1742, 1743, 1744, 1745, 1746, 1748, 
+	1729, 1, 1732, 1740, 1747, 1, 1731, 262, 
+	264, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 
+	1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 
+	1765, 1766, 1767, 1749, 262, 264, 1750, 1751, 
+	1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 
+	1760, 1761, 1768, 1763, 1764, 1765, 1769, 1767, 
+	1749, 256, 258, 1770, 1771, 1772, 1773, 1774, 
+	1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 
+	1783, 1784, 1785, 1786, 1787, 1749, 1789, 1790, 
+	1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 
+	1799, 1800, 1801, 1803, 268, 530, 576, 1802, 
+	1788, 527, 529, 1804, 1805, 1806, 1807, 1808, 
+	1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 
+	1817, 1818, 1819, 1820, 1821, 1788, 527, 529, 
+	1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 
+	1812, 1813, 1814, 1815, 1822, 1817, 1818, 1819, 
+	1823, 1821, 1788, 521, 523, 1824, 1825, 1826, 
+	1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 
+	1835, 1836, 1837, 1838, 1839, 1840, 1841, 1788, 
+	527, 529, 1804, 1805, 1806, 1807, 1808, 1809, 
+	1810, 1811, 1812, 1813, 1814, 1842, 1816, 1817, 
+	1843, 1844, 1845, 1846, 1819, 1820, 1821, 1788, 
+	527, 529, 1804, 1805, 1806, 1807, 1808, 1809, 
+	1810, 1811, 1812, 1813, 1814, 1847, 1816, 1817, 
+	1818, 1848, 1819, 1820, 1821, 1788, 527, 529, 
+	1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 
+	1812, 1813, 1814, 1849, 1816, 1817, 1818, 1850, 
+	1819, 1820, 1821, 1788, 527, 529, 1804, 1805, 
+	1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 
+	1814, 1851, 1816, 1817, 1818, 1852, 1819, 1820, 
+	1821, 1788, 527, 529, 1804, 1805, 1806, 1807, 
+	1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 
+	1816, 1817, 1818, 1819, 1853, 1821, 1788, 871, 
+	873, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 
+	1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 
+	1870, 1871, 1872, 1873, 1874, 1875, 1854, 871, 
+	873, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 
+	1862, 1863, 1864, 1865, 1876, 1867, 1868, 1877, 
+	1873, 1874, 1875, 1854, 871, 873, 1855, 1856, 
+	1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 
+	1865, 1876, 1878, 1868, 1877, 1873, 1879, 1875, 
+	1854, 865, 867, 1880, 1881, 1882, 1883, 1884, 
+	1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 
+	1893, 1894, 1895, 1896, 1897, 1854, 871, 873, 
+	1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 
+	1863, 1864, 1865, 1898, 1867, 1868, 1877, 1899, 
+	1873, 1874, 1875, 1854, 871, 873, 1855, 1856, 
+	1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 
+	1865, 1900, 1867, 1868, 1877, 1901, 1873, 1874, 
+	1875, 1854, 871, 873, 1855, 1856, 1857, 1858, 
+	1859, 1860, 1861, 1862, 1863, 1864, 1865, 1902, 
+	1867, 1868, 1877, 1903, 1873, 1874, 1875, 1854, 
+	1025, 1027, 1905, 1906, 1907, 1908, 1909, 1910, 
+	1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 
+	1919, 1920, 1921, 1922, 1904, 1025, 1027, 1905, 
+	1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 
+	1914, 1915, 1916, 1923, 1918, 1919, 1920, 1924, 
+	1922, 1904, 1159, 1161, 1925, 1926, 1927, 1928, 
+	1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 
+	1937, 1938, 1939, 1940, 1941, 1942, 1904, 1422, 
+	1424, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 
+	1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 
+	1959, 1960, 1961, 1943, 1323, 1325, 1962, 1963, 
+	1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 
+	1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 
+	1943, 1323, 1325, 1962, 1963, 1964, 1965, 1966, 
+	1967, 1968, 1969, 1970, 1971, 1972, 1973, 1980, 
+	1975, 1976, 1977, 1981, 1979, 1943, 1721, 1723, 
+	1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 
+	1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 
+	1999, 2000, 1982, 1721, 1723, 1983, 1984, 1985, 
+	1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 
+	1994, 1995, 1996, 1997, 1998, 2001, 2000, 1982, 
+	1721, 1723, 1983, 1984, 1985, 1986, 1987, 1988, 
+	1989, 1990, 1991, 1992, 1993, 1994, 2002, 1996, 
+	1997, 1998, 2003, 2000, 1982, 1715, 1717, 2004, 
+	2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 
+	2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 
+	2021, 1982, 
+}
+
+var _graphclust_trans_targs []int16 = []int16{
+	1974, 0, 1974, 1975, 15, 16, 17, 18, 
+	19, 20, 21, 22, 23, 24, 25, 26, 
+	27, 28, 29, 30, 31, 32, 33, 34, 
+	35, 36, 37, 38, 39, 40, 41, 42, 
+	44, 45, 46, 47, 48, 49, 50, 51, 
+	52, 53, 54, 55, 56, 57, 58, 59, 
+	60, 61, 62, 63, 64, 66, 68, 70, 
+	71, 72, 1976, 69, 74, 75, 77, 78, 
+	79, 80, 81, 82, 83, 84, 85, 86, 
+	87, 88, 89, 90, 91, 93, 94, 96, 
+	102, 125, 130, 132, 139, 143, 97, 98, 
+	99, 100, 101, 103, 104, 105, 106, 107, 
+	108, 109, 110, 111, 112, 113, 114, 115, 
+	116, 117, 118, 119, 120, 121, 122, 123, 
+	124, 126, 127, 128, 129, 131, 133, 134, 
+	135, 136, 137, 138, 140, 141, 142, 144, 
+	291, 292, 1977, 158, 159, 160, 161, 162, 
+	163, 164, 165, 166, 167, 168, 169, 170, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	188, 189, 190, 191, 192, 193, 194, 195, 
+	196, 197, 198, 199, 200, 201, 202, 203, 
+	204, 205, 206, 207, 208, 210, 211, 212, 
+	213, 214, 216, 217, 219, 220, 221, 222, 
+	223, 224, 225, 226, 227, 228, 229, 230, 
+	231, 232, 234, 235, 237, 243, 267, 271, 
+	273, 280, 284, 238, 239, 240, 241, 242, 
+	244, 245, 246, 247, 248, 249, 250, 251, 
+	252, 253, 254, 255, 256, 257, 258, 259, 
+	260, 261, 262, 263, 264, 265, 266, 268, 
+	269, 270, 272, 274, 275, 276, 277, 278, 
+	279, 281, 282, 283, 285, 287, 288, 289, 
+	145, 290, 146, 294, 295, 296, 2, 297, 
+	3, 1974, 1978, 1974, 1979, 315, 316, 317, 
+	318, 319, 320, 321, 322, 323, 324, 325, 
+	326, 327, 328, 329, 330, 331, 332, 333, 
+	334, 335, 336, 337, 338, 339, 340, 341, 
+	342, 344, 345, 346, 347, 348, 349, 350, 
+	351, 352, 353, 354, 355, 356, 357, 358, 
+	359, 360, 361, 362, 363, 364, 366, 368, 
+	370, 371, 372, 1980, 369, 374, 375, 377, 
+	378, 379, 380, 381, 382, 383, 384, 385, 
+	386, 387, 388, 389, 390, 391, 393, 394, 
+	396, 402, 425, 430, 432, 439, 443, 397, 
+	398, 399, 400, 401, 403, 404, 405, 406, 
+	407, 408, 409, 410, 411, 412, 413, 414, 
+	415, 416, 417, 418, 419, 420, 421, 422, 
+	423, 424, 426, 427, 428, 429, 431, 433, 
+	434, 435, 436, 437, 438, 440, 441, 442, 
+	444, 591, 592, 1981, 458, 459, 460, 461, 
+	462, 463, 464, 465, 466, 467, 468, 469, 
+	470, 471, 472, 473, 474, 475, 476, 477, 
+	478, 479, 480, 481, 482, 483, 484, 485, 
+	486, 488, 489, 490, 491, 492, 493, 494, 
+	495, 496, 497, 498, 499, 500, 501, 502, 
+	503, 504, 505, 506, 507, 508, 510, 511, 
+	512, 513, 514, 516, 517, 519, 520, 521, 
+	522, 523, 524, 525, 526, 527, 528, 529, 
+	530, 531, 532, 534, 535, 537, 543, 567, 
+	571, 573, 580, 584, 538, 539, 540, 541, 
+	542, 544, 545, 546, 547, 548, 549, 550, 
+	551, 552, 553, 554, 555, 556, 557, 558, 
+	559, 560, 561, 562, 563, 564, 565, 566, 
+	568, 569, 570, 572, 574, 575, 576, 577, 
+	578, 579, 581, 582, 583, 585, 587, 588, 
+	589, 445, 590, 446, 594, 595, 596, 302, 
+	597, 303, 599, 605, 606, 608, 610, 613, 
+	616, 640, 1982, 622, 1983, 612, 1984, 615, 
+	618, 620, 621, 624, 625, 629, 630, 631, 
+	632, 633, 634, 635, 1985, 628, 639, 642, 
+	643, 644, 645, 646, 649, 650, 651, 652, 
+	653, 654, 655, 656, 660, 661, 663, 664, 
+	647, 666, 669, 671, 673, 667, 668, 670, 
+	672, 674, 678, 679, 680, 681, 682, 683, 
+	684, 685, 686, 687, 1986, 676, 677, 690, 
+	691, 299, 695, 696, 698, 997, 1000, 1003, 
+	1027, 1974, 1987, 1974, 1988, 712, 713, 714, 
+	715, 716, 717, 718, 719, 720, 721, 722, 
+	723, 724, 725, 726, 727, 728, 729, 730, 
+	731, 732, 733, 734, 735, 736, 737, 738, 
+	739, 741, 742, 743, 744, 745, 746, 747, 
+	748, 749, 750, 751, 752, 753, 754, 755, 
+	756, 757, 758, 759, 760, 761, 763, 765, 
+	767, 768, 769, 1989, 766, 771, 772, 774, 
+	775, 776, 777, 778, 779, 780, 781, 782, 
+	783, 784, 785, 786, 787, 788, 790, 791, 
+	793, 799, 822, 827, 829, 836, 840, 794, 
+	795, 796, 797, 798, 800, 801, 802, 803, 
+	804, 805, 806, 807, 808, 809, 810, 811, 
+	812, 813, 814, 815, 816, 817, 818, 819, 
+	820, 821, 823, 824, 825, 826, 828, 830, 
+	831, 832, 833, 834, 835, 837, 838, 839, 
+	841, 988, 989, 1990, 855, 856, 857, 858, 
+	859, 860, 861, 862, 863, 864, 865, 866, 
+	867, 868, 869, 870, 871, 872, 873, 874, 
+	875, 876, 877, 878, 879, 880, 881, 882, 
+	883, 885, 886, 887, 888, 889, 890, 891, 
+	892, 893, 894, 895, 896, 897, 898, 899, 
+	900, 901, 902, 903, 904, 905, 907, 908, 
+	909, 910, 911, 913, 914, 916, 917, 918, 
+	919, 920, 921, 922, 923, 924, 925, 926, 
+	927, 928, 929, 931, 932, 934, 940, 964, 
+	968, 970, 977, 981, 935, 936, 937, 938, 
+	939, 941, 942, 943, 944, 945, 946, 947, 
+	948, 949, 950, 951, 952, 953, 954, 955, 
+	956, 957, 958, 959, 960, 961, 962, 963, 
+	965, 966, 967, 969, 971, 972, 973, 974, 
+	975, 976, 978, 979, 980, 982, 984, 985, 
+	986, 842, 987, 843, 991, 992, 993, 699, 
+	994, 700, 1009, 1991, 999, 1992, 1002, 1005, 
+	1007, 1008, 1011, 1012, 1016, 1017, 1018, 1019, 
+	1020, 1021, 1022, 1993, 1015, 1026, 1029, 1327, 
+	1328, 1626, 1627, 1994, 1974, 1995, 1043, 1044, 
+	1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 
+	1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 
+	1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 
+	1069, 1070, 1072, 1073, 1074, 1075, 1076, 1077, 
+	1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 
+	1086, 1087, 1088, 1089, 1090, 1091, 1092, 1094, 
+	1095, 1096, 1097, 1098, 1100, 1101, 1103, 1104, 
+	1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 
+	1113, 1114, 1115, 1116, 1117, 1119, 1120, 1122, 
+	1128, 1151, 1156, 1158, 1165, 1123, 1124, 1125, 
+	1126, 1127, 1129, 1130, 1131, 1132, 1133, 1134, 
+	1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 
+	1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 
+	1152, 1153, 1154, 1155, 1157, 1159, 1160, 1161, 
+	1162, 1163, 1164, 1166, 1167, 1168, 1170, 1171, 
+	1172, 1030, 1173, 1031, 1175, 1177, 1178, 1325, 
+	1326, 1996, 1192, 1193, 1194, 1195, 1196, 1197, 
+	1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 
+	1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 
+	1214, 1215, 1216, 1217, 1218, 1219, 1220, 1222, 
+	1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 
+	1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 
+	1239, 1240, 1241, 1242, 1244, 1245, 1246, 1247, 
+	1248, 1250, 1251, 1253, 1254, 1255, 1256, 1257, 
+	1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 
+	1266, 1268, 1269, 1271, 1277, 1301, 1305, 1307, 
+	1314, 1318, 1272, 1273, 1274, 1275, 1276, 1278, 
+	1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 
+	1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 
+	1295, 1296, 1297, 1298, 1299, 1300, 1302, 1303, 
+	1304, 1306, 1308, 1309, 1310, 1311, 1312, 1313, 
+	1315, 1316, 1317, 1319, 1321, 1322, 1323, 1179, 
+	1324, 1180, 1997, 1974, 1342, 1343, 1344, 1345, 
+	1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 
+	1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 
+	1377, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 
+	1520, 1521, 1998, 1359, 1360, 1361, 1362, 1363, 
+	1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 
+	1372, 1373, 1374, 1375, 1376, 1378, 1379, 1380, 
+	1381, 1382, 1383, 1384, 1385, 1386, 1388, 1389, 
+	1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 
+	1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 
+	1406, 1407, 1408, 1410, 1412, 1414, 1415, 1416, 
+	1999, 1413, 1418, 1419, 1421, 1422, 1423, 1424, 
+	1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 
+	1433, 1434, 1435, 1437, 1438, 1440, 1446, 1469, 
+	1474, 1476, 1483, 1487, 1441, 1442, 1443, 1444, 
+	1445, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 
+	1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 
+	1462, 1463, 1464, 1465, 1466, 1467, 1468, 1470, 
+	1471, 1472, 1473, 1475, 1477, 1478, 1479, 1480, 
+	1481, 1482, 1484, 1485, 1486, 1488, 1489, 1490, 
+	1492, 1493, 1494, 1346, 1495, 1347, 1523, 1524, 
+	1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 
+	1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 
+	1541, 1542, 1543, 1545, 1546, 1547, 1548, 1549, 
+	1551, 1552, 1554, 1555, 1556, 1557, 1558, 1559, 
+	1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 
+	1569, 1570, 1572, 1578, 1602, 1606, 1608, 1615, 
+	1619, 1573, 1574, 1575, 1576, 1577, 1579, 1580, 
+	1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 
+	1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 
+	1597, 1598, 1599, 1600, 1601, 1603, 1604, 1605, 
+	1607, 1609, 1610, 1611, 1612, 1613, 1614, 1616, 
+	1617, 1618, 1620, 1622, 1623, 1624, 1329, 1625, 
+	1330, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 
+	1637, 1641, 1642, 1643, 1644, 1645, 1647, 1648, 
+	1628, 1650, 1653, 1655, 1657, 1651, 1652, 1654, 
+	1656, 1658, 1959, 1960, 1961, 1962, 1963, 1964, 
+	1965, 1966, 1967, 1968, 2000, 1974, 2001, 1672, 
+	1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 
+	1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 
+	1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 
+	1697, 1698, 1699, 1701, 1702, 1703, 1704, 1705, 
+	1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 
+	1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 
+	1723, 1725, 1727, 1728, 1729, 2002, 1726, 1731, 
+	1732, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 
+	1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 
+	1750, 1751, 1753, 1759, 1782, 1787, 1789, 1796, 
+	1800, 1754, 1755, 1756, 1757, 1758, 1760, 1761, 
+	1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 
+	1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 
+	1778, 1779, 1780, 1781, 1783, 1784, 1785, 1786, 
+	1788, 1790, 1791, 1792, 1793, 1794, 1795, 1797, 
+	1798, 1799, 1801, 1948, 1949, 2003, 1815, 1816, 
+	1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 
+	1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 
+	1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 
+	1841, 1842, 1843, 1845, 1846, 1847, 1848, 1849, 
+	1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 
+	1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 
+	1867, 1868, 1869, 1870, 1871, 1873, 1874, 1876, 
+	1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 
+	1885, 1886, 1887, 1888, 1889, 1891, 1892, 1894, 
+	1900, 1924, 1928, 1930, 1937, 1941, 1895, 1896, 
+	1897, 1898, 1899, 1901, 1902, 1903, 1904, 1905, 
+	1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 
+	1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 
+	1922, 1923, 1925, 1926, 1927, 1929, 1931, 1932, 
+	1933, 1934, 1935, 1936, 1938, 1939, 1940, 1942, 
+	1944, 1945, 1946, 1802, 1947, 1803, 1951, 1952, 
+	1953, 1659, 1954, 1660, 1957, 1958, 1971, 1972, 
+	1973, 1974, 1, 1975, 299, 300, 301, 692, 
+	693, 694, 697, 1028, 1628, 1629, 1638, 1639, 
+	1640, 1646, 1649, 1969, 1970, 1974, 4, 5, 
+	6, 7, 8, 9, 10, 11, 12, 13, 
+	14, 43, 65, 73, 76, 92, 298, 293, 
+	67, 95, 147, 148, 149, 150, 151, 152, 
+	153, 154, 155, 156, 157, 187, 209, 215, 
+	218, 233, 236, 286, 1974, 600, 601, 602, 
+	603, 604, 607, 641, 648, 657, 658, 659, 
+	662, 665, 688, 689, 304, 305, 306, 307, 
+	308, 309, 310, 311, 312, 313, 314, 343, 
+	365, 373, 376, 392, 598, 593, 367, 395, 
+	447, 448, 449, 450, 451, 452, 453, 454, 
+	455, 456, 457, 487, 509, 515, 518, 533, 
+	536, 586, 609, 623, 636, 637, 638, 611, 
+	619, 614, 617, 626, 627, 675, 1974, 701, 
+	702, 703, 704, 705, 706, 707, 708, 709, 
+	710, 711, 996, 762, 770, 1010, 1023, 1024, 
+	1025, 789, 995, 990, 740, 773, 764, 792, 
+	844, 845, 846, 847, 848, 849, 850, 851, 
+	852, 853, 854, 884, 906, 912, 915, 930, 
+	933, 983, 998, 1006, 1001, 1004, 1013, 1014, 
+	1974, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 
+	1039, 1040, 1041, 1042, 1071, 1174, 1099, 1102, 
+	1118, 1176, 1169, 1093, 1121, 1181, 1182, 1183, 
+	1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 
+	1221, 1243, 1249, 1252, 1267, 1270, 1320, 1974, 
+	1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 
+	1339, 1340, 1341, 1522, 1544, 1550, 1553, 1568, 
+	1571, 1621, 1348, 1349, 1350, 1351, 1352, 1353, 
+	1354, 1355, 1356, 1357, 1358, 1387, 1409, 1417, 
+	1420, 1436, 1496, 1491, 1411, 1439, 1974, 1661, 
+	1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 
+	1670, 1671, 1700, 1722, 1730, 1733, 1749, 1956, 
+	1950, 1955, 1724, 1752, 1804, 1805, 1806, 1807, 
+	1808, 1809, 1810, 1811, 1812, 1813, 1814, 1844, 
+	1866, 1872, 1875, 1890, 1893, 1943, 
+}
+
+var _graphclust_trans_actions []byte = []byte{
+	31, 0, 27, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 34, 40, 25, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 40, 0, 40, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 29, 51, 17, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 51, 0, 51, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 40, 21, 40, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 40, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 19, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	40, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 40, 23, 40, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 40, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 40, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 43, 1, 47, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 15, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 13, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 5, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	9, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 7, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 11, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 
+}
+
+var _graphclust_to_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 37, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 
+}
+
+var _graphclust_from_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 
+}
+
+var _graphclust_eof_trans []int16 = []int16{
+	0, 0, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 0, 0, 0, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 0, 0, 0, 0, 
+	0, 0, 610, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 610, 612, 612, 
+	610, 612, 612, 610, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 610, 612, 
+	612, 612, 612, 0, 0, 0, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 0, 
+	0, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 1750, 
+	1750, 1750, 1789, 1789, 1789, 1789, 1789, 1789, 
+	1789, 1789, 1789, 1855, 1855, 1855, 1855, 1855, 
+	1855, 1855, 1905, 1905, 1905, 1944, 1944, 1944, 
+	1983, 1983, 1983, 1983, 
+}
+
+const graphclust_start int = 1974
+const graphclust_first_final int = 1974
+const graphclust_error int = 0
+
+const graphclust_en_main int = 1974
+
+
+// line 14 "grapheme_clusters.rl"
+
+
+var Error = errors.New("invalid UTF8 text")
+
+// ScanGraphemeClusters is a split function for bufio.Scanner that splits
+// on grapheme cluster boundaries.
+func ScanGraphemeClusters(data []byte, atEOF bool) (int, []byte, error) {
+    if len(data) == 0 {
+        return 0, nil, nil
+    }
+
+    // Ragel state
+	cs := 0 // Current State
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    act := 0
+    eof := pe
+
+    // Make Go compiler happy
+    _ = ts
+    _ = te
+    _ = act
+    _ = eof
+
+    startPos := 0
+    endPos := 0
+
+    
+// line 4976 "grapheme_clusters.go"
+	{
+	cs = graphclust_start
+	ts = 0
+	te = 0
+	act = 0
+	}
+
+// line 4984 "grapheme_clusters.go"
+	{
+	var _klen int
+	var _trans int
+	var _acts int
+	var _nacts uint
+	var _keys int
+	if p == pe {
+		goto _test_eof
+	}
+	if cs == 0 {
+		goto _out
+	}
+_resume:
+	_acts = int(_graphclust_from_state_actions[cs])
+	_nacts = uint(_graphclust_actions[_acts]); _acts++
+	for ; _nacts > 0; _nacts-- {
+		 _acts++
+		switch _graphclust_actions[_acts - 1] {
+		case 4:
+// line 1 "NONE"
+
+ts = p
+
+// line 5008 "grapheme_clusters.go"
+		}
+	}
+
+	_keys = int(_graphclust_key_offsets[cs])
+	_trans = int(_graphclust_index_offsets[cs])
+
+	_klen = int(_graphclust_single_lengths[cs])
+	if _klen > 0 {
+		_lower := int(_keys)
+		var _mid int
+		_upper := int(_keys + _klen - 1)
+		for {
+			if _upper < _lower {
+				break
+			}
+
+			_mid = _lower + ((_upper - _lower) >> 1)
+			switch {
+			case data[p] < _graphclust_trans_keys[_mid]:
+				_upper = _mid - 1
+			case data[p] > _graphclust_trans_keys[_mid]:
+				_lower = _mid + 1
+			default:
+				_trans += int(_mid - int(_keys))
+				goto _match
+			}
+		}
+		_keys += _klen
+		_trans += _klen
+	}
+
+	_klen = int(_graphclust_range_lengths[cs])
+	if _klen > 0 {
+		_lower := int(_keys)
+		var _mid int
+		_upper := int(_keys + (_klen << 1) - 2)
+		for {
+			if _upper < _lower {
+				break
+			}
+
+			_mid = _lower + (((_upper - _lower) >> 1) & ^1)
+			switch {
+			case data[p] < _graphclust_trans_keys[_mid]:
+				_upper = _mid - 2
+			case data[p] > _graphclust_trans_keys[_mid + 1]:
+				_lower = _mid + 2
+			default:
+				_trans += int((_mid - int(_keys)) >> 1)
+				goto _match
+			}
+		}
+		_trans += _klen
+	}
+
+_match:
+	_trans = int(_graphclust_indicies[_trans])
+_eof_trans:
+	cs = int(_graphclust_trans_targs[_trans])
+
+	if _graphclust_trans_actions[_trans] == 0 {
+		goto _again
+	}
+
+	_acts = int(_graphclust_trans_actions[_trans])
+	_nacts = uint(_graphclust_actions[_acts]); _acts++
+	for ; _nacts > 0; _nacts-- {
+		_acts++
+		switch _graphclust_actions[_acts-1] {
+		case 0:
+// line 46 "grapheme_clusters.rl"
+
+
+            startPos = p
+        
+		case 1:
+// line 50 "grapheme_clusters.rl"
+
+
+            endPos = p
+        
+		case 5:
+// line 1 "NONE"
+
+te = p+1
+
+		case 6:
+// line 54 "grapheme_clusters.rl"
+
+act = 3;
+		case 7:
+// line 54 "grapheme_clusters.rl"
+
+te = p+1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 8:
+// line 54 "grapheme_clusters.rl"
+
+te = p+1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 9:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 10:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 11:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 12:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 13:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 14:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 15:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 16:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 17:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 18:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 19:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 20:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 21:
+// line 1 "NONE"
+
+	switch act {
+	case 0:
+	{cs = 0
+goto _again
+}
+	case 3:
+	{p = (te) - 1
+
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+	}
+	
+// line 5218 "grapheme_clusters.go"
+		}
+	}
+
+_again:
+	_acts = int(_graphclust_to_state_actions[cs])
+	_nacts = uint(_graphclust_actions[_acts]); _acts++
+	for ; _nacts > 0; _nacts-- {
+		_acts++
+		switch _graphclust_actions[_acts-1] {
+		case 2:
+// line 1 "NONE"
+
+ts = 0
+
+		case 3:
+// line 1 "NONE"
+
+act = 0
+
+// line 5238 "grapheme_clusters.go"
+		}
+	}
+
+	if cs == 0 {
+		goto _out
+	}
+	p++
+	if p != pe {
+		goto _resume
+	}
+	_test_eof: {}
+	if p == eof {
+		if _graphclust_eof_trans[cs] > 0 {
+			_trans = int(_graphclust_eof_trans[cs] - 1)
+			goto _eof_trans
+		}
+	}
+
+	_out: {}
+	}
+
+// line 116 "grapheme_clusters.rl"
+
+
+    // If we fall out here then we were unable to complete a sequence.
+    // If we weren't able to complete a sequence then either we've
+    // reached the end of a partial buffer (so there's more data to come)
+    // or we have an isolated symbol that would normally be part of a
+    // grapheme cluster but has appeared in isolation here.
+
+    if !atEOF {
+        // Request more
+        return 0, nil, nil
+    }
+
+    // Just take the first UTF-8 sequence and return that.
+    _, seqLen := utf8.DecodeRune(data)
+    return seqLen, data[:seqLen], nil
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl
new file mode 100644
index 000000000..003ffbf59
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl
@@ -0,0 +1,132 @@
+package textseg
+
+import (
+    "errors"
+    "unicode/utf8"
+)
+
+// Generated from grapheme_clusters.rl. DO NOT EDIT
+%%{
+  # (except you are actually in grapheme_clusters.rl here, so edit away!)
+
+  machine graphclust;
+  write data;
+}%%
+
+var Error = errors.New("invalid UTF8 text")
+
+// ScanGraphemeClusters is a split function for bufio.Scanner that splits
+// on grapheme cluster boundaries.
+func ScanGraphemeClusters(data []byte, atEOF bool) (int, []byte, error) {
+    if len(data) == 0 {
+        return 0, nil, nil
+    }
+
+    // Ragel state
+	cs := 0 // Current State
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    act := 0
+    eof := pe
+
+    // Make Go compiler happy
+    _ = ts
+    _ = te
+    _ = act
+    _ = eof
+
+    startPos := 0
+    endPos := 0
+
+    %%{
+        include GraphemeCluster "grapheme_clusters_table.rl";
+
+        action start {
+            startPos = p
+        }
+
+        action end {
+            endPos = p
+        }
+
+        action emit {
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+
+        ZWJGlue = ZWJ (Glue_After_Zwj | E_Base_GAZ Extend* E_Modifier?)?;
+        AnyExtender = Extend | ZWJGlue | SpacingMark;
+        Extension = AnyExtender*;
+        ReplacementChar = (0xEF 0xBF 0xBD);
+
+        CRLFSeq = CR LF;
+        ControlSeq = Control | ReplacementChar;
+        HangulSeq = (
+            L+ (((LV? V+ | LVT) T*)?|LV?) |
+            LV V* T* |
+            V+ T* |
+            LVT T* |
+            T+
+        ) Extension;
+        EmojiSeq = (E_Base | E_Base_GAZ) Extend* E_Modifier? Extension;
+        ZWJSeq = ZWJGlue Extension;
+        EmojiFlagSeq = Regional_Indicator Regional_Indicator? Extension;
+
+        UTF8Cont = 0x80 .. 0xBF;
+        AnyUTF8 = (
+            0x00..0x7F |
+            0xC0..0xDF . UTF8Cont |
+            0xE0..0xEF . UTF8Cont . UTF8Cont |
+            0xF0..0xF7 . UTF8Cont . UTF8Cont . UTF8Cont
+        );
+
+        # OtherSeq is any character that isn't at the start of one of the extended sequences above, followed by extension
+        OtherSeq = (AnyUTF8 - (CR|LF|Control|ReplacementChar|L|LV|V|LVT|T|E_Base|E_Base_GAZ|ZWJ|Regional_Indicator|Prepend)) Extension;
+
+        # PrependSeq is prepend followed by any of the other patterns above, except control characters which explicitly break
+        PrependSeq = Prepend+ (HangulSeq|EmojiSeq|ZWJSeq|EmojiFlagSeq|OtherSeq)?;
+
+        CRLFTok = CRLFSeq >start @end;
+        ControlTok = ControlSeq >start @end;
+        HangulTok = HangulSeq >start @end;
+        EmojiTok = EmojiSeq >start @end;
+        ZWJTok = ZWJSeq >start @end;
+        EmojiFlagTok = EmojiFlagSeq >start @end;
+        OtherTok = OtherSeq >start @end;
+        PrependTok = PrependSeq >start @end;
+
+        main := |*
+            CRLFTok => emit;
+            ControlTok => emit;
+            HangulTok => emit;
+            EmojiTok => emit;
+            ZWJTok => emit;
+            EmojiFlagTok => emit;
+            PrependTok => emit;
+            OtherTok => emit;
+
+            # any single valid UTF-8 character would also be valid per spec,
+            # but we'll handle that separately after the loop so we can deal
+            # with requesting more bytes if we're not at EOF.
+        *|;
+
+        write init;
+        write exec;
+    }%%
+
+    // If we fall out here then we were unable to complete a sequence.
+    // If we weren't able to complete a sequence then either we've
+    // reached the end of a partial buffer (so there's more data to come)
+    // or we have an isolated symbol that would normally be part of a
+    // grapheme cluster but has appeared in isolation here.
+
+    if !atEOF {
+        // Request more
+        return 0, nil, nil
+    }
+
+    // Just take the first UTF-8 sequence and return that.
+    _, seqLen := utf8.DecodeRune(data)
+    return seqLen, data[:seqLen], nil
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl
new file mode 100644
index 000000000..fb4511825
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl
@@ -0,0 +1,1583 @@
+# The following Ragel file was autogenerated with unicode2ragel.rb 
+# from: http://www.unicode.org/Public/9.0.0/ucd/auxiliary/GraphemeBreakProperty.txt
+#
+# It defines ["Prepend", "CR", "LF", "Control", "Extend", "Regional_Indicator", "SpacingMark", "L", "V", "T", "LV", "LVT", "E_Base", "E_Modifier", "ZWJ", "Glue_After_Zwj", "E_Base_GAZ"].
+#
+# To use this, make sure that your alphtype is set to byte,
+# and that your input is in utf8.
+
+%%{
+    machine GraphemeCluster;
+    
+    Prepend = 
+        0xD8 0x80..0x85         #Cf   [6] ARABIC NUMBER SIGN..ARABIC NUMBER ...
+      | 0xDB 0x9D               #Cf       ARABIC END OF AYAH
+      | 0xDC 0x8F               #Cf       SYRIAC ABBREVIATION MARK
+      | 0xE0 0xA3 0xA2          #Cf       ARABIC DISPUTED END OF AYAH
+      | 0xE0 0xB5 0x8E          #Lo       MALAYALAM LETTER DOT REPH
+      | 0xF0 0x91 0x82 0xBD     #Cf       KAITHI NUMBER SIGN
+      | 0xF0 0x91 0x87 0x82..0x83  #Lo   [2] SHARADA SIGN JIHVAMULIYA..SHARA...
+      ;
+
+    CR = 
+        0x0D                    #Cc       <control-000D>
+      ;
+
+    LF = 
+        0x0A                    #Cc       <control-000A>
+      ;
+
+    Control = 
+        0x00..0x09              #Cc  [10] <control-0000>..<control-0009>
+      | 0x0B..0x0C              #Cc   [2] <control-000B>..<control-000C>
+      | 0x0E..0x1F              #Cc  [18] <control-000E>..<control-001F>
+      | 0x7F                    #Cc  [33] <control-007F>..<control-009F>
+      | 0xC2 0x80..0x9F         #
+      | 0xC2 0xAD               #Cf       SOFT HYPHEN
+      | 0xD8 0x9C               #Cf       ARABIC LETTER MARK
+      | 0xE1 0xA0 0x8E          #Cf       MONGOLIAN VOWEL SEPARATOR
+      | 0xE2 0x80 0x8B          #Cf       ZERO WIDTH SPACE
+      | 0xE2 0x80 0x8E..0x8F    #Cf   [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT ...
+      | 0xE2 0x80 0xA8          #Zl       LINE SEPARATOR
+      | 0xE2 0x80 0xA9          #Zp       PARAGRAPH SEPARATOR
+      | 0xE2 0x80 0xAA..0xAE    #Cf   [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-...
+      | 0xE2 0x81 0xA0..0xA4    #Cf   [5] WORD JOINER..INVISIBLE PLUS
+      | 0xE2 0x81 0xA5          #Cn       <reserved-2065>
+      | 0xE2 0x81 0xA6..0xAF    #Cf  [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIG...
+      | 0xED 0xA0 0x80..0xFF        #Cs [2048] <surrogate-D800>..<surrogate-...
+      | 0xED 0xA1..0xBE 0x00..0xFF  #
+      | 0xED 0xBF 0x00..0xBF        #
+      | 0xEF 0xBB 0xBF          #Cf       ZERO WIDTH NO-BREAK SPACE
+      | 0xEF 0xBF 0xB0..0xB8    #Cn   [9] <reserved-FFF0>..<reserved-FFF8>
+      | 0xEF 0xBF 0xB9..0xBB    #Cf   [3] INTERLINEAR ANNOTATION ANCHOR..INT...
+      | 0xF0 0x9B 0xB2 0xA0..0xA3  #Cf   [4] SHORTHAND FORMAT LETTER OVERLAP...
+      | 0xF0 0x9D 0x85 0xB3..0xBA  #Cf   [8] MUSICAL SYMBOL BEGIN BEAM..MUSI...
+      | 0xF3 0xA0 0x80 0x80     #Cn       <reserved-E0000>
+      | 0xF3 0xA0 0x80 0x81     #Cf       LANGUAGE TAG
+      | 0xF3 0xA0 0x80 0x82..0x9F  #Cn  [30] <reserved-E0002>..<reserved-E001F>
+      | 0xF3 0xA0 0x82 0x80..0xFF  #Cn [128] <reserved-E0080>..<reserved-E00FF>
+      | 0xF3 0xA0 0x83 0x00..0xBF  #
+      | 0xF3 0xA0 0x87 0xB0..0xFF        #Cn [3600] <reserved-E01F0>..<reser...
+      | 0xF3 0xA0 0x88..0xBE 0x00..0xFF  #
+      | 0xF3 0xA0 0xBF 0x00..0xBF        #
+      ;
+
+    Extend = 
+        0xCC 0x80..0xFF         #Mn [112] COMBINING GRAVE ACCENT..COMBINING ...
+      | 0xCD 0x00..0xAF         #
+      | 0xD2 0x83..0x87         #Mn   [5] COMBINING CYRILLIC TITLO..COMBININ...
+      | 0xD2 0x88..0x89         #Me   [2] COMBINING CYRILLIC HUNDRED THOUSAN...
+      | 0xD6 0x91..0xBD         #Mn  [45] HEBREW ACCENT ETNAHTA..HEBREW POIN...
+      | 0xD6 0xBF               #Mn       HEBREW POINT RAFE
+      | 0xD7 0x81..0x82         #Mn   [2] HEBREW POINT SHIN DOT..HEBREW POIN...
+      | 0xD7 0x84..0x85         #Mn   [2] HEBREW MARK UPPER DOT..HEBREW MARK...
+      | 0xD7 0x87               #Mn       HEBREW POINT QAMATS QATAN
+      | 0xD8 0x90..0x9A         #Mn  [11] ARABIC SIGN SALLALLAHOU ALAYHE WAS...
+      | 0xD9 0x8B..0x9F         #Mn  [21] ARABIC FATHATAN..ARABIC WAVY HAMZA...
+      | 0xD9 0xB0               #Mn       ARABIC LETTER SUPERSCRIPT ALEF
+      | 0xDB 0x96..0x9C         #Mn   [7] ARABIC SMALL HIGH LIGATURE SAD WIT...
+      | 0xDB 0x9F..0xA4         #Mn   [6] ARABIC SMALL HIGH ROUNDED ZERO..AR...
+      | 0xDB 0xA7..0xA8         #Mn   [2] ARABIC SMALL HIGH YEH..ARABIC SMAL...
+      | 0xDB 0xAA..0xAD         #Mn   [4] ARABIC EMPTY CENTRE LOW STOP..ARAB...
+      | 0xDC 0x91               #Mn       SYRIAC LETTER SUPERSCRIPT ALAPH
+      | 0xDC 0xB0..0xFF         #Mn  [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
+      | 0xDD 0x00..0x8A         #
+      | 0xDE 0xA6..0xB0         #Mn  [11] THAANA ABAFILI..THAANA SUKUN
+      | 0xDF 0xAB..0xB3         #Mn   [9] NKO COMBINING SHORT HIGH TONE..NKO...
+      | 0xE0 0xA0 0x96..0x99    #Mn   [4] SAMARITAN MARK IN..SAMARITAN MARK ...
+      | 0xE0 0xA0 0x9B..0xA3    #Mn   [9] SAMARITAN MARK EPENTHETIC YUT..SAM...
+      | 0xE0 0xA0 0xA5..0xA7    #Mn   [3] SAMARITAN VOWEL SIGN SHORT A..SAMA...
+      | 0xE0 0xA0 0xA9..0xAD    #Mn   [5] SAMARITAN VOWEL SIGN LONG I..SAMAR...
+      | 0xE0 0xA1 0x99..0x9B    #Mn   [3] MANDAIC AFFRICATION MARK..MANDAIC ...
+      | 0xE0 0xA3 0x94..0xA1    #Mn  [14] ARABIC SMALL HIGH WORD AR-RUB..ARA...
+      | 0xE0 0xA3 0xA3..0xFF    #Mn  [32] ARABIC TURNED DAMMA BELOW..DEVANAG...
+      | 0xE0 0xA4 0x00..0x82    #
+      | 0xE0 0xA4 0xBA          #Mn       DEVANAGARI VOWEL SIGN OE
+      | 0xE0 0xA4 0xBC          #Mn       DEVANAGARI SIGN NUKTA
+      | 0xE0 0xA5 0x81..0x88    #Mn   [8] DEVANAGARI VOWEL SIGN U..DEVANAGAR...
+      | 0xE0 0xA5 0x8D          #Mn       DEVANAGARI SIGN VIRAMA
+      | 0xE0 0xA5 0x91..0x97    #Mn   [7] DEVANAGARI STRESS SIGN UDATTA..DEV...
+      | 0xE0 0xA5 0xA2..0xA3    #Mn   [2] DEVANAGARI VOWEL SIGN VOCALIC L..D...
+      | 0xE0 0xA6 0x81          #Mn       BENGALI SIGN CANDRABINDU
+      | 0xE0 0xA6 0xBC          #Mn       BENGALI SIGN NUKTA
+      | 0xE0 0xA6 0xBE          #Mc       BENGALI VOWEL SIGN AA
+      | 0xE0 0xA7 0x81..0x84    #Mn   [4] BENGALI VOWEL SIGN U..BENGALI VOWE...
+      | 0xE0 0xA7 0x8D          #Mn       BENGALI SIGN VIRAMA
+      | 0xE0 0xA7 0x97          #Mc       BENGALI AU LENGTH MARK
+      | 0xE0 0xA7 0xA2..0xA3    #Mn   [2] BENGALI VOWEL SIGN VOCALIC L..BENG...
+      | 0xE0 0xA8 0x81..0x82    #Mn   [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI...
+      | 0xE0 0xA8 0xBC          #Mn       GURMUKHI SIGN NUKTA
+      | 0xE0 0xA9 0x81..0x82    #Mn   [2] GURMUKHI VOWEL SIGN U..GURMUKHI VO...
+      | 0xE0 0xA9 0x87..0x88    #Mn   [2] GURMUKHI VOWEL SIGN EE..GURMUKHI V...
+      | 0xE0 0xA9 0x8B..0x8D    #Mn   [3] GURMUKHI VOWEL SIGN OO..GURMUKHI S...
+      | 0xE0 0xA9 0x91          #Mn       GURMUKHI SIGN UDAAT
+      | 0xE0 0xA9 0xB0..0xB1    #Mn   [2] GURMUKHI TIPPI..GURMUKHI ADDAK
+      | 0xE0 0xA9 0xB5          #Mn       GURMUKHI SIGN YAKASH
+      | 0xE0 0xAA 0x81..0x82    #Mn   [2] GUJARATI SIGN CANDRABINDU..GUJARAT...
+      | 0xE0 0xAA 0xBC          #Mn       GUJARATI SIGN NUKTA
+      | 0xE0 0xAB 0x81..0x85    #Mn   [5] GUJARATI VOWEL SIGN U..GUJARATI VO...
+      | 0xE0 0xAB 0x87..0x88    #Mn   [2] GUJARATI VOWEL SIGN E..GUJARATI VO...
+      | 0xE0 0xAB 0x8D          #Mn       GUJARATI SIGN VIRAMA
+      | 0xE0 0xAB 0xA2..0xA3    #Mn   [2] GUJARATI VOWEL SIGN VOCALIC L..GUJ...
+      | 0xE0 0xAC 0x81          #Mn       ORIYA SIGN CANDRABINDU
+      | 0xE0 0xAC 0xBC          #Mn       ORIYA SIGN NUKTA
+      | 0xE0 0xAC 0xBE          #Mc       ORIYA VOWEL SIGN AA
+      | 0xE0 0xAC 0xBF          #Mn       ORIYA VOWEL SIGN I
+      | 0xE0 0xAD 0x81..0x84    #Mn   [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8D          #Mn       ORIYA SIGN VIRAMA
+      | 0xE0 0xAD 0x96          #Mn       ORIYA AI LENGTH MARK
+      | 0xE0 0xAD 0x97          #Mc       ORIYA AU LENGTH MARK
+      | 0xE0 0xAD 0xA2..0xA3    #Mn   [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA ...
+      | 0xE0 0xAE 0x82          #Mn       TAMIL SIGN ANUSVARA
+      | 0xE0 0xAE 0xBE          #Mc       TAMIL VOWEL SIGN AA
+      | 0xE0 0xAF 0x80          #Mn       TAMIL VOWEL SIGN II
+      | 0xE0 0xAF 0x8D          #Mn       TAMIL SIGN VIRAMA
+      | 0xE0 0xAF 0x97          #Mc       TAMIL AU LENGTH MARK
+      | 0xE0 0xB0 0x80          #Mn       TELUGU SIGN COMBINING CANDRABINDU ...
+      | 0xE0 0xB0 0xBE..0xFF    #Mn   [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL...
+      | 0xE0 0xB1 0x00..0x80    #
+      | 0xE0 0xB1 0x86..0x88    #Mn   [3] TELUGU VOWEL SIGN E..TELUGU VOWEL ...
+      | 0xE0 0xB1 0x8A..0x8D    #Mn   [4] TELUGU VOWEL SIGN O..TELUGU SIGN V...
+      | 0xE0 0xB1 0x95..0x96    #Mn   [2] TELUGU LENGTH MARK..TELUGU AI LENG...
+      | 0xE0 0xB1 0xA2..0xA3    #Mn   [2] TELUGU VOWEL SIGN VOCALIC L..TELUG...
+      | 0xE0 0xB2 0x81          #Mn       KANNADA SIGN CANDRABINDU
+      | 0xE0 0xB2 0xBC          #Mn       KANNADA SIGN NUKTA
+      | 0xE0 0xB2 0xBF          #Mn       KANNADA VOWEL SIGN I
+      | 0xE0 0xB3 0x82          #Mc       KANNADA VOWEL SIGN UU
+      | 0xE0 0xB3 0x86          #Mn       KANNADA VOWEL SIGN E
+      | 0xE0 0xB3 0x8C..0x8D    #Mn   [2] KANNADA VOWEL SIGN AU..KANNADA SIG...
+      | 0xE0 0xB3 0x95..0x96    #Mc   [2] KANNADA LENGTH MARK..KANNADA AI LE...
+      | 0xE0 0xB3 0xA2..0xA3    #Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANN...
+      | 0xE0 0xB4 0x81          #Mn       MALAYALAM SIGN CANDRABINDU
+      | 0xE0 0xB4 0xBE          #Mc       MALAYALAM VOWEL SIGN AA
+      | 0xE0 0xB5 0x81..0x84    #Mn   [4] MALAYALAM VOWEL SIGN U..MALAYALAM ...
+      | 0xE0 0xB5 0x8D          #Mn       MALAYALAM SIGN VIRAMA
+      | 0xE0 0xB5 0x97          #Mc       MALAYALAM AU LENGTH MARK
+      | 0xE0 0xB5 0xA2..0xA3    #Mn   [2] MALAYALAM VOWEL SIGN VOCALIC L..MA...
+      | 0xE0 0xB7 0x8A          #Mn       SINHALA SIGN AL-LAKUNA
+      | 0xE0 0xB7 0x8F          #Mc       SINHALA VOWEL SIGN AELA-PILLA
+      | 0xE0 0xB7 0x92..0x94    #Mn   [3] SINHALA VOWEL SIGN KETTI IS-PILLA....
+      | 0xE0 0xB7 0x96          #Mn       SINHALA VOWEL SIGN DIGA PAA-PILLA
+      | 0xE0 0xB7 0x9F          #Mc       SINHALA VOWEL SIGN GAYANUKITTA
+      | 0xE0 0xB8 0xB1          #Mn       THAI CHARACTER MAI HAN-AKAT
+      | 0xE0 0xB8 0xB4..0xBA    #Mn   [7] THAI CHARACTER SARA I..THAI CHARAC...
+      | 0xE0 0xB9 0x87..0x8E    #Mn   [8] THAI CHARACTER MAITAIKHU..THAI CHA...
+      | 0xE0 0xBA 0xB1          #Mn       LAO VOWEL SIGN MAI KAN
+      | 0xE0 0xBA 0xB4..0xB9    #Mn   [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU
+      | 0xE0 0xBA 0xBB..0xBC    #Mn   [2] LAO VOWEL SIGN MAI KON..LAO SEMIVO...
+      | 0xE0 0xBB 0x88..0x8D    #Mn   [6] LAO TONE MAI EK..LAO NIGGAHITA
+      | 0xE0 0xBC 0x98..0x99    #Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD P...
+      | 0xE0 0xBC 0xB5          #Mn       TIBETAN MARK NGAS BZUNG NYI ZLA
+      | 0xE0 0xBC 0xB7          #Mn       TIBETAN MARK NGAS BZUNG SGOR RTAGS
+      | 0xE0 0xBC 0xB9          #Mn       TIBETAN MARK TSA -PHRU
+      | 0xE0 0xBD 0xB1..0xBE    #Mn  [14] TIBETAN VOWEL SIGN AA..TIBETAN SIG...
+      | 0xE0 0xBE 0x80..0x84    #Mn   [5] TIBETAN VOWEL SIGN REVERSED I..TIB...
+      | 0xE0 0xBE 0x86..0x87    #Mn   [2] TIBETAN SIGN LCI RTAGS..TIBETAN SI...
+      | 0xE0 0xBE 0x8D..0x97    #Mn  [11] TIBETAN SUBJOINED SIGN LCE TSA CAN...
+      | 0xE0 0xBE 0x99..0xBC    #Mn  [36] TIBETAN SUBJOINED LETTER NYA..TIBE...
+      | 0xE0 0xBF 0x86          #Mn       TIBETAN SYMBOL PADMA GDAN
+      | 0xE1 0x80 0xAD..0xB0    #Mn   [4] MYANMAR VOWEL SIGN I..MYANMAR VOWE...
+      | 0xE1 0x80 0xB2..0xB7    #Mn   [6] MYANMAR VOWEL SIGN AI..MYANMAR SIG...
+      | 0xE1 0x80 0xB9..0xBA    #Mn   [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ...
+      | 0xE1 0x80 0xBD..0xBE    #Mn   [2] MYANMAR CONSONANT SIGN MEDIAL WA.....
+      | 0xE1 0x81 0x98..0x99    #Mn   [2] MYANMAR VOWEL SIGN VOCALIC L..MYAN...
+      | 0xE1 0x81 0x9E..0xA0    #Mn   [3] MYANMAR CONSONANT SIGN MON MEDIAL ...
+      | 0xE1 0x81 0xB1..0xB4    #Mn   [4] MYANMAR VOWEL SIGN GEBA KAREN I..M...
+      | 0xE1 0x82 0x82          #Mn       MYANMAR CONSONANT SIGN SHAN MEDIAL WA
+      | 0xE1 0x82 0x85..0x86    #Mn   [2] MYANMAR VOWEL SIGN SHAN E ABOVE..M...
+      | 0xE1 0x82 0x8D          #Mn       MYANMAR SIGN SHAN COUNCIL EMPHATIC...
+      | 0xE1 0x82 0x9D          #Mn       MYANMAR VOWEL SIGN AITON AI
+      | 0xE1 0x8D 0x9D..0x9F    #Mn   [3] ETHIOPIC COMBINING GEMINATION AND ...
+      | 0xE1 0x9C 0x92..0x94    #Mn   [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN...
+      | 0xE1 0x9C 0xB2..0xB4    #Mn   [3] HANUNOO VOWEL SIGN I..HANUNOO SIGN...
+      | 0xE1 0x9D 0x92..0x93    #Mn   [2] BUHID VOWEL SIGN I..BUHID VOWEL SI...
+      | 0xE1 0x9D 0xB2..0xB3    #Mn   [2] TAGBANWA VOWEL SIGN I..TAGBANWA VO...
+      | 0xE1 0x9E 0xB4..0xB5    #Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOW...
+      | 0xE1 0x9E 0xB7..0xBD    #Mn   [7] KHMER VOWEL SIGN I..KHMER VOWEL SI...
+      | 0xE1 0x9F 0x86          #Mn       KHMER SIGN NIKAHIT
+      | 0xE1 0x9F 0x89..0x93    #Mn  [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN...
+      | 0xE1 0x9F 0x9D          #Mn       KHMER SIGN ATTHACAN
+      | 0xE1 0xA0 0x8B..0x8D    #Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ...
+      | 0xE1 0xA2 0x85..0x86    #Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA.....
+      | 0xE1 0xA2 0xA9          #Mn       MONGOLIAN LETTER ALI GALI DAGALGA
+      | 0xE1 0xA4 0xA0..0xA2    #Mn   [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xA7..0xA8    #Mn   [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xB2          #Mn       LIMBU SMALL LETTER ANUSVARA
+      | 0xE1 0xA4 0xB9..0xBB    #Mn   [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
+      | 0xE1 0xA8 0x97..0x98    #Mn   [2] BUGINESE VOWEL SIGN I..BUGINESE VO...
+      | 0xE1 0xA8 0x9B          #Mn       BUGINESE VOWEL SIGN AE
+      | 0xE1 0xA9 0x96          #Mn       TAI THAM CONSONANT SIGN MEDIAL LA
+      | 0xE1 0xA9 0x98..0x9E    #Mn   [7] TAI THAM SIGN MAI KANG LAI..TAI TH...
+      | 0xE1 0xA9 0xA0          #Mn       TAI THAM SIGN SAKOT
+      | 0xE1 0xA9 0xA2          #Mn       TAI THAM VOWEL SIGN MAI SAT
+      | 0xE1 0xA9 0xA5..0xAC    #Mn   [8] TAI THAM VOWEL SIGN I..TAI THAM VO...
+      | 0xE1 0xA9 0xB3..0xBC    #Mn  [10] TAI THAM VOWEL SIGN OA ABOVE..TAI ...
+      | 0xE1 0xA9 0xBF          #Mn       TAI THAM COMBINING CRYPTOGRAMMIC DOT
+      | 0xE1 0xAA 0xB0..0xBD    #Mn  [14] COMBINING DOUBLED CIRCUMFLEX ACCEN...
+      | 0xE1 0xAA 0xBE          #Me       COMBINING PARENTHESES OVERLAY
+      | 0xE1 0xAC 0x80..0x83    #Mn   [4] BALINESE SIGN ULU RICEM..BALINESE ...
+      | 0xE1 0xAC 0xB4          #Mn       BALINESE SIGN REREKAN
+      | 0xE1 0xAC 0xB6..0xBA    #Mn   [5] BALINESE VOWEL SIGN ULU..BALINESE ...
+      | 0xE1 0xAC 0xBC          #Mn       BALINESE VOWEL SIGN LA LENGA
+      | 0xE1 0xAD 0x82          #Mn       BALINESE VOWEL SIGN PEPET
+      | 0xE1 0xAD 0xAB..0xB3    #Mn   [9] BALINESE MUSICAL SYMBOL COMBINING ...
+      | 0xE1 0xAE 0x80..0x81    #Mn   [2] SUNDANESE SIGN PANYECEK..SUNDANESE...
+      | 0xE1 0xAE 0xA2..0xA5    #Mn   [4] SUNDANESE CONSONANT SIGN PANYAKRA....
+      | 0xE1 0xAE 0xA8..0xA9    #Mn   [2] SUNDANESE VOWEL SIGN PAMEPET..SUND...
+      | 0xE1 0xAE 0xAB..0xAD    #Mn   [3] SUNDANESE SIGN VIRAMA..SUNDANESE C...
+      | 0xE1 0xAF 0xA6          #Mn       BATAK SIGN TOMPI
+      | 0xE1 0xAF 0xA8..0xA9    #Mn   [2] BATAK VOWEL SIGN PAKPAK E..BATAK V...
+      | 0xE1 0xAF 0xAD          #Mn       BATAK VOWEL SIGN KARO O
+      | 0xE1 0xAF 0xAF..0xB1    #Mn   [3] BATAK VOWEL SIGN U FOR SIMALUNGUN ...
+      | 0xE1 0xB0 0xAC..0xB3    #Mn   [8] LEPCHA VOWEL SIGN E..LEPCHA CONSON...
+      | 0xE1 0xB0 0xB6..0xB7    #Mn   [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
+      | 0xE1 0xB3 0x90..0x92    #Mn   [3] VEDIC TONE KARSHANA..VEDIC TONE PR...
+      | 0xE1 0xB3 0x94..0xA0    #Mn  [13] VEDIC SIGN YAJURVEDIC MIDLINE SVAR...
+      | 0xE1 0xB3 0xA2..0xA8    #Mn   [7] VEDIC SIGN VISARGA SVARITA..VEDIC ...
+      | 0xE1 0xB3 0xAD          #Mn       VEDIC SIGN TIRYAK
+      | 0xE1 0xB3 0xB4          #Mn       VEDIC TONE CANDRA ABOVE
+      | 0xE1 0xB3 0xB8..0xB9    #Mn   [2] VEDIC TONE RING ABOVE..VEDIC TONE ...
+      | 0xE1 0xB7 0x80..0xB5    #Mn  [54] COMBINING DOTTED GRAVE ACCENT..COM...
+      | 0xE1 0xB7 0xBB..0xBF    #Mn   [5] COMBINING DELETION MARK..COMBINING...
+      | 0xE2 0x80 0x8C          #Cf       ZERO WIDTH NON-JOINER
+      | 0xE2 0x83 0x90..0x9C    #Mn  [13] COMBINING LEFT HARPOON ABOVE..COMB...
+      | 0xE2 0x83 0x9D..0xA0    #Me   [4] COMBINING ENCLOSING CIRCLE..COMBIN...
+      | 0xE2 0x83 0xA1          #Mn       COMBINING LEFT RIGHT ARROW ABOVE
+      | 0xE2 0x83 0xA2..0xA4    #Me   [3] COMBINING ENCLOSING SCREEN..COMBIN...
+      | 0xE2 0x83 0xA5..0xB0    #Mn  [12] COMBINING REVERSE SOLIDUS OVERLAY....
+      | 0xE2 0xB3 0xAF..0xB1    #Mn   [3] COPTIC COMBINING NI ABOVE..COPTIC ...
+      | 0xE2 0xB5 0xBF          #Mn       TIFINAGH CONSONANT JOINER
+      | 0xE2 0xB7 0xA0..0xBF    #Mn  [32] COMBINING CYRILLIC LETTER BE..COMB...
+      | 0xE3 0x80 0xAA..0xAD    #Mn   [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOG...
+      | 0xE3 0x80 0xAE..0xAF    #Mc   [2] HANGUL SINGLE DOT TONE MARK..HANGU...
+      | 0xE3 0x82 0x99..0x9A    #Mn   [2] COMBINING KATAKANA-HIRAGANA VOICED...
+      | 0xEA 0x99 0xAF          #Mn       COMBINING CYRILLIC VZMET
+      | 0xEA 0x99 0xB0..0xB2    #Me   [3] COMBINING CYRILLIC TEN MILLIONS SI...
+      | 0xEA 0x99 0xB4..0xBD    #Mn  [10] COMBINING CYRILLIC LETTER UKRAINIA...
+      | 0xEA 0x9A 0x9E..0x9F    #Mn   [2] COMBINING CYRILLIC LETTER EF..COMB...
+      | 0xEA 0x9B 0xB0..0xB1    #Mn   [2] BAMUM COMBINING MARK KOQNDON..BAMU...
+      | 0xEA 0xA0 0x82          #Mn       SYLOTI NAGRI SIGN DVISVARA
+      | 0xEA 0xA0 0x86          #Mn       SYLOTI NAGRI SIGN HASANTA
+      | 0xEA 0xA0 0x8B          #Mn       SYLOTI NAGRI SIGN ANUSVARA
+      | 0xEA 0xA0 0xA5..0xA6    #Mn   [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI ...
+      | 0xEA 0xA3 0x84..0x85    #Mn   [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA...
+      | 0xEA 0xA3 0xA0..0xB1    #Mn  [18] COMBINING DEVANAGARI DIGIT ZERO..C...
+      | 0xEA 0xA4 0xA6..0xAD    #Mn   [8] KAYAH LI VOWEL UE..KAYAH LI TONE C...
+      | 0xEA 0xA5 0x87..0x91    #Mn  [11] REJANG VOWEL SIGN I..REJANG CONSON...
+      | 0xEA 0xA6 0x80..0x82    #Mn   [3] JAVANESE SIGN PANYANGGA..JAVANESE ...
+      | 0xEA 0xA6 0xB3          #Mn       JAVANESE SIGN CECAK TELU
+      | 0xEA 0xA6 0xB6..0xB9    #Mn   [4] JAVANESE VOWEL SIGN WULU..JAVANESE...
+      | 0xEA 0xA6 0xBC          #Mn       JAVANESE VOWEL SIGN PEPET
+      | 0xEA 0xA7 0xA5          #Mn       MYANMAR SIGN SHAN SAW
+      | 0xEA 0xA8 0xA9..0xAE    #Mn   [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xB1..0xB2    #Mn   [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xB5..0xB6    #Mn   [2] CHAM CONSONANT SIGN LA..CHAM CONSO...
+      | 0xEA 0xA9 0x83          #Mn       CHAM CONSONANT SIGN FINAL NG
+      | 0xEA 0xA9 0x8C          #Mn       CHAM CONSONANT SIGN FINAL M
+      | 0xEA 0xA9 0xBC          #Mn       MYANMAR SIGN TAI LAING TONE-2
+      | 0xEA 0xAA 0xB0          #Mn       TAI VIET MAI KANG
+      | 0xEA 0xAA 0xB2..0xB4    #Mn   [3] TAI VIET VOWEL I..TAI VIET VOWEL U
+      | 0xEA 0xAA 0xB7..0xB8    #Mn   [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
+      | 0xEA 0xAA 0xBE..0xBF    #Mn   [2] TAI VIET VOWEL AM..TAI VIET TONE M...
+      | 0xEA 0xAB 0x81          #Mn       TAI VIET TONE MAI THO
+      | 0xEA 0xAB 0xAC..0xAD    #Mn   [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI...
+      | 0xEA 0xAB 0xB6          #Mn       MEETEI MAYEK VIRAMA
+      | 0xEA 0xAF 0xA5          #Mn       MEETEI MAYEK VOWEL SIGN ANAP
+      | 0xEA 0xAF 0xA8          #Mn       MEETEI MAYEK VOWEL SIGN UNAP
+      | 0xEA 0xAF 0xAD          #Mn       MEETEI MAYEK APUN IYEK
+      | 0xEF 0xAC 0x9E          #Mn       HEBREW POINT JUDEO-SPANISH VARIKA
+      | 0xEF 0xB8 0x80..0x8F    #Mn  [16] VARIATION SELECTOR-1..VARIATION SE...
+      | 0xEF 0xB8 0xA0..0xAF    #Mn  [16] COMBINING LIGATURE LEFT HALF..COMB...
+      | 0xEF 0xBE 0x9E..0x9F    #Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MA...
+      | 0xF0 0x90 0x87 0xBD     #Mn       PHAISTOS DISC SIGN COMBINING OBLIQ...
+      | 0xF0 0x90 0x8B 0xA0     #Mn       COPTIC EPACT THOUSANDS MARK
+      | 0xF0 0x90 0x8D 0xB6..0xBA  #Mn   [5] COMBINING OLD PERMIC LETTER AN....
+      | 0xF0 0x90 0xA8 0x81..0x83  #Mn   [3] KHAROSHTHI VOWEL SIGN I..KHAROS...
+      | 0xF0 0x90 0xA8 0x85..0x86  #Mn   [2] KHAROSHTHI VOWEL SIGN E..KHAROS...
+      | 0xF0 0x90 0xA8 0x8C..0x8F  #Mn   [4] KHAROSHTHI VOWEL LENGTH MARK..K...
+      | 0xF0 0x90 0xA8 0xB8..0xBA  #Mn   [3] KHAROSHTHI SIGN BAR ABOVE..KHAR...
+      | 0xF0 0x90 0xA8 0xBF     #Mn       KHAROSHTHI VIRAMA
+      | 0xF0 0x90 0xAB 0xA5..0xA6  #Mn   [2] MANICHAEAN ABBREVIATION MARK AB...
+      | 0xF0 0x91 0x80 0x81     #Mn       BRAHMI SIGN ANUSVARA
+      | 0xF0 0x91 0x80 0xB8..0xFF  #Mn  [15] BRAHMI VOWEL SIGN AA..BRAHMI VI...
+      | 0xF0 0x91 0x81 0x00..0x86  #
+      | 0xF0 0x91 0x81 0xBF..0xFF  #Mn   [3] BRAHMI NUMBER JOINER..KAITHI SI...
+      | 0xF0 0x91 0x82 0x00..0x81  #
+      | 0xF0 0x91 0x82 0xB3..0xB6  #Mn   [4] KAITHI VOWEL SIGN U..KAITHI VOW...
+      | 0xF0 0x91 0x82 0xB9..0xBA  #Mn   [2] KAITHI SIGN VIRAMA..KAITHI SIGN...
+      | 0xF0 0x91 0x84 0x80..0x82  #Mn   [3] CHAKMA SIGN CANDRABINDU..CHAKMA...
+      | 0xF0 0x91 0x84 0xA7..0xAB  #Mn   [5] CHAKMA VOWEL SIGN A..CHAKMA VOW...
+      | 0xF0 0x91 0x84 0xAD..0xB4  #Mn   [8] CHAKMA VOWEL SIGN AI..CHAKMA MA...
+      | 0xF0 0x91 0x85 0xB3     #Mn       MAHAJANI SIGN NUKTA
+      | 0xF0 0x91 0x86 0x80..0x81  #Mn   [2] SHARADA SIGN CANDRABINDU..SHARA...
+      | 0xF0 0x91 0x86 0xB6..0xBE  #Mn   [9] SHARADA VOWEL SIGN U..SHARADA V...
+      | 0xF0 0x91 0x87 0x8A..0x8C  #Mn   [3] SHARADA SIGN NUKTA..SHARADA EXT...
+      | 0xF0 0x91 0x88 0xAF..0xB1  #Mn   [3] KHOJKI VOWEL SIGN U..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB4     #Mn       KHOJKI SIGN ANUSVARA
+      | 0xF0 0x91 0x88 0xB6..0xB7  #Mn   [2] KHOJKI SIGN NUKTA..KHOJKI SIGN ...
+      | 0xF0 0x91 0x88 0xBE     #Mn       KHOJKI SIGN SUKUN
+      | 0xF0 0x91 0x8B 0x9F     #Mn       KHUDAWADI SIGN ANUSVARA
+      | 0xF0 0x91 0x8B 0xA3..0xAA  #Mn   [8] KHUDAWADI VOWEL SIGN U..KHUDAWA...
+      | 0xF0 0x91 0x8C 0x80..0x81  #Mn   [2] GRANTHA SIGN COMBINING ANUSVARA...
+      | 0xF0 0x91 0x8C 0xBC     #Mn       GRANTHA SIGN NUKTA
+      | 0xF0 0x91 0x8C 0xBE     #Mc       GRANTHA VOWEL SIGN AA
+      | 0xF0 0x91 0x8D 0x80     #Mn       GRANTHA VOWEL SIGN II
+      | 0xF0 0x91 0x8D 0x97     #Mc       GRANTHA AU LENGTH MARK
+      | 0xF0 0x91 0x8D 0xA6..0xAC  #Mn   [7] COMBINING GRANTHA DIGIT ZERO..C...
+      | 0xF0 0x91 0x8D 0xB0..0xB4  #Mn   [5] COMBINING GRANTHA LETTER A..COM...
+      | 0xF0 0x91 0x90 0xB8..0xBF  #Mn   [8] NEWA VOWEL SIGN U..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x82..0x84  #Mn   [3] NEWA SIGN VIRAMA..NEWA SIGN ANU...
+      | 0xF0 0x91 0x91 0x86     #Mn       NEWA SIGN NUKTA
+      | 0xF0 0x91 0x92 0xB0     #Mc       TIRHUTA VOWEL SIGN AA
+      | 0xF0 0x91 0x92 0xB3..0xB8  #Mn   [6] TIRHUTA VOWEL SIGN U..TIRHUTA V...
+      | 0xF0 0x91 0x92 0xBA     #Mn       TIRHUTA VOWEL SIGN SHORT E
+      | 0xF0 0x91 0x92 0xBD     #Mc       TIRHUTA VOWEL SIGN SHORT O
+      | 0xF0 0x91 0x92 0xBF..0xFF  #Mn   [2] TIRHUTA SIGN CANDRABINDU..TIRHU...
+      | 0xF0 0x91 0x93 0x00..0x80  #
+      | 0xF0 0x91 0x93 0x82..0x83  #Mn   [2] TIRHUTA SIGN VIRAMA..TIRHUTA SI...
+      | 0xF0 0x91 0x96 0xAF     #Mc       SIDDHAM VOWEL SIGN AA
+      | 0xF0 0x91 0x96 0xB2..0xB5  #Mn   [4] SIDDHAM VOWEL SIGN U..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xBC..0xBD  #Mn   [2] SIDDHAM SIGN CANDRABINDU..SIDDH...
+      | 0xF0 0x91 0x96 0xBF..0xFF  #Mn   [2] SIDDHAM SIGN VIRAMA..SIDDHAM SI...
+      | 0xF0 0x91 0x97 0x00..0x80  #
+      | 0xF0 0x91 0x97 0x9C..0x9D  #Mn   [2] SIDDHAM VOWEL SIGN ALTERNATE U....
+      | 0xF0 0x91 0x98 0xB3..0xBA  #Mn   [8] MODI VOWEL SIGN U..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBD     #Mn       MODI SIGN ANUSVARA
+      | 0xF0 0x91 0x98 0xBF..0xFF  #Mn   [2] MODI SIGN VIRAMA..MODI SIGN ARD...
+      | 0xF0 0x91 0x99 0x00..0x80  #
+      | 0xF0 0x91 0x9A 0xAB     #Mn       TAKRI SIGN ANUSVARA
+      | 0xF0 0x91 0x9A 0xAD     #Mn       TAKRI VOWEL SIGN AA
+      | 0xF0 0x91 0x9A 0xB0..0xB5  #Mn   [6] TAKRI VOWEL SIGN U..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB7     #Mn       TAKRI SIGN NUKTA
+      | 0xF0 0x91 0x9C 0x9D..0x9F  #Mn   [3] AHOM CONSONANT SIGN MEDIAL LA.....
+      | 0xF0 0x91 0x9C 0xA2..0xA5  #Mn   [4] AHOM VOWEL SIGN I..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA7..0xAB  #Mn   [5] AHOM VOWEL SIGN AW..AHOM SIGN K...
+      | 0xF0 0x91 0xB0 0xB0..0xB6  #Mn   [7] BHAIKSUKI VOWEL SIGN I..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xB8..0xBD  #Mn   [6] BHAIKSUKI VOWEL SIGN E..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xBF     #Mn       BHAIKSUKI SIGN VIRAMA
+      | 0xF0 0x91 0xB2 0x92..0xA7  #Mn  [22] MARCHEN SUBJOINED LETTER KA..MA...
+      | 0xF0 0x91 0xB2 0xAA..0xB0  #Mn   [7] MARCHEN SUBJOINED LETTER RA..MA...
+      | 0xF0 0x91 0xB2 0xB2..0xB3  #Mn   [2] MARCHEN VOWEL SIGN U..MARCHEN V...
+      | 0xF0 0x91 0xB2 0xB5..0xB6  #Mn   [2] MARCHEN SIGN ANUSVARA..MARCHEN ...
+      | 0xF0 0x96 0xAB 0xB0..0xB4  #Mn   [5] BASSA VAH COMBINING HIGH TONE.....
+      | 0xF0 0x96 0xAC 0xB0..0xB6  #Mn   [7] PAHAWH HMONG MARK CIM TUB..PAHA...
+      | 0xF0 0x96 0xBE 0x8F..0x92  #Mn   [4] MIAO TONE RIGHT..MIAO TONE BELOW
+      | 0xF0 0x9B 0xB2 0x9D..0x9E  #Mn   [2] DUPLOYAN THICK LETTER SELECTOR....
+      | 0xF0 0x9D 0x85 0xA5     #Mc       MUSICAL SYMBOL COMBINING STEM
+      | 0xF0 0x9D 0x85 0xA7..0xA9  #Mn   [3] MUSICAL SYMBOL COMBINING TREMOL...
+      | 0xF0 0x9D 0x85 0xAE..0xB2  #Mc   [5] MUSICAL SYMBOL COMBINING FLAG-1...
+      | 0xF0 0x9D 0x85 0xBB..0xFF  #Mn   [8] MUSICAL SYMBOL COMBINING ACCENT...
+      | 0xF0 0x9D 0x86 0x00..0x82  #
+      | 0xF0 0x9D 0x86 0x85..0x8B  #Mn   [7] MUSICAL SYMBOL COMBINING DOIT.....
+      | 0xF0 0x9D 0x86 0xAA..0xAD  #Mn   [4] MUSICAL SYMBOL COMBINING DOWN B...
+      | 0xF0 0x9D 0x89 0x82..0x84  #Mn   [3] COMBINING GREEK MUSICAL TRISEME...
+      | 0xF0 0x9D 0xA8 0x80..0xB6  #Mn  [55] SIGNWRITING HEAD RIM..SIGNWRITI...
+      | 0xF0 0x9D 0xA8 0xBB..0xFF  #Mn  [50] SIGNWRITING MOUTH CLOSED NEUTRA...
+      | 0xF0 0x9D 0xA9 0x00..0xAC  #
+      | 0xF0 0x9D 0xA9 0xB5     #Mn       SIGNWRITING UPPER BODY TILTING FRO...
+      | 0xF0 0x9D 0xAA 0x84     #Mn       SIGNWRITING LOCATION HEAD NECK
+      | 0xF0 0x9D 0xAA 0x9B..0x9F  #Mn   [5] SIGNWRITING FILL MODIFIER-2..SI...
+      | 0xF0 0x9D 0xAA 0xA1..0xAF  #Mn  [15] SIGNWRITING ROTATION MODIFIER-2...
+      | 0xF0 0x9E 0x80 0x80..0x86  #Mn   [7] COMBINING GLAGOLITIC LETTER AZU...
+      | 0xF0 0x9E 0x80 0x88..0x98  #Mn  [17] COMBINING GLAGOLITIC LETTER ZEM...
+      | 0xF0 0x9E 0x80 0x9B..0xA1  #Mn   [7] COMBINING GLAGOLITIC LETTER SHT...
+      | 0xF0 0x9E 0x80 0xA3..0xA4  #Mn   [2] COMBINING GLAGOLITIC LETTER YU....
+      | 0xF0 0x9E 0x80 0xA6..0xAA  #Mn   [5] COMBINING GLAGOLITIC LETTER YO....
+      | 0xF0 0x9E 0xA3 0x90..0x96  #Mn   [7] MENDE KIKAKUI COMBINING NUMBER ...
+      | 0xF0 0x9E 0xA5 0x84..0x8A  #Mn   [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA
+      | 0xF3 0xA0 0x80 0xA0..0xFF  #Cf  [96] TAG SPACE..CANCEL TAG
+      | 0xF3 0xA0 0x81 0x00..0xBF  #
+      | 0xF3 0xA0 0x84 0x80..0xFF        #Mn [240] VARIATION SELECTOR-17..VA...
+      | 0xF3 0xA0 0x85..0x86 0x00..0xFF  #
+      | 0xF3 0xA0 0x87 0x00..0xAF        #
+      ;
+
+    Regional_Indicator = 
+        0xF0 0x9F 0x87 0xA6..0xBF  #So  [26] REGIONAL INDICATOR SYMBOL LETTE...
+      ;
+
+    SpacingMark = 
+        0xE0 0xA4 0x83          #Mc       DEVANAGARI SIGN VISARGA
+      | 0xE0 0xA4 0xBB          #Mc       DEVANAGARI VOWEL SIGN OOE
+      | 0xE0 0xA4 0xBE..0xFF    #Mc   [3] DEVANAGARI VOWEL SIGN AA..DEVANAGA...
+      | 0xE0 0xA5 0x00..0x80    #
+      | 0xE0 0xA5 0x89..0x8C    #Mc   [4] DEVANAGARI VOWEL SIGN CANDRA O..DE...
+      | 0xE0 0xA5 0x8E..0x8F    #Mc   [2] DEVANAGARI VOWEL SIGN PRISHTHAMATR...
+      | 0xE0 0xA6 0x82..0x83    #Mc   [2] BENGALI SIGN ANUSVARA..BENGALI SIG...
+      | 0xE0 0xA6 0xBF..0xFF    #Mc   [2] BENGALI VOWEL SIGN I..BENGALI VOWE...
+      | 0xE0 0xA7 0x00..0x80    #
+      | 0xE0 0xA7 0x87..0x88    #Mc   [2] BENGALI VOWEL SIGN E..BENGALI VOWE...
+      | 0xE0 0xA7 0x8B..0x8C    #Mc   [2] BENGALI VOWEL SIGN O..BENGALI VOWE...
+      | 0xE0 0xA8 0x83          #Mc       GURMUKHI SIGN VISARGA
+      | 0xE0 0xA8 0xBE..0xFF    #Mc   [3] GURMUKHI VOWEL SIGN AA..GURMUKHI V...
+      | 0xE0 0xA9 0x00..0x80    #
+      | 0xE0 0xAA 0x83          #Mc       GUJARATI SIGN VISARGA
+      | 0xE0 0xAA 0xBE..0xFF    #Mc   [3] GUJARATI VOWEL SIGN AA..GUJARATI V...
+      | 0xE0 0xAB 0x00..0x80    #
+      | 0xE0 0xAB 0x89          #Mc       GUJARATI VOWEL SIGN CANDRA O
+      | 0xE0 0xAB 0x8B..0x8C    #Mc   [2] GUJARATI VOWEL SIGN O..GUJARATI VO...
+      | 0xE0 0xAC 0x82..0x83    #Mc   [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VI...
+      | 0xE0 0xAD 0x80          #Mc       ORIYA VOWEL SIGN II
+      | 0xE0 0xAD 0x87..0x88    #Mc   [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8B..0x8C    #Mc   [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SI...
+      | 0xE0 0xAE 0xBF          #Mc       TAMIL VOWEL SIGN I
+      | 0xE0 0xAF 0x81..0x82    #Mc   [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x86..0x88    #Mc   [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x8A..0x8C    #Mc   [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SI...
+      | 0xE0 0xB0 0x81..0x83    #Mc   [3] TELUGU SIGN CANDRABINDU..TELUGU SI...
+      | 0xE0 0xB1 0x81..0x84    #Mc   [4] TELUGU VOWEL SIGN U..TELUGU VOWEL ...
+      | 0xE0 0xB2 0x82..0x83    #Mc   [2] KANNADA SIGN ANUSVARA..KANNADA SIG...
+      | 0xE0 0xB2 0xBE          #Mc       KANNADA VOWEL SIGN AA
+      | 0xE0 0xB3 0x80..0x81    #Mc   [2] KANNADA VOWEL SIGN II..KANNADA VOW...
+      | 0xE0 0xB3 0x83..0x84    #Mc   [2] KANNADA VOWEL SIGN VOCALIC R..KANN...
+      | 0xE0 0xB3 0x87..0x88    #Mc   [2] KANNADA VOWEL SIGN EE..KANNADA VOW...
+      | 0xE0 0xB3 0x8A..0x8B    #Mc   [2] KANNADA VOWEL SIGN O..KANNADA VOWE...
+      | 0xE0 0xB4 0x82..0x83    #Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM...
+      | 0xE0 0xB4 0xBF..0xFF    #Mc   [2] MALAYALAM VOWEL SIGN I..MALAYALAM ...
+      | 0xE0 0xB5 0x00..0x80    #
+      | 0xE0 0xB5 0x86..0x88    #Mc   [3] MALAYALAM VOWEL SIGN E..MALAYALAM ...
+      | 0xE0 0xB5 0x8A..0x8C    #Mc   [3] MALAYALAM VOWEL SIGN O..MALAYALAM ...
+      | 0xE0 0xB6 0x82..0x83    #Mc   [2] SINHALA SIGN ANUSVARAYA..SINHALA S...
+      | 0xE0 0xB7 0x90..0x91    #Mc   [2] SINHALA VOWEL SIGN KETTI AEDA-PILL...
+      | 0xE0 0xB7 0x98..0x9E    #Mc   [7] SINHALA VOWEL SIGN GAETTA-PILLA..S...
+      | 0xE0 0xB7 0xB2..0xB3    #Mc   [2] SINHALA VOWEL SIGN DIGA GAETTA-PIL...
+      | 0xE0 0xB8 0xB3          #Lo       THAI CHARACTER SARA AM
+      | 0xE0 0xBA 0xB3          #Lo       LAO VOWEL SIGN AM
+      | 0xE0 0xBC 0xBE..0xBF    #Mc   [2] TIBETAN SIGN YAR TSHES..TIBETAN SI...
+      | 0xE0 0xBD 0xBF          #Mc       TIBETAN SIGN RNAM BCAD
+      | 0xE1 0x80 0xB1          #Mc       MYANMAR VOWEL SIGN E
+      | 0xE1 0x80 0xBB..0xBC    #Mc   [2] MYANMAR CONSONANT SIGN MEDIAL YA.....
+      | 0xE1 0x81 0x96..0x97    #Mc   [2] MYANMAR VOWEL SIGN VOCALIC R..MYAN...
+      | 0xE1 0x82 0x84          #Mc       MYANMAR VOWEL SIGN SHAN E
+      | 0xE1 0x9E 0xB6          #Mc       KHMER VOWEL SIGN AA
+      | 0xE1 0x9E 0xBE..0xFF    #Mc   [8] KHMER VOWEL SIGN OE..KHMER VOWEL S...
+      | 0xE1 0x9F 0x00..0x85    #
+      | 0xE1 0x9F 0x87..0x88    #Mc   [2] KHMER SIGN REAHMUK..KHMER SIGN YUU...
+      | 0xE1 0xA4 0xA3..0xA6    #Mc   [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL S...
+      | 0xE1 0xA4 0xA9..0xAB    #Mc   [3] LIMBU SUBJOINED LETTER YA..LIMBU S...
+      | 0xE1 0xA4 0xB0..0xB1    #Mc   [2] LIMBU SMALL LETTER KA..LIMBU SMALL...
+      | 0xE1 0xA4 0xB3..0xB8    #Mc   [6] LIMBU SMALL LETTER TA..LIMBU SMALL...
+      | 0xE1 0xA8 0x99..0x9A    #Mc   [2] BUGINESE VOWEL SIGN E..BUGINESE VO...
+      | 0xE1 0xA9 0x95          #Mc       TAI THAM CONSONANT SIGN MEDIAL RA
+      | 0xE1 0xA9 0x97          #Mc       TAI THAM CONSONANT SIGN LA TANG LAI
+      | 0xE1 0xA9 0xAD..0xB2    #Mc   [6] TAI THAM VOWEL SIGN OY..TAI THAM V...
+      | 0xE1 0xAC 0x84          #Mc       BALINESE SIGN BISAH
+      | 0xE1 0xAC 0xB5          #Mc       BALINESE VOWEL SIGN TEDUNG
+      | 0xE1 0xAC 0xBB          #Mc       BALINESE VOWEL SIGN RA REPA TEDUNG
+      | 0xE1 0xAC 0xBD..0xFF    #Mc   [5] BALINESE VOWEL SIGN LA LENGA TEDUN...
+      | 0xE1 0xAD 0x00..0x81    #
+      | 0xE1 0xAD 0x83..0x84    #Mc   [2] BALINESE VOWEL SIGN PEPET TEDUNG.....
+      | 0xE1 0xAE 0x82          #Mc       SUNDANESE SIGN PANGWISAD
+      | 0xE1 0xAE 0xA1          #Mc       SUNDANESE CONSONANT SIGN PAMINGKAL
+      | 0xE1 0xAE 0xA6..0xA7    #Mc   [2] SUNDANESE VOWEL SIGN PANAELAENG..S...
+      | 0xE1 0xAE 0xAA          #Mc       SUNDANESE SIGN PAMAAEH
+      | 0xE1 0xAF 0xA7          #Mc       BATAK VOWEL SIGN E
+      | 0xE1 0xAF 0xAA..0xAC    #Mc   [3] BATAK VOWEL SIGN I..BATAK VOWEL SI...
+      | 0xE1 0xAF 0xAE          #Mc       BATAK VOWEL SIGN U
+      | 0xE1 0xAF 0xB2..0xB3    #Mc   [2] BATAK PANGOLAT..BATAK PANONGONAN
+      | 0xE1 0xB0 0xA4..0xAB    #Mc   [8] LEPCHA SUBJOINED LETTER YA..LEPCHA...
+      | 0xE1 0xB0 0xB4..0xB5    #Mc   [2] LEPCHA CONSONANT SIGN NYIN-DO..LEP...
+      | 0xE1 0xB3 0xA1          #Mc       VEDIC TONE ATHARVAVEDIC INDEPENDEN...
+      | 0xE1 0xB3 0xB2..0xB3    #Mc   [2] VEDIC SIGN ARDHAVISARGA..VEDIC SIG...
+      | 0xEA 0xA0 0xA3..0xA4    #Mc   [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI ...
+      | 0xEA 0xA0 0xA7          #Mc       SYLOTI NAGRI VOWEL SIGN OO
+      | 0xEA 0xA2 0x80..0x81    #Mc   [2] SAURASHTRA SIGN ANUSVARA..SAURASHT...
+      | 0xEA 0xA2 0xB4..0xFF    #Mc  [16] SAURASHTRA CONSONANT SIGN HAARU..S...
+      | 0xEA 0xA3 0x00..0x83    #
+      | 0xEA 0xA5 0x92..0x93    #Mc   [2] REJANG CONSONANT SIGN H..REJANG VI...
+      | 0xEA 0xA6 0x83          #Mc       JAVANESE SIGN WIGNYAN
+      | 0xEA 0xA6 0xB4..0xB5    #Mc   [2] JAVANESE VOWEL SIGN TARUNG..JAVANE...
+      | 0xEA 0xA6 0xBA..0xBB    #Mc   [2] JAVANESE VOWEL SIGN TALING..JAVANE...
+      | 0xEA 0xA6 0xBD..0xFF    #Mc   [4] JAVANESE CONSONANT SIGN KERET..JAV...
+      | 0xEA 0xA7 0x00..0x80    #
+      | 0xEA 0xA8 0xAF..0xB0    #Mc   [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
+      | 0xEA 0xA8 0xB3..0xB4    #Mc   [2] CHAM CONSONANT SIGN YA..CHAM CONSO...
+      | 0xEA 0xA9 0x8D          #Mc       CHAM CONSONANT SIGN FINAL H
+      | 0xEA 0xAB 0xAB          #Mc       MEETEI MAYEK VOWEL SIGN II
+      | 0xEA 0xAB 0xAE..0xAF    #Mc   [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI...
+      | 0xEA 0xAB 0xB5          #Mc       MEETEI MAYEK VOWEL SIGN VISARGA
+      | 0xEA 0xAF 0xA3..0xA4    #Mc   [2] MEETEI MAYEK VOWEL SIGN ONAP..MEET...
+      | 0xEA 0xAF 0xA6..0xA7    #Mc   [2] MEETEI MAYEK VOWEL SIGN YENAP..MEE...
+      | 0xEA 0xAF 0xA9..0xAA    #Mc   [2] MEETEI MAYEK VOWEL SIGN CHEINAP..M...
+      | 0xEA 0xAF 0xAC          #Mc       MEETEI MAYEK LUM IYEK
+      | 0xF0 0x91 0x80 0x80     #Mc       BRAHMI SIGN CANDRABINDU
+      | 0xF0 0x91 0x80 0x82     #Mc       BRAHMI SIGN VISARGA
+      | 0xF0 0x91 0x82 0x82     #Mc       KAITHI SIGN VISARGA
+      | 0xF0 0x91 0x82 0xB0..0xB2  #Mc   [3] KAITHI VOWEL SIGN AA..KAITHI VO...
+      | 0xF0 0x91 0x82 0xB7..0xB8  #Mc   [2] KAITHI VOWEL SIGN O..KAITHI VOW...
+      | 0xF0 0x91 0x84 0xAC     #Mc       CHAKMA VOWEL SIGN E
+      | 0xF0 0x91 0x86 0x82     #Mc       SHARADA SIGN VISARGA
+      | 0xF0 0x91 0x86 0xB3..0xB5  #Mc   [3] SHARADA VOWEL SIGN AA..SHARADA ...
+      | 0xF0 0x91 0x86 0xBF..0xFF  #Mc   [2] SHARADA VOWEL SIGN AU..SHARADA ...
+      | 0xF0 0x91 0x87 0x00..0x80  #
+      | 0xF0 0x91 0x88 0xAC..0xAE  #Mc   [3] KHOJKI VOWEL SIGN AA..KHOJKI VO...
+      | 0xF0 0x91 0x88 0xB2..0xB3  #Mc   [2] KHOJKI VOWEL SIGN O..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB5     #Mc       KHOJKI SIGN VIRAMA
+      | 0xF0 0x91 0x8B 0xA0..0xA2  #Mc   [3] KHUDAWADI VOWEL SIGN AA..KHUDAW...
+      | 0xF0 0x91 0x8C 0x82..0x83  #Mc   [2] GRANTHA SIGN ANUSVARA..GRANTHA ...
+      | 0xF0 0x91 0x8C 0xBF     #Mc       GRANTHA VOWEL SIGN I
+      | 0xF0 0x91 0x8D 0x81..0x84  #Mc   [4] GRANTHA VOWEL SIGN U..GRANTHA V...
+      | 0xF0 0x91 0x8D 0x87..0x88  #Mc   [2] GRANTHA VOWEL SIGN EE..GRANTHA ...
+      | 0xF0 0x91 0x8D 0x8B..0x8D  #Mc   [3] GRANTHA VOWEL SIGN OO..GRANTHA ...
+      | 0xF0 0x91 0x8D 0xA2..0xA3  #Mc   [2] GRANTHA VOWEL SIGN VOCALIC L..G...
+      | 0xF0 0x91 0x90 0xB5..0xB7  #Mc   [3] NEWA VOWEL SIGN AA..NEWA VOWEL ...
+      | 0xF0 0x91 0x91 0x80..0x81  #Mc   [2] NEWA VOWEL SIGN O..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x85     #Mc       NEWA SIGN VISARGA
+      | 0xF0 0x91 0x92 0xB1..0xB2  #Mc   [2] TIRHUTA VOWEL SIGN I..TIRHUTA V...
+      | 0xF0 0x91 0x92 0xB9     #Mc       TIRHUTA VOWEL SIGN E
+      | 0xF0 0x91 0x92 0xBB..0xBC  #Mc   [2] TIRHUTA VOWEL SIGN AI..TIRHUTA ...
+      | 0xF0 0x91 0x92 0xBE     #Mc       TIRHUTA VOWEL SIGN AU
+      | 0xF0 0x91 0x93 0x81     #Mc       TIRHUTA SIGN VISARGA
+      | 0xF0 0x91 0x96 0xB0..0xB1  #Mc   [2] SIDDHAM VOWEL SIGN I..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xB8..0xBB  #Mc   [4] SIDDHAM VOWEL SIGN E..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xBE     #Mc       SIDDHAM SIGN VISARGA
+      | 0xF0 0x91 0x98 0xB0..0xB2  #Mc   [3] MODI VOWEL SIGN AA..MODI VOWEL ...
+      | 0xF0 0x91 0x98 0xBB..0xBC  #Mc   [2] MODI VOWEL SIGN O..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBE     #Mc       MODI SIGN VISARGA
+      | 0xF0 0x91 0x9A 0xAC     #Mc       TAKRI SIGN VISARGA
+      | 0xF0 0x91 0x9A 0xAE..0xAF  #Mc   [2] TAKRI VOWEL SIGN I..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB6     #Mc       TAKRI SIGN VIRAMA
+      | 0xF0 0x91 0x9C 0xA0..0xA1  #Mc   [2] AHOM VOWEL SIGN A..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA6     #Mc       AHOM VOWEL SIGN E
+      | 0xF0 0x91 0xB0 0xAF     #Mc       BHAIKSUKI VOWEL SIGN AA
+      | 0xF0 0x91 0xB0 0xBE     #Mc       BHAIKSUKI SIGN VISARGA
+      | 0xF0 0x91 0xB2 0xA9     #Mc       MARCHEN SUBJOINED LETTER YA
+      | 0xF0 0x91 0xB2 0xB1     #Mc       MARCHEN VOWEL SIGN I
+      | 0xF0 0x91 0xB2 0xB4     #Mc       MARCHEN VOWEL SIGN O
+      | 0xF0 0x96 0xBD 0x91..0xBE  #Mc  [46] MIAO SIGN ASPIRATION..MIAO VOWE...
+      | 0xF0 0x9D 0x85 0xA6     #Mc       MUSICAL SYMBOL COMBINING SPRECHGES...
+      | 0xF0 0x9D 0x85 0xAD     #Mc       MUSICAL SYMBOL COMBINING AUGMENTAT...
+      ;
+
+    L = 
+        0xE1 0x84 0x80..0xFF    #Lo  [96] HANGUL CHOSEONG KIYEOK..HANGUL CHO...
+      | 0xE1 0x85 0x00..0x9F    #
+      | 0xEA 0xA5 0xA0..0xBC    #Lo  [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANG...
+      ;
+
+    V = 
+        0xE1 0x85 0xA0..0xFF    #Lo  [72] HANGUL JUNGSEONG FILLER..HANGUL JU...
+      | 0xE1 0x86 0x00..0xA7    #
+      | 0xED 0x9E 0xB0..0xFF    #Lo  [23] HANGUL JUNGSEONG O-YEO..HANGUL JUN...
+      | 0xED 0x9F 0x00..0x86    #
+      ;
+
+    T = 
+        0xE1 0x86 0xA8..0xFF    #Lo  [88] HANGUL JONGSEONG KIYEOK..HANGUL JO...
+      | 0xE1 0x87 0x00..0xBF    #
+      | 0xED 0x9F 0x8B..0xBB    #Lo  [49] HANGUL JONGSEONG NIEUN-RIEUL..HANG...
+      ;
+
+    LV = 
+        0xEA 0xB0 0x80          #Lo       HANGUL SYLLABLE GA
+      | 0xEA 0xB0 0x9C          #Lo       HANGUL SYLLABLE GAE
+      | 0xEA 0xB0 0xB8          #Lo       HANGUL SYLLABLE GYA
+      | 0xEA 0xB1 0x94          #Lo       HANGUL SYLLABLE GYAE
+      | 0xEA 0xB1 0xB0          #Lo       HANGUL SYLLABLE GEO
+      | 0xEA 0xB2 0x8C          #Lo       HANGUL SYLLABLE GE
+      | 0xEA 0xB2 0xA8          #Lo       HANGUL SYLLABLE GYEO
+      | 0xEA 0xB3 0x84          #Lo       HANGUL SYLLABLE GYE
+      | 0xEA 0xB3 0xA0          #Lo       HANGUL SYLLABLE GO
+      | 0xEA 0xB3 0xBC          #Lo       HANGUL SYLLABLE GWA
+      | 0xEA 0xB4 0x98          #Lo       HANGUL SYLLABLE GWAE
+      | 0xEA 0xB4 0xB4          #Lo       HANGUL SYLLABLE GOE
+      | 0xEA 0xB5 0x90          #Lo       HANGUL SYLLABLE GYO
+      | 0xEA 0xB5 0xAC          #Lo       HANGUL SYLLABLE GU
+      | 0xEA 0xB6 0x88          #Lo       HANGUL SYLLABLE GWEO
+      | 0xEA 0xB6 0xA4          #Lo       HANGUL SYLLABLE GWE
+      | 0xEA 0xB7 0x80          #Lo       HANGUL SYLLABLE GWI
+      | 0xEA 0xB7 0x9C          #Lo       HANGUL SYLLABLE GYU
+      | 0xEA 0xB7 0xB8          #Lo       HANGUL SYLLABLE GEU
+      | 0xEA 0xB8 0x94          #Lo       HANGUL SYLLABLE GYI
+      | 0xEA 0xB8 0xB0          #Lo       HANGUL SYLLABLE GI
+      | 0xEA 0xB9 0x8C          #Lo       HANGUL SYLLABLE GGA
+      | 0xEA 0xB9 0xA8          #Lo       HANGUL SYLLABLE GGAE
+      | 0xEA 0xBA 0x84          #Lo       HANGUL SYLLABLE GGYA
+      | 0xEA 0xBA 0xA0          #Lo       HANGUL SYLLABLE GGYAE
+      | 0xEA 0xBA 0xBC          #Lo       HANGUL SYLLABLE GGEO
+      | 0xEA 0xBB 0x98          #Lo       HANGUL SYLLABLE GGE
+      | 0xEA 0xBB 0xB4          #Lo       HANGUL SYLLABLE GGYEO
+      | 0xEA 0xBC 0x90          #Lo       HANGUL SYLLABLE GGYE
+      | 0xEA 0xBC 0xAC          #Lo       HANGUL SYLLABLE GGO
+      | 0xEA 0xBD 0x88          #Lo       HANGUL SYLLABLE GGWA
+      | 0xEA 0xBD 0xA4          #Lo       HANGUL SYLLABLE GGWAE
+      | 0xEA 0xBE 0x80          #Lo       HANGUL SYLLABLE GGOE
+      | 0xEA 0xBE 0x9C          #Lo       HANGUL SYLLABLE GGYO
+      | 0xEA 0xBE 0xB8          #Lo       HANGUL SYLLABLE GGU
+      | 0xEA 0xBF 0x94          #Lo       HANGUL SYLLABLE GGWEO
+      | 0xEA 0xBF 0xB0          #Lo       HANGUL SYLLABLE GGWE
+      | 0xEB 0x80 0x8C          #Lo       HANGUL SYLLABLE GGWI
+      | 0xEB 0x80 0xA8          #Lo       HANGUL SYLLABLE GGYU
+      | 0xEB 0x81 0x84          #Lo       HANGUL SYLLABLE GGEU
+      | 0xEB 0x81 0xA0          #Lo       HANGUL SYLLABLE GGYI
+      | 0xEB 0x81 0xBC          #Lo       HANGUL SYLLABLE GGI
+      | 0xEB 0x82 0x98          #Lo       HANGUL SYLLABLE NA
+      | 0xEB 0x82 0xB4          #Lo       HANGUL SYLLABLE NAE
+      | 0xEB 0x83 0x90          #Lo       HANGUL SYLLABLE NYA
+      | 0xEB 0x83 0xAC          #Lo       HANGUL SYLLABLE NYAE
+      | 0xEB 0x84 0x88          #Lo       HANGUL SYLLABLE NEO
+      | 0xEB 0x84 0xA4          #Lo       HANGUL SYLLABLE NE
+      | 0xEB 0x85 0x80          #Lo       HANGUL SYLLABLE NYEO
+      | 0xEB 0x85 0x9C          #Lo       HANGUL SYLLABLE NYE
+      | 0xEB 0x85 0xB8          #Lo       HANGUL SYLLABLE NO
+      | 0xEB 0x86 0x94          #Lo       HANGUL SYLLABLE NWA
+      | 0xEB 0x86 0xB0          #Lo       HANGUL SYLLABLE NWAE
+      | 0xEB 0x87 0x8C          #Lo       HANGUL SYLLABLE NOE
+      | 0xEB 0x87 0xA8          #Lo       HANGUL SYLLABLE NYO
+      | 0xEB 0x88 0x84          #Lo       HANGUL SYLLABLE NU
+      | 0xEB 0x88 0xA0          #Lo       HANGUL SYLLABLE NWEO
+      | 0xEB 0x88 0xBC          #Lo       HANGUL SYLLABLE NWE
+      | 0xEB 0x89 0x98          #Lo       HANGUL SYLLABLE NWI
+      | 0xEB 0x89 0xB4          #Lo       HANGUL SYLLABLE NYU
+      | 0xEB 0x8A 0x90          #Lo       HANGUL SYLLABLE NEU
+      | 0xEB 0x8A 0xAC          #Lo       HANGUL SYLLABLE NYI
+      | 0xEB 0x8B 0x88          #Lo       HANGUL SYLLABLE NI
+      | 0xEB 0x8B 0xA4          #Lo       HANGUL SYLLABLE DA
+      | 0xEB 0x8C 0x80          #Lo       HANGUL SYLLABLE DAE
+      | 0xEB 0x8C 0x9C          #Lo       HANGUL SYLLABLE DYA
+      | 0xEB 0x8C 0xB8          #Lo       HANGUL SYLLABLE DYAE
+      | 0xEB 0x8D 0x94          #Lo       HANGUL SYLLABLE DEO
+      | 0xEB 0x8D 0xB0          #Lo       HANGUL SYLLABLE DE
+      | 0xEB 0x8E 0x8C          #Lo       HANGUL SYLLABLE DYEO
+      | 0xEB 0x8E 0xA8          #Lo       HANGUL SYLLABLE DYE
+      | 0xEB 0x8F 0x84          #Lo       HANGUL SYLLABLE DO
+      | 0xEB 0x8F 0xA0          #Lo       HANGUL SYLLABLE DWA
+      | 0xEB 0x8F 0xBC          #Lo       HANGUL SYLLABLE DWAE
+      | 0xEB 0x90 0x98          #Lo       HANGUL SYLLABLE DOE
+      | 0xEB 0x90 0xB4          #Lo       HANGUL SYLLABLE DYO
+      | 0xEB 0x91 0x90          #Lo       HANGUL SYLLABLE DU
+      | 0xEB 0x91 0xAC          #Lo       HANGUL SYLLABLE DWEO
+      | 0xEB 0x92 0x88          #Lo       HANGUL SYLLABLE DWE
+      | 0xEB 0x92 0xA4          #Lo       HANGUL SYLLABLE DWI
+      | 0xEB 0x93 0x80          #Lo       HANGUL SYLLABLE DYU
+      | 0xEB 0x93 0x9C          #Lo       HANGUL SYLLABLE DEU
+      | 0xEB 0x93 0xB8          #Lo       HANGUL SYLLABLE DYI
+      | 0xEB 0x94 0x94          #Lo       HANGUL SYLLABLE DI
+      | 0xEB 0x94 0xB0          #Lo       HANGUL SYLLABLE DDA
+      | 0xEB 0x95 0x8C          #Lo       HANGUL SYLLABLE DDAE
+      | 0xEB 0x95 0xA8          #Lo       HANGUL SYLLABLE DDYA
+      | 0xEB 0x96 0x84          #Lo       HANGUL SYLLABLE DDYAE
+      | 0xEB 0x96 0xA0          #Lo       HANGUL SYLLABLE DDEO
+      | 0xEB 0x96 0xBC          #Lo       HANGUL SYLLABLE DDE
+      | 0xEB 0x97 0x98          #Lo       HANGUL SYLLABLE DDYEO
+      | 0xEB 0x97 0xB4          #Lo       HANGUL SYLLABLE DDYE
+      | 0xEB 0x98 0x90          #Lo       HANGUL SYLLABLE DDO
+      | 0xEB 0x98 0xAC          #Lo       HANGUL SYLLABLE DDWA
+      | 0xEB 0x99 0x88          #Lo       HANGUL SYLLABLE DDWAE
+      | 0xEB 0x99 0xA4          #Lo       HANGUL SYLLABLE DDOE
+      | 0xEB 0x9A 0x80          #Lo       HANGUL SYLLABLE DDYO
+      | 0xEB 0x9A 0x9C          #Lo       HANGUL SYLLABLE DDU
+      | 0xEB 0x9A 0xB8          #Lo       HANGUL SYLLABLE DDWEO
+      | 0xEB 0x9B 0x94          #Lo       HANGUL SYLLABLE DDWE
+      | 0xEB 0x9B 0xB0          #Lo       HANGUL SYLLABLE DDWI
+      | 0xEB 0x9C 0x8C          #Lo       HANGUL SYLLABLE DDYU
+      | 0xEB 0x9C 0xA8          #Lo       HANGUL SYLLABLE DDEU
+      | 0xEB 0x9D 0x84          #Lo       HANGUL SYLLABLE DDYI
+      | 0xEB 0x9D 0xA0          #Lo       HANGUL SYLLABLE DDI
+      | 0xEB 0x9D 0xBC          #Lo       HANGUL SYLLABLE RA
+      | 0xEB 0x9E 0x98          #Lo       HANGUL SYLLABLE RAE
+      | 0xEB 0x9E 0xB4          #Lo       HANGUL SYLLABLE RYA
+      | 0xEB 0x9F 0x90          #Lo       HANGUL SYLLABLE RYAE
+      | 0xEB 0x9F 0xAC          #Lo       HANGUL SYLLABLE REO
+      | 0xEB 0xA0 0x88          #Lo       HANGUL SYLLABLE RE
+      | 0xEB 0xA0 0xA4          #Lo       HANGUL SYLLABLE RYEO
+      | 0xEB 0xA1 0x80          #Lo       HANGUL SYLLABLE RYE
+      | 0xEB 0xA1 0x9C          #Lo       HANGUL SYLLABLE RO
+      | 0xEB 0xA1 0xB8          #Lo       HANGUL SYLLABLE RWA
+      | 0xEB 0xA2 0x94          #Lo       HANGUL SYLLABLE RWAE
+      | 0xEB 0xA2 0xB0          #Lo       HANGUL SYLLABLE ROE
+      | 0xEB 0xA3 0x8C          #Lo       HANGUL SYLLABLE RYO
+      | 0xEB 0xA3 0xA8          #Lo       HANGUL SYLLABLE RU
+      | 0xEB 0xA4 0x84          #Lo       HANGUL SYLLABLE RWEO
+      | 0xEB 0xA4 0xA0          #Lo       HANGUL SYLLABLE RWE
+      | 0xEB 0xA4 0xBC          #Lo       HANGUL SYLLABLE RWI
+      | 0xEB 0xA5 0x98          #Lo       HANGUL SYLLABLE RYU
+      | 0xEB 0xA5 0xB4          #Lo       HANGUL SYLLABLE REU
+      | 0xEB 0xA6 0x90          #Lo       HANGUL SYLLABLE RYI
+      | 0xEB 0xA6 0xAC          #Lo       HANGUL SYLLABLE RI
+      | 0xEB 0xA7 0x88          #Lo       HANGUL SYLLABLE MA
+      | 0xEB 0xA7 0xA4          #Lo       HANGUL SYLLABLE MAE
+      | 0xEB 0xA8 0x80          #Lo       HANGUL SYLLABLE MYA
+      | 0xEB 0xA8 0x9C          #Lo       HANGUL SYLLABLE MYAE
+      | 0xEB 0xA8 0xB8          #Lo       HANGUL SYLLABLE MEO
+      | 0xEB 0xA9 0x94          #Lo       HANGUL SYLLABLE ME
+      | 0xEB 0xA9 0xB0          #Lo       HANGUL SYLLABLE MYEO
+      | 0xEB 0xAA 0x8C          #Lo       HANGUL SYLLABLE MYE
+      | 0xEB 0xAA 0xA8          #Lo       HANGUL SYLLABLE MO
+      | 0xEB 0xAB 0x84          #Lo       HANGUL SYLLABLE MWA
+      | 0xEB 0xAB 0xA0          #Lo       HANGUL SYLLABLE MWAE
+      | 0xEB 0xAB 0xBC          #Lo       HANGUL SYLLABLE MOE
+      | 0xEB 0xAC 0x98          #Lo       HANGUL SYLLABLE MYO
+      | 0xEB 0xAC 0xB4          #Lo       HANGUL SYLLABLE MU
+      | 0xEB 0xAD 0x90          #Lo       HANGUL SYLLABLE MWEO
+      | 0xEB 0xAD 0xAC          #Lo       HANGUL SYLLABLE MWE
+      | 0xEB 0xAE 0x88          #Lo       HANGUL SYLLABLE MWI
+      | 0xEB 0xAE 0xA4          #Lo       HANGUL SYLLABLE MYU
+      | 0xEB 0xAF 0x80          #Lo       HANGUL SYLLABLE MEU
+      | 0xEB 0xAF 0x9C          #Lo       HANGUL SYLLABLE MYI
+      | 0xEB 0xAF 0xB8          #Lo       HANGUL SYLLABLE MI
+      | 0xEB 0xB0 0x94          #Lo       HANGUL SYLLABLE BA
+      | 0xEB 0xB0 0xB0          #Lo       HANGUL SYLLABLE BAE
+      | 0xEB 0xB1 0x8C          #Lo       HANGUL SYLLABLE BYA
+      | 0xEB 0xB1 0xA8          #Lo       HANGUL SYLLABLE BYAE
+      | 0xEB 0xB2 0x84          #Lo       HANGUL SYLLABLE BEO
+      | 0xEB 0xB2 0xA0          #Lo       HANGUL SYLLABLE BE
+      | 0xEB 0xB2 0xBC          #Lo       HANGUL SYLLABLE BYEO
+      | 0xEB 0xB3 0x98          #Lo       HANGUL SYLLABLE BYE
+      | 0xEB 0xB3 0xB4          #Lo       HANGUL SYLLABLE BO
+      | 0xEB 0xB4 0x90          #Lo       HANGUL SYLLABLE BWA
+      | 0xEB 0xB4 0xAC          #Lo       HANGUL SYLLABLE BWAE
+      | 0xEB 0xB5 0x88          #Lo       HANGUL SYLLABLE BOE
+      | 0xEB 0xB5 0xA4          #Lo       HANGUL SYLLABLE BYO
+      | 0xEB 0xB6 0x80          #Lo       HANGUL SYLLABLE BU
+      | 0xEB 0xB6 0x9C          #Lo       HANGUL SYLLABLE BWEO
+      | 0xEB 0xB6 0xB8          #Lo       HANGUL SYLLABLE BWE
+      | 0xEB 0xB7 0x94          #Lo       HANGUL SYLLABLE BWI
+      | 0xEB 0xB7 0xB0          #Lo       HANGUL SYLLABLE BYU
+      | 0xEB 0xB8 0x8C          #Lo       HANGUL SYLLABLE BEU
+      | 0xEB 0xB8 0xA8          #Lo       HANGUL SYLLABLE BYI
+      | 0xEB 0xB9 0x84          #Lo       HANGUL SYLLABLE BI
+      | 0xEB 0xB9 0xA0          #Lo       HANGUL SYLLABLE BBA
+      | 0xEB 0xB9 0xBC          #Lo       HANGUL SYLLABLE BBAE
+      | 0xEB 0xBA 0x98          #Lo       HANGUL SYLLABLE BBYA
+      | 0xEB 0xBA 0xB4          #Lo       HANGUL SYLLABLE BBYAE
+      | 0xEB 0xBB 0x90          #Lo       HANGUL SYLLABLE BBEO
+      | 0xEB 0xBB 0xAC          #Lo       HANGUL SYLLABLE BBE
+      | 0xEB 0xBC 0x88          #Lo       HANGUL SYLLABLE BBYEO
+      | 0xEB 0xBC 0xA4          #Lo       HANGUL SYLLABLE BBYE
+      | 0xEB 0xBD 0x80          #Lo       HANGUL SYLLABLE BBO
+      | 0xEB 0xBD 0x9C          #Lo       HANGUL SYLLABLE BBWA
+      | 0xEB 0xBD 0xB8          #Lo       HANGUL SYLLABLE BBWAE
+      | 0xEB 0xBE 0x94          #Lo       HANGUL SYLLABLE BBOE
+      | 0xEB 0xBE 0xB0          #Lo       HANGUL SYLLABLE BBYO
+      | 0xEB 0xBF 0x8C          #Lo       HANGUL SYLLABLE BBU
+      | 0xEB 0xBF 0xA8          #Lo       HANGUL SYLLABLE BBWEO
+      | 0xEC 0x80 0x84          #Lo       HANGUL SYLLABLE BBWE
+      | 0xEC 0x80 0xA0          #Lo       HANGUL SYLLABLE BBWI
+      | 0xEC 0x80 0xBC          #Lo       HANGUL SYLLABLE BBYU
+      | 0xEC 0x81 0x98          #Lo       HANGUL SYLLABLE BBEU
+      | 0xEC 0x81 0xB4          #Lo       HANGUL SYLLABLE BBYI
+      | 0xEC 0x82 0x90          #Lo       HANGUL SYLLABLE BBI
+      | 0xEC 0x82 0xAC          #Lo       HANGUL SYLLABLE SA
+      | 0xEC 0x83 0x88          #Lo       HANGUL SYLLABLE SAE
+      | 0xEC 0x83 0xA4          #Lo       HANGUL SYLLABLE SYA
+      | 0xEC 0x84 0x80          #Lo       HANGUL SYLLABLE SYAE
+      | 0xEC 0x84 0x9C          #Lo       HANGUL SYLLABLE SEO
+      | 0xEC 0x84 0xB8          #Lo       HANGUL SYLLABLE SE
+      | 0xEC 0x85 0x94          #Lo       HANGUL SYLLABLE SYEO
+      | 0xEC 0x85 0xB0          #Lo       HANGUL SYLLABLE SYE
+      | 0xEC 0x86 0x8C          #Lo       HANGUL SYLLABLE SO
+      | 0xEC 0x86 0xA8          #Lo       HANGUL SYLLABLE SWA
+      | 0xEC 0x87 0x84          #Lo       HANGUL SYLLABLE SWAE
+      | 0xEC 0x87 0xA0          #Lo       HANGUL SYLLABLE SOE
+      | 0xEC 0x87 0xBC          #Lo       HANGUL SYLLABLE SYO
+      | 0xEC 0x88 0x98          #Lo       HANGUL SYLLABLE SU
+      | 0xEC 0x88 0xB4          #Lo       HANGUL SYLLABLE SWEO
+      | 0xEC 0x89 0x90          #Lo       HANGUL SYLLABLE SWE
+      | 0xEC 0x89 0xAC          #Lo       HANGUL SYLLABLE SWI
+      | 0xEC 0x8A 0x88          #Lo       HANGUL SYLLABLE SYU
+      | 0xEC 0x8A 0xA4          #Lo       HANGUL SYLLABLE SEU
+      | 0xEC 0x8B 0x80          #Lo       HANGUL SYLLABLE SYI
+      | 0xEC 0x8B 0x9C          #Lo       HANGUL SYLLABLE SI
+      | 0xEC 0x8B 0xB8          #Lo       HANGUL SYLLABLE SSA
+      | 0xEC 0x8C 0x94          #Lo       HANGUL SYLLABLE SSAE
+      | 0xEC 0x8C 0xB0          #Lo       HANGUL SYLLABLE SSYA
+      | 0xEC 0x8D 0x8C          #Lo       HANGUL SYLLABLE SSYAE
+      | 0xEC 0x8D 0xA8          #Lo       HANGUL SYLLABLE SSEO
+      | 0xEC 0x8E 0x84          #Lo       HANGUL SYLLABLE SSE
+      | 0xEC 0x8E 0xA0          #Lo       HANGUL SYLLABLE SSYEO
+      | 0xEC 0x8E 0xBC          #Lo       HANGUL SYLLABLE SSYE
+      | 0xEC 0x8F 0x98          #Lo       HANGUL SYLLABLE SSO
+      | 0xEC 0x8F 0xB4          #Lo       HANGUL SYLLABLE SSWA
+      | 0xEC 0x90 0x90          #Lo       HANGUL SYLLABLE SSWAE
+      | 0xEC 0x90 0xAC          #Lo       HANGUL SYLLABLE SSOE
+      | 0xEC 0x91 0x88          #Lo       HANGUL SYLLABLE SSYO
+      | 0xEC 0x91 0xA4          #Lo       HANGUL SYLLABLE SSU
+      | 0xEC 0x92 0x80          #Lo       HANGUL SYLLABLE SSWEO
+      | 0xEC 0x92 0x9C          #Lo       HANGUL SYLLABLE SSWE
+      | 0xEC 0x92 0xB8          #Lo       HANGUL SYLLABLE SSWI
+      | 0xEC 0x93 0x94          #Lo       HANGUL SYLLABLE SSYU
+      | 0xEC 0x93 0xB0          #Lo       HANGUL SYLLABLE SSEU
+      | 0xEC 0x94 0x8C          #Lo       HANGUL SYLLABLE SSYI
+      | 0xEC 0x94 0xA8          #Lo       HANGUL SYLLABLE SSI
+      | 0xEC 0x95 0x84          #Lo       HANGUL SYLLABLE A
+      | 0xEC 0x95 0xA0          #Lo       HANGUL SYLLABLE AE
+      | 0xEC 0x95 0xBC          #Lo       HANGUL SYLLABLE YA
+      | 0xEC 0x96 0x98          #Lo       HANGUL SYLLABLE YAE
+      | 0xEC 0x96 0xB4          #Lo       HANGUL SYLLABLE EO
+      | 0xEC 0x97 0x90          #Lo       HANGUL SYLLABLE E
+      | 0xEC 0x97 0xAC          #Lo       HANGUL SYLLABLE YEO
+      | 0xEC 0x98 0x88          #Lo       HANGUL SYLLABLE YE
+      | 0xEC 0x98 0xA4          #Lo       HANGUL SYLLABLE O
+      | 0xEC 0x99 0x80          #Lo       HANGUL SYLLABLE WA
+      | 0xEC 0x99 0x9C          #Lo       HANGUL SYLLABLE WAE
+      | 0xEC 0x99 0xB8          #Lo       HANGUL SYLLABLE OE
+      | 0xEC 0x9A 0x94          #Lo       HANGUL SYLLABLE YO
+      | 0xEC 0x9A 0xB0          #Lo       HANGUL SYLLABLE U
+      | 0xEC 0x9B 0x8C          #Lo       HANGUL SYLLABLE WEO
+      | 0xEC 0x9B 0xA8          #Lo       HANGUL SYLLABLE WE
+      | 0xEC 0x9C 0x84          #Lo       HANGUL SYLLABLE WI
+      | 0xEC 0x9C 0xA0          #Lo       HANGUL SYLLABLE YU
+      | 0xEC 0x9C 0xBC          #Lo       HANGUL SYLLABLE EU
+      | 0xEC 0x9D 0x98          #Lo       HANGUL SYLLABLE YI
+      | 0xEC 0x9D 0xB4          #Lo       HANGUL SYLLABLE I
+      | 0xEC 0x9E 0x90          #Lo       HANGUL SYLLABLE JA
+      | 0xEC 0x9E 0xAC          #Lo       HANGUL SYLLABLE JAE
+      | 0xEC 0x9F 0x88          #Lo       HANGUL SYLLABLE JYA
+      | 0xEC 0x9F 0xA4          #Lo       HANGUL SYLLABLE JYAE
+      | 0xEC 0xA0 0x80          #Lo       HANGUL SYLLABLE JEO
+      | 0xEC 0xA0 0x9C          #Lo       HANGUL SYLLABLE JE
+      | 0xEC 0xA0 0xB8          #Lo       HANGUL SYLLABLE JYEO
+      | 0xEC 0xA1 0x94          #Lo       HANGUL SYLLABLE JYE
+      | 0xEC 0xA1 0xB0          #Lo       HANGUL SYLLABLE JO
+      | 0xEC 0xA2 0x8C          #Lo       HANGUL SYLLABLE JWA
+      | 0xEC 0xA2 0xA8          #Lo       HANGUL SYLLABLE JWAE
+      | 0xEC 0xA3 0x84          #Lo       HANGUL SYLLABLE JOE
+      | 0xEC 0xA3 0xA0          #Lo       HANGUL SYLLABLE JYO
+      | 0xEC 0xA3 0xBC          #Lo       HANGUL SYLLABLE JU
+      | 0xEC 0xA4 0x98          #Lo       HANGUL SYLLABLE JWEO
+      | 0xEC 0xA4 0xB4          #Lo       HANGUL SYLLABLE JWE
+      | 0xEC 0xA5 0x90          #Lo       HANGUL SYLLABLE JWI
+      | 0xEC 0xA5 0xAC          #Lo       HANGUL SYLLABLE JYU
+      | 0xEC 0xA6 0x88          #Lo       HANGUL SYLLABLE JEU
+      | 0xEC 0xA6 0xA4          #Lo       HANGUL SYLLABLE JYI
+      | 0xEC 0xA7 0x80          #Lo       HANGUL SYLLABLE JI
+      | 0xEC 0xA7 0x9C          #Lo       HANGUL SYLLABLE JJA
+      | 0xEC 0xA7 0xB8          #Lo       HANGUL SYLLABLE JJAE
+      | 0xEC 0xA8 0x94          #Lo       HANGUL SYLLABLE JJYA
+      | 0xEC 0xA8 0xB0          #Lo       HANGUL SYLLABLE JJYAE
+      | 0xEC 0xA9 0x8C          #Lo       HANGUL SYLLABLE JJEO
+      | 0xEC 0xA9 0xA8          #Lo       HANGUL SYLLABLE JJE
+      | 0xEC 0xAA 0x84          #Lo       HANGUL SYLLABLE JJYEO
+      | 0xEC 0xAA 0xA0          #Lo       HANGUL SYLLABLE JJYE
+      | 0xEC 0xAA 0xBC          #Lo       HANGUL SYLLABLE JJO
+      | 0xEC 0xAB 0x98          #Lo       HANGUL SYLLABLE JJWA
+      | 0xEC 0xAB 0xB4          #Lo       HANGUL SYLLABLE JJWAE
+      | 0xEC 0xAC 0x90          #Lo       HANGUL SYLLABLE JJOE
+      | 0xEC 0xAC 0xAC          #Lo       HANGUL SYLLABLE JJYO
+      | 0xEC 0xAD 0x88          #Lo       HANGUL SYLLABLE JJU
+      | 0xEC 0xAD 0xA4          #Lo       HANGUL SYLLABLE JJWEO
+      | 0xEC 0xAE 0x80          #Lo       HANGUL SYLLABLE JJWE
+      | 0xEC 0xAE 0x9C          #Lo       HANGUL SYLLABLE JJWI
+      | 0xEC 0xAE 0xB8          #Lo       HANGUL SYLLABLE JJYU
+      | 0xEC 0xAF 0x94          #Lo       HANGUL SYLLABLE JJEU
+      | 0xEC 0xAF 0xB0          #Lo       HANGUL SYLLABLE JJYI
+      | 0xEC 0xB0 0x8C          #Lo       HANGUL SYLLABLE JJI
+      | 0xEC 0xB0 0xA8          #Lo       HANGUL SYLLABLE CA
+      | 0xEC 0xB1 0x84          #Lo       HANGUL SYLLABLE CAE
+      | 0xEC 0xB1 0xA0          #Lo       HANGUL SYLLABLE CYA
+      | 0xEC 0xB1 0xBC          #Lo       HANGUL SYLLABLE CYAE
+      | 0xEC 0xB2 0x98          #Lo       HANGUL SYLLABLE CEO
+      | 0xEC 0xB2 0xB4          #Lo       HANGUL SYLLABLE CE
+      | 0xEC 0xB3 0x90          #Lo       HANGUL SYLLABLE CYEO
+      | 0xEC 0xB3 0xAC          #Lo       HANGUL SYLLABLE CYE
+      | 0xEC 0xB4 0x88          #Lo       HANGUL SYLLABLE CO
+      | 0xEC 0xB4 0xA4          #Lo       HANGUL SYLLABLE CWA
+      | 0xEC 0xB5 0x80          #Lo       HANGUL SYLLABLE CWAE
+      | 0xEC 0xB5 0x9C          #Lo       HANGUL SYLLABLE COE
+      | 0xEC 0xB5 0xB8          #Lo       HANGUL SYLLABLE CYO
+      | 0xEC 0xB6 0x94          #Lo       HANGUL SYLLABLE CU
+      | 0xEC 0xB6 0xB0          #Lo       HANGUL SYLLABLE CWEO
+      | 0xEC 0xB7 0x8C          #Lo       HANGUL SYLLABLE CWE
+      | 0xEC 0xB7 0xA8          #Lo       HANGUL SYLLABLE CWI
+      | 0xEC 0xB8 0x84          #Lo       HANGUL SYLLABLE CYU
+      | 0xEC 0xB8 0xA0          #Lo       HANGUL SYLLABLE CEU
+      | 0xEC 0xB8 0xBC          #Lo       HANGUL SYLLABLE CYI
+      | 0xEC 0xB9 0x98          #Lo       HANGUL SYLLABLE CI
+      | 0xEC 0xB9 0xB4          #Lo       HANGUL SYLLABLE KA
+      | 0xEC 0xBA 0x90          #Lo       HANGUL SYLLABLE KAE
+      | 0xEC 0xBA 0xAC          #Lo       HANGUL SYLLABLE KYA
+      | 0xEC 0xBB 0x88          #Lo       HANGUL SYLLABLE KYAE
+      | 0xEC 0xBB 0xA4          #Lo       HANGUL SYLLABLE KEO
+      | 0xEC 0xBC 0x80          #Lo       HANGUL SYLLABLE KE
+      | 0xEC 0xBC 0x9C          #Lo       HANGUL SYLLABLE KYEO
+      | 0xEC 0xBC 0xB8          #Lo       HANGUL SYLLABLE KYE
+      | 0xEC 0xBD 0x94          #Lo       HANGUL SYLLABLE KO
+      | 0xEC 0xBD 0xB0          #Lo       HANGUL SYLLABLE KWA
+      | 0xEC 0xBE 0x8C          #Lo       HANGUL SYLLABLE KWAE
+      | 0xEC 0xBE 0xA8          #Lo       HANGUL SYLLABLE KOE
+      | 0xEC 0xBF 0x84          #Lo       HANGUL SYLLABLE KYO
+      | 0xEC 0xBF 0xA0          #Lo       HANGUL SYLLABLE KU
+      | 0xEC 0xBF 0xBC          #Lo       HANGUL SYLLABLE KWEO
+      | 0xED 0x80 0x98          #Lo       HANGUL SYLLABLE KWE
+      | 0xED 0x80 0xB4          #Lo       HANGUL SYLLABLE KWI
+      | 0xED 0x81 0x90          #Lo       HANGUL SYLLABLE KYU
+      | 0xED 0x81 0xAC          #Lo       HANGUL SYLLABLE KEU
+      | 0xED 0x82 0x88          #Lo       HANGUL SYLLABLE KYI
+      | 0xED 0x82 0xA4          #Lo       HANGUL SYLLABLE KI
+      | 0xED 0x83 0x80          #Lo       HANGUL SYLLABLE TA
+      | 0xED 0x83 0x9C          #Lo       HANGUL SYLLABLE TAE
+      | 0xED 0x83 0xB8          #Lo       HANGUL SYLLABLE TYA
+      | 0xED 0x84 0x94          #Lo       HANGUL SYLLABLE TYAE
+      | 0xED 0x84 0xB0          #Lo       HANGUL SYLLABLE TEO
+      | 0xED 0x85 0x8C          #Lo       HANGUL SYLLABLE TE
+      | 0xED 0x85 0xA8          #Lo       HANGUL SYLLABLE TYEO
+      | 0xED 0x86 0x84          #Lo       HANGUL SYLLABLE TYE
+      | 0xED 0x86 0xA0          #Lo       HANGUL SYLLABLE TO
+      | 0xED 0x86 0xBC          #Lo       HANGUL SYLLABLE TWA
+      | 0xED 0x87 0x98          #Lo       HANGUL SYLLABLE TWAE
+      | 0xED 0x87 0xB4          #Lo       HANGUL SYLLABLE TOE
+      | 0xED 0x88 0x90          #Lo       HANGUL SYLLABLE TYO
+      | 0xED 0x88 0xAC          #Lo       HANGUL SYLLABLE TU
+      | 0xED 0x89 0x88          #Lo       HANGUL SYLLABLE TWEO
+      | 0xED 0x89 0xA4          #Lo       HANGUL SYLLABLE TWE
+      | 0xED 0x8A 0x80          #Lo       HANGUL SYLLABLE TWI
+      | 0xED 0x8A 0x9C          #Lo       HANGUL SYLLABLE TYU
+      | 0xED 0x8A 0xB8          #Lo       HANGUL SYLLABLE TEU
+      | 0xED 0x8B 0x94          #Lo       HANGUL SYLLABLE TYI
+      | 0xED 0x8B 0xB0          #Lo       HANGUL SYLLABLE TI
+      | 0xED 0x8C 0x8C          #Lo       HANGUL SYLLABLE PA
+      | 0xED 0x8C 0xA8          #Lo       HANGUL SYLLABLE PAE
+      | 0xED 0x8D 0x84          #Lo       HANGUL SYLLABLE PYA
+      | 0xED 0x8D 0xA0          #Lo       HANGUL SYLLABLE PYAE
+      | 0xED 0x8D 0xBC          #Lo       HANGUL SYLLABLE PEO
+      | 0xED 0x8E 0x98          #Lo       HANGUL SYLLABLE PE
+      | 0xED 0x8E 0xB4          #Lo       HANGUL SYLLABLE PYEO
+      | 0xED 0x8F 0x90          #Lo       HANGUL SYLLABLE PYE
+      | 0xED 0x8F 0xAC          #Lo       HANGUL SYLLABLE PO
+      | 0xED 0x90 0x88          #Lo       HANGUL SYLLABLE PWA
+      | 0xED 0x90 0xA4          #Lo       HANGUL SYLLABLE PWAE
+      | 0xED 0x91 0x80          #Lo       HANGUL SYLLABLE POE
+      | 0xED 0x91 0x9C          #Lo       HANGUL SYLLABLE PYO
+      | 0xED 0x91 0xB8          #Lo       HANGUL SYLLABLE PU
+      | 0xED 0x92 0x94          #Lo       HANGUL SYLLABLE PWEO
+      | 0xED 0x92 0xB0          #Lo       HANGUL SYLLABLE PWE
+      | 0xED 0x93 0x8C          #Lo       HANGUL SYLLABLE PWI
+      | 0xED 0x93 0xA8          #Lo       HANGUL SYLLABLE PYU
+      | 0xED 0x94 0x84          #Lo       HANGUL SYLLABLE PEU
+      | 0xED 0x94 0xA0          #Lo       HANGUL SYLLABLE PYI
+      | 0xED 0x94 0xBC          #Lo       HANGUL SYLLABLE PI
+      | 0xED 0x95 0x98          #Lo       HANGUL SYLLABLE HA
+      | 0xED 0x95 0xB4          #Lo       HANGUL SYLLABLE HAE
+      | 0xED 0x96 0x90          #Lo       HANGUL SYLLABLE HYA
+      | 0xED 0x96 0xAC          #Lo       HANGUL SYLLABLE HYAE
+      | 0xED 0x97 0x88          #Lo       HANGUL SYLLABLE HEO
+      | 0xED 0x97 0xA4          #Lo       HANGUL SYLLABLE HE
+      | 0xED 0x98 0x80          #Lo       HANGUL SYLLABLE HYEO
+      | 0xED 0x98 0x9C          #Lo       HANGUL SYLLABLE HYE
+      | 0xED 0x98 0xB8          #Lo       HANGUL SYLLABLE HO
+      | 0xED 0x99 0x94          #Lo       HANGUL SYLLABLE HWA
+      | 0xED 0x99 0xB0          #Lo       HANGUL SYLLABLE HWAE
+      | 0xED 0x9A 0x8C          #Lo       HANGUL SYLLABLE HOE
+      | 0xED 0x9A 0xA8          #Lo       HANGUL SYLLABLE HYO
+      | 0xED 0x9B 0x84          #Lo       HANGUL SYLLABLE HU
+      | 0xED 0x9B 0xA0          #Lo       HANGUL SYLLABLE HWEO
+      | 0xED 0x9B 0xBC          #Lo       HANGUL SYLLABLE HWE
+      | 0xED 0x9C 0x98          #Lo       HANGUL SYLLABLE HWI
+      | 0xED 0x9C 0xB4          #Lo       HANGUL SYLLABLE HYU
+      | 0xED 0x9D 0x90          #Lo       HANGUL SYLLABLE HEU
+      | 0xED 0x9D 0xAC          #Lo       HANGUL SYLLABLE HYI
+      | 0xED 0x9E 0x88          #Lo       HANGUL SYLLABLE HI
+      ;
+
+    LVT = 
+        0xEA 0xB0 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE GAG..HANGUL SYLLAB...
+      | 0xEA 0xB0 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE GAEG..HANGUL SYLLA...
+      | 0xEA 0xB0 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE GYAG..HANGUL SYLLA...
+      | 0xEA 0xB1 0x00..0x93    #
+      | 0xEA 0xB1 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE GYAEG..HANGUL SYLL...
+      | 0xEA 0xB1 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE GEOG..HANGUL SYLLA...
+      | 0xEA 0xB2 0x00..0x8B    #
+      | 0xEA 0xB2 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE GEG..HANGUL SYLLAB...
+      | 0xEA 0xB2 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE GYEOG..HANGUL SYLL...
+      | 0xEA 0xB3 0x00..0x83    #
+      | 0xEA 0xB3 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE GYEG..HANGUL SYLLA...
+      | 0xEA 0xB3 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE GOG..HANGUL SYLLAB...
+      | 0xEA 0xB3 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE GWAG..HANGUL SYLLA...
+      | 0xEA 0xB4 0x00..0x97    #
+      | 0xEA 0xB4 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE GWAEG..HANGUL SYLL...
+      | 0xEA 0xB4 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE GOEG..HANGUL SYLLA...
+      | 0xEA 0xB5 0x00..0x8F    #
+      | 0xEA 0xB5 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE GYOG..HANGUL SYLLA...
+      | 0xEA 0xB5 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE GUG..HANGUL SYLLAB...
+      | 0xEA 0xB6 0x00..0x87    #
+      | 0xEA 0xB6 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE GWEOG..HANGUL SYLL...
+      | 0xEA 0xB6 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE GWEG..HANGUL SYLLA...
+      | 0xEA 0xB7 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE GWIG..HANGUL SYLLA...
+      | 0xEA 0xB7 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE GYUG..HANGUL SYLLA...
+      | 0xEA 0xB7 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE GEUG..HANGUL SYLLA...
+      | 0xEA 0xB8 0x00..0x93    #
+      | 0xEA 0xB8 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE GYIG..HANGUL SYLLA...
+      | 0xEA 0xB8 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE GIG..HANGUL SYLLAB...
+      | 0xEA 0xB9 0x00..0x8B    #
+      | 0xEA 0xB9 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE GGAG..HANGUL SYLLA...
+      | 0xEA 0xB9 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE GGAEG..HANGUL SYLL...
+      | 0xEA 0xBA 0x00..0x83    #
+      | 0xEA 0xBA 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE GGYAG..HANGUL SYLL...
+      | 0xEA 0xBA 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE GGYAEG..HANGUL SYL...
+      | 0xEA 0xBA 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE GGEOG..HANGUL SYLL...
+      | 0xEA 0xBB 0x00..0x97    #
+      | 0xEA 0xBB 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE GGEG..HANGUL SYLLA...
+      | 0xEA 0xBB 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE GGYEOG..HANGUL SYL...
+      | 0xEA 0xBC 0x00..0x8F    #
+      | 0xEA 0xBC 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE GGYEG..HANGUL SYLL...
+      | 0xEA 0xBC 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE GGOG..HANGUL SYLLA...
+      | 0xEA 0xBD 0x00..0x87    #
+      | 0xEA 0xBD 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE GGWAG..HANGUL SYLL...
+      | 0xEA 0xBD 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE GGWAEG..HANGUL SYL...
+      | 0xEA 0xBE 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE GGOEG..HANGUL SYLL...
+      | 0xEA 0xBE 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE GGYOG..HANGUL SYLL...
+      | 0xEA 0xBE 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE GGUG..HANGUL SYLLA...
+      | 0xEA 0xBF 0x00..0x93    #
+      | 0xEA 0xBF 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE GGWEOG..HANGUL SYL...
+      | 0xEA 0xBF 0xB1..0xFF        #Lo  [27] HANGUL SYLLABLE GGWEG..HANGUL ...
+      | 0xEA 0xC0..0xFF 0x00..0xFF  #
+      | 0xEB 0x00 0x00..0xFF        #
+      | 0xEB 0x01..0x7F 0x00..0xFF  #
+      | 0xEB 0x80 0x00..0x8B        #
+      | 0xEB 0x80 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE GGWIG..HANGUL SYLL...
+      | 0xEB 0x80 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE GGYUG..HANGUL SYLL...
+      | 0xEB 0x81 0x00..0x83    #
+      | 0xEB 0x81 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE GGEUG..HANGUL SYLL...
+      | 0xEB 0x81 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE GGYIG..HANGUL SYLL...
+      | 0xEB 0x81 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE GGIG..HANGUL SYLLA...
+      | 0xEB 0x82 0x00..0x97    #
+      | 0xEB 0x82 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE NAG..HANGUL SYLLAB...
+      | 0xEB 0x82 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE NAEG..HANGUL SYLLA...
+      | 0xEB 0x83 0x00..0x8F    #
+      | 0xEB 0x83 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE NYAG..HANGUL SYLLA...
+      | 0xEB 0x83 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE NYAEG..HANGUL SYLL...
+      | 0xEB 0x84 0x00..0x87    #
+      | 0xEB 0x84 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE NEOG..HANGUL SYLLA...
+      | 0xEB 0x84 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE NEG..HANGUL SYLLAB...
+      | 0xEB 0x85 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE NYEOG..HANGUL SYLL...
+      | 0xEB 0x85 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE NYEG..HANGUL SYLLA...
+      | 0xEB 0x85 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE NOG..HANGUL SYLLAB...
+      | 0xEB 0x86 0x00..0x93    #
+      | 0xEB 0x86 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE NWAG..HANGUL SYLLA...
+      | 0xEB 0x86 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE NWAEG..HANGUL SYLL...
+      | 0xEB 0x87 0x00..0x8B    #
+      | 0xEB 0x87 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE NOEG..HANGUL SYLLA...
+      | 0xEB 0x87 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE NYOG..HANGUL SYLLA...
+      | 0xEB 0x88 0x00..0x83    #
+      | 0xEB 0x88 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE NUG..HANGUL SYLLAB...
+      | 0xEB 0x88 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE NWEOG..HANGUL SYLL...
+      | 0xEB 0x88 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE NWEG..HANGUL SYLLA...
+      | 0xEB 0x89 0x00..0x97    #
+      | 0xEB 0x89 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE NWIG..HANGUL SYLLA...
+      | 0xEB 0x89 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE NYUG..HANGUL SYLLA...
+      | 0xEB 0x8A 0x00..0x8F    #
+      | 0xEB 0x8A 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE NEUG..HANGUL SYLLA...
+      | 0xEB 0x8A 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE NYIG..HANGUL SYLLA...
+      | 0xEB 0x8B 0x00..0x87    #
+      | 0xEB 0x8B 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE NIG..HANGUL SYLLAB...
+      | 0xEB 0x8B 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE DAG..HANGUL SYLLAB...
+      | 0xEB 0x8C 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE DAEG..HANGUL SYLLA...
+      | 0xEB 0x8C 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE DYAG..HANGUL SYLLA...
+      | 0xEB 0x8C 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE DYAEG..HANGUL SYLL...
+      | 0xEB 0x8D 0x00..0x93    #
+      | 0xEB 0x8D 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE DEOG..HANGUL SYLLA...
+      | 0xEB 0x8D 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE DEG..HANGUL SYLLAB...
+      | 0xEB 0x8E 0x00..0x8B    #
+      | 0xEB 0x8E 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE DYEOG..HANGUL SYLL...
+      | 0xEB 0x8E 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE DYEG..HANGUL SYLLA...
+      | 0xEB 0x8F 0x00..0x83    #
+      | 0xEB 0x8F 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE DOG..HANGUL SYLLAB...
+      | 0xEB 0x8F 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE DWAG..HANGUL SYLLA...
+      | 0xEB 0x8F 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE DWAEG..HANGUL SYLL...
+      | 0xEB 0x90 0x00..0x97    #
+      | 0xEB 0x90 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE DOEG..HANGUL SYLLA...
+      | 0xEB 0x90 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE DYOG..HANGUL SYLLA...
+      | 0xEB 0x91 0x00..0x8F    #
+      | 0xEB 0x91 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE DUG..HANGUL SYLLAB...
+      | 0xEB 0x91 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE DWEOG..HANGUL SYLL...
+      | 0xEB 0x92 0x00..0x87    #
+      | 0xEB 0x92 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE DWEG..HANGUL SYLLA...
+      | 0xEB 0x92 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE DWIG..HANGUL SYLLA...
+      | 0xEB 0x93 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE DYUG..HANGUL SYLLA...
+      | 0xEB 0x93 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE DEUG..HANGUL SYLLA...
+      | 0xEB 0x93 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE DYIG..HANGUL SYLLA...
+      | 0xEB 0x94 0x00..0x93    #
+      | 0xEB 0x94 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE DIG..HANGUL SYLLAB...
+      | 0xEB 0x94 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE DDAG..HANGUL SYLLA...
+      | 0xEB 0x95 0x00..0x8B    #
+      | 0xEB 0x95 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE DDAEG..HANGUL SYLL...
+      | 0xEB 0x95 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE DDYAG..HANGUL SYLL...
+      | 0xEB 0x96 0x00..0x83    #
+      | 0xEB 0x96 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE DDYAEG..HANGUL SYL...
+      | 0xEB 0x96 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE DDEOG..HANGUL SYLL...
+      | 0xEB 0x96 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE DDEG..HANGUL SYLLA...
+      | 0xEB 0x97 0x00..0x97    #
+      | 0xEB 0x97 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE DDYEOG..HANGUL SYL...
+      | 0xEB 0x97 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE DDYEG..HANGUL SYLL...
+      | 0xEB 0x98 0x00..0x8F    #
+      | 0xEB 0x98 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE DDOG..HANGUL SYLLA...
+      | 0xEB 0x98 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE DDWAG..HANGUL SYLL...
+      | 0xEB 0x99 0x00..0x87    #
+      | 0xEB 0x99 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE DDWAEG..HANGUL SYL...
+      | 0xEB 0x99 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE DDOEG..HANGUL SYLL...
+      | 0xEB 0x9A 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE DDYOG..HANGUL SYLL...
+      | 0xEB 0x9A 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE DDUG..HANGUL SYLLA...
+      | 0xEB 0x9A 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE DDWEOG..HANGUL SYL...
+      | 0xEB 0x9B 0x00..0x93    #
+      | 0xEB 0x9B 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE DDWEG..HANGUL SYLL...
+      | 0xEB 0x9B 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE DDWIG..HANGUL SYLL...
+      | 0xEB 0x9C 0x00..0x8B    #
+      | 0xEB 0x9C 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE DDYUG..HANGUL SYLL...
+      | 0xEB 0x9C 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE DDEUG..HANGUL SYLL...
+      | 0xEB 0x9D 0x00..0x83    #
+      | 0xEB 0x9D 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE DDYIG..HANGUL SYLL...
+      | 0xEB 0x9D 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE DDIG..HANGUL SYLLA...
+      | 0xEB 0x9D 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE RAG..HANGUL SYLLAB...
+      | 0xEB 0x9E 0x00..0x97    #
+      | 0xEB 0x9E 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE RAEG..HANGUL SYLLA...
+      | 0xEB 0x9E 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE RYAG..HANGUL SYLLA...
+      | 0xEB 0x9F 0x00..0x8F    #
+      | 0xEB 0x9F 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE RYAEG..HANGUL SYLL...
+      | 0xEB 0x9F 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE REOG..HANGUL SYLLA...
+      | 0xEB 0xA0 0x00..0x87    #
+      | 0xEB 0xA0 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE REG..HANGUL SYLLAB...
+      | 0xEB 0xA0 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE RYEOG..HANGUL SYLL...
+      | 0xEB 0xA1 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE RYEG..HANGUL SYLLA...
+      | 0xEB 0xA1 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE ROG..HANGUL SYLLAB...
+      | 0xEB 0xA1 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE RWAG..HANGUL SYLLA...
+      | 0xEB 0xA2 0x00..0x93    #
+      | 0xEB 0xA2 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE RWAEG..HANGUL SYLL...
+      | 0xEB 0xA2 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE ROEG..HANGUL SYLLA...
+      | 0xEB 0xA3 0x00..0x8B    #
+      | 0xEB 0xA3 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE RYOG..HANGUL SYLLA...
+      | 0xEB 0xA3 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE RUG..HANGUL SYLLAB...
+      | 0xEB 0xA4 0x00..0x83    #
+      | 0xEB 0xA4 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE RWEOG..HANGUL SYLL...
+      | 0xEB 0xA4 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE RWEG..HANGUL SYLLA...
+      | 0xEB 0xA4 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE RWIG..HANGUL SYLLA...
+      | 0xEB 0xA5 0x00..0x97    #
+      | 0xEB 0xA5 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE RYUG..HANGUL SYLLA...
+      | 0xEB 0xA5 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE REUG..HANGUL SYLLA...
+      | 0xEB 0xA6 0x00..0x8F    #
+      | 0xEB 0xA6 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE RYIG..HANGUL SYLLA...
+      | 0xEB 0xA6 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE RIG..HANGUL SYLLAB...
+      | 0xEB 0xA7 0x00..0x87    #
+      | 0xEB 0xA7 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE MAG..HANGUL SYLLAB...
+      | 0xEB 0xA7 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE MAEG..HANGUL SYLLA...
+      | 0xEB 0xA8 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE MYAG..HANGUL SYLLA...
+      | 0xEB 0xA8 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE MYAEG..HANGUL SYLL...
+      | 0xEB 0xA8 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE MEOG..HANGUL SYLLA...
+      | 0xEB 0xA9 0x00..0x93    #
+      | 0xEB 0xA9 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE MEG..HANGUL SYLLAB...
+      | 0xEB 0xA9 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE MYEOG..HANGUL SYLL...
+      | 0xEB 0xAA 0x00..0x8B    #
+      | 0xEB 0xAA 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE MYEG..HANGUL SYLLA...
+      | 0xEB 0xAA 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE MOG..HANGUL SYLLAB...
+      | 0xEB 0xAB 0x00..0x83    #
+      | 0xEB 0xAB 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE MWAG..HANGUL SYLLA...
+      | 0xEB 0xAB 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE MWAEG..HANGUL SYLL...
+      | 0xEB 0xAB 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE MOEG..HANGUL SYLLA...
+      | 0xEB 0xAC 0x00..0x97    #
+      | 0xEB 0xAC 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE MYOG..HANGUL SYLLA...
+      | 0xEB 0xAC 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE MUG..HANGUL SYLLAB...
+      | 0xEB 0xAD 0x00..0x8F    #
+      | 0xEB 0xAD 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE MWEOG..HANGUL SYLL...
+      | 0xEB 0xAD 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE MWEG..HANGUL SYLLA...
+      | 0xEB 0xAE 0x00..0x87    #
+      | 0xEB 0xAE 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE MWIG..HANGUL SYLLA...
+      | 0xEB 0xAE 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE MYUG..HANGUL SYLLA...
+      | 0xEB 0xAF 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE MEUG..HANGUL SYLLA...
+      | 0xEB 0xAF 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE MYIG..HANGUL SYLLA...
+      | 0xEB 0xAF 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE MIG..HANGUL SYLLAB...
+      | 0xEB 0xB0 0x00..0x93    #
+      | 0xEB 0xB0 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE BAG..HANGUL SYLLAB...
+      | 0xEB 0xB0 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE BAEG..HANGUL SYLLA...
+      | 0xEB 0xB1 0x00..0x8B    #
+      | 0xEB 0xB1 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE BYAG..HANGUL SYLLA...
+      | 0xEB 0xB1 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE BYAEG..HANGUL SYLL...
+      | 0xEB 0xB2 0x00..0x83    #
+      | 0xEB 0xB2 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE BEOG..HANGUL SYLLA...
+      | 0xEB 0xB2 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE BEG..HANGUL SYLLAB...
+      | 0xEB 0xB2 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE BYEOG..HANGUL SYLL...
+      | 0xEB 0xB3 0x00..0x97    #
+      | 0xEB 0xB3 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE BYEG..HANGUL SYLLA...
+      | 0xEB 0xB3 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE BOG..HANGUL SYLLAB...
+      | 0xEB 0xB4 0x00..0x8F    #
+      | 0xEB 0xB4 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE BWAG..HANGUL SYLLA...
+      | 0xEB 0xB4 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE BWAEG..HANGUL SYLL...
+      | 0xEB 0xB5 0x00..0x87    #
+      | 0xEB 0xB5 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE BOEG..HANGUL SYLLA...
+      | 0xEB 0xB5 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE BYOG..HANGUL SYLLA...
+      | 0xEB 0xB6 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE BUG..HANGUL SYLLAB...
+      | 0xEB 0xB6 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE BWEOG..HANGUL SYLL...
+      | 0xEB 0xB6 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE BWEG..HANGUL SYLLA...
+      | 0xEB 0xB7 0x00..0x93    #
+      | 0xEB 0xB7 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE BWIG..HANGUL SYLLA...
+      | 0xEB 0xB7 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE BYUG..HANGUL SYLLA...
+      | 0xEB 0xB8 0x00..0x8B    #
+      | 0xEB 0xB8 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE BEUG..HANGUL SYLLA...
+      | 0xEB 0xB8 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE BYIG..HANGUL SYLLA...
+      | 0xEB 0xB9 0x00..0x83    #
+      | 0xEB 0xB9 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE BIG..HANGUL SYLLAB...
+      | 0xEB 0xB9 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE BBAG..HANGUL SYLLA...
+      | 0xEB 0xB9 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE BBAEG..HANGUL SYLL...
+      | 0xEB 0xBA 0x00..0x97    #
+      | 0xEB 0xBA 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE BBYAG..HANGUL SYLL...
+      | 0xEB 0xBA 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE BBYAEG..HANGUL SYL...
+      | 0xEB 0xBB 0x00..0x8F    #
+      | 0xEB 0xBB 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE BBEOG..HANGUL SYLL...
+      | 0xEB 0xBB 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE BBEG..HANGUL SYLLA...
+      | 0xEB 0xBC 0x00..0x87    #
+      | 0xEB 0xBC 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE BBYEOG..HANGUL SYL...
+      | 0xEB 0xBC 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE BBYEG..HANGUL SYLL...
+      | 0xEB 0xBD 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE BBOG..HANGUL SYLLA...
+      | 0xEB 0xBD 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE BBWAG..HANGUL SYLL...
+      | 0xEB 0xBD 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE BBWAEG..HANGUL SYL...
+      | 0xEB 0xBE 0x00..0x93    #
+      | 0xEB 0xBE 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE BBOEG..HANGUL SYLL...
+      | 0xEB 0xBE 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE BBYOG..HANGUL SYLL...
+      | 0xEB 0xBF 0x00..0x8B    #
+      | 0xEB 0xBF 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE BBUG..HANGUL SYLLA...
+      | 0xEB 0xBF 0xA9..0xFF        #Lo  [27] HANGUL SYLLABLE BBWEOG..HANGUL...
+      | 0xEB 0xC0..0xFF 0x00..0xFF  #
+      | 0xEC 0x00 0x00..0xFF        #
+      | 0xEC 0x01..0x7F 0x00..0xFF  #
+      | 0xEC 0x80 0x00..0x83        #
+      | 0xEC 0x80 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE BBWEG..HANGUL SYLL...
+      | 0xEC 0x80 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE BBWIG..HANGUL SYLL...
+      | 0xEC 0x80 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE BBYUG..HANGUL SYLL...
+      | 0xEC 0x81 0x00..0x97    #
+      | 0xEC 0x81 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE BBEUG..HANGUL SYLL...
+      | 0xEC 0x81 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE BBYIG..HANGUL SYLL...
+      | 0xEC 0x82 0x00..0x8F    #
+      | 0xEC 0x82 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE BBIG..HANGUL SYLLA...
+      | 0xEC 0x82 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE SAG..HANGUL SYLLAB...
+      | 0xEC 0x83 0x00..0x87    #
+      | 0xEC 0x83 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE SAEG..HANGUL SYLLA...
+      | 0xEC 0x83 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE SYAG..HANGUL SYLLA...
+      | 0xEC 0x84 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE SYAEG..HANGUL SYLL...
+      | 0xEC 0x84 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE SEOG..HANGUL SYLLA...
+      | 0xEC 0x84 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE SEG..HANGUL SYLLAB...
+      | 0xEC 0x85 0x00..0x93    #
+      | 0xEC 0x85 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE SYEOG..HANGUL SYLL...
+      | 0xEC 0x85 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE SYEG..HANGUL SYLLA...
+      | 0xEC 0x86 0x00..0x8B    #
+      | 0xEC 0x86 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE SOG..HANGUL SYLLAB...
+      | 0xEC 0x86 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE SWAG..HANGUL SYLLA...
+      | 0xEC 0x87 0x00..0x83    #
+      | 0xEC 0x87 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE SWAEG..HANGUL SYLL...
+      | 0xEC 0x87 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE SOEG..HANGUL SYLLA...
+      | 0xEC 0x87 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE SYOG..HANGUL SYLLA...
+      | 0xEC 0x88 0x00..0x97    #
+      | 0xEC 0x88 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE SUG..HANGUL SYLLAB...
+      | 0xEC 0x88 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE SWEOG..HANGUL SYLL...
+      | 0xEC 0x89 0x00..0x8F    #
+      | 0xEC 0x89 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE SWEG..HANGUL SYLLA...
+      | 0xEC 0x89 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE SWIG..HANGUL SYLLA...
+      | 0xEC 0x8A 0x00..0x87    #
+      | 0xEC 0x8A 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE SYUG..HANGUL SYLLA...
+      | 0xEC 0x8A 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE SEUG..HANGUL SYLLA...
+      | 0xEC 0x8B 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE SYIG..HANGUL SYLLA...
+      | 0xEC 0x8B 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE SIG..HANGUL SYLLAB...
+      | 0xEC 0x8B 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE SSAG..HANGUL SYLLA...
+      | 0xEC 0x8C 0x00..0x93    #
+      | 0xEC 0x8C 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE SSAEG..HANGUL SYLL...
+      | 0xEC 0x8C 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE SSYAG..HANGUL SYLL...
+      | 0xEC 0x8D 0x00..0x8B    #
+      | 0xEC 0x8D 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE SSYAEG..HANGUL SYL...
+      | 0xEC 0x8D 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE SSEOG..HANGUL SYLL...
+      | 0xEC 0x8E 0x00..0x83    #
+      | 0xEC 0x8E 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE SSEG..HANGUL SYLLA...
+      | 0xEC 0x8E 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE SSYEOG..HANGUL SYL...
+      | 0xEC 0x8E 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE SSYEG..HANGUL SYLL...
+      | 0xEC 0x8F 0x00..0x97    #
+      | 0xEC 0x8F 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE SSOG..HANGUL SYLLA...
+      | 0xEC 0x8F 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE SSWAG..HANGUL SYLL...
+      | 0xEC 0x90 0x00..0x8F    #
+      | 0xEC 0x90 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE SSWAEG..HANGUL SYL...
+      | 0xEC 0x90 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE SSOEG..HANGUL SYLL...
+      | 0xEC 0x91 0x00..0x87    #
+      | 0xEC 0x91 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE SSYOG..HANGUL SYLL...
+      | 0xEC 0x91 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE SSUG..HANGUL SYLLA...
+      | 0xEC 0x92 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE SSWEOG..HANGUL SYL...
+      | 0xEC 0x92 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE SSWEG..HANGUL SYLL...
+      | 0xEC 0x92 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE SSWIG..HANGUL SYLL...
+      | 0xEC 0x93 0x00..0x93    #
+      | 0xEC 0x93 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE SSYUG..HANGUL SYLL...
+      | 0xEC 0x93 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE SSEUG..HANGUL SYLL...
+      | 0xEC 0x94 0x00..0x8B    #
+      | 0xEC 0x94 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE SSYIG..HANGUL SYLL...
+      | 0xEC 0x94 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE SSIG..HANGUL SYLLA...
+      | 0xEC 0x95 0x00..0x83    #
+      | 0xEC 0x95 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE AG..HANGUL SYLLABL...
+      | 0xEC 0x95 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE AEG..HANGUL SYLLAB...
+      | 0xEC 0x95 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE YAG..HANGUL SYLLAB...
+      | 0xEC 0x96 0x00..0x97    #
+      | 0xEC 0x96 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE YAEG..HANGUL SYLLA...
+      | 0xEC 0x96 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE EOG..HANGUL SYLLAB...
+      | 0xEC 0x97 0x00..0x8F    #
+      | 0xEC 0x97 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE EG..HANGUL SYLLABL...
+      | 0xEC 0x97 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE YEOG..HANGUL SYLLA...
+      | 0xEC 0x98 0x00..0x87    #
+      | 0xEC 0x98 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE YEG..HANGUL SYLLAB...
+      | 0xEC 0x98 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE OG..HANGUL SYLLABL...
+      | 0xEC 0x99 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE WAG..HANGUL SYLLAB...
+      | 0xEC 0x99 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE WAEG..HANGUL SYLLA...
+      | 0xEC 0x99 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE OEG..HANGUL SYLLAB...
+      | 0xEC 0x9A 0x00..0x93    #
+      | 0xEC 0x9A 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE YOG..HANGUL SYLLAB...
+      | 0xEC 0x9A 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE UG..HANGUL SYLLABL...
+      | 0xEC 0x9B 0x00..0x8B    #
+      | 0xEC 0x9B 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE WEOG..HANGUL SYLLA...
+      | 0xEC 0x9B 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE WEG..HANGUL SYLLAB...
+      | 0xEC 0x9C 0x00..0x83    #
+      | 0xEC 0x9C 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE WIG..HANGUL SYLLAB...
+      | 0xEC 0x9C 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE YUG..HANGUL SYLLAB...
+      | 0xEC 0x9C 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE EUG..HANGUL SYLLAB...
+      | 0xEC 0x9D 0x00..0x97    #
+      | 0xEC 0x9D 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE YIG..HANGUL SYLLAB...
+      | 0xEC 0x9D 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE IG..HANGUL SYLLABL...
+      | 0xEC 0x9E 0x00..0x8F    #
+      | 0xEC 0x9E 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE JAG..HANGUL SYLLAB...
+      | 0xEC 0x9E 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE JAEG..HANGUL SYLLA...
+      | 0xEC 0x9F 0x00..0x87    #
+      | 0xEC 0x9F 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE JYAG..HANGUL SYLLA...
+      | 0xEC 0x9F 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE JYAEG..HANGUL SYLL...
+      | 0xEC 0xA0 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE JEOG..HANGUL SYLLA...
+      | 0xEC 0xA0 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE JEG..HANGUL SYLLAB...
+      | 0xEC 0xA0 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE JYEOG..HANGUL SYLL...
+      | 0xEC 0xA1 0x00..0x93    #
+      | 0xEC 0xA1 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE JYEG..HANGUL SYLLA...
+      | 0xEC 0xA1 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE JOG..HANGUL SYLLAB...
+      | 0xEC 0xA2 0x00..0x8B    #
+      | 0xEC 0xA2 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE JWAG..HANGUL SYLLA...
+      | 0xEC 0xA2 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE JWAEG..HANGUL SYLL...
+      | 0xEC 0xA3 0x00..0x83    #
+      | 0xEC 0xA3 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE JOEG..HANGUL SYLLA...
+      | 0xEC 0xA3 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE JYOG..HANGUL SYLLA...
+      | 0xEC 0xA3 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE JUG..HANGUL SYLLAB...
+      | 0xEC 0xA4 0x00..0x97    #
+      | 0xEC 0xA4 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE JWEOG..HANGUL SYLL...
+      | 0xEC 0xA4 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE JWEG..HANGUL SYLLA...
+      | 0xEC 0xA5 0x00..0x8F    #
+      | 0xEC 0xA5 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE JWIG..HANGUL SYLLA...
+      | 0xEC 0xA5 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE JYUG..HANGUL SYLLA...
+      | 0xEC 0xA6 0x00..0x87    #
+      | 0xEC 0xA6 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE JEUG..HANGUL SYLLA...
+      | 0xEC 0xA6 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE JYIG..HANGUL SYLLA...
+      | 0xEC 0xA7 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE JIG..HANGUL SYLLAB...
+      | 0xEC 0xA7 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE JJAG..HANGUL SYLLA...
+      | 0xEC 0xA7 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE JJAEG..HANGUL SYLL...
+      | 0xEC 0xA8 0x00..0x93    #
+      | 0xEC 0xA8 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE JJYAG..HANGUL SYLL...
+      | 0xEC 0xA8 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE JJYAEG..HANGUL SYL...
+      | 0xEC 0xA9 0x00..0x8B    #
+      | 0xEC 0xA9 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE JJEOG..HANGUL SYLL...
+      | 0xEC 0xA9 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE JJEG..HANGUL SYLLA...
+      | 0xEC 0xAA 0x00..0x83    #
+      | 0xEC 0xAA 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE JJYEOG..HANGUL SYL...
+      | 0xEC 0xAA 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE JJYEG..HANGUL SYLL...
+      | 0xEC 0xAA 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE JJOG..HANGUL SYLLA...
+      | 0xEC 0xAB 0x00..0x97    #
+      | 0xEC 0xAB 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE JJWAG..HANGUL SYLL...
+      | 0xEC 0xAB 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE JJWAEG..HANGUL SYL...
+      | 0xEC 0xAC 0x00..0x8F    #
+      | 0xEC 0xAC 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE JJOEG..HANGUL SYLL...
+      | 0xEC 0xAC 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE JJYOG..HANGUL SYLL...
+      | 0xEC 0xAD 0x00..0x87    #
+      | 0xEC 0xAD 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE JJUG..HANGUL SYLLA...
+      | 0xEC 0xAD 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE JJWEOG..HANGUL SYL...
+      | 0xEC 0xAE 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE JJWEG..HANGUL SYLL...
+      | 0xEC 0xAE 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE JJWIG..HANGUL SYLL...
+      | 0xEC 0xAE 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE JJYUG..HANGUL SYLL...
+      | 0xEC 0xAF 0x00..0x93    #
+      | 0xEC 0xAF 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE JJEUG..HANGUL SYLL...
+      | 0xEC 0xAF 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE JJYIG..HANGUL SYLL...
+      | 0xEC 0xB0 0x00..0x8B    #
+      | 0xEC 0xB0 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE JJIG..HANGUL SYLLA...
+      | 0xEC 0xB0 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE CAG..HANGUL SYLLAB...
+      | 0xEC 0xB1 0x00..0x83    #
+      | 0xEC 0xB1 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE CAEG..HANGUL SYLLA...
+      | 0xEC 0xB1 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE CYAG..HANGUL SYLLA...
+      | 0xEC 0xB1 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE CYAEG..HANGUL SYLL...
+      | 0xEC 0xB2 0x00..0x97    #
+      | 0xEC 0xB2 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE CEOG..HANGUL SYLLA...
+      | 0xEC 0xB2 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE CEG..HANGUL SYLLAB...
+      | 0xEC 0xB3 0x00..0x8F    #
+      | 0xEC 0xB3 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE CYEOG..HANGUL SYLL...
+      | 0xEC 0xB3 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE CYEG..HANGUL SYLLA...
+      | 0xEC 0xB4 0x00..0x87    #
+      | 0xEC 0xB4 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE COG..HANGUL SYLLAB...
+      | 0xEC 0xB4 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE CWAG..HANGUL SYLLA...
+      | 0xEC 0xB5 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE CWAEG..HANGUL SYLL...
+      | 0xEC 0xB5 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE COEG..HANGUL SYLLA...
+      | 0xEC 0xB5 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE CYOG..HANGUL SYLLA...
+      | 0xEC 0xB6 0x00..0x93    #
+      | 0xEC 0xB6 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE CUG..HANGUL SYLLAB...
+      | 0xEC 0xB6 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE CWEOG..HANGUL SYLL...
+      | 0xEC 0xB7 0x00..0x8B    #
+      | 0xEC 0xB7 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE CWEG..HANGUL SYLLA...
+      | 0xEC 0xB7 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE CWIG..HANGUL SYLLA...
+      | 0xEC 0xB8 0x00..0x83    #
+      | 0xEC 0xB8 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE CYUG..HANGUL SYLLA...
+      | 0xEC 0xB8 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE CEUG..HANGUL SYLLA...
+      | 0xEC 0xB8 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE CYIG..HANGUL SYLLA...
+      | 0xEC 0xB9 0x00..0x97    #
+      | 0xEC 0xB9 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE CIG..HANGUL SYLLAB...
+      | 0xEC 0xB9 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE KAG..HANGUL SYLLAB...
+      | 0xEC 0xBA 0x00..0x8F    #
+      | 0xEC 0xBA 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE KAEG..HANGUL SYLLA...
+      | 0xEC 0xBA 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE KYAG..HANGUL SYLLA...
+      | 0xEC 0xBB 0x00..0x87    #
+      | 0xEC 0xBB 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE KYAEG..HANGUL SYLL...
+      | 0xEC 0xBB 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE KEOG..HANGUL SYLLA...
+      | 0xEC 0xBC 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE KEG..HANGUL SYLLAB...
+      | 0xEC 0xBC 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE KYEOG..HANGUL SYLL...
+      | 0xEC 0xBC 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE KYEG..HANGUL SYLLA...
+      | 0xEC 0xBD 0x00..0x93    #
+      | 0xEC 0xBD 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE KOG..HANGUL SYLLAB...
+      | 0xEC 0xBD 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE KWAG..HANGUL SYLLA...
+      | 0xEC 0xBE 0x00..0x8B    #
+      | 0xEC 0xBE 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE KWAEG..HANGUL SYLL...
+      | 0xEC 0xBE 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE KOEG..HANGUL SYLLA...
+      | 0xEC 0xBF 0x00..0x83    #
+      | 0xEC 0xBF 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE KYOG..HANGUL SYLLA...
+      | 0xEC 0xBF 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE KUG..HANGUL SYLLAB...
+      | 0xEC 0xBF 0xBD..0xFF        #Lo  [27] HANGUL SYLLABLE KWEOG..HANGUL ...
+      | 0xEC 0xC0..0xFF 0x00..0xFF  #
+      | 0xED 0x00 0x00..0xFF        #
+      | 0xED 0x01..0x7F 0x00..0xFF  #
+      | 0xED 0x80 0x00..0x97        #
+      | 0xED 0x80 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE KWEG..HANGUL SYLLA...
+      | 0xED 0x80 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE KWIG..HANGUL SYLLA...
+      | 0xED 0x81 0x00..0x8F    #
+      | 0xED 0x81 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE KYUG..HANGUL SYLLA...
+      | 0xED 0x81 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE KEUG..HANGUL SYLLA...
+      | 0xED 0x82 0x00..0x87    #
+      | 0xED 0x82 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE KYIG..HANGUL SYLLA...
+      | 0xED 0x82 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE KIG..HANGUL SYLLAB...
+      | 0xED 0x83 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE TAG..HANGUL SYLLAB...
+      | 0xED 0x83 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE TAEG..HANGUL SYLLA...
+      | 0xED 0x83 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE TYAG..HANGUL SYLLA...
+      | 0xED 0x84 0x00..0x93    #
+      | 0xED 0x84 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE TYAEG..HANGUL SYLL...
+      | 0xED 0x84 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE TEOG..HANGUL SYLLA...
+      | 0xED 0x85 0x00..0x8B    #
+      | 0xED 0x85 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE TEG..HANGUL SYLLAB...
+      | 0xED 0x85 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE TYEOG..HANGUL SYLL...
+      | 0xED 0x86 0x00..0x83    #
+      | 0xED 0x86 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE TYEG..HANGUL SYLLA...
+      | 0xED 0x86 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE TOG..HANGUL SYLLAB...
+      | 0xED 0x86 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE TWAG..HANGUL SYLLA...
+      | 0xED 0x87 0x00..0x97    #
+      | 0xED 0x87 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE TWAEG..HANGUL SYLL...
+      | 0xED 0x87 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE TOEG..HANGUL SYLLA...
+      | 0xED 0x88 0x00..0x8F    #
+      | 0xED 0x88 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE TYOG..HANGUL SYLLA...
+      | 0xED 0x88 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE TUG..HANGUL SYLLAB...
+      | 0xED 0x89 0x00..0x87    #
+      | 0xED 0x89 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE TWEOG..HANGUL SYLL...
+      | 0xED 0x89 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE TWEG..HANGUL SYLLA...
+      | 0xED 0x8A 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE TWIG..HANGUL SYLLA...
+      | 0xED 0x8A 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE TYUG..HANGUL SYLLA...
+      | 0xED 0x8A 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE TEUG..HANGUL SYLLA...
+      | 0xED 0x8B 0x00..0x93    #
+      | 0xED 0x8B 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE TYIG..HANGUL SYLLA...
+      | 0xED 0x8B 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE TIG..HANGUL SYLLAB...
+      | 0xED 0x8C 0x00..0x8B    #
+      | 0xED 0x8C 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE PAG..HANGUL SYLLAB...
+      | 0xED 0x8C 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE PAEG..HANGUL SYLLA...
+      | 0xED 0x8D 0x00..0x83    #
+      | 0xED 0x8D 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE PYAG..HANGUL SYLLA...
+      | 0xED 0x8D 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE PYAEG..HANGUL SYLL...
+      | 0xED 0x8D 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE PEOG..HANGUL SYLLA...
+      | 0xED 0x8E 0x00..0x97    #
+      | 0xED 0x8E 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE PEG..HANGUL SYLLAB...
+      | 0xED 0x8E 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE PYEOG..HANGUL SYLL...
+      | 0xED 0x8F 0x00..0x8F    #
+      | 0xED 0x8F 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE PYEG..HANGUL SYLLA...
+      | 0xED 0x8F 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE POG..HANGUL SYLLAB...
+      | 0xED 0x90 0x00..0x87    #
+      | 0xED 0x90 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE PWAG..HANGUL SYLLA...
+      | 0xED 0x90 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE PWAEG..HANGUL SYLL...
+      | 0xED 0x91 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE POEG..HANGUL SYLLA...
+      | 0xED 0x91 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE PYOG..HANGUL SYLLA...
+      | 0xED 0x91 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE PUG..HANGUL SYLLAB...
+      | 0xED 0x92 0x00..0x93    #
+      | 0xED 0x92 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE PWEOG..HANGUL SYLL...
+      | 0xED 0x92 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE PWEG..HANGUL SYLLA...
+      | 0xED 0x93 0x00..0x8B    #
+      | 0xED 0x93 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE PWIG..HANGUL SYLLA...
+      | 0xED 0x93 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE PYUG..HANGUL SYLLA...
+      | 0xED 0x94 0x00..0x83    #
+      | 0xED 0x94 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE PEUG..HANGUL SYLLA...
+      | 0xED 0x94 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE PYIG..HANGUL SYLLA...
+      | 0xED 0x94 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE PIG..HANGUL SYLLAB...
+      | 0xED 0x95 0x00..0x97    #
+      | 0xED 0x95 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE HAG..HANGUL SYLLAB...
+      | 0xED 0x95 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE HAEG..HANGUL SYLLA...
+      | 0xED 0x96 0x00..0x8F    #
+      | 0xED 0x96 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE HYAG..HANGUL SYLLA...
+      | 0xED 0x96 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE HYAEG..HANGUL SYLL...
+      | 0xED 0x97 0x00..0x87    #
+      | 0xED 0x97 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE HEOG..HANGUL SYLLA...
+      | 0xED 0x97 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE HEG..HANGUL SYLLAB...
+      | 0xED 0x98 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE HYEOG..HANGUL SYLL...
+      | 0xED 0x98 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE HYEG..HANGUL SYLLA...
+      | 0xED 0x98 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE HOG..HANGUL SYLLAB...
+      | 0xED 0x99 0x00..0x93    #
+      | 0xED 0x99 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE HWAG..HANGUL SYLLA...
+      | 0xED 0x99 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE HWAEG..HANGUL SYLL...
+      | 0xED 0x9A 0x00..0x8B    #
+      | 0xED 0x9A 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE HOEG..HANGUL SYLLA...
+      | 0xED 0x9A 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE HYOG..HANGUL SYLLA...
+      | 0xED 0x9B 0x00..0x83    #
+      | 0xED 0x9B 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE HUG..HANGUL SYLLAB...
+      | 0xED 0x9B 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE HWEOG..HANGUL SYLL...
+      | 0xED 0x9B 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE HWEG..HANGUL SYLLA...
+      | 0xED 0x9C 0x00..0x97    #
+      | 0xED 0x9C 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE HWIG..HANGUL SYLLA...
+      | 0xED 0x9C 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE HYUG..HANGUL SYLLA...
+      | 0xED 0x9D 0x00..0x8F    #
+      | 0xED 0x9D 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE HEUG..HANGUL SYLLA...
+      | 0xED 0x9D 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE HYIG..HANGUL SYLLA...
+      | 0xED 0x9E 0x00..0x87    #
+      | 0xED 0x9E 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE HIG..HANGUL SYLLAB...
+      ;
+
+    E_Base = 
+        0xE2 0x98 0x9D          #So       WHITE UP POINTING INDEX
+      | 0xE2 0x9B 0xB9          #So       PERSON WITH BALL
+      | 0xE2 0x9C 0x8A..0x8D    #So   [4] RAISED FIST..WRITING HAND
+      | 0xF0 0x9F 0x8E 0x85     #So       FATHER CHRISTMAS
+      | 0xF0 0x9F 0x8F 0x83..0x84  #So   [2] RUNNER..SURFER
+      | 0xF0 0x9F 0x8F 0x8A..0x8B  #So   [2] SWIMMER..WEIGHT LIFTER
+      | 0xF0 0x9F 0x91 0x82..0x83  #So   [2] EAR..NOSE
+      | 0xF0 0x9F 0x91 0x86..0x90  #So  [11] WHITE UP POINTING BACKHAND INDE...
+      | 0xF0 0x9F 0x91 0xAE     #So       POLICE OFFICER
+      | 0xF0 0x9F 0x91 0xB0..0xB8  #So   [9] BRIDE WITH VEIL..PRINCESS
+      | 0xF0 0x9F 0x91 0xBC     #So       BABY ANGEL
+      | 0xF0 0x9F 0x92 0x81..0x83  #So   [3] INFORMATION DESK PERSON..DANCER
+      | 0xF0 0x9F 0x92 0x85..0x87  #So   [3] NAIL POLISH..HAIRCUT
+      | 0xF0 0x9F 0x92 0xAA     #So       FLEXED BICEPS
+      | 0xF0 0x9F 0x95 0xB5     #So       SLEUTH OR SPY
+      | 0xF0 0x9F 0x95 0xBA     #So       MAN DANCING
+      | 0xF0 0x9F 0x96 0x90     #So       RAISED HAND WITH FINGERS SPLAYED
+      | 0xF0 0x9F 0x96 0x95..0x96  #So   [2] REVERSED HAND WITH MIDDLE FINGE...
+      | 0xF0 0x9F 0x99 0x85..0x87  #So   [3] FACE WITH NO GOOD GESTURE..PERS...
+      | 0xF0 0x9F 0x99 0x8B..0x8F  #So   [5] HAPPY PERSON RAISING ONE HAND.....
+      | 0xF0 0x9F 0x9A 0xA3     #So       ROWBOAT
+      | 0xF0 0x9F 0x9A 0xB4..0xB6  #So   [3] BICYCLIST..PEDESTRIAN
+      | 0xF0 0x9F 0x9B 0x80     #So       BATH
+      | 0xF0 0x9F 0xA4 0x98..0x9E  #So   [7] SIGN OF THE HORNS..HAND WITH IN...
+      | 0xF0 0x9F 0xA4 0xA6     #So       FACE PALM
+      | 0xF0 0x9F 0xA4 0xB0     #So       PREGNANT WOMAN
+      | 0xF0 0x9F 0xA4 0xB3..0xB9  #So   [7] SELFIE..JUGGLING
+      | 0xF0 0x9F 0xA4 0xBC..0xBE  #So   [3] WRESTLERS..HANDBALL
+      ;
+
+    E_Modifier = 
+        0xF0 0x9F 0x8F 0xBB..0xBF  #Sk   [5] EMOJI MODIFIER FITZPATRICK TYPE...
+      ;
+
+    ZWJ = 
+        0xE2 0x80 0x8D          #Cf       ZERO WIDTH JOINER
+      ;
+
+    Glue_After_Zwj = 
+        0xE2 0x9D 0xA4          #So       HEAVY BLACK HEART
+      | 0xF0 0x9F 0x92 0x8B     #So       KISS MARK
+      | 0xF0 0x9F 0x97 0xA8     #So       LEFT SPEECH BUBBLE
+      ;
+
+    E_Base_GAZ = 
+        0xF0 0x9F 0x91 0xA6..0xA9  #So   [4] BOY..WOMAN
+      ;
+
+}%%
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/tables.go b/vendor/github.com/apparentlymart/go-textseg/textseg/tables.go
new file mode 100644
index 000000000..fab7e8429
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/tables.go
@@ -0,0 +1,5700 @@
+// Generated by running
+//      maketables --url=http://www.unicode.org/Public/9.0.0/ucd/auxiliary/
+// DO NOT EDIT
+
+package textseg
+
+import (
+	"unicode"
+)
+
+var _GraphemeCR = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xd, Hi: 0xd, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _GraphemeControl = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x0, Hi: 0x9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb, Hi: 0xc, Stride: 0x1},
+		unicode.Range16{Lo: 0xe, Hi: 0x1f, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f, Hi: 0x9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xad, Hi: 0xad, Stride: 0x1},
+		unicode.Range16{Lo: 0x61c, Hi: 0x61c, Stride: 0x1},
+		unicode.Range16{Lo: 0x180e, Hi: 0x180e, Stride: 0x1},
+		unicode.Range16{Lo: 0x200b, Hi: 0x200b, Stride: 0x1},
+		unicode.Range16{Lo: 0x200e, Hi: 0x200f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2028, Hi: 0x2028, Stride: 0x1},
+		unicode.Range16{Lo: 0x2029, Hi: 0x2029, Stride: 0x1},
+		unicode.Range16{Lo: 0x202a, Hi: 0x202e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2060, Hi: 0x2064, Stride: 0x1},
+		unicode.Range16{Lo: 0x2065, Hi: 0x2065, Stride: 0x1},
+		unicode.Range16{Lo: 0x2066, Hi: 0x206f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd800, Hi: 0xdfff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfeff, Hi: 0xfeff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff0, Hi: 0xfff8, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff9, Hi: 0xfffb, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1bca0, Hi: 0x1bca3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d173, Hi: 0x1d17a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0000, Hi: 0xe0000, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0001, Hi: 0xe0001, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0002, Hi: 0xe001f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0080, Hi: 0xe00ff, Stride: 0x1},
+		unicode.Range32{Lo: 0xe01f0, Hi: 0xe0fff, Stride: 0x1},
+	},
+	LatinOffset: 5,
+}
+
+var _GraphemeE_Base = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x261d, Hi: 0x261d, Stride: 0x1},
+		unicode.Range16{Lo: 0x26f9, Hi: 0x26f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x270a, Hi: 0x270d, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f385, Hi: 0x1f385, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3c3, Hi: 0x1f3c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3ca, Hi: 0x1f3cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f442, Hi: 0x1f443, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f446, Hi: 0x1f450, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f46e, Hi: 0x1f46e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f470, Hi: 0x1f478, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f47c, Hi: 0x1f47c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f481, Hi: 0x1f483, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f485, Hi: 0x1f487, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f4aa, Hi: 0x1f4aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f575, Hi: 0x1f575, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f57a, Hi: 0x1f57a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f590, Hi: 0x1f590, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f595, Hi: 0x1f596, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f645, Hi: 0x1f647, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f64b, Hi: 0x1f64f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6a3, Hi: 0x1f6a3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6b4, Hi: 0x1f6b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6c0, Hi: 0x1f6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f918, Hi: 0x1f91e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f926, Hi: 0x1f926, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f930, Hi: 0x1f930, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f933, Hi: 0x1f939, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f93c, Hi: 0x1f93e, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeE_Base_GAZ = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f466, Hi: 0x1f469, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeE_Modifier = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f3fb, Hi: 0x1f3ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeExtend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x300, Hi: 0x36f, Stride: 0x1},
+		unicode.Range16{Lo: 0x483, Hi: 0x487, Stride: 0x1},
+		unicode.Range16{Lo: 0x488, Hi: 0x489, Stride: 0x1},
+		unicode.Range16{Lo: 0x591, Hi: 0x5bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x5bf, Hi: 0x5bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c1, Hi: 0x5c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c4, Hi: 0x5c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c7, Hi: 0x5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x610, Hi: 0x61a, Stride: 0x1},
+		unicode.Range16{Lo: 0x64b, Hi: 0x65f, Stride: 0x1},
+		unicode.Range16{Lo: 0x670, Hi: 0x670, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d6, Hi: 0x6dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6df, Hi: 0x6e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e7, Hi: 0x6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ea, Hi: 0x6ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x711, Hi: 0x711, Stride: 0x1},
+		unicode.Range16{Lo: 0x730, Hi: 0x74a, Stride: 0x1},
+		unicode.Range16{Lo: 0x7a6, Hi: 0x7b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x7eb, Hi: 0x7f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x816, Hi: 0x819, Stride: 0x1},
+		unicode.Range16{Lo: 0x81b, Hi: 0x823, Stride: 0x1},
+		unicode.Range16{Lo: 0x825, Hi: 0x827, Stride: 0x1},
+		unicode.Range16{Lo: 0x829, Hi: 0x82d, Stride: 0x1},
+		unicode.Range16{Lo: 0x859, Hi: 0x85b, Stride: 0x1},
+		unicode.Range16{Lo: 0x8d4, Hi: 0x8e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e3, Hi: 0x902, Stride: 0x1},
+		unicode.Range16{Lo: 0x93a, Hi: 0x93a, Stride: 0x1},
+		unicode.Range16{Lo: 0x93c, Hi: 0x93c, Stride: 0x1},
+		unicode.Range16{Lo: 0x941, Hi: 0x948, Stride: 0x1},
+		unicode.Range16{Lo: 0x94d, Hi: 0x94d, Stride: 0x1},
+		unicode.Range16{Lo: 0x951, Hi: 0x957, Stride: 0x1},
+		unicode.Range16{Lo: 0x962, Hi: 0x963, Stride: 0x1},
+		unicode.Range16{Lo: 0x981, Hi: 0x981, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bc, Hi: 0x9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9be, Hi: 0x9be, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c1, Hi: 0x9c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cd, Hi: 0x9cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9d7, Hi: 0x9d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e2, Hi: 0x9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa01, Hi: 0xa02, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3c, Hi: 0xa3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa41, Hi: 0xa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xa47, Hi: 0xa48, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4b, Hi: 0xa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa51, Hi: 0xa51, Stride: 0x1},
+		unicode.Range16{Lo: 0xa70, Hi: 0xa71, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75, Hi: 0xa75, Stride: 0x1},
+		unicode.Range16{Lo: 0xa81, Hi: 0xa82, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc, Hi: 0xabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1, Hi: 0xac5, Stride: 0x1},
+		unicode.Range16{Lo: 0xac7, Hi: 0xac8, Stride: 0x1},
+		unicode.Range16{Lo: 0xacd, Hi: 0xacd, Stride: 0x1},
+		unicode.Range16{Lo: 0xae2, Hi: 0xae3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb01, Hi: 0xb01, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c, Hi: 0xb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e, Hi: 0xb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3f, Hi: 0xb3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb41, Hi: 0xb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4d, Hi: 0xb4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb56, Hi: 0xb56, Stride: 0x1},
+		unicode.Range16{Lo: 0xb57, Hi: 0xb57, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62, Hi: 0xb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xb82, Hi: 0xb82, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbe, Hi: 0xbbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc0, Hi: 0xbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd, Hi: 0xbcd, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd7, Hi: 0xbd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc00, Hi: 0xc00, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3e, Hi: 0xc40, Stride: 0x1},
+		unicode.Range16{Lo: 0xc46, Hi: 0xc48, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4a, Hi: 0xc4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc55, Hi: 0xc56, Stride: 0x1},
+		unicode.Range16{Lo: 0xc62, Hi: 0xc63, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81, Hi: 0xc81, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbc, Hi: 0xcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf, Hi: 0xcbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc2, Hi: 0xcc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc6, Hi: 0xcc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xccc, Hi: 0xccd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5, Hi: 0xcd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xce2, Hi: 0xce3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd01, Hi: 0xd01, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3e, Hi: 0xd3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xd41, Hi: 0xd44, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4d, Hi: 0xd4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd57, Hi: 0xd57, Stride: 0x1},
+		unicode.Range16{Lo: 0xd62, Hi: 0xd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xdca, Hi: 0xdca, Stride: 0x1},
+		unicode.Range16{Lo: 0xdcf, Hi: 0xdcf, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd2, Hi: 0xdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd6, Hi: 0xdd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xddf, Hi: 0xddf, Stride: 0x1},
+		unicode.Range16{Lo: 0xe31, Hi: 0xe31, Stride: 0x1},
+		unicode.Range16{Lo: 0xe34, Hi: 0xe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe47, Hi: 0xe4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb1, Hi: 0xeb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb4, Hi: 0xeb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xebb, Hi: 0xebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xec8, Hi: 0xecd, Stride: 0x1},
+		unicode.Range16{Lo: 0xf18, Hi: 0xf19, Stride: 0x1},
+		unicode.Range16{Lo: 0xf35, Hi: 0xf35, Stride: 0x1},
+		unicode.Range16{Lo: 0xf37, Hi: 0xf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xf39, Hi: 0xf39, Stride: 0x1},
+		unicode.Range16{Lo: 0xf71, Hi: 0xf7e, Stride: 0x1},
+		unicode.Range16{Lo: 0xf80, Hi: 0xf84, Stride: 0x1},
+		unicode.Range16{Lo: 0xf86, Hi: 0xf87, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8d, Hi: 0xf97, Stride: 0x1},
+		unicode.Range16{Lo: 0xf99, Hi: 0xfbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xfc6, Hi: 0xfc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x102d, Hi: 0x1030, Stride: 0x1},
+		unicode.Range16{Lo: 0x1032, Hi: 0x1037, Stride: 0x1},
+		unicode.Range16{Lo: 0x1039, Hi: 0x103a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103d, Hi: 0x103e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1058, Hi: 0x1059, Stride: 0x1},
+		unicode.Range16{Lo: 0x105e, Hi: 0x1060, Stride: 0x1},
+		unicode.Range16{Lo: 0x1071, Hi: 0x1074, Stride: 0x1},
+		unicode.Range16{Lo: 0x1082, Hi: 0x1082, Stride: 0x1},
+		unicode.Range16{Lo: 0x1085, Hi: 0x1086, Stride: 0x1},
+		unicode.Range16{Lo: 0x108d, Hi: 0x108d, Stride: 0x1},
+		unicode.Range16{Lo: 0x109d, Hi: 0x109d, Stride: 0x1},
+		unicode.Range16{Lo: 0x135d, Hi: 0x135f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1712, Hi: 0x1714, Stride: 0x1},
+		unicode.Range16{Lo: 0x1732, Hi: 0x1734, Stride: 0x1},
+		unicode.Range16{Lo: 0x1752, Hi: 0x1753, Stride: 0x1},
+		unicode.Range16{Lo: 0x1772, Hi: 0x1773, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b4, Hi: 0x17b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b7, Hi: 0x17bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c6, Hi: 0x17c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c9, Hi: 0x17d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dd, Hi: 0x17dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x180b, Hi: 0x180d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1885, Hi: 0x1886, Stride: 0x1},
+		unicode.Range16{Lo: 0x18a9, Hi: 0x18a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1920, Hi: 0x1922, Stride: 0x1},
+		unicode.Range16{Lo: 0x1927, Hi: 0x1928, Stride: 0x1},
+		unicode.Range16{Lo: 0x1932, Hi: 0x1932, Stride: 0x1},
+		unicode.Range16{Lo: 0x1939, Hi: 0x193b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a17, Hi: 0x1a18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1b, Hi: 0x1a1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a56, Hi: 0x1a56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a58, Hi: 0x1a5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a60, Hi: 0x1a60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a62, Hi: 0x1a62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a65, Hi: 0x1a6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a73, Hi: 0x1a7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a7f, Hi: 0x1a7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ab0, Hi: 0x1abd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1abe, Hi: 0x1abe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b00, Hi: 0x1b03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b34, Hi: 0x1b34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b36, Hi: 0x1b3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3c, Hi: 0x1b3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b42, Hi: 0x1b42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6b, Hi: 0x1b73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b80, Hi: 0x1b81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba2, Hi: 0x1ba5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba8, Hi: 0x1ba9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bab, Hi: 0x1bad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be6, Hi: 0x1be6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be8, Hi: 0x1be9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bed, Hi: 0x1bed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bef, Hi: 0x1bf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c2c, Hi: 0x1c33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c36, Hi: 0x1c37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd0, Hi: 0x1cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd4, Hi: 0x1ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce2, Hi: 0x1ce8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ced, Hi: 0x1ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf4, Hi: 0x1cf4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf8, Hi: 0x1cf9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc0, Hi: 0x1df5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dfb, Hi: 0x1dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x200c, Hi: 0x200c, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d0, Hi: 0x20dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20dd, Hi: 0x20e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e1, Hi: 0x20e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e2, Hi: 0x20e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e5, Hi: 0x20f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cef, Hi: 0x2cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7f, Hi: 0x2d7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2de0, Hi: 0x2dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x302a, Hi: 0x302d, Stride: 0x1},
+		unicode.Range16{Lo: 0x302e, Hi: 0x302f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3099, Hi: 0x309a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66f, Hi: 0xa66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa670, Hi: 0xa672, Stride: 0x1},
+		unicode.Range16{Lo: 0xa674, Hi: 0xa67d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69e, Hi: 0xa69f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f0, Hi: 0xa6f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa802, Hi: 0xa802, Stride: 0x1},
+		unicode.Range16{Lo: 0xa806, Hi: 0xa806, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80b, Hi: 0xa80b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa825, Hi: 0xa826, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8c4, Hi: 0xa8c5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8e0, Hi: 0xa8f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa926, Hi: 0xa92d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa947, Hi: 0xa951, Stride: 0x1},
+		unicode.Range16{Lo: 0xa980, Hi: 0xa982, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b3, Hi: 0xa9b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b6, Hi: 0xa9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bc, Hi: 0xa9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e5, Hi: 0xa9e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa29, Hi: 0xaa2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa31, Hi: 0xaa32, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa35, Hi: 0xaa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa43, Hi: 0xaa43, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4c, Hi: 0xaa4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7c, Hi: 0xaa7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab0, Hi: 0xaab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab2, Hi: 0xaab4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab7, Hi: 0xaab8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaabe, Hi: 0xaabf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac1, Hi: 0xaac1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaec, Hi: 0xaaed, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf6, Hi: 0xaaf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe5, Hi: 0xabe5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe8, Hi: 0xabe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xabed, Hi: 0xabed, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1e, Hi: 0xfb1e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe00, Hi: 0xfe0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe20, Hi: 0xfe2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff9e, Hi: 0xff9f, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x101fd, Hi: 0x101fd, Stride: 0x1},
+		unicode.Range32{Lo: 0x102e0, Hi: 0x102e0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10376, Hi: 0x1037a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a01, Hi: 0x10a03, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a05, Hi: 0x10a06, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a0c, Hi: 0x10a0f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a38, Hi: 0x10a3a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a3f, Hi: 0x10a3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ae5, Hi: 0x10ae6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11001, Hi: 0x11001, Stride: 0x1},
+		unicode.Range32{Lo: 0x11038, Hi: 0x11046, Stride: 0x1},
+		unicode.Range32{Lo: 0x1107f, Hi: 0x11081, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b3, Hi: 0x110b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b9, Hi: 0x110ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x11100, Hi: 0x11102, Stride: 0x1},
+		unicode.Range32{Lo: 0x11127, Hi: 0x1112b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112d, Hi: 0x11134, Stride: 0x1},
+		unicode.Range32{Lo: 0x11173, Hi: 0x11173, Stride: 0x1},
+		unicode.Range32{Lo: 0x11180, Hi: 0x11181, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b6, Hi: 0x111be, Stride: 0x1},
+		unicode.Range32{Lo: 0x111ca, Hi: 0x111cc, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122f, Hi: 0x11231, Stride: 0x1},
+		unicode.Range32{Lo: 0x11234, Hi: 0x11234, Stride: 0x1},
+		unicode.Range32{Lo: 0x11236, Hi: 0x11237, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123e, Hi: 0x1123e, Stride: 0x1},
+		unicode.Range32{Lo: 0x112df, Hi: 0x112df, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e3, Hi: 0x112ea, Stride: 0x1},
+		unicode.Range32{Lo: 0x11300, Hi: 0x11301, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133c, Hi: 0x1133c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133e, Hi: 0x1133e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11340, Hi: 0x11340, Stride: 0x1},
+		unicode.Range32{Lo: 0x11357, Hi: 0x11357, Stride: 0x1},
+		unicode.Range32{Lo: 0x11366, Hi: 0x1136c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11370, Hi: 0x11374, Stride: 0x1},
+		unicode.Range32{Lo: 0x11438, Hi: 0x1143f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11442, Hi: 0x11444, Stride: 0x1},
+		unicode.Range32{Lo: 0x11446, Hi: 0x11446, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b0, Hi: 0x114b0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b3, Hi: 0x114b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x114ba, Hi: 0x114ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bd, Hi: 0x114bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bf, Hi: 0x114c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c2, Hi: 0x114c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115af, Hi: 0x115af, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b2, Hi: 0x115b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bc, Hi: 0x115bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bf, Hi: 0x115c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x115dc, Hi: 0x115dd, Stride: 0x1},
+		unicode.Range32{Lo: 0x11633, Hi: 0x1163a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163d, Hi: 0x1163d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163f, Hi: 0x11640, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ab, Hi: 0x116ab, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ad, Hi: 0x116ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b0, Hi: 0x116b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b7, Hi: 0x116b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x1171d, Hi: 0x1171f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11722, Hi: 0x11725, Stride: 0x1},
+		unicode.Range32{Lo: 0x11727, Hi: 0x1172b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c30, Hi: 0x11c36, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c38, Hi: 0x11c3d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3f, Hi: 0x11c3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c92, Hi: 0x11ca7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11caa, Hi: 0x11cb0, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb2, Hi: 0x11cb3, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb5, Hi: 0x11cb6, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af0, Hi: 0x16af4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b30, Hi: 0x16b36, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f8f, Hi: 0x16f92, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9d, Hi: 0x1bc9e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d165, Hi: 0x1d165, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d167, Hi: 0x1d169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16e, Hi: 0x1d172, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d17b, Hi: 0x1d182, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d185, Hi: 0x1d18b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d1aa, Hi: 0x1d1ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d242, Hi: 0x1d244, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da00, Hi: 0x1da36, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da3b, Hi: 0x1da6c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da75, Hi: 0x1da75, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da84, Hi: 0x1da84, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da9b, Hi: 0x1da9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1daa1, Hi: 0x1daaf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e000, Hi: 0x1e006, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e008, Hi: 0x1e018, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e01b, Hi: 0x1e021, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e023, Hi: 0x1e024, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e026, Hi: 0x1e02a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e8d0, Hi: 0x1e8d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e944, Hi: 0x1e94a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0020, Hi: 0xe007f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0100, Hi: 0xe01ef, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeGlue_After_Zwj = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2764, Hi: 0x2764, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f48b, Hi: 0x1f48b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f5e8, Hi: 0x1f5e8, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeL = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x1100, Hi: 0x115f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa960, Hi: 0xa97c, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeLF = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xa, Hi: 0xa, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _GraphemeLV = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xac00, Hi: 0xac00, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1c, Hi: 0xac1c, Stride: 0x1},
+		unicode.Range16{Lo: 0xac38, Hi: 0xac38, Stride: 0x1},
+		unicode.Range16{Lo: 0xac54, Hi: 0xac54, Stride: 0x1},
+		unicode.Range16{Lo: 0xac70, Hi: 0xac70, Stride: 0x1},
+		unicode.Range16{Lo: 0xac8c, Hi: 0xac8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaca8, Hi: 0xaca8, Stride: 0x1},
+		unicode.Range16{Lo: 0xacc4, Hi: 0xacc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xace0, Hi: 0xace0, Stride: 0x1},
+		unicode.Range16{Lo: 0xacfc, Hi: 0xacfc, Stride: 0x1},
+		unicode.Range16{Lo: 0xad18, Hi: 0xad18, Stride: 0x1},
+		unicode.Range16{Lo: 0xad34, Hi: 0xad34, Stride: 0x1},
+		unicode.Range16{Lo: 0xad50, Hi: 0xad50, Stride: 0x1},
+		unicode.Range16{Lo: 0xad6c, Hi: 0xad6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xad88, Hi: 0xad88, Stride: 0x1},
+		unicode.Range16{Lo: 0xada4, Hi: 0xada4, Stride: 0x1},
+		unicode.Range16{Lo: 0xadc0, Hi: 0xadc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaddc, Hi: 0xaddc, Stride: 0x1},
+		unicode.Range16{Lo: 0xadf8, Hi: 0xadf8, Stride: 0x1},
+		unicode.Range16{Lo: 0xae14, Hi: 0xae14, Stride: 0x1},
+		unicode.Range16{Lo: 0xae30, Hi: 0xae30, Stride: 0x1},
+		unicode.Range16{Lo: 0xae4c, Hi: 0xae4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xae68, Hi: 0xae68, Stride: 0x1},
+		unicode.Range16{Lo: 0xae84, Hi: 0xae84, Stride: 0x1},
+		unicode.Range16{Lo: 0xaea0, Hi: 0xaea0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaebc, Hi: 0xaebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xaed8, Hi: 0xaed8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaef4, Hi: 0xaef4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf10, Hi: 0xaf10, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf2c, Hi: 0xaf2c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf48, Hi: 0xaf48, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf64, Hi: 0xaf64, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf80, Hi: 0xaf80, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9c, Hi: 0xaf9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xafb8, Hi: 0xafb8, Stride: 0x1},
+		unicode.Range16{Lo: 0xafd4, Hi: 0xafd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaff0, Hi: 0xaff0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb00c, Hi: 0xb00c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb028, Hi: 0xb028, Stride: 0x1},
+		unicode.Range16{Lo: 0xb044, Hi: 0xb044, Stride: 0x1},
+		unicode.Range16{Lo: 0xb060, Hi: 0xb060, Stride: 0x1},
+		unicode.Range16{Lo: 0xb07c, Hi: 0xb07c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb098, Hi: 0xb098, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0b4, Hi: 0xb0b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0d0, Hi: 0xb0d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0ec, Hi: 0xb0ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xb108, Hi: 0xb108, Stride: 0x1},
+		unicode.Range16{Lo: 0xb124, Hi: 0xb124, Stride: 0x1},
+		unicode.Range16{Lo: 0xb140, Hi: 0xb140, Stride: 0x1},
+		unicode.Range16{Lo: 0xb15c, Hi: 0xb15c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb178, Hi: 0xb178, Stride: 0x1},
+		unicode.Range16{Lo: 0xb194, Hi: 0xb194, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1b0, Hi: 0xb1b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1cc, Hi: 0xb1cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1e8, Hi: 0xb1e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb204, Hi: 0xb204, Stride: 0x1},
+		unicode.Range16{Lo: 0xb220, Hi: 0xb220, Stride: 0x1},
+		unicode.Range16{Lo: 0xb23c, Hi: 0xb23c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb258, Hi: 0xb258, Stride: 0x1},
+		unicode.Range16{Lo: 0xb274, Hi: 0xb274, Stride: 0x1},
+		unicode.Range16{Lo: 0xb290, Hi: 0xb290, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2ac, Hi: 0xb2ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2c8, Hi: 0xb2c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2e4, Hi: 0xb2e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb300, Hi: 0xb300, Stride: 0x1},
+		unicode.Range16{Lo: 0xb31c, Hi: 0xb31c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb338, Hi: 0xb338, Stride: 0x1},
+		unicode.Range16{Lo: 0xb354, Hi: 0xb354, Stride: 0x1},
+		unicode.Range16{Lo: 0xb370, Hi: 0xb370, Stride: 0x1},
+		unicode.Range16{Lo: 0xb38c, Hi: 0xb38c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3a8, Hi: 0xb3a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c4, Hi: 0xb3c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e0, Hi: 0xb3e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3fc, Hi: 0xb3fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb418, Hi: 0xb418, Stride: 0x1},
+		unicode.Range16{Lo: 0xb434, Hi: 0xb434, Stride: 0x1},
+		unicode.Range16{Lo: 0xb450, Hi: 0xb450, Stride: 0x1},
+		unicode.Range16{Lo: 0xb46c, Hi: 0xb46c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb488, Hi: 0xb488, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4a4, Hi: 0xb4a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4c0, Hi: 0xb4c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4dc, Hi: 0xb4dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4f8, Hi: 0xb4f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb514, Hi: 0xb514, Stride: 0x1},
+		unicode.Range16{Lo: 0xb530, Hi: 0xb530, Stride: 0x1},
+		unicode.Range16{Lo: 0xb54c, Hi: 0xb54c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb568, Hi: 0xb568, Stride: 0x1},
+		unicode.Range16{Lo: 0xb584, Hi: 0xb584, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5a0, Hi: 0xb5a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5bc, Hi: 0xb5bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5d8, Hi: 0xb5d8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f4, Hi: 0xb5f4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb610, Hi: 0xb610, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62c, Hi: 0xb62c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb648, Hi: 0xb648, Stride: 0x1},
+		unicode.Range16{Lo: 0xb664, Hi: 0xb664, Stride: 0x1},
+		unicode.Range16{Lo: 0xb680, Hi: 0xb680, Stride: 0x1},
+		unicode.Range16{Lo: 0xb69c, Hi: 0xb69c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6b8, Hi: 0xb6b8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6d4, Hi: 0xb6d4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6f0, Hi: 0xb6f0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb70c, Hi: 0xb70c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb728, Hi: 0xb728, Stride: 0x1},
+		unicode.Range16{Lo: 0xb744, Hi: 0xb744, Stride: 0x1},
+		unicode.Range16{Lo: 0xb760, Hi: 0xb760, Stride: 0x1},
+		unicode.Range16{Lo: 0xb77c, Hi: 0xb77c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb798, Hi: 0xb798, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7b4, Hi: 0xb7b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7d0, Hi: 0xb7d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7ec, Hi: 0xb7ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xb808, Hi: 0xb808, Stride: 0x1},
+		unicode.Range16{Lo: 0xb824, Hi: 0xb824, Stride: 0x1},
+		unicode.Range16{Lo: 0xb840, Hi: 0xb840, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85c, Hi: 0xb85c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb878, Hi: 0xb878, Stride: 0x1},
+		unicode.Range16{Lo: 0xb894, Hi: 0xb894, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8b0, Hi: 0xb8b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8cc, Hi: 0xb8cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e8, Hi: 0xb8e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb904, Hi: 0xb904, Stride: 0x1},
+		unicode.Range16{Lo: 0xb920, Hi: 0xb920, Stride: 0x1},
+		unicode.Range16{Lo: 0xb93c, Hi: 0xb93c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb958, Hi: 0xb958, Stride: 0x1},
+		unicode.Range16{Lo: 0xb974, Hi: 0xb974, Stride: 0x1},
+		unicode.Range16{Lo: 0xb990, Hi: 0xb990, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9ac, Hi: 0xb9ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c8, Hi: 0xb9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e4, Hi: 0xb9e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xba00, Hi: 0xba00, Stride: 0x1},
+		unicode.Range16{Lo: 0xba1c, Hi: 0xba1c, Stride: 0x1},
+		unicode.Range16{Lo: 0xba38, Hi: 0xba38, Stride: 0x1},
+		unicode.Range16{Lo: 0xba54, Hi: 0xba54, Stride: 0x1},
+		unicode.Range16{Lo: 0xba70, Hi: 0xba70, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8c, Hi: 0xba8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbaa8, Hi: 0xbaa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbac4, Hi: 0xbac4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae0, Hi: 0xbae0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbafc, Hi: 0xbafc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb18, Hi: 0xbb18, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb34, Hi: 0xbb34, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb50, Hi: 0xbb50, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb6c, Hi: 0xbb6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb88, Hi: 0xbb88, Stride: 0x1},
+		unicode.Range16{Lo: 0xbba4, Hi: 0xbba4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbc0, Hi: 0xbbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbdc, Hi: 0xbbdc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbf8, Hi: 0xbbf8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc14, Hi: 0xbc14, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc30, Hi: 0xbc30, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc4c, Hi: 0xbc4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc68, Hi: 0xbc68, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc84, Hi: 0xbc84, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca0, Hi: 0xbca0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcbc, Hi: 0xbcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd8, Hi: 0xbcd8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcf4, Hi: 0xbcf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd10, Hi: 0xbd10, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd2c, Hi: 0xbd2c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd48, Hi: 0xbd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd64, Hi: 0xbd64, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd80, Hi: 0xbd80, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd9c, Hi: 0xbd9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdb8, Hi: 0xbdb8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdd4, Hi: 0xbdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdf0, Hi: 0xbdf0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe0c, Hi: 0xbe0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe28, Hi: 0xbe28, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe44, Hi: 0xbe44, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe60, Hi: 0xbe60, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe7c, Hi: 0xbe7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe98, Hi: 0xbe98, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeb4, Hi: 0xbeb4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbed0, Hi: 0xbed0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeec, Hi: 0xbeec, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf08, Hi: 0xbf08, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf24, Hi: 0xbf24, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf40, Hi: 0xbf40, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf5c, Hi: 0xbf5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf78, Hi: 0xbf78, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf94, Hi: 0xbf94, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfb0, Hi: 0xbfb0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfcc, Hi: 0xbfcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfe8, Hi: 0xbfe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc004, Hi: 0xc004, Stride: 0x1},
+		unicode.Range16{Lo: 0xc020, Hi: 0xc020, Stride: 0x1},
+		unicode.Range16{Lo: 0xc03c, Hi: 0xc03c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc058, Hi: 0xc058, Stride: 0x1},
+		unicode.Range16{Lo: 0xc074, Hi: 0xc074, Stride: 0x1},
+		unicode.Range16{Lo: 0xc090, Hi: 0xc090, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0ac, Hi: 0xc0ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0c8, Hi: 0xc0c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e4, Hi: 0xc0e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc100, Hi: 0xc100, Stride: 0x1},
+		unicode.Range16{Lo: 0xc11c, Hi: 0xc11c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc138, Hi: 0xc138, Stride: 0x1},
+		unicode.Range16{Lo: 0xc154, Hi: 0xc154, Stride: 0x1},
+		unicode.Range16{Lo: 0xc170, Hi: 0xc170, Stride: 0x1},
+		unicode.Range16{Lo: 0xc18c, Hi: 0xc18c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1a8, Hi: 0xc1a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1c4, Hi: 0xc1c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1e0, Hi: 0xc1e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1fc, Hi: 0xc1fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc218, Hi: 0xc218, Stride: 0x1},
+		unicode.Range16{Lo: 0xc234, Hi: 0xc234, Stride: 0x1},
+		unicode.Range16{Lo: 0xc250, Hi: 0xc250, Stride: 0x1},
+		unicode.Range16{Lo: 0xc26c, Hi: 0xc26c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc288, Hi: 0xc288, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a4, Hi: 0xc2a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2c0, Hi: 0xc2c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2dc, Hi: 0xc2dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2f8, Hi: 0xc2f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc314, Hi: 0xc314, Stride: 0x1},
+		unicode.Range16{Lo: 0xc330, Hi: 0xc330, Stride: 0x1},
+		unicode.Range16{Lo: 0xc34c, Hi: 0xc34c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc368, Hi: 0xc368, Stride: 0x1},
+		unicode.Range16{Lo: 0xc384, Hi: 0xc384, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3a0, Hi: 0xc3a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3bc, Hi: 0xc3bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d8, Hi: 0xc3d8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3f4, Hi: 0xc3f4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc410, Hi: 0xc410, Stride: 0x1},
+		unicode.Range16{Lo: 0xc42c, Hi: 0xc42c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc448, Hi: 0xc448, Stride: 0x1},
+		unicode.Range16{Lo: 0xc464, Hi: 0xc464, Stride: 0x1},
+		unicode.Range16{Lo: 0xc480, Hi: 0xc480, Stride: 0x1},
+		unicode.Range16{Lo: 0xc49c, Hi: 0xc49c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4b8, Hi: 0xc4b8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4d4, Hi: 0xc4d4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4f0, Hi: 0xc4f0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc50c, Hi: 0xc50c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc528, Hi: 0xc528, Stride: 0x1},
+		unicode.Range16{Lo: 0xc544, Hi: 0xc544, Stride: 0x1},
+		unicode.Range16{Lo: 0xc560, Hi: 0xc560, Stride: 0x1},
+		unicode.Range16{Lo: 0xc57c, Hi: 0xc57c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc598, Hi: 0xc598, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5b4, Hi: 0xc5b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5d0, Hi: 0xc5d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5ec, Hi: 0xc5ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xc608, Hi: 0xc608, Stride: 0x1},
+		unicode.Range16{Lo: 0xc624, Hi: 0xc624, Stride: 0x1},
+		unicode.Range16{Lo: 0xc640, Hi: 0xc640, Stride: 0x1},
+		unicode.Range16{Lo: 0xc65c, Hi: 0xc65c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc678, Hi: 0xc678, Stride: 0x1},
+		unicode.Range16{Lo: 0xc694, Hi: 0xc694, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6b0, Hi: 0xc6b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6cc, Hi: 0xc6cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6e8, Hi: 0xc6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc704, Hi: 0xc704, Stride: 0x1},
+		unicode.Range16{Lo: 0xc720, Hi: 0xc720, Stride: 0x1},
+		unicode.Range16{Lo: 0xc73c, Hi: 0xc73c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc758, Hi: 0xc758, Stride: 0x1},
+		unicode.Range16{Lo: 0xc774, Hi: 0xc774, Stride: 0x1},
+		unicode.Range16{Lo: 0xc790, Hi: 0xc790, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7ac, Hi: 0xc7ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7c8, Hi: 0xc7c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7e4, Hi: 0xc7e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc800, Hi: 0xc800, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81c, Hi: 0xc81c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc838, Hi: 0xc838, Stride: 0x1},
+		unicode.Range16{Lo: 0xc854, Hi: 0xc854, Stride: 0x1},
+		unicode.Range16{Lo: 0xc870, Hi: 0xc870, Stride: 0x1},
+		unicode.Range16{Lo: 0xc88c, Hi: 0xc88c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8a8, Hi: 0xc8a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8c4, Hi: 0xc8c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e0, Hi: 0xc8e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8fc, Hi: 0xc8fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc918, Hi: 0xc918, Stride: 0x1},
+		unicode.Range16{Lo: 0xc934, Hi: 0xc934, Stride: 0x1},
+		unicode.Range16{Lo: 0xc950, Hi: 0xc950, Stride: 0x1},
+		unicode.Range16{Lo: 0xc96c, Hi: 0xc96c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc988, Hi: 0xc988, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9a4, Hi: 0xc9a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9c0, Hi: 0xc9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9dc, Hi: 0xc9dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9f8, Hi: 0xc9f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xca14, Hi: 0xca14, Stride: 0x1},
+		unicode.Range16{Lo: 0xca30, Hi: 0xca30, Stride: 0x1},
+		unicode.Range16{Lo: 0xca4c, Hi: 0xca4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xca68, Hi: 0xca68, Stride: 0x1},
+		unicode.Range16{Lo: 0xca84, Hi: 0xca84, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa0, Hi: 0xcaa0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcabc, Hi: 0xcabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcad8, Hi: 0xcad8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaf4, Hi: 0xcaf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb10, Hi: 0xcb10, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb2c, Hi: 0xcb2c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb48, Hi: 0xcb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb64, Hi: 0xcb64, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb80, Hi: 0xcb80, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb9c, Hi: 0xcb9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbb8, Hi: 0xcbb8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd4, Hi: 0xcbd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf0, Hi: 0xcbf0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0c, Hi: 0xcc0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc28, Hi: 0xcc28, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc44, Hi: 0xcc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc60, Hi: 0xcc60, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7c, Hi: 0xcc7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc98, Hi: 0xcc98, Stride: 0x1},
+		unicode.Range16{Lo: 0xccb4, Hi: 0xccb4, Stride: 0x1},
+		unicode.Range16{Lo: 0xccd0, Hi: 0xccd0, Stride: 0x1},
+		unicode.Range16{Lo: 0xccec, Hi: 0xccec, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd08, Hi: 0xcd08, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd24, Hi: 0xcd24, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd40, Hi: 0xcd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5c, Hi: 0xcd5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd78, Hi: 0xcd78, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd94, Hi: 0xcd94, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdb0, Hi: 0xcdb0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdcc, Hi: 0xcdcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde8, Hi: 0xcde8, Stride: 0x1},
+		unicode.Range16{Lo: 0xce04, Hi: 0xce04, Stride: 0x1},
+		unicode.Range16{Lo: 0xce20, Hi: 0xce20, Stride: 0x1},
+		unicode.Range16{Lo: 0xce3c, Hi: 0xce3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xce58, Hi: 0xce58, Stride: 0x1},
+		unicode.Range16{Lo: 0xce74, Hi: 0xce74, Stride: 0x1},
+		unicode.Range16{Lo: 0xce90, Hi: 0xce90, Stride: 0x1},
+		unicode.Range16{Lo: 0xceac, Hi: 0xceac, Stride: 0x1},
+		unicode.Range16{Lo: 0xcec8, Hi: 0xcec8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcee4, Hi: 0xcee4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf00, Hi: 0xcf00, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1c, Hi: 0xcf1c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf38, Hi: 0xcf38, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf54, Hi: 0xcf54, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf70, Hi: 0xcf70, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf8c, Hi: 0xcf8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfa8, Hi: 0xcfa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfc4, Hi: 0xcfc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfe0, Hi: 0xcfe0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcffc, Hi: 0xcffc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd018, Hi: 0xd018, Stride: 0x1},
+		unicode.Range16{Lo: 0xd034, Hi: 0xd034, Stride: 0x1},
+		unicode.Range16{Lo: 0xd050, Hi: 0xd050, Stride: 0x1},
+		unicode.Range16{Lo: 0xd06c, Hi: 0xd06c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd088, Hi: 0xd088, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0a4, Hi: 0xd0a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0c0, Hi: 0xd0c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0dc, Hi: 0xd0dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0f8, Hi: 0xd0f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd114, Hi: 0xd114, Stride: 0x1},
+		unicode.Range16{Lo: 0xd130, Hi: 0xd130, Stride: 0x1},
+		unicode.Range16{Lo: 0xd14c, Hi: 0xd14c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd168, Hi: 0xd168, Stride: 0x1},
+		unicode.Range16{Lo: 0xd184, Hi: 0xd184, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1a0, Hi: 0xd1a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1bc, Hi: 0xd1bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1d8, Hi: 0xd1d8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1f4, Hi: 0xd1f4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd210, Hi: 0xd210, Stride: 0x1},
+		unicode.Range16{Lo: 0xd22c, Hi: 0xd22c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd248, Hi: 0xd248, Stride: 0x1},
+		unicode.Range16{Lo: 0xd264, Hi: 0xd264, Stride: 0x1},
+		unicode.Range16{Lo: 0xd280, Hi: 0xd280, Stride: 0x1},
+		unicode.Range16{Lo: 0xd29c, Hi: 0xd29c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2b8, Hi: 0xd2b8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2d4, Hi: 0xd2d4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2f0, Hi: 0xd2f0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd30c, Hi: 0xd30c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd328, Hi: 0xd328, Stride: 0x1},
+		unicode.Range16{Lo: 0xd344, Hi: 0xd344, Stride: 0x1},
+		unicode.Range16{Lo: 0xd360, Hi: 0xd360, Stride: 0x1},
+		unicode.Range16{Lo: 0xd37c, Hi: 0xd37c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd398, Hi: 0xd398, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3b4, Hi: 0xd3b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d0, Hi: 0xd3d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3ec, Hi: 0xd3ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xd408, Hi: 0xd408, Stride: 0x1},
+		unicode.Range16{Lo: 0xd424, Hi: 0xd424, Stride: 0x1},
+		unicode.Range16{Lo: 0xd440, Hi: 0xd440, Stride: 0x1},
+		unicode.Range16{Lo: 0xd45c, Hi: 0xd45c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd478, Hi: 0xd478, Stride: 0x1},
+		unicode.Range16{Lo: 0xd494, Hi: 0xd494, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4b0, Hi: 0xd4b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4cc, Hi: 0xd4cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e8, Hi: 0xd4e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd504, Hi: 0xd504, Stride: 0x1},
+		unicode.Range16{Lo: 0xd520, Hi: 0xd520, Stride: 0x1},
+		unicode.Range16{Lo: 0xd53c, Hi: 0xd53c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd558, Hi: 0xd558, Stride: 0x1},
+		unicode.Range16{Lo: 0xd574, Hi: 0xd574, Stride: 0x1},
+		unicode.Range16{Lo: 0xd590, Hi: 0xd590, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5ac, Hi: 0xd5ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5c8, Hi: 0xd5c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5e4, Hi: 0xd5e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd600, Hi: 0xd600, Stride: 0x1},
+		unicode.Range16{Lo: 0xd61c, Hi: 0xd61c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd638, Hi: 0xd638, Stride: 0x1},
+		unicode.Range16{Lo: 0xd654, Hi: 0xd654, Stride: 0x1},
+		unicode.Range16{Lo: 0xd670, Hi: 0xd670, Stride: 0x1},
+		unicode.Range16{Lo: 0xd68c, Hi: 0xd68c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6a8, Hi: 0xd6a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6c4, Hi: 0xd6c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6e0, Hi: 0xd6e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6fc, Hi: 0xd6fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd718, Hi: 0xd718, Stride: 0x1},
+		unicode.Range16{Lo: 0xd734, Hi: 0xd734, Stride: 0x1},
+		unicode.Range16{Lo: 0xd750, Hi: 0xd750, Stride: 0x1},
+		unicode.Range16{Lo: 0xd76c, Hi: 0xd76c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd788, Hi: 0xd788, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeLVT = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xac01, Hi: 0xac1b, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1d, Hi: 0xac37, Stride: 0x1},
+		unicode.Range16{Lo: 0xac39, Hi: 0xac53, Stride: 0x1},
+		unicode.Range16{Lo: 0xac55, Hi: 0xac6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xac71, Hi: 0xac8b, Stride: 0x1},
+		unicode.Range16{Lo: 0xac8d, Hi: 0xaca7, Stride: 0x1},
+		unicode.Range16{Lo: 0xaca9, Hi: 0xacc3, Stride: 0x1},
+		unicode.Range16{Lo: 0xacc5, Hi: 0xacdf, Stride: 0x1},
+		unicode.Range16{Lo: 0xace1, Hi: 0xacfb, Stride: 0x1},
+		unicode.Range16{Lo: 0xacfd, Hi: 0xad17, Stride: 0x1},
+		unicode.Range16{Lo: 0xad19, Hi: 0xad33, Stride: 0x1},
+		unicode.Range16{Lo: 0xad35, Hi: 0xad4f, Stride: 0x1},
+		unicode.Range16{Lo: 0xad51, Hi: 0xad6b, Stride: 0x1},
+		unicode.Range16{Lo: 0xad6d, Hi: 0xad87, Stride: 0x1},
+		unicode.Range16{Lo: 0xad89, Hi: 0xada3, Stride: 0x1},
+		unicode.Range16{Lo: 0xada5, Hi: 0xadbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xadc1, Hi: 0xaddb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaddd, Hi: 0xadf7, Stride: 0x1},
+		unicode.Range16{Lo: 0xadf9, Hi: 0xae13, Stride: 0x1},
+		unicode.Range16{Lo: 0xae15, Hi: 0xae2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xae31, Hi: 0xae4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xae4d, Hi: 0xae67, Stride: 0x1},
+		unicode.Range16{Lo: 0xae69, Hi: 0xae83, Stride: 0x1},
+		unicode.Range16{Lo: 0xae85, Hi: 0xae9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaea1, Hi: 0xaebb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaebd, Hi: 0xaed7, Stride: 0x1},
+		unicode.Range16{Lo: 0xaed9, Hi: 0xaef3, Stride: 0x1},
+		unicode.Range16{Lo: 0xaef5, Hi: 0xaf0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf11, Hi: 0xaf2b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf2d, Hi: 0xaf47, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf49, Hi: 0xaf63, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf65, Hi: 0xaf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf81, Hi: 0xaf9b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9d, Hi: 0xafb7, Stride: 0x1},
+		unicode.Range16{Lo: 0xafb9, Hi: 0xafd3, Stride: 0x1},
+		unicode.Range16{Lo: 0xafd5, Hi: 0xafef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaff1, Hi: 0xb00b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb00d, Hi: 0xb027, Stride: 0x1},
+		unicode.Range16{Lo: 0xb029, Hi: 0xb043, Stride: 0x1},
+		unicode.Range16{Lo: 0xb045, Hi: 0xb05f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb061, Hi: 0xb07b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb07d, Hi: 0xb097, Stride: 0x1},
+		unicode.Range16{Lo: 0xb099, Hi: 0xb0b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0b5, Hi: 0xb0cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0d1, Hi: 0xb0eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0ed, Hi: 0xb107, Stride: 0x1},
+		unicode.Range16{Lo: 0xb109, Hi: 0xb123, Stride: 0x1},
+		unicode.Range16{Lo: 0xb125, Hi: 0xb13f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb141, Hi: 0xb15b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb15d, Hi: 0xb177, Stride: 0x1},
+		unicode.Range16{Lo: 0xb179, Hi: 0xb193, Stride: 0x1},
+		unicode.Range16{Lo: 0xb195, Hi: 0xb1af, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1b1, Hi: 0xb1cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1cd, Hi: 0xb1e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1e9, Hi: 0xb203, Stride: 0x1},
+		unicode.Range16{Lo: 0xb205, Hi: 0xb21f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb221, Hi: 0xb23b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb23d, Hi: 0xb257, Stride: 0x1},
+		unicode.Range16{Lo: 0xb259, Hi: 0xb273, Stride: 0x1},
+		unicode.Range16{Lo: 0xb275, Hi: 0xb28f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb291, Hi: 0xb2ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2ad, Hi: 0xb2c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2c9, Hi: 0xb2e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2e5, Hi: 0xb2ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xb301, Hi: 0xb31b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb31d, Hi: 0xb337, Stride: 0x1},
+		unicode.Range16{Lo: 0xb339, Hi: 0xb353, Stride: 0x1},
+		unicode.Range16{Lo: 0xb355, Hi: 0xb36f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb371, Hi: 0xb38b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb38d, Hi: 0xb3a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3a9, Hi: 0xb3c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c5, Hi: 0xb3df, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e1, Hi: 0xb3fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3fd, Hi: 0xb417, Stride: 0x1},
+		unicode.Range16{Lo: 0xb419, Hi: 0xb433, Stride: 0x1},
+		unicode.Range16{Lo: 0xb435, Hi: 0xb44f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb451, Hi: 0xb46b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb46d, Hi: 0xb487, Stride: 0x1},
+		unicode.Range16{Lo: 0xb489, Hi: 0xb4a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4a5, Hi: 0xb4bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4c1, Hi: 0xb4db, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4dd, Hi: 0xb4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4f9, Hi: 0xb513, Stride: 0x1},
+		unicode.Range16{Lo: 0xb515, Hi: 0xb52f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb531, Hi: 0xb54b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb54d, Hi: 0xb567, Stride: 0x1},
+		unicode.Range16{Lo: 0xb569, Hi: 0xb583, Stride: 0x1},
+		unicode.Range16{Lo: 0xb585, Hi: 0xb59f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5a1, Hi: 0xb5bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5bd, Hi: 0xb5d7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5d9, Hi: 0xb5f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f5, Hi: 0xb60f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb611, Hi: 0xb62b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62d, Hi: 0xb647, Stride: 0x1},
+		unicode.Range16{Lo: 0xb649, Hi: 0xb663, Stride: 0x1},
+		unicode.Range16{Lo: 0xb665, Hi: 0xb67f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb681, Hi: 0xb69b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb69d, Hi: 0xb6b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6b9, Hi: 0xb6d3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6d5, Hi: 0xb6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6f1, Hi: 0xb70b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb70d, Hi: 0xb727, Stride: 0x1},
+		unicode.Range16{Lo: 0xb729, Hi: 0xb743, Stride: 0x1},
+		unicode.Range16{Lo: 0xb745, Hi: 0xb75f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb761, Hi: 0xb77b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb77d, Hi: 0xb797, Stride: 0x1},
+		unicode.Range16{Lo: 0xb799, Hi: 0xb7b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7b5, Hi: 0xb7cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7d1, Hi: 0xb7eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7ed, Hi: 0xb807, Stride: 0x1},
+		unicode.Range16{Lo: 0xb809, Hi: 0xb823, Stride: 0x1},
+		unicode.Range16{Lo: 0xb825, Hi: 0xb83f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb841, Hi: 0xb85b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85d, Hi: 0xb877, Stride: 0x1},
+		unicode.Range16{Lo: 0xb879, Hi: 0xb893, Stride: 0x1},
+		unicode.Range16{Lo: 0xb895, Hi: 0xb8af, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8b1, Hi: 0xb8cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8cd, Hi: 0xb8e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e9, Hi: 0xb903, Stride: 0x1},
+		unicode.Range16{Lo: 0xb905, Hi: 0xb91f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb921, Hi: 0xb93b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb93d, Hi: 0xb957, Stride: 0x1},
+		unicode.Range16{Lo: 0xb959, Hi: 0xb973, Stride: 0x1},
+		unicode.Range16{Lo: 0xb975, Hi: 0xb98f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb991, Hi: 0xb9ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9ad, Hi: 0xb9c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c9, Hi: 0xb9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e5, Hi: 0xb9ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xba01, Hi: 0xba1b, Stride: 0x1},
+		unicode.Range16{Lo: 0xba1d, Hi: 0xba37, Stride: 0x1},
+		unicode.Range16{Lo: 0xba39, Hi: 0xba53, Stride: 0x1},
+		unicode.Range16{Lo: 0xba55, Hi: 0xba6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xba71, Hi: 0xba8b, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8d, Hi: 0xbaa7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbaa9, Hi: 0xbac3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbac5, Hi: 0xbadf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae1, Hi: 0xbafb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbafd, Hi: 0xbb17, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb19, Hi: 0xbb33, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb35, Hi: 0xbb4f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb51, Hi: 0xbb6b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb6d, Hi: 0xbb87, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb89, Hi: 0xbba3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbba5, Hi: 0xbbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbc1, Hi: 0xbbdb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbdd, Hi: 0xbbf7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbf9, Hi: 0xbc13, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc15, Hi: 0xbc2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc31, Hi: 0xbc4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc4d, Hi: 0xbc67, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc69, Hi: 0xbc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc85, Hi: 0xbc9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca1, Hi: 0xbcbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcbd, Hi: 0xbcd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd9, Hi: 0xbcf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcf5, Hi: 0xbd0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd11, Hi: 0xbd2b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd2d, Hi: 0xbd47, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd49, Hi: 0xbd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd65, Hi: 0xbd7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd81, Hi: 0xbd9b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd9d, Hi: 0xbdb7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdb9, Hi: 0xbdd3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdd5, Hi: 0xbdef, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdf1, Hi: 0xbe0b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe0d, Hi: 0xbe27, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe29, Hi: 0xbe43, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe45, Hi: 0xbe5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe61, Hi: 0xbe7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe7d, Hi: 0xbe97, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe99, Hi: 0xbeb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeb5, Hi: 0xbecf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbed1, Hi: 0xbeeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeed, Hi: 0xbf07, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf09, Hi: 0xbf23, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf25, Hi: 0xbf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf41, Hi: 0xbf5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf5d, Hi: 0xbf77, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf79, Hi: 0xbf93, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf95, Hi: 0xbfaf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfb1, Hi: 0xbfcb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfcd, Hi: 0xbfe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfe9, Hi: 0xc003, Stride: 0x1},
+		unicode.Range16{Lo: 0xc005, Hi: 0xc01f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc021, Hi: 0xc03b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc03d, Hi: 0xc057, Stride: 0x1},
+		unicode.Range16{Lo: 0xc059, Hi: 0xc073, Stride: 0x1},
+		unicode.Range16{Lo: 0xc075, Hi: 0xc08f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc091, Hi: 0xc0ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0ad, Hi: 0xc0c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0c9, Hi: 0xc0e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e5, Hi: 0xc0ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xc101, Hi: 0xc11b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc11d, Hi: 0xc137, Stride: 0x1},
+		unicode.Range16{Lo: 0xc139, Hi: 0xc153, Stride: 0x1},
+		unicode.Range16{Lo: 0xc155, Hi: 0xc16f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc171, Hi: 0xc18b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc18d, Hi: 0xc1a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1a9, Hi: 0xc1c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1c5, Hi: 0xc1df, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1e1, Hi: 0xc1fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1fd, Hi: 0xc217, Stride: 0x1},
+		unicode.Range16{Lo: 0xc219, Hi: 0xc233, Stride: 0x1},
+		unicode.Range16{Lo: 0xc235, Hi: 0xc24f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc251, Hi: 0xc26b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc26d, Hi: 0xc287, Stride: 0x1},
+		unicode.Range16{Lo: 0xc289, Hi: 0xc2a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a5, Hi: 0xc2bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2c1, Hi: 0xc2db, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2dd, Hi: 0xc2f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2f9, Hi: 0xc313, Stride: 0x1},
+		unicode.Range16{Lo: 0xc315, Hi: 0xc32f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc331, Hi: 0xc34b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc34d, Hi: 0xc367, Stride: 0x1},
+		unicode.Range16{Lo: 0xc369, Hi: 0xc383, Stride: 0x1},
+		unicode.Range16{Lo: 0xc385, Hi: 0xc39f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3a1, Hi: 0xc3bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3bd, Hi: 0xc3d7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d9, Hi: 0xc3f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3f5, Hi: 0xc40f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc411, Hi: 0xc42b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc42d, Hi: 0xc447, Stride: 0x1},
+		unicode.Range16{Lo: 0xc449, Hi: 0xc463, Stride: 0x1},
+		unicode.Range16{Lo: 0xc465, Hi: 0xc47f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc481, Hi: 0xc49b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc49d, Hi: 0xc4b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4b9, Hi: 0xc4d3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4d5, Hi: 0xc4ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4f1, Hi: 0xc50b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc50d, Hi: 0xc527, Stride: 0x1},
+		unicode.Range16{Lo: 0xc529, Hi: 0xc543, Stride: 0x1},
+		unicode.Range16{Lo: 0xc545, Hi: 0xc55f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc561, Hi: 0xc57b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc57d, Hi: 0xc597, Stride: 0x1},
+		unicode.Range16{Lo: 0xc599, Hi: 0xc5b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5b5, Hi: 0xc5cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5d1, Hi: 0xc5eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5ed, Hi: 0xc607, Stride: 0x1},
+		unicode.Range16{Lo: 0xc609, Hi: 0xc623, Stride: 0x1},
+		unicode.Range16{Lo: 0xc625, Hi: 0xc63f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc641, Hi: 0xc65b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc65d, Hi: 0xc677, Stride: 0x1},
+		unicode.Range16{Lo: 0xc679, Hi: 0xc693, Stride: 0x1},
+		unicode.Range16{Lo: 0xc695, Hi: 0xc6af, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6b1, Hi: 0xc6cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6cd, Hi: 0xc6e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6e9, Hi: 0xc703, Stride: 0x1},
+		unicode.Range16{Lo: 0xc705, Hi: 0xc71f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc721, Hi: 0xc73b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc73d, Hi: 0xc757, Stride: 0x1},
+		unicode.Range16{Lo: 0xc759, Hi: 0xc773, Stride: 0x1},
+		unicode.Range16{Lo: 0xc775, Hi: 0xc78f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc791, Hi: 0xc7ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7ad, Hi: 0xc7c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7c9, Hi: 0xc7e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7e5, Hi: 0xc7ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xc801, Hi: 0xc81b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81d, Hi: 0xc837, Stride: 0x1},
+		unicode.Range16{Lo: 0xc839, Hi: 0xc853, Stride: 0x1},
+		unicode.Range16{Lo: 0xc855, Hi: 0xc86f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc871, Hi: 0xc88b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc88d, Hi: 0xc8a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8a9, Hi: 0xc8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8c5, Hi: 0xc8df, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e1, Hi: 0xc8fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8fd, Hi: 0xc917, Stride: 0x1},
+		unicode.Range16{Lo: 0xc919, Hi: 0xc933, Stride: 0x1},
+		unicode.Range16{Lo: 0xc935, Hi: 0xc94f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc951, Hi: 0xc96b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc96d, Hi: 0xc987, Stride: 0x1},
+		unicode.Range16{Lo: 0xc989, Hi: 0xc9a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9a5, Hi: 0xc9bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9c1, Hi: 0xc9db, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9dd, Hi: 0xc9f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9f9, Hi: 0xca13, Stride: 0x1},
+		unicode.Range16{Lo: 0xca15, Hi: 0xca2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xca31, Hi: 0xca4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xca4d, Hi: 0xca67, Stride: 0x1},
+		unicode.Range16{Lo: 0xca69, Hi: 0xca83, Stride: 0x1},
+		unicode.Range16{Lo: 0xca85, Hi: 0xca9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa1, Hi: 0xcabb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcabd, Hi: 0xcad7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcad9, Hi: 0xcaf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaf5, Hi: 0xcb0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb11, Hi: 0xcb2b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb2d, Hi: 0xcb47, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb49, Hi: 0xcb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb65, Hi: 0xcb7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb81, Hi: 0xcb9b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb9d, Hi: 0xcbb7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbb9, Hi: 0xcbd3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd5, Hi: 0xcbef, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf1, Hi: 0xcc0b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0d, Hi: 0xcc27, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc29, Hi: 0xcc43, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc45, Hi: 0xcc5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc61, Hi: 0xcc7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7d, Hi: 0xcc97, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc99, Hi: 0xccb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xccb5, Hi: 0xcccf, Stride: 0x1},
+		unicode.Range16{Lo: 0xccd1, Hi: 0xcceb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcced, Hi: 0xcd07, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd09, Hi: 0xcd23, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd25, Hi: 0xcd3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd41, Hi: 0xcd5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5d, Hi: 0xcd77, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd79, Hi: 0xcd93, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd95, Hi: 0xcdaf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdb1, Hi: 0xcdcb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdcd, Hi: 0xcde7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde9, Hi: 0xce03, Stride: 0x1},
+		unicode.Range16{Lo: 0xce05, Hi: 0xce1f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce21, Hi: 0xce3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xce3d, Hi: 0xce57, Stride: 0x1},
+		unicode.Range16{Lo: 0xce59, Hi: 0xce73, Stride: 0x1},
+		unicode.Range16{Lo: 0xce75, Hi: 0xce8f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce91, Hi: 0xceab, Stride: 0x1},
+		unicode.Range16{Lo: 0xcead, Hi: 0xcec7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcec9, Hi: 0xcee3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcee5, Hi: 0xceff, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf01, Hi: 0xcf1b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1d, Hi: 0xcf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf39, Hi: 0xcf53, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf55, Hi: 0xcf6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf71, Hi: 0xcf8b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf8d, Hi: 0xcfa7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfa9, Hi: 0xcfc3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfc5, Hi: 0xcfdf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfe1, Hi: 0xcffb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcffd, Hi: 0xd017, Stride: 0x1},
+		unicode.Range16{Lo: 0xd019, Hi: 0xd033, Stride: 0x1},
+		unicode.Range16{Lo: 0xd035, Hi: 0xd04f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd051, Hi: 0xd06b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd06d, Hi: 0xd087, Stride: 0x1},
+		unicode.Range16{Lo: 0xd089, Hi: 0xd0a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0a5, Hi: 0xd0bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0c1, Hi: 0xd0db, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0dd, Hi: 0xd0f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0f9, Hi: 0xd113, Stride: 0x1},
+		unicode.Range16{Lo: 0xd115, Hi: 0xd12f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd131, Hi: 0xd14b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd14d, Hi: 0xd167, Stride: 0x1},
+		unicode.Range16{Lo: 0xd169, Hi: 0xd183, Stride: 0x1},
+		unicode.Range16{Lo: 0xd185, Hi: 0xd19f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1a1, Hi: 0xd1bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1bd, Hi: 0xd1d7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1d9, Hi: 0xd1f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1f5, Hi: 0xd20f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd211, Hi: 0xd22b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd22d, Hi: 0xd247, Stride: 0x1},
+		unicode.Range16{Lo: 0xd249, Hi: 0xd263, Stride: 0x1},
+		unicode.Range16{Lo: 0xd265, Hi: 0xd27f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd281, Hi: 0xd29b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd29d, Hi: 0xd2b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2b9, Hi: 0xd2d3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2d5, Hi: 0xd2ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2f1, Hi: 0xd30b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd30d, Hi: 0xd327, Stride: 0x1},
+		unicode.Range16{Lo: 0xd329, Hi: 0xd343, Stride: 0x1},
+		unicode.Range16{Lo: 0xd345, Hi: 0xd35f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd361, Hi: 0xd37b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd37d, Hi: 0xd397, Stride: 0x1},
+		unicode.Range16{Lo: 0xd399, Hi: 0xd3b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3b5, Hi: 0xd3cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d1, Hi: 0xd3eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3ed, Hi: 0xd407, Stride: 0x1},
+		unicode.Range16{Lo: 0xd409, Hi: 0xd423, Stride: 0x1},
+		unicode.Range16{Lo: 0xd425, Hi: 0xd43f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd441, Hi: 0xd45b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd45d, Hi: 0xd477, Stride: 0x1},
+		unicode.Range16{Lo: 0xd479, Hi: 0xd493, Stride: 0x1},
+		unicode.Range16{Lo: 0xd495, Hi: 0xd4af, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4b1, Hi: 0xd4cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4cd, Hi: 0xd4e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e9, Hi: 0xd503, Stride: 0x1},
+		unicode.Range16{Lo: 0xd505, Hi: 0xd51f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd521, Hi: 0xd53b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd53d, Hi: 0xd557, Stride: 0x1},
+		unicode.Range16{Lo: 0xd559, Hi: 0xd573, Stride: 0x1},
+		unicode.Range16{Lo: 0xd575, Hi: 0xd58f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd591, Hi: 0xd5ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5ad, Hi: 0xd5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5c9, Hi: 0xd5e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5e5, Hi: 0xd5ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xd601, Hi: 0xd61b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd61d, Hi: 0xd637, Stride: 0x1},
+		unicode.Range16{Lo: 0xd639, Hi: 0xd653, Stride: 0x1},
+		unicode.Range16{Lo: 0xd655, Hi: 0xd66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd671, Hi: 0xd68b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd68d, Hi: 0xd6a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6a9, Hi: 0xd6c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6c5, Hi: 0xd6df, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6e1, Hi: 0xd6fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6fd, Hi: 0xd717, Stride: 0x1},
+		unicode.Range16{Lo: 0xd719, Hi: 0xd733, Stride: 0x1},
+		unicode.Range16{Lo: 0xd735, Hi: 0xd74f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd751, Hi: 0xd76b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd76d, Hi: 0xd787, Stride: 0x1},
+		unicode.Range16{Lo: 0xd789, Hi: 0xd7a3, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemePrepend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x600, Hi: 0x605, Stride: 0x1},
+		unicode.Range16{Lo: 0x6dd, Hi: 0x6dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x70f, Hi: 0x70f, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e2, Hi: 0x8e2, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e, Hi: 0xd4e, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x110bd, Hi: 0x110bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c2, Hi: 0x111c3, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeRegional_Indicator = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f1e6, Hi: 0x1f1ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeSpacingMark = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x903, Hi: 0x903, Stride: 0x1},
+		unicode.Range16{Lo: 0x93b, Hi: 0x93b, Stride: 0x1},
+		unicode.Range16{Lo: 0x93e, Hi: 0x940, Stride: 0x1},
+		unicode.Range16{Lo: 0x949, Hi: 0x94c, Stride: 0x1},
+		unicode.Range16{Lo: 0x94e, Hi: 0x94f, Stride: 0x1},
+		unicode.Range16{Lo: 0x982, Hi: 0x983, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bf, Hi: 0x9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c7, Hi: 0x9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cb, Hi: 0x9cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa03, Hi: 0xa03, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3e, Hi: 0xa40, Stride: 0x1},
+		unicode.Range16{Lo: 0xa83, Hi: 0xa83, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe, Hi: 0xac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xac9, Hi: 0xac9, Stride: 0x1},
+		unicode.Range16{Lo: 0xacb, Hi: 0xacc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb02, Hi: 0xb03, Stride: 0x1},
+		unicode.Range16{Lo: 0xb40, Hi: 0xb40, Stride: 0x1},
+		unicode.Range16{Lo: 0xb47, Hi: 0xb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4b, Hi: 0xb4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbf, Hi: 0xbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc1, Hi: 0xbc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc6, Hi: 0xbc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca, Hi: 0xbcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc01, Hi: 0xc03, Stride: 0x1},
+		unicode.Range16{Lo: 0xc41, Hi: 0xc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xc82, Hi: 0xc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbe, Hi: 0xcbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0, Hi: 0xcc1, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc3, Hi: 0xcc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7, Hi: 0xcc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcca, Hi: 0xccb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd02, Hi: 0xd03, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3f, Hi: 0xd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xd46, Hi: 0xd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4a, Hi: 0xd4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd82, Hi: 0xd83, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd0, Hi: 0xdd1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd8, Hi: 0xdde, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf2, Hi: 0xdf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xe33, Hi: 0xe33, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb3, Hi: 0xeb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3e, Hi: 0xf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf7f, Hi: 0xf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1031, Hi: 0x1031, Stride: 0x1},
+		unicode.Range16{Lo: 0x103b, Hi: 0x103c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1056, Hi: 0x1057, Stride: 0x1},
+		unicode.Range16{Lo: 0x1084, Hi: 0x1084, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b6, Hi: 0x17b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17be, Hi: 0x17c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c7, Hi: 0x17c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1923, Hi: 0x1926, Stride: 0x1},
+		unicode.Range16{Lo: 0x1929, Hi: 0x192b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1930, Hi: 0x1931, Stride: 0x1},
+		unicode.Range16{Lo: 0x1933, Hi: 0x1938, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a19, Hi: 0x1a1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a55, Hi: 0x1a55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a57, Hi: 0x1a57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6d, Hi: 0x1a72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b04, Hi: 0x1b04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b35, Hi: 0x1b35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3b, Hi: 0x1b3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3d, Hi: 0x1b41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b43, Hi: 0x1b44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b82, Hi: 0x1b82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba1, Hi: 0x1ba1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba6, Hi: 0x1ba7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1baa, Hi: 0x1baa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be7, Hi: 0x1be7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bea, Hi: 0x1bec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bee, Hi: 0x1bee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bf2, Hi: 0x1bf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c24, Hi: 0x1c2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c34, Hi: 0x1c35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce1, Hi: 0x1ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf2, Hi: 0x1cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa823, Hi: 0xa824, Stride: 0x1},
+		unicode.Range16{Lo: 0xa827, Hi: 0xa827, Stride: 0x1},
+		unicode.Range16{Lo: 0xa880, Hi: 0xa881, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8b4, Hi: 0xa8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa952, Hi: 0xa953, Stride: 0x1},
+		unicode.Range16{Lo: 0xa983, Hi: 0xa983, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b4, Hi: 0xa9b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9ba, Hi: 0xa9bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bd, Hi: 0xa9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa2f, Hi: 0xaa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa33, Hi: 0xaa34, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4d, Hi: 0xaa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaeb, Hi: 0xaaeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaee, Hi: 0xaaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf5, Hi: 0xaaf5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe3, Hi: 0xabe4, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe6, Hi: 0xabe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe9, Hi: 0xabea, Stride: 0x1},
+		unicode.Range16{Lo: 0xabec, Hi: 0xabec, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x11000, Hi: 0x11000, Stride: 0x1},
+		unicode.Range32{Lo: 0x11002, Hi: 0x11002, Stride: 0x1},
+		unicode.Range32{Lo: 0x11082, Hi: 0x11082, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b0, Hi: 0x110b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b7, Hi: 0x110b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112c, Hi: 0x1112c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11182, Hi: 0x11182, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b3, Hi: 0x111b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x111bf, Hi: 0x111c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122c, Hi: 0x1122e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11232, Hi: 0x11233, Stride: 0x1},
+		unicode.Range32{Lo: 0x11235, Hi: 0x11235, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e0, Hi: 0x112e2, Stride: 0x1},
+		unicode.Range32{Lo: 0x11302, Hi: 0x11303, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133f, Hi: 0x1133f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11341, Hi: 0x11344, Stride: 0x1},
+		unicode.Range32{Lo: 0x11347, Hi: 0x11348, Stride: 0x1},
+		unicode.Range32{Lo: 0x1134b, Hi: 0x1134d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11362, Hi: 0x11363, Stride: 0x1},
+		unicode.Range32{Lo: 0x11435, Hi: 0x11437, Stride: 0x1},
+		unicode.Range32{Lo: 0x11440, Hi: 0x11441, Stride: 0x1},
+		unicode.Range32{Lo: 0x11445, Hi: 0x11445, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b1, Hi: 0x114b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b9, Hi: 0x114b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bb, Hi: 0x114bc, Stride: 0x1},
+		unicode.Range32{Lo: 0x114be, Hi: 0x114be, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c1, Hi: 0x114c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b0, Hi: 0x115b1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b8, Hi: 0x115bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x115be, Hi: 0x115be, Stride: 0x1},
+		unicode.Range32{Lo: 0x11630, Hi: 0x11632, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163b, Hi: 0x1163c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163e, Hi: 0x1163e, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ac, Hi: 0x116ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ae, Hi: 0x116af, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b6, Hi: 0x116b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11720, Hi: 0x11721, Stride: 0x1},
+		unicode.Range32{Lo: 0x11726, Hi: 0x11726, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c2f, Hi: 0x11c2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3e, Hi: 0x11c3e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ca9, Hi: 0x11ca9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb1, Hi: 0x11cb1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb4, Hi: 0x11cb4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f51, Hi: 0x16f7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d166, Hi: 0x1d166, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16d, Hi: 0x1d16d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeT = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x11a8, Hi: 0x11ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7cb, Hi: 0xd7fb, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeV = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x1160, Hi: 0x11a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7b0, Hi: 0xd7c6, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeZWJ = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x200d, Hi: 0x200d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+type _GraphemeRuneRange unicode.RangeTable
+
+func _GraphemeRuneType(r rune) *_GraphemeRuneRange {
+	switch {
+	case unicode.Is(_GraphemeCR, r):
+		return (*_GraphemeRuneRange)(_GraphemeCR)
+	case unicode.Is(_GraphemeControl, r):
+		return (*_GraphemeRuneRange)(_GraphemeControl)
+	case unicode.Is(_GraphemeE_Base, r):
+		return (*_GraphemeRuneRange)(_GraphemeE_Base)
+	case unicode.Is(_GraphemeE_Base_GAZ, r):
+		return (*_GraphemeRuneRange)(_GraphemeE_Base_GAZ)
+	case unicode.Is(_GraphemeE_Modifier, r):
+		return (*_GraphemeRuneRange)(_GraphemeE_Modifier)
+	case unicode.Is(_GraphemeExtend, r):
+		return (*_GraphemeRuneRange)(_GraphemeExtend)
+	case unicode.Is(_GraphemeGlue_After_Zwj, r):
+		return (*_GraphemeRuneRange)(_GraphemeGlue_After_Zwj)
+	case unicode.Is(_GraphemeL, r):
+		return (*_GraphemeRuneRange)(_GraphemeL)
+	case unicode.Is(_GraphemeLF, r):
+		return (*_GraphemeRuneRange)(_GraphemeLF)
+	case unicode.Is(_GraphemeLV, r):
+		return (*_GraphemeRuneRange)(_GraphemeLV)
+	case unicode.Is(_GraphemeLVT, r):
+		return (*_GraphemeRuneRange)(_GraphemeLVT)
+	case unicode.Is(_GraphemePrepend, r):
+		return (*_GraphemeRuneRange)(_GraphemePrepend)
+	case unicode.Is(_GraphemeRegional_Indicator, r):
+		return (*_GraphemeRuneRange)(_GraphemeRegional_Indicator)
+	case unicode.Is(_GraphemeSpacingMark, r):
+		return (*_GraphemeRuneRange)(_GraphemeSpacingMark)
+	case unicode.Is(_GraphemeT, r):
+		return (*_GraphemeRuneRange)(_GraphemeT)
+	case unicode.Is(_GraphemeV, r):
+		return (*_GraphemeRuneRange)(_GraphemeV)
+	case unicode.Is(_GraphemeZWJ, r):
+		return (*_GraphemeRuneRange)(_GraphemeZWJ)
+	default:
+		return nil
+	}
+}
+func (rng *_GraphemeRuneRange) String() string {
+	switch (*unicode.RangeTable)(rng) {
+	case _GraphemeCR:
+		return "CR"
+	case _GraphemeControl:
+		return "Control"
+	case _GraphemeE_Base:
+		return "E_Base"
+	case _GraphemeE_Base_GAZ:
+		return "E_Base_GAZ"
+	case _GraphemeE_Modifier:
+		return "E_Modifier"
+	case _GraphemeExtend:
+		return "Extend"
+	case _GraphemeGlue_After_Zwj:
+		return "Glue_After_Zwj"
+	case _GraphemeL:
+		return "L"
+	case _GraphemeLF:
+		return "LF"
+	case _GraphemeLV:
+		return "LV"
+	case _GraphemeLVT:
+		return "LVT"
+	case _GraphemePrepend:
+		return "Prepend"
+	case _GraphemeRegional_Indicator:
+		return "Regional_Indicator"
+	case _GraphemeSpacingMark:
+		return "SpacingMark"
+	case _GraphemeT:
+		return "T"
+	case _GraphemeV:
+		return "V"
+	case _GraphemeZWJ:
+		return "ZWJ"
+	default:
+		return "Other"
+	}
+}
+
+var _WordALetter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x41, Hi: 0x5a, Stride: 0x1},
+		unicode.Range16{Lo: 0x61, Hi: 0x7a, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa, Hi: 0xaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5, Hi: 0xb5, Stride: 0x1},
+		unicode.Range16{Lo: 0xba, Hi: 0xba, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0, Hi: 0xd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd8, Hi: 0xf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8, Hi: 0x1ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bb, Hi: 0x1bb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bc, Hi: 0x1bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c0, Hi: 0x1c3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4, Hi: 0x293, Stride: 0x1},
+		unicode.Range16{Lo: 0x294, Hi: 0x294, Stride: 0x1},
+		unicode.Range16{Lo: 0x295, Hi: 0x2af, Stride: 0x1},
+		unicode.Range16{Lo: 0x2b0, Hi: 0x2c1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6, Hi: 0x2d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0, Hi: 0x2e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ec, Hi: 0x2ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ee, Hi: 0x2ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x370, Hi: 0x373, Stride: 0x1},
+		unicode.Range16{Lo: 0x374, Hi: 0x374, Stride: 0x1},
+		unicode.Range16{Lo: 0x376, Hi: 0x377, Stride: 0x1},
+		unicode.Range16{Lo: 0x37a, Hi: 0x37a, Stride: 0x1},
+		unicode.Range16{Lo: 0x37b, Hi: 0x37d, Stride: 0x1},
+		unicode.Range16{Lo: 0x37f, Hi: 0x37f, Stride: 0x1},
+		unicode.Range16{Lo: 0x386, Hi: 0x386, Stride: 0x1},
+		unicode.Range16{Lo: 0x388, Hi: 0x38a, Stride: 0x1},
+		unicode.Range16{Lo: 0x38c, Hi: 0x38c, Stride: 0x1},
+		unicode.Range16{Lo: 0x38e, Hi: 0x3a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3a3, Hi: 0x3f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f7, Hi: 0x481, Stride: 0x1},
+		unicode.Range16{Lo: 0x48a, Hi: 0x52f, Stride: 0x1},
+		unicode.Range16{Lo: 0x531, Hi: 0x556, Stride: 0x1},
+		unicode.Range16{Lo: 0x559, Hi: 0x559, Stride: 0x1},
+		unicode.Range16{Lo: 0x561, Hi: 0x587, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f3, Hi: 0x5f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x620, Hi: 0x63f, Stride: 0x1},
+		unicode.Range16{Lo: 0x640, Hi: 0x640, Stride: 0x1},
+		unicode.Range16{Lo: 0x641, Hi: 0x64a, Stride: 0x1},
+		unicode.Range16{Lo: 0x66e, Hi: 0x66f, Stride: 0x1},
+		unicode.Range16{Lo: 0x671, Hi: 0x6d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d5, Hi: 0x6d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e5, Hi: 0x6e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ee, Hi: 0x6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x6fa, Hi: 0x6fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ff, Hi: 0x6ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x710, Hi: 0x710, Stride: 0x1},
+		unicode.Range16{Lo: 0x712, Hi: 0x72f, Stride: 0x1},
+		unicode.Range16{Lo: 0x74d, Hi: 0x7a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7b1, Hi: 0x7b1, Stride: 0x1},
+		unicode.Range16{Lo: 0x7ca, Hi: 0x7ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f4, Hi: 0x7f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7fa, Hi: 0x7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x800, Hi: 0x815, Stride: 0x1},
+		unicode.Range16{Lo: 0x81a, Hi: 0x81a, Stride: 0x1},
+		unicode.Range16{Lo: 0x824, Hi: 0x824, Stride: 0x1},
+		unicode.Range16{Lo: 0x828, Hi: 0x828, Stride: 0x1},
+		unicode.Range16{Lo: 0x840, Hi: 0x858, Stride: 0x1},
+		unicode.Range16{Lo: 0x8a0, Hi: 0x8b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x8b6, Hi: 0x8bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x904, Hi: 0x939, Stride: 0x1},
+		unicode.Range16{Lo: 0x93d, Hi: 0x93d, Stride: 0x1},
+		unicode.Range16{Lo: 0x950, Hi: 0x950, Stride: 0x1},
+		unicode.Range16{Lo: 0x958, Hi: 0x961, Stride: 0x1},
+		unicode.Range16{Lo: 0x971, Hi: 0x971, Stride: 0x1},
+		unicode.Range16{Lo: 0x972, Hi: 0x980, Stride: 0x1},
+		unicode.Range16{Lo: 0x985, Hi: 0x98c, Stride: 0x1},
+		unicode.Range16{Lo: 0x98f, Hi: 0x990, Stride: 0x1},
+		unicode.Range16{Lo: 0x993, Hi: 0x9a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9aa, Hi: 0x9b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b2, Hi: 0x9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b6, Hi: 0x9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bd, Hi: 0x9bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9ce, Hi: 0x9ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x9dc, Hi: 0x9dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9df, Hi: 0x9e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x9f0, Hi: 0x9f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa05, Hi: 0xa0a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa0f, Hi: 0xa10, Stride: 0x1},
+		unicode.Range16{Lo: 0xa13, Hi: 0xa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xa2a, Hi: 0xa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xa32, Hi: 0xa33, Stride: 0x1},
+		unicode.Range16{Lo: 0xa35, Hi: 0xa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xa38, Hi: 0xa39, Stride: 0x1},
+		unicode.Range16{Lo: 0xa59, Hi: 0xa5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa5e, Hi: 0xa5e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72, Hi: 0xa74, Stride: 0x1},
+		unicode.Range16{Lo: 0xa85, Hi: 0xa8d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f, Hi: 0xa91, Stride: 0x1},
+		unicode.Range16{Lo: 0xa93, Hi: 0xaa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaa, Hi: 0xab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xab2, Hi: 0xab3, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5, Hi: 0xab9, Stride: 0x1},
+		unicode.Range16{Lo: 0xabd, Hi: 0xabd, Stride: 0x1},
+		unicode.Range16{Lo: 0xad0, Hi: 0xad0, Stride: 0x1},
+		unicode.Range16{Lo: 0xae0, Hi: 0xae1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9, Hi: 0xaf9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb05, Hi: 0xb0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0f, Hi: 0xb10, Stride: 0x1},
+		unicode.Range16{Lo: 0xb13, Hi: 0xb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2a, Hi: 0xb30, Stride: 0x1},
+		unicode.Range16{Lo: 0xb32, Hi: 0xb33, Stride: 0x1},
+		unicode.Range16{Lo: 0xb35, Hi: 0xb39, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3d, Hi: 0xb3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5c, Hi: 0xb5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f, Hi: 0xb61, Stride: 0x1},
+		unicode.Range16{Lo: 0xb71, Hi: 0xb71, Stride: 0x1},
+		unicode.Range16{Lo: 0xb83, Hi: 0xb83, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85, Hi: 0xb8a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e, Hi: 0xb90, Stride: 0x1},
+		unicode.Range16{Lo: 0xb92, Hi: 0xb95, Stride: 0x1},
+		unicode.Range16{Lo: 0xb99, Hi: 0xb9a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c, Hi: 0xb9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e, Hi: 0xb9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xba3, Hi: 0xba4, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8, Hi: 0xbaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae, Hi: 0xbb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd0, Hi: 0xbd0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc05, Hi: 0xc0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e, Hi: 0xc10, Stride: 0x1},
+		unicode.Range16{Lo: 0xc12, Hi: 0xc28, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a, Hi: 0xc39, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d, Hi: 0xc3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc58, Hi: 0xc5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xc60, Hi: 0xc61, Stride: 0x1},
+		unicode.Range16{Lo: 0xc80, Hi: 0xc80, Stride: 0x1},
+		unicode.Range16{Lo: 0xc85, Hi: 0xc8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e, Hi: 0xc90, Stride: 0x1},
+		unicode.Range16{Lo: 0xc92, Hi: 0xca8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa, Hi: 0xcb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb5, Hi: 0xcb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd, Hi: 0xcbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde, Hi: 0xcde, Stride: 0x1},
+		unicode.Range16{Lo: 0xce0, Hi: 0xce1, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1, Hi: 0xcf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xd05, Hi: 0xd0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0e, Hi: 0xd10, Stride: 0x1},
+		unicode.Range16{Lo: 0xd12, Hi: 0xd3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d, Hi: 0xd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e, Hi: 0xd4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xd54, Hi: 0xd56, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5f, Hi: 0xd61, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7a, Hi: 0xd7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd85, Hi: 0xd96, Stride: 0x1},
+		unicode.Range16{Lo: 0xd9a, Hi: 0xdb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdb3, Hi: 0xdbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xdbd, Hi: 0xdbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xdc0, Hi: 0xdc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xf00, Hi: 0xf00, Stride: 0x1},
+		unicode.Range16{Lo: 0xf40, Hi: 0xf47, Stride: 0x1},
+		unicode.Range16{Lo: 0xf49, Hi: 0xf6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xf88, Hi: 0xf8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x10a0, Hi: 0x10c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x10c7, Hi: 0x10c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x10cd, Hi: 0x10cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x10d0, Hi: 0x10fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fc, Hi: 0x10fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fd, Hi: 0x1248, Stride: 0x1},
+		unicode.Range16{Lo: 0x124a, Hi: 0x124d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1250, Hi: 0x1256, Stride: 0x1},
+		unicode.Range16{Lo: 0x1258, Hi: 0x1258, Stride: 0x1},
+		unicode.Range16{Lo: 0x125a, Hi: 0x125d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1260, Hi: 0x1288, Stride: 0x1},
+		unicode.Range16{Lo: 0x128a, Hi: 0x128d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1290, Hi: 0x12b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b2, Hi: 0x12b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b8, Hi: 0x12be, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c0, Hi: 0x12c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c2, Hi: 0x12c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c8, Hi: 0x12d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x12d8, Hi: 0x1310, Stride: 0x1},
+		unicode.Range16{Lo: 0x1312, Hi: 0x1315, Stride: 0x1},
+		unicode.Range16{Lo: 0x1318, Hi: 0x135a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1380, Hi: 0x138f, Stride: 0x1},
+		unicode.Range16{Lo: 0x13a0, Hi: 0x13f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x13f8, Hi: 0x13fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1401, Hi: 0x166c, Stride: 0x1},
+		unicode.Range16{Lo: 0x166f, Hi: 0x167f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1681, Hi: 0x169a, Stride: 0x1},
+		unicode.Range16{Lo: 0x16a0, Hi: 0x16ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x16ee, Hi: 0x16f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x16f1, Hi: 0x16f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1700, Hi: 0x170c, Stride: 0x1},
+		unicode.Range16{Lo: 0x170e, Hi: 0x1711, Stride: 0x1},
+		unicode.Range16{Lo: 0x1720, Hi: 0x1731, Stride: 0x1},
+		unicode.Range16{Lo: 0x1740, Hi: 0x1751, Stride: 0x1},
+		unicode.Range16{Lo: 0x1760, Hi: 0x176c, Stride: 0x1},
+		unicode.Range16{Lo: 0x176e, Hi: 0x1770, Stride: 0x1},
+		unicode.Range16{Lo: 0x1820, Hi: 0x1842, Stride: 0x1},
+		unicode.Range16{Lo: 0x1843, Hi: 0x1843, Stride: 0x1},
+		unicode.Range16{Lo: 0x1844, Hi: 0x1877, Stride: 0x1},
+		unicode.Range16{Lo: 0x1880, Hi: 0x1884, Stride: 0x1},
+		unicode.Range16{Lo: 0x1887, Hi: 0x18a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x18aa, Hi: 0x18aa, Stride: 0x1},
+		unicode.Range16{Lo: 0x18b0, Hi: 0x18f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1900, Hi: 0x191e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a00, Hi: 0x1a16, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b05, Hi: 0x1b33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b45, Hi: 0x1b4b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b83, Hi: 0x1ba0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bae, Hi: 0x1baf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bba, Hi: 0x1be5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c00, Hi: 0x1c23, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4d, Hi: 0x1c4f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c5a, Hi: 0x1c77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c78, Hi: 0x1c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c80, Hi: 0x1c88, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce9, Hi: 0x1cec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cee, Hi: 0x1cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf5, Hi: 0x1cf6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d00, Hi: 0x1d2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d2c, Hi: 0x1d6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d6b, Hi: 0x1d77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d78, Hi: 0x1d78, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d79, Hi: 0x1d9a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d9b, Hi: 0x1dbf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e00, Hi: 0x1f15, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f18, Hi: 0x1f1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f20, Hi: 0x1f45, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f48, Hi: 0x1f4d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f50, Hi: 0x1f57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f59, Hi: 0x1f59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5b, Hi: 0x1f5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5d, Hi: 0x1f5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5f, Hi: 0x1f7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f80, Hi: 0x1fb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb6, Hi: 0x1fbc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fbe, Hi: 0x1fbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc2, Hi: 0x1fc4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc6, Hi: 0x1fcc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd0, Hi: 0x1fd3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd6, Hi: 0x1fdb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe0, Hi: 0x1fec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff2, Hi: 0x1ff4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff6, Hi: 0x1ffc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2071, Hi: 0x2071, Stride: 0x1},
+		unicode.Range16{Lo: 0x207f, Hi: 0x207f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2090, Hi: 0x209c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2102, Hi: 0x2102, Stride: 0x1},
+		unicode.Range16{Lo: 0x2107, Hi: 0x2107, Stride: 0x1},
+		unicode.Range16{Lo: 0x210a, Hi: 0x2113, Stride: 0x1},
+		unicode.Range16{Lo: 0x2115, Hi: 0x2115, Stride: 0x1},
+		unicode.Range16{Lo: 0x2119, Hi: 0x211d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2124, Hi: 0x2124, Stride: 0x1},
+		unicode.Range16{Lo: 0x2126, Hi: 0x2126, Stride: 0x1},
+		unicode.Range16{Lo: 0x2128, Hi: 0x2128, Stride: 0x1},
+		unicode.Range16{Lo: 0x212a, Hi: 0x212d, Stride: 0x1},
+		unicode.Range16{Lo: 0x212f, Hi: 0x2134, Stride: 0x1},
+		unicode.Range16{Lo: 0x2135, Hi: 0x2138, Stride: 0x1},
+		unicode.Range16{Lo: 0x2139, Hi: 0x2139, Stride: 0x1},
+		unicode.Range16{Lo: 0x213c, Hi: 0x213f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2145, Hi: 0x2149, Stride: 0x1},
+		unicode.Range16{Lo: 0x214e, Hi: 0x214e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2160, Hi: 0x2182, Stride: 0x1},
+		unicode.Range16{Lo: 0x2183, Hi: 0x2184, Stride: 0x1},
+		unicode.Range16{Lo: 0x2185, Hi: 0x2188, Stride: 0x1},
+		unicode.Range16{Lo: 0x24b6, Hi: 0x24e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c00, Hi: 0x2c2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c30, Hi: 0x2c5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c60, Hi: 0x2c7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7c, Hi: 0x2c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7e, Hi: 0x2ce4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ceb, Hi: 0x2cee, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cf2, Hi: 0x2cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d00, Hi: 0x2d25, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d27, Hi: 0x2d27, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d2d, Hi: 0x2d2d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d30, Hi: 0x2d67, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d6f, Hi: 0x2d6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d80, Hi: 0x2d96, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da0, Hi: 0x2da6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da8, Hi: 0x2dae, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db0, Hi: 0x2db6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db8, Hi: 0x2dbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc0, Hi: 0x2dc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc8, Hi: 0x2dce, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd0, Hi: 0x2dd6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd8, Hi: 0x2dde, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e2f, Hi: 0x2e2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3005, Hi: 0x3005, Stride: 0x1},
+		unicode.Range16{Lo: 0x303b, Hi: 0x303b, Stride: 0x1},
+		unicode.Range16{Lo: 0x303c, Hi: 0x303c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3105, Hi: 0x312d, Stride: 0x1},
+		unicode.Range16{Lo: 0x3131, Hi: 0x318e, Stride: 0x1},
+		unicode.Range16{Lo: 0x31a0, Hi: 0x31ba, Stride: 0x1},
+		unicode.Range16{Lo: 0xa000, Hi: 0xa014, Stride: 0x1},
+		unicode.Range16{Lo: 0xa015, Hi: 0xa015, Stride: 0x1},
+		unicode.Range16{Lo: 0xa016, Hi: 0xa48c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4d0, Hi: 0xa4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4f8, Hi: 0xa4fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa500, Hi: 0xa60b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa60c, Hi: 0xa60c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa610, Hi: 0xa61f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa62a, Hi: 0xa62b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa640, Hi: 0xa66d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66e, Hi: 0xa66e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa67f, Hi: 0xa67f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa680, Hi: 0xa69b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69c, Hi: 0xa69d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6a0, Hi: 0xa6e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6e6, Hi: 0xa6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa717, Hi: 0xa71f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa722, Hi: 0xa76f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa770, Hi: 0xa770, Stride: 0x1},
+		unicode.Range16{Lo: 0xa771, Hi: 0xa787, Stride: 0x1},
+		unicode.Range16{Lo: 0xa788, Hi: 0xa788, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78b, Hi: 0xa78e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78f, Hi: 0xa78f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa790, Hi: 0xa7ae, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b0, Hi: 0xa7b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f7, Hi: 0xa7f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f8, Hi: 0xa7f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fa, Hi: 0xa7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fb, Hi: 0xa801, Stride: 0x1},
+		unicode.Range16{Lo: 0xa803, Hi: 0xa805, Stride: 0x1},
+		unicode.Range16{Lo: 0xa807, Hi: 0xa80a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80c, Hi: 0xa822, Stride: 0x1},
+		unicode.Range16{Lo: 0xa840, Hi: 0xa873, Stride: 0x1},
+		unicode.Range16{Lo: 0xa882, Hi: 0xa8b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f2, Hi: 0xa8f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fb, Hi: 0xa8fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fd, Hi: 0xa8fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa90a, Hi: 0xa925, Stride: 0x1},
+		unicode.Range16{Lo: 0xa930, Hi: 0xa946, Stride: 0x1},
+		unicode.Range16{Lo: 0xa960, Hi: 0xa97c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa984, Hi: 0xa9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9cf, Hi: 0xa9cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa00, Hi: 0xaa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa40, Hi: 0xaa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa44, Hi: 0xaa4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaae0, Hi: 0xaaea, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf2, Hi: 0xaaf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf3, Hi: 0xaaf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xab01, Hi: 0xab06, Stride: 0x1},
+		unicode.Range16{Lo: 0xab09, Hi: 0xab0e, Stride: 0x1},
+		unicode.Range16{Lo: 0xab11, Hi: 0xab16, Stride: 0x1},
+		unicode.Range16{Lo: 0xab20, Hi: 0xab26, Stride: 0x1},
+		unicode.Range16{Lo: 0xab28, Hi: 0xab2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xab30, Hi: 0xab5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5c, Hi: 0xab5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xab60, Hi: 0xab65, Stride: 0x1},
+		unicode.Range16{Lo: 0xab70, Hi: 0xabbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc0, Hi: 0xabe2, Stride: 0x1},
+		unicode.Range16{Lo: 0xac00, Hi: 0xd7a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7b0, Hi: 0xd7c6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7cb, Hi: 0xd7fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb00, Hi: 0xfb06, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb13, Hi: 0xfb17, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb50, Hi: 0xfbb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xfbd3, Hi: 0xfd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd50, Hi: 0xfd8f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd92, Hi: 0xfdc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xfdf0, Hi: 0xfdfb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe70, Hi: 0xfe74, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe76, Hi: 0xfefc, Stride: 0x1},
+		unicode.Range16{Lo: 0xff21, Hi: 0xff3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xff41, Hi: 0xff5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xffa0, Hi: 0xffbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xffc2, Hi: 0xffc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffca, Hi: 0xffcf, Stride: 0x1},
+		unicode.Range16{Lo: 0xffd2, Hi: 0xffd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffda, Hi: 0xffdc, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10000, Hi: 0x1000b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1000d, Hi: 0x10026, Stride: 0x1},
+		unicode.Range32{Lo: 0x10028, Hi: 0x1003a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003c, Hi: 0x1003d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003f, Hi: 0x1004d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10050, Hi: 0x1005d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10080, Hi: 0x100fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x10140, Hi: 0x10174, Stride: 0x1},
+		unicode.Range32{Lo: 0x10280, Hi: 0x1029c, Stride: 0x1},
+		unicode.Range32{Lo: 0x102a0, Hi: 0x102d0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10300, Hi: 0x1031f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10330, Hi: 0x10340, Stride: 0x1},
+		unicode.Range32{Lo: 0x10341, Hi: 0x10341, Stride: 0x1},
+		unicode.Range32{Lo: 0x10342, Hi: 0x10349, Stride: 0x1},
+		unicode.Range32{Lo: 0x1034a, Hi: 0x1034a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10350, Hi: 0x10375, Stride: 0x1},
+		unicode.Range32{Lo: 0x10380, Hi: 0x1039d, Stride: 0x1},
+		unicode.Range32{Lo: 0x103a0, Hi: 0x103c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x103c8, Hi: 0x103cf, Stride: 0x1},
+		unicode.Range32{Lo: 0x103d1, Hi: 0x103d5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10400, Hi: 0x1044f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10450, Hi: 0x1049d, Stride: 0x1},
+		unicode.Range32{Lo: 0x104b0, Hi: 0x104d3, Stride: 0x1},
+		unicode.Range32{Lo: 0x104d8, Hi: 0x104fb, Stride: 0x1},
+		unicode.Range32{Lo: 0x10500, Hi: 0x10527, Stride: 0x1},
+		unicode.Range32{Lo: 0x10530, Hi: 0x10563, Stride: 0x1},
+		unicode.Range32{Lo: 0x10600, Hi: 0x10736, Stride: 0x1},
+		unicode.Range32{Lo: 0x10740, Hi: 0x10755, Stride: 0x1},
+		unicode.Range32{Lo: 0x10760, Hi: 0x10767, Stride: 0x1},
+		unicode.Range32{Lo: 0x10800, Hi: 0x10805, Stride: 0x1},
+		unicode.Range32{Lo: 0x10808, Hi: 0x10808, Stride: 0x1},
+		unicode.Range32{Lo: 0x1080a, Hi: 0x10835, Stride: 0x1},
+		unicode.Range32{Lo: 0x10837, Hi: 0x10838, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083c, Hi: 0x1083c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083f, Hi: 0x10855, Stride: 0x1},
+		unicode.Range32{Lo: 0x10860, Hi: 0x10876, Stride: 0x1},
+		unicode.Range32{Lo: 0x10880, Hi: 0x1089e, Stride: 0x1},
+		unicode.Range32{Lo: 0x108e0, Hi: 0x108f2, Stride: 0x1},
+		unicode.Range32{Lo: 0x108f4, Hi: 0x108f5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10900, Hi: 0x10915, Stride: 0x1},
+		unicode.Range32{Lo: 0x10920, Hi: 0x10939, Stride: 0x1},
+		unicode.Range32{Lo: 0x10980, Hi: 0x109b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x109be, Hi: 0x109bf, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a00, Hi: 0x10a00, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a10, Hi: 0x10a13, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a15, Hi: 0x10a17, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a19, Hi: 0x10a33, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a60, Hi: 0x10a7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a80, Hi: 0x10a9c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac0, Hi: 0x10ac7, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac9, Hi: 0x10ae4, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b00, Hi: 0x10b35, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b40, Hi: 0x10b55, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b60, Hi: 0x10b72, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b80, Hi: 0x10b91, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c00, Hi: 0x10c48, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c80, Hi: 0x10cb2, Stride: 0x1},
+		unicode.Range32{Lo: 0x10cc0, Hi: 0x10cf2, Stride: 0x1},
+		unicode.Range32{Lo: 0x11003, Hi: 0x11037, Stride: 0x1},
+		unicode.Range32{Lo: 0x11083, Hi: 0x110af, Stride: 0x1},
+		unicode.Range32{Lo: 0x110d0, Hi: 0x110e8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11103, Hi: 0x11126, Stride: 0x1},
+		unicode.Range32{Lo: 0x11150, Hi: 0x11172, Stride: 0x1},
+		unicode.Range32{Lo: 0x11176, Hi: 0x11176, Stride: 0x1},
+		unicode.Range32{Lo: 0x11183, Hi: 0x111b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c1, Hi: 0x111c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x111da, Hi: 0x111da, Stride: 0x1},
+		unicode.Range32{Lo: 0x111dc, Hi: 0x111dc, Stride: 0x1},
+		unicode.Range32{Lo: 0x11200, Hi: 0x11211, Stride: 0x1},
+		unicode.Range32{Lo: 0x11213, Hi: 0x1122b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11280, Hi: 0x11286, Stride: 0x1},
+		unicode.Range32{Lo: 0x11288, Hi: 0x11288, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128a, Hi: 0x1128d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128f, Hi: 0x1129d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1129f, Hi: 0x112a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x112b0, Hi: 0x112de, Stride: 0x1},
+		unicode.Range32{Lo: 0x11305, Hi: 0x1130c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1130f, Hi: 0x11310, Stride: 0x1},
+		unicode.Range32{Lo: 0x11313, Hi: 0x11328, Stride: 0x1},
+		unicode.Range32{Lo: 0x1132a, Hi: 0x11330, Stride: 0x1},
+		unicode.Range32{Lo: 0x11332, Hi: 0x11333, Stride: 0x1},
+		unicode.Range32{Lo: 0x11335, Hi: 0x11339, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133d, Hi: 0x1133d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11350, Hi: 0x11350, Stride: 0x1},
+		unicode.Range32{Lo: 0x1135d, Hi: 0x11361, Stride: 0x1},
+		unicode.Range32{Lo: 0x11400, Hi: 0x11434, Stride: 0x1},
+		unicode.Range32{Lo: 0x11447, Hi: 0x1144a, Stride: 0x1},
+		unicode.Range32{Lo: 0x11480, Hi: 0x114af, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c4, Hi: 0x114c5, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c7, Hi: 0x114c7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11580, Hi: 0x115ae, Stride: 0x1},
+		unicode.Range32{Lo: 0x115d8, Hi: 0x115db, Stride: 0x1},
+		unicode.Range32{Lo: 0x11600, Hi: 0x1162f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11644, Hi: 0x11644, Stride: 0x1},
+		unicode.Range32{Lo: 0x11680, Hi: 0x116aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x118a0, Hi: 0x118df, Stride: 0x1},
+		unicode.Range32{Lo: 0x118ff, Hi: 0x118ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ac0, Hi: 0x11af8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c00, Hi: 0x11c08, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c0a, Hi: 0x11c2e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c40, Hi: 0x11c40, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c72, Hi: 0x11c8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x12000, Hi: 0x12399, Stride: 0x1},
+		unicode.Range32{Lo: 0x12400, Hi: 0x1246e, Stride: 0x1},
+		unicode.Range32{Lo: 0x12480, Hi: 0x12543, Stride: 0x1},
+		unicode.Range32{Lo: 0x13000, Hi: 0x1342e, Stride: 0x1},
+		unicode.Range32{Lo: 0x14400, Hi: 0x14646, Stride: 0x1},
+		unicode.Range32{Lo: 0x16800, Hi: 0x16a38, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a40, Hi: 0x16a5e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16ad0, Hi: 0x16aed, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b00, Hi: 0x16b2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b40, Hi: 0x16b43, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b63, Hi: 0x16b77, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b7d, Hi: 0x16b8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f00, Hi: 0x16f44, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f50, Hi: 0x16f50, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f93, Hi: 0x16f9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16fe0, Hi: 0x16fe0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc00, Hi: 0x1bc6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc70, Hi: 0x1bc7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc80, Hi: 0x1bc88, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc90, Hi: 0x1bc99, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d400, Hi: 0x1d454, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d456, Hi: 0x1d49c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d49e, Hi: 0x1d49f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a2, Hi: 0x1d4a2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a5, Hi: 0x1d4a6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a9, Hi: 0x1d4ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4ae, Hi: 0x1d4b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bb, Hi: 0x1d4bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bd, Hi: 0x1d4c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4c5, Hi: 0x1d505, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d507, Hi: 0x1d50a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d50d, Hi: 0x1d514, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d516, Hi: 0x1d51c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d51e, Hi: 0x1d539, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d53b, Hi: 0x1d53e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d540, Hi: 0x1d544, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d546, Hi: 0x1d546, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d54a, Hi: 0x1d550, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d552, Hi: 0x1d6a5, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6a8, Hi: 0x1d6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6c2, Hi: 0x1d6da, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6dc, Hi: 0x1d6fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6fc, Hi: 0x1d714, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d716, Hi: 0x1d734, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d736, Hi: 0x1d74e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d750, Hi: 0x1d76e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d770, Hi: 0x1d788, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d78a, Hi: 0x1d7a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7aa, Hi: 0x1d7c2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7c4, Hi: 0x1d7cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e800, Hi: 0x1e8c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e900, Hi: 0x1e943, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee00, Hi: 0x1ee03, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee05, Hi: 0x1ee1f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee21, Hi: 0x1ee22, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee24, Hi: 0x1ee24, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee27, Hi: 0x1ee27, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee29, Hi: 0x1ee32, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee34, Hi: 0x1ee37, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee39, Hi: 0x1ee39, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee3b, Hi: 0x1ee3b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee42, Hi: 0x1ee42, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee47, Hi: 0x1ee47, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee49, Hi: 0x1ee49, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4b, Hi: 0x1ee4b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4d, Hi: 0x1ee4f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee51, Hi: 0x1ee52, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee54, Hi: 0x1ee54, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee57, Hi: 0x1ee57, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee59, Hi: 0x1ee59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5b, Hi: 0x1ee5b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5d, Hi: 0x1ee5d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5f, Hi: 0x1ee5f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee61, Hi: 0x1ee62, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee64, Hi: 0x1ee64, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee67, Hi: 0x1ee6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee6c, Hi: 0x1ee72, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee74, Hi: 0x1ee77, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee79, Hi: 0x1ee7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee7e, Hi: 0x1ee7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee80, Hi: 0x1ee89, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee8b, Hi: 0x1ee9b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea1, Hi: 0x1eea3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea5, Hi: 0x1eea9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eeab, Hi: 0x1eebb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f130, Hi: 0x1f149, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f150, Hi: 0x1f169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f170, Hi: 0x1f189, Stride: 0x1},
+	},
+	LatinOffset: 7,
+}
+
+var _WordCR = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xd, Hi: 0xd, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordDouble_Quote = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x22, Hi: 0x22, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordE_Base = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x261d, Hi: 0x261d, Stride: 0x1},
+		unicode.Range16{Lo: 0x26f9, Hi: 0x26f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x270a, Hi: 0x270d, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f385, Hi: 0x1f385, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3c3, Hi: 0x1f3c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3ca, Hi: 0x1f3cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f442, Hi: 0x1f443, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f446, Hi: 0x1f450, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f46e, Hi: 0x1f46e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f470, Hi: 0x1f478, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f47c, Hi: 0x1f47c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f481, Hi: 0x1f483, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f485, Hi: 0x1f487, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f4aa, Hi: 0x1f4aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f575, Hi: 0x1f575, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f57a, Hi: 0x1f57a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f590, Hi: 0x1f590, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f595, Hi: 0x1f596, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f645, Hi: 0x1f647, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f64b, Hi: 0x1f64f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6a3, Hi: 0x1f6a3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6b4, Hi: 0x1f6b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6c0, Hi: 0x1f6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f918, Hi: 0x1f91e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f926, Hi: 0x1f926, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f930, Hi: 0x1f930, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f933, Hi: 0x1f939, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f93c, Hi: 0x1f93e, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordE_Base_GAZ = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f466, Hi: 0x1f469, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordE_Modifier = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f3fb, Hi: 0x1f3ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordExtend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x300, Hi: 0x36f, Stride: 0x1},
+		unicode.Range16{Lo: 0x483, Hi: 0x487, Stride: 0x1},
+		unicode.Range16{Lo: 0x488, Hi: 0x489, Stride: 0x1},
+		unicode.Range16{Lo: 0x591, Hi: 0x5bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x5bf, Hi: 0x5bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c1, Hi: 0x5c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c4, Hi: 0x5c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c7, Hi: 0x5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x610, Hi: 0x61a, Stride: 0x1},
+		unicode.Range16{Lo: 0x64b, Hi: 0x65f, Stride: 0x1},
+		unicode.Range16{Lo: 0x670, Hi: 0x670, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d6, Hi: 0x6dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6df, Hi: 0x6e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e7, Hi: 0x6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ea, Hi: 0x6ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x711, Hi: 0x711, Stride: 0x1},
+		unicode.Range16{Lo: 0x730, Hi: 0x74a, Stride: 0x1},
+		unicode.Range16{Lo: 0x7a6, Hi: 0x7b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x7eb, Hi: 0x7f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x816, Hi: 0x819, Stride: 0x1},
+		unicode.Range16{Lo: 0x81b, Hi: 0x823, Stride: 0x1},
+		unicode.Range16{Lo: 0x825, Hi: 0x827, Stride: 0x1},
+		unicode.Range16{Lo: 0x829, Hi: 0x82d, Stride: 0x1},
+		unicode.Range16{Lo: 0x859, Hi: 0x85b, Stride: 0x1},
+		unicode.Range16{Lo: 0x8d4, Hi: 0x8e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e3, Hi: 0x902, Stride: 0x1},
+		unicode.Range16{Lo: 0x903, Hi: 0x903, Stride: 0x1},
+		unicode.Range16{Lo: 0x93a, Hi: 0x93a, Stride: 0x1},
+		unicode.Range16{Lo: 0x93b, Hi: 0x93b, Stride: 0x1},
+		unicode.Range16{Lo: 0x93c, Hi: 0x93c, Stride: 0x1},
+		unicode.Range16{Lo: 0x93e, Hi: 0x940, Stride: 0x1},
+		unicode.Range16{Lo: 0x941, Hi: 0x948, Stride: 0x1},
+		unicode.Range16{Lo: 0x949, Hi: 0x94c, Stride: 0x1},
+		unicode.Range16{Lo: 0x94d, Hi: 0x94d, Stride: 0x1},
+		unicode.Range16{Lo: 0x94e, Hi: 0x94f, Stride: 0x1},
+		unicode.Range16{Lo: 0x951, Hi: 0x957, Stride: 0x1},
+		unicode.Range16{Lo: 0x962, Hi: 0x963, Stride: 0x1},
+		unicode.Range16{Lo: 0x981, Hi: 0x981, Stride: 0x1},
+		unicode.Range16{Lo: 0x982, Hi: 0x983, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bc, Hi: 0x9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9be, Hi: 0x9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c1, Hi: 0x9c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c7, Hi: 0x9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cb, Hi: 0x9cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cd, Hi: 0x9cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9d7, Hi: 0x9d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e2, Hi: 0x9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa01, Hi: 0xa02, Stride: 0x1},
+		unicode.Range16{Lo: 0xa03, Hi: 0xa03, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3c, Hi: 0xa3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3e, Hi: 0xa40, Stride: 0x1},
+		unicode.Range16{Lo: 0xa41, Hi: 0xa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xa47, Hi: 0xa48, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4b, Hi: 0xa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa51, Hi: 0xa51, Stride: 0x1},
+		unicode.Range16{Lo: 0xa70, Hi: 0xa71, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75, Hi: 0xa75, Stride: 0x1},
+		unicode.Range16{Lo: 0xa81, Hi: 0xa82, Stride: 0x1},
+		unicode.Range16{Lo: 0xa83, Hi: 0xa83, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc, Hi: 0xabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe, Hi: 0xac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1, Hi: 0xac5, Stride: 0x1},
+		unicode.Range16{Lo: 0xac7, Hi: 0xac8, Stride: 0x1},
+		unicode.Range16{Lo: 0xac9, Hi: 0xac9, Stride: 0x1},
+		unicode.Range16{Lo: 0xacb, Hi: 0xacc, Stride: 0x1},
+		unicode.Range16{Lo: 0xacd, Hi: 0xacd, Stride: 0x1},
+		unicode.Range16{Lo: 0xae2, Hi: 0xae3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb01, Hi: 0xb01, Stride: 0x1},
+		unicode.Range16{Lo: 0xb02, Hi: 0xb03, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c, Hi: 0xb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e, Hi: 0xb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3f, Hi: 0xb3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb40, Hi: 0xb40, Stride: 0x1},
+		unicode.Range16{Lo: 0xb41, Hi: 0xb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xb47, Hi: 0xb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4b, Hi: 0xb4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4d, Hi: 0xb4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb56, Hi: 0xb56, Stride: 0x1},
+		unicode.Range16{Lo: 0xb57, Hi: 0xb57, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62, Hi: 0xb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xb82, Hi: 0xb82, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbe, Hi: 0xbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc0, Hi: 0xbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc1, Hi: 0xbc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc6, Hi: 0xbc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca, Hi: 0xbcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd, Hi: 0xbcd, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd7, Hi: 0xbd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc00, Hi: 0xc00, Stride: 0x1},
+		unicode.Range16{Lo: 0xc01, Hi: 0xc03, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3e, Hi: 0xc40, Stride: 0x1},
+		unicode.Range16{Lo: 0xc41, Hi: 0xc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xc46, Hi: 0xc48, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4a, Hi: 0xc4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc55, Hi: 0xc56, Stride: 0x1},
+		unicode.Range16{Lo: 0xc62, Hi: 0xc63, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81, Hi: 0xc81, Stride: 0x1},
+		unicode.Range16{Lo: 0xc82, Hi: 0xc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbc, Hi: 0xcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbe, Hi: 0xcbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf, Hi: 0xcbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0, Hi: 0xcc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc6, Hi: 0xcc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7, Hi: 0xcc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcca, Hi: 0xccb, Stride: 0x1},
+		unicode.Range16{Lo: 0xccc, Hi: 0xccd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5, Hi: 0xcd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xce2, Hi: 0xce3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd01, Hi: 0xd01, Stride: 0x1},
+		unicode.Range16{Lo: 0xd02, Hi: 0xd03, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3e, Hi: 0xd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xd41, Hi: 0xd44, Stride: 0x1},
+		unicode.Range16{Lo: 0xd46, Hi: 0xd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4a, Hi: 0xd4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4d, Hi: 0xd4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd57, Hi: 0xd57, Stride: 0x1},
+		unicode.Range16{Lo: 0xd62, Hi: 0xd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xd82, Hi: 0xd83, Stride: 0x1},
+		unicode.Range16{Lo: 0xdca, Hi: 0xdca, Stride: 0x1},
+		unicode.Range16{Lo: 0xdcf, Hi: 0xdd1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd2, Hi: 0xdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd6, Hi: 0xdd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd8, Hi: 0xddf, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf2, Hi: 0xdf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xe31, Hi: 0xe31, Stride: 0x1},
+		unicode.Range16{Lo: 0xe34, Hi: 0xe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe47, Hi: 0xe4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb1, Hi: 0xeb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb4, Hi: 0xeb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xebb, Hi: 0xebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xec8, Hi: 0xecd, Stride: 0x1},
+		unicode.Range16{Lo: 0xf18, Hi: 0xf19, Stride: 0x1},
+		unicode.Range16{Lo: 0xf35, Hi: 0xf35, Stride: 0x1},
+		unicode.Range16{Lo: 0xf37, Hi: 0xf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xf39, Hi: 0xf39, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3e, Hi: 0xf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf71, Hi: 0xf7e, Stride: 0x1},
+		unicode.Range16{Lo: 0xf7f, Hi: 0xf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf80, Hi: 0xf84, Stride: 0x1},
+		unicode.Range16{Lo: 0xf86, Hi: 0xf87, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8d, Hi: 0xf97, Stride: 0x1},
+		unicode.Range16{Lo: 0xf99, Hi: 0xfbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xfc6, Hi: 0xfc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x102b, Hi: 0x102c, Stride: 0x1},
+		unicode.Range16{Lo: 0x102d, Hi: 0x1030, Stride: 0x1},
+		unicode.Range16{Lo: 0x1031, Hi: 0x1031, Stride: 0x1},
+		unicode.Range16{Lo: 0x1032, Hi: 0x1037, Stride: 0x1},
+		unicode.Range16{Lo: 0x1038, Hi: 0x1038, Stride: 0x1},
+		unicode.Range16{Lo: 0x1039, Hi: 0x103a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103b, Hi: 0x103c, Stride: 0x1},
+		unicode.Range16{Lo: 0x103d, Hi: 0x103e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1056, Hi: 0x1057, Stride: 0x1},
+		unicode.Range16{Lo: 0x1058, Hi: 0x1059, Stride: 0x1},
+		unicode.Range16{Lo: 0x105e, Hi: 0x1060, Stride: 0x1},
+		unicode.Range16{Lo: 0x1062, Hi: 0x1064, Stride: 0x1},
+		unicode.Range16{Lo: 0x1067, Hi: 0x106d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1071, Hi: 0x1074, Stride: 0x1},
+		unicode.Range16{Lo: 0x1082, Hi: 0x1082, Stride: 0x1},
+		unicode.Range16{Lo: 0x1083, Hi: 0x1084, Stride: 0x1},
+		unicode.Range16{Lo: 0x1085, Hi: 0x1086, Stride: 0x1},
+		unicode.Range16{Lo: 0x1087, Hi: 0x108c, Stride: 0x1},
+		unicode.Range16{Lo: 0x108d, Hi: 0x108d, Stride: 0x1},
+		unicode.Range16{Lo: 0x108f, Hi: 0x108f, Stride: 0x1},
+		unicode.Range16{Lo: 0x109a, Hi: 0x109c, Stride: 0x1},
+		unicode.Range16{Lo: 0x109d, Hi: 0x109d, Stride: 0x1},
+		unicode.Range16{Lo: 0x135d, Hi: 0x135f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1712, Hi: 0x1714, Stride: 0x1},
+		unicode.Range16{Lo: 0x1732, Hi: 0x1734, Stride: 0x1},
+		unicode.Range16{Lo: 0x1752, Hi: 0x1753, Stride: 0x1},
+		unicode.Range16{Lo: 0x1772, Hi: 0x1773, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b4, Hi: 0x17b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b6, Hi: 0x17b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b7, Hi: 0x17bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x17be, Hi: 0x17c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c6, Hi: 0x17c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c7, Hi: 0x17c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c9, Hi: 0x17d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dd, Hi: 0x17dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x180b, Hi: 0x180d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1885, Hi: 0x1886, Stride: 0x1},
+		unicode.Range16{Lo: 0x18a9, Hi: 0x18a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1920, Hi: 0x1922, Stride: 0x1},
+		unicode.Range16{Lo: 0x1923, Hi: 0x1926, Stride: 0x1},
+		unicode.Range16{Lo: 0x1927, Hi: 0x1928, Stride: 0x1},
+		unicode.Range16{Lo: 0x1929, Hi: 0x192b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1930, Hi: 0x1931, Stride: 0x1},
+		unicode.Range16{Lo: 0x1932, Hi: 0x1932, Stride: 0x1},
+		unicode.Range16{Lo: 0x1933, Hi: 0x1938, Stride: 0x1},
+		unicode.Range16{Lo: 0x1939, Hi: 0x193b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a17, Hi: 0x1a18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a19, Hi: 0x1a1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1b, Hi: 0x1a1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a55, Hi: 0x1a55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a56, Hi: 0x1a56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a57, Hi: 0x1a57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a58, Hi: 0x1a5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a60, Hi: 0x1a60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a61, Hi: 0x1a61, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a62, Hi: 0x1a62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a63, Hi: 0x1a64, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a65, Hi: 0x1a6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6d, Hi: 0x1a72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a73, Hi: 0x1a7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a7f, Hi: 0x1a7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ab0, Hi: 0x1abd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1abe, Hi: 0x1abe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b00, Hi: 0x1b03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b04, Hi: 0x1b04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b34, Hi: 0x1b34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b35, Hi: 0x1b35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b36, Hi: 0x1b3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3b, Hi: 0x1b3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3c, Hi: 0x1b3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3d, Hi: 0x1b41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b42, Hi: 0x1b42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b43, Hi: 0x1b44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6b, Hi: 0x1b73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b80, Hi: 0x1b81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b82, Hi: 0x1b82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba1, Hi: 0x1ba1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba2, Hi: 0x1ba5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba6, Hi: 0x1ba7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba8, Hi: 0x1ba9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1baa, Hi: 0x1baa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bab, Hi: 0x1bad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be6, Hi: 0x1be6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be7, Hi: 0x1be7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be8, Hi: 0x1be9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bea, Hi: 0x1bec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bed, Hi: 0x1bed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bee, Hi: 0x1bee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bef, Hi: 0x1bf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bf2, Hi: 0x1bf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c24, Hi: 0x1c2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c2c, Hi: 0x1c33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c34, Hi: 0x1c35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c36, Hi: 0x1c37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd0, Hi: 0x1cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd4, Hi: 0x1ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce1, Hi: 0x1ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce2, Hi: 0x1ce8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ced, Hi: 0x1ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf2, Hi: 0x1cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf4, Hi: 0x1cf4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf8, Hi: 0x1cf9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc0, Hi: 0x1df5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dfb, Hi: 0x1dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x200c, Hi: 0x200c, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d0, Hi: 0x20dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20dd, Hi: 0x20e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e1, Hi: 0x20e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e2, Hi: 0x20e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e5, Hi: 0x20f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cef, Hi: 0x2cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7f, Hi: 0x2d7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2de0, Hi: 0x2dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x302a, Hi: 0x302d, Stride: 0x1},
+		unicode.Range16{Lo: 0x302e, Hi: 0x302f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3099, Hi: 0x309a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66f, Hi: 0xa66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa670, Hi: 0xa672, Stride: 0x1},
+		unicode.Range16{Lo: 0xa674, Hi: 0xa67d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69e, Hi: 0xa69f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f0, Hi: 0xa6f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa802, Hi: 0xa802, Stride: 0x1},
+		unicode.Range16{Lo: 0xa806, Hi: 0xa806, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80b, Hi: 0xa80b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa823, Hi: 0xa824, Stride: 0x1},
+		unicode.Range16{Lo: 0xa825, Hi: 0xa826, Stride: 0x1},
+		unicode.Range16{Lo: 0xa827, Hi: 0xa827, Stride: 0x1},
+		unicode.Range16{Lo: 0xa880, Hi: 0xa881, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8b4, Hi: 0xa8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8c4, Hi: 0xa8c5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8e0, Hi: 0xa8f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa926, Hi: 0xa92d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa947, Hi: 0xa951, Stride: 0x1},
+		unicode.Range16{Lo: 0xa952, Hi: 0xa953, Stride: 0x1},
+		unicode.Range16{Lo: 0xa980, Hi: 0xa982, Stride: 0x1},
+		unicode.Range16{Lo: 0xa983, Hi: 0xa983, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b3, Hi: 0xa9b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b4, Hi: 0xa9b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b6, Hi: 0xa9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9ba, Hi: 0xa9bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bc, Hi: 0xa9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bd, Hi: 0xa9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e5, Hi: 0xa9e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa29, Hi: 0xaa2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa2f, Hi: 0xaa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa31, Hi: 0xaa32, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa33, Hi: 0xaa34, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa35, Hi: 0xaa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa43, Hi: 0xaa43, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4c, Hi: 0xaa4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4d, Hi: 0xaa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7b, Hi: 0xaa7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7c, Hi: 0xaa7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7d, Hi: 0xaa7d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab0, Hi: 0xaab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab2, Hi: 0xaab4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab7, Hi: 0xaab8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaabe, Hi: 0xaabf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac1, Hi: 0xaac1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaeb, Hi: 0xaaeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaec, Hi: 0xaaed, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaee, Hi: 0xaaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf5, Hi: 0xaaf5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf6, Hi: 0xaaf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe3, Hi: 0xabe4, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe5, Hi: 0xabe5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe6, Hi: 0xabe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe8, Hi: 0xabe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe9, Hi: 0xabea, Stride: 0x1},
+		unicode.Range16{Lo: 0xabec, Hi: 0xabec, Stride: 0x1},
+		unicode.Range16{Lo: 0xabed, Hi: 0xabed, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1e, Hi: 0xfb1e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe00, Hi: 0xfe0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe20, Hi: 0xfe2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff9e, Hi: 0xff9f, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x101fd, Hi: 0x101fd, Stride: 0x1},
+		unicode.Range32{Lo: 0x102e0, Hi: 0x102e0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10376, Hi: 0x1037a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a01, Hi: 0x10a03, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a05, Hi: 0x10a06, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a0c, Hi: 0x10a0f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a38, Hi: 0x10a3a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a3f, Hi: 0x10a3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ae5, Hi: 0x10ae6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11000, Hi: 0x11000, Stride: 0x1},
+		unicode.Range32{Lo: 0x11001, Hi: 0x11001, Stride: 0x1},
+		unicode.Range32{Lo: 0x11002, Hi: 0x11002, Stride: 0x1},
+		unicode.Range32{Lo: 0x11038, Hi: 0x11046, Stride: 0x1},
+		unicode.Range32{Lo: 0x1107f, Hi: 0x11081, Stride: 0x1},
+		unicode.Range32{Lo: 0x11082, Hi: 0x11082, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b0, Hi: 0x110b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b3, Hi: 0x110b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b7, Hi: 0x110b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b9, Hi: 0x110ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x11100, Hi: 0x11102, Stride: 0x1},
+		unicode.Range32{Lo: 0x11127, Hi: 0x1112b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112c, Hi: 0x1112c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112d, Hi: 0x11134, Stride: 0x1},
+		unicode.Range32{Lo: 0x11173, Hi: 0x11173, Stride: 0x1},
+		unicode.Range32{Lo: 0x11180, Hi: 0x11181, Stride: 0x1},
+		unicode.Range32{Lo: 0x11182, Hi: 0x11182, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b3, Hi: 0x111b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b6, Hi: 0x111be, Stride: 0x1},
+		unicode.Range32{Lo: 0x111bf, Hi: 0x111c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x111ca, Hi: 0x111cc, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122c, Hi: 0x1122e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122f, Hi: 0x11231, Stride: 0x1},
+		unicode.Range32{Lo: 0x11232, Hi: 0x11233, Stride: 0x1},
+		unicode.Range32{Lo: 0x11234, Hi: 0x11234, Stride: 0x1},
+		unicode.Range32{Lo: 0x11235, Hi: 0x11235, Stride: 0x1},
+		unicode.Range32{Lo: 0x11236, Hi: 0x11237, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123e, Hi: 0x1123e, Stride: 0x1},
+		unicode.Range32{Lo: 0x112df, Hi: 0x112df, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e0, Hi: 0x112e2, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e3, Hi: 0x112ea, Stride: 0x1},
+		unicode.Range32{Lo: 0x11300, Hi: 0x11301, Stride: 0x1},
+		unicode.Range32{Lo: 0x11302, Hi: 0x11303, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133c, Hi: 0x1133c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133e, Hi: 0x1133f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11340, Hi: 0x11340, Stride: 0x1},
+		unicode.Range32{Lo: 0x11341, Hi: 0x11344, Stride: 0x1},
+		unicode.Range32{Lo: 0x11347, Hi: 0x11348, Stride: 0x1},
+		unicode.Range32{Lo: 0x1134b, Hi: 0x1134d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11357, Hi: 0x11357, Stride: 0x1},
+		unicode.Range32{Lo: 0x11362, Hi: 0x11363, Stride: 0x1},
+		unicode.Range32{Lo: 0x11366, Hi: 0x1136c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11370, Hi: 0x11374, Stride: 0x1},
+		unicode.Range32{Lo: 0x11435, Hi: 0x11437, Stride: 0x1},
+		unicode.Range32{Lo: 0x11438, Hi: 0x1143f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11440, Hi: 0x11441, Stride: 0x1},
+		unicode.Range32{Lo: 0x11442, Hi: 0x11444, Stride: 0x1},
+		unicode.Range32{Lo: 0x11445, Hi: 0x11445, Stride: 0x1},
+		unicode.Range32{Lo: 0x11446, Hi: 0x11446, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b0, Hi: 0x114b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b3, Hi: 0x114b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b9, Hi: 0x114b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x114ba, Hi: 0x114ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bb, Hi: 0x114be, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bf, Hi: 0x114c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c1, Hi: 0x114c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c2, Hi: 0x114c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115af, Hi: 0x115b1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b2, Hi: 0x115b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b8, Hi: 0x115bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bc, Hi: 0x115bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x115be, Hi: 0x115be, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bf, Hi: 0x115c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x115dc, Hi: 0x115dd, Stride: 0x1},
+		unicode.Range32{Lo: 0x11630, Hi: 0x11632, Stride: 0x1},
+		unicode.Range32{Lo: 0x11633, Hi: 0x1163a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163b, Hi: 0x1163c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163d, Hi: 0x1163d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163e, Hi: 0x1163e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163f, Hi: 0x11640, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ab, Hi: 0x116ab, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ac, Hi: 0x116ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ad, Hi: 0x116ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ae, Hi: 0x116af, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b0, Hi: 0x116b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b6, Hi: 0x116b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b7, Hi: 0x116b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x1171d, Hi: 0x1171f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11720, Hi: 0x11721, Stride: 0x1},
+		unicode.Range32{Lo: 0x11722, Hi: 0x11725, Stride: 0x1},
+		unicode.Range32{Lo: 0x11726, Hi: 0x11726, Stride: 0x1},
+		unicode.Range32{Lo: 0x11727, Hi: 0x1172b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c2f, Hi: 0x11c2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c30, Hi: 0x11c36, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c38, Hi: 0x11c3d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3e, Hi: 0x11c3e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3f, Hi: 0x11c3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c92, Hi: 0x11ca7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ca9, Hi: 0x11ca9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11caa, Hi: 0x11cb0, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb1, Hi: 0x11cb1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb2, Hi: 0x11cb3, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb4, Hi: 0x11cb4, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb5, Hi: 0x11cb6, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af0, Hi: 0x16af4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b30, Hi: 0x16b36, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f51, Hi: 0x16f7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f8f, Hi: 0x16f92, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9d, Hi: 0x1bc9e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d165, Hi: 0x1d166, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d167, Hi: 0x1d169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16d, Hi: 0x1d172, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d17b, Hi: 0x1d182, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d185, Hi: 0x1d18b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d1aa, Hi: 0x1d1ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d242, Hi: 0x1d244, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da00, Hi: 0x1da36, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da3b, Hi: 0x1da6c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da75, Hi: 0x1da75, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da84, Hi: 0x1da84, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da9b, Hi: 0x1da9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1daa1, Hi: 0x1daaf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e000, Hi: 0x1e006, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e008, Hi: 0x1e018, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e01b, Hi: 0x1e021, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e023, Hi: 0x1e024, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e026, Hi: 0x1e02a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e8d0, Hi: 0x1e8d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e944, Hi: 0x1e94a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0020, Hi: 0xe007f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0100, Hi: 0xe01ef, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordExtendNumLet = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x5f, Hi: 0x5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x202f, Hi: 0x202f, Stride: 0x1},
+		unicode.Range16{Lo: 0x203f, Hi: 0x2040, Stride: 0x1},
+		unicode.Range16{Lo: 0x2054, Hi: 0x2054, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe33, Hi: 0xfe34, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe4d, Hi: 0xfe4f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff3f, Hi: 0xff3f, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordFormat = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xad, Hi: 0xad, Stride: 0x1},
+		unicode.Range16{Lo: 0x600, Hi: 0x605, Stride: 0x1},
+		unicode.Range16{Lo: 0x61c, Hi: 0x61c, Stride: 0x1},
+		unicode.Range16{Lo: 0x6dd, Hi: 0x6dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x70f, Hi: 0x70f, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e2, Hi: 0x8e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x180e, Hi: 0x180e, Stride: 0x1},
+		unicode.Range16{Lo: 0x200e, Hi: 0x200f, Stride: 0x1},
+		unicode.Range16{Lo: 0x202a, Hi: 0x202e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2060, Hi: 0x2064, Stride: 0x1},
+		unicode.Range16{Lo: 0x2066, Hi: 0x206f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfeff, Hi: 0xfeff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff9, Hi: 0xfffb, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x110bd, Hi: 0x110bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bca0, Hi: 0x1bca3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d173, Hi: 0x1d17a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0001, Hi: 0xe0001, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordGlue_After_Zwj = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2764, Hi: 0x2764, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f48b, Hi: 0x1f48b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f5e8, Hi: 0x1f5e8, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordHebrew_Letter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x5d0, Hi: 0x5ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f0, Hi: 0x5f2, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1d, Hi: 0xfb1d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1f, Hi: 0xfb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb2a, Hi: 0xfb36, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb38, Hi: 0xfb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb3e, Hi: 0xfb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb40, Hi: 0xfb41, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb43, Hi: 0xfb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb46, Hi: 0xfb4f, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordKatakana = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x3031, Hi: 0x3035, Stride: 0x1},
+		unicode.Range16{Lo: 0x309b, Hi: 0x309c, Stride: 0x1},
+		unicode.Range16{Lo: 0x30a0, Hi: 0x30a0, Stride: 0x1},
+		unicode.Range16{Lo: 0x30a1, Hi: 0x30fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x30fc, Hi: 0x30fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x30ff, Hi: 0x30ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x31f0, Hi: 0x31ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x32d0, Hi: 0x32fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x3300, Hi: 0x3357, Stride: 0x1},
+		unicode.Range16{Lo: 0xff66, Hi: 0xff6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff70, Hi: 0xff70, Stride: 0x1},
+		unicode.Range16{Lo: 0xff71, Hi: 0xff9d, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1b000, Hi: 0x1b000, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordLF = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xa, Hi: 0xa, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordMidLetter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x3a, Hi: 0x3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7, Hi: 0xb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7, Hi: 0x2d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x387, Hi: 0x387, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f4, Hi: 0x5f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2027, Hi: 0x2027, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe13, Hi: 0xfe13, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe55, Hi: 0xfe55, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1a, Hi: 0xff1a, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _WordMidNum = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2c, Hi: 0x2c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3b, Hi: 0x3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x37e, Hi: 0x37e, Stride: 0x1},
+		unicode.Range16{Lo: 0x589, Hi: 0x589, Stride: 0x1},
+		unicode.Range16{Lo: 0x60c, Hi: 0x60d, Stride: 0x1},
+		unicode.Range16{Lo: 0x66c, Hi: 0x66c, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f8, Hi: 0x7f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2044, Hi: 0x2044, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe10, Hi: 0xfe10, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe14, Hi: 0xfe14, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe50, Hi: 0xfe50, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe54, Hi: 0xfe54, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0c, Hi: 0xff0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1b, Hi: 0xff1b, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _WordMidNumLet = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2e, Hi: 0x2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2018, Hi: 0x2018, Stride: 0x1},
+		unicode.Range16{Lo: 0x2019, Hi: 0x2019, Stride: 0x1},
+		unicode.Range16{Lo: 0x2024, Hi: 0x2024, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe52, Hi: 0xfe52, Stride: 0x1},
+		unicode.Range16{Lo: 0xff07, Hi: 0xff07, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0e, Hi: 0xff0e, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordNewline = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xb, Hi: 0xc, Stride: 0x1},
+		unicode.Range16{Lo: 0x85, Hi: 0x85, Stride: 0x1},
+		unicode.Range16{Lo: 0x2028, Hi: 0x2028, Stride: 0x1},
+		unicode.Range16{Lo: 0x2029, Hi: 0x2029, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _WordNumeric = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x30, Hi: 0x39, Stride: 0x1},
+		unicode.Range16{Lo: 0x660, Hi: 0x669, Stride: 0x1},
+		unicode.Range16{Lo: 0x66b, Hi: 0x66b, Stride: 0x1},
+		unicode.Range16{Lo: 0x6f0, Hi: 0x6f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x7c0, Hi: 0x7c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x966, Hi: 0x96f, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e6, Hi: 0x9ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66, Hi: 0xa6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xae6, Hi: 0xaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xb66, Hi: 0xb6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe6, Hi: 0xbef, Stride: 0x1},
+		unicode.Range16{Lo: 0xc66, Hi: 0xc6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce6, Hi: 0xcef, Stride: 0x1},
+		unicode.Range16{Lo: 0xd66, Hi: 0xd6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xde6, Hi: 0xdef, Stride: 0x1},
+		unicode.Range16{Lo: 0xe50, Hi: 0xe59, Stride: 0x1},
+		unicode.Range16{Lo: 0xed0, Hi: 0xed9, Stride: 0x1},
+		unicode.Range16{Lo: 0xf20, Hi: 0xf29, Stride: 0x1},
+		unicode.Range16{Lo: 0x1040, Hi: 0x1049, Stride: 0x1},
+		unicode.Range16{Lo: 0x1090, Hi: 0x1099, Stride: 0x1},
+		unicode.Range16{Lo: 0x17e0, Hi: 0x17e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1810, Hi: 0x1819, Stride: 0x1},
+		unicode.Range16{Lo: 0x1946, Hi: 0x194f, Stride: 0x1},
+		unicode.Range16{Lo: 0x19d0, Hi: 0x19d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a80, Hi: 0x1a89, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a90, Hi: 0x1a99, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b50, Hi: 0x1b59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bb0, Hi: 0x1bb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c40, Hi: 0x1c49, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c50, Hi: 0x1c59, Stride: 0x1},
+		unicode.Range16{Lo: 0xa620, Hi: 0xa629, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8d0, Hi: 0xa8d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa900, Hi: 0xa909, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9d0, Hi: 0xa9d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9f0, Hi: 0xa9f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa50, Hi: 0xaa59, Stride: 0x1},
+		unicode.Range16{Lo: 0xabf0, Hi: 0xabf9, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x104a0, Hi: 0x104a9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11066, Hi: 0x1106f, Stride: 0x1},
+		unicode.Range32{Lo: 0x110f0, Hi: 0x110f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11136, Hi: 0x1113f, Stride: 0x1},
+		unicode.Range32{Lo: 0x111d0, Hi: 0x111d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x112f0, Hi: 0x112f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11450, Hi: 0x11459, Stride: 0x1},
+		unicode.Range32{Lo: 0x114d0, Hi: 0x114d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11650, Hi: 0x11659, Stride: 0x1},
+		unicode.Range32{Lo: 0x116c0, Hi: 0x116c9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11730, Hi: 0x11739, Stride: 0x1},
+		unicode.Range32{Lo: 0x118e0, Hi: 0x118e9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c50, Hi: 0x11c59, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a60, Hi: 0x16a69, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b50, Hi: 0x16b59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7ce, Hi: 0x1d7ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e950, Hi: 0x1e959, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordRegional_Indicator = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f1e6, Hi: 0x1f1ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordSingle_Quote = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x27, Hi: 0x27, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordZWJ = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x200d, Hi: 0x200d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+type _WordRuneRange unicode.RangeTable
+
+func _WordRuneType(r rune) *_WordRuneRange {
+	switch {
+	case unicode.Is(_WordALetter, r):
+		return (*_WordRuneRange)(_WordALetter)
+	case unicode.Is(_WordCR, r):
+		return (*_WordRuneRange)(_WordCR)
+	case unicode.Is(_WordDouble_Quote, r):
+		return (*_WordRuneRange)(_WordDouble_Quote)
+	case unicode.Is(_WordE_Base, r):
+		return (*_WordRuneRange)(_WordE_Base)
+	case unicode.Is(_WordE_Base_GAZ, r):
+		return (*_WordRuneRange)(_WordE_Base_GAZ)
+	case unicode.Is(_WordE_Modifier, r):
+		return (*_WordRuneRange)(_WordE_Modifier)
+	case unicode.Is(_WordExtend, r):
+		return (*_WordRuneRange)(_WordExtend)
+	case unicode.Is(_WordExtendNumLet, r):
+		return (*_WordRuneRange)(_WordExtendNumLet)
+	case unicode.Is(_WordFormat, r):
+		return (*_WordRuneRange)(_WordFormat)
+	case unicode.Is(_WordGlue_After_Zwj, r):
+		return (*_WordRuneRange)(_WordGlue_After_Zwj)
+	case unicode.Is(_WordHebrew_Letter, r):
+		return (*_WordRuneRange)(_WordHebrew_Letter)
+	case unicode.Is(_WordKatakana, r):
+		return (*_WordRuneRange)(_WordKatakana)
+	case unicode.Is(_WordLF, r):
+		return (*_WordRuneRange)(_WordLF)
+	case unicode.Is(_WordMidLetter, r):
+		return (*_WordRuneRange)(_WordMidLetter)
+	case unicode.Is(_WordMidNum, r):
+		return (*_WordRuneRange)(_WordMidNum)
+	case unicode.Is(_WordMidNumLet, r):
+		return (*_WordRuneRange)(_WordMidNumLet)
+	case unicode.Is(_WordNewline, r):
+		return (*_WordRuneRange)(_WordNewline)
+	case unicode.Is(_WordNumeric, r):
+		return (*_WordRuneRange)(_WordNumeric)
+	case unicode.Is(_WordRegional_Indicator, r):
+		return (*_WordRuneRange)(_WordRegional_Indicator)
+	case unicode.Is(_WordSingle_Quote, r):
+		return (*_WordRuneRange)(_WordSingle_Quote)
+	case unicode.Is(_WordZWJ, r):
+		return (*_WordRuneRange)(_WordZWJ)
+	default:
+		return nil
+	}
+}
+func (rng *_WordRuneRange) String() string {
+	switch (*unicode.RangeTable)(rng) {
+	case _WordALetter:
+		return "ALetter"
+	case _WordCR:
+		return "CR"
+	case _WordDouble_Quote:
+		return "Double_Quote"
+	case _WordE_Base:
+		return "E_Base"
+	case _WordE_Base_GAZ:
+		return "E_Base_GAZ"
+	case _WordE_Modifier:
+		return "E_Modifier"
+	case _WordExtend:
+		return "Extend"
+	case _WordExtendNumLet:
+		return "ExtendNumLet"
+	case _WordFormat:
+		return "Format"
+	case _WordGlue_After_Zwj:
+		return "Glue_After_Zwj"
+	case _WordHebrew_Letter:
+		return "Hebrew_Letter"
+	case _WordKatakana:
+		return "Katakana"
+	case _WordLF:
+		return "LF"
+	case _WordMidLetter:
+		return "MidLetter"
+	case _WordMidNum:
+		return "MidNum"
+	case _WordMidNumLet:
+		return "MidNumLet"
+	case _WordNewline:
+		return "Newline"
+	case _WordNumeric:
+		return "Numeric"
+	case _WordRegional_Indicator:
+		return "Regional_Indicator"
+	case _WordSingle_Quote:
+		return "Single_Quote"
+	case _WordZWJ:
+		return "ZWJ"
+	default:
+		return "Other"
+	}
+}
+
+var _SentenceATerm = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2e, Hi: 0x2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2024, Hi: 0x2024, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe52, Hi: 0xfe52, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0e, Hi: 0xff0e, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceCR = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xd, Hi: 0xd, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceClose = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x22, Hi: 0x22, Stride: 0x1},
+		unicode.Range16{Lo: 0x27, Hi: 0x27, Stride: 0x1},
+		unicode.Range16{Lo: 0x28, Hi: 0x28, Stride: 0x1},
+		unicode.Range16{Lo: 0x29, Hi: 0x29, Stride: 0x1},
+		unicode.Range16{Lo: 0x5b, Hi: 0x5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x5d, Hi: 0x5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x7b, Hi: 0x7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x7d, Hi: 0x7d, Stride: 0x1},
+		unicode.Range16{Lo: 0xab, Hi: 0xab, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb, Hi: 0xbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3a, Hi: 0xf3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3b, Hi: 0xf3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3c, Hi: 0xf3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3d, Hi: 0xf3d, Stride: 0x1},
+		unicode.Range16{Lo: 0x169b, Hi: 0x169b, Stride: 0x1},
+		unicode.Range16{Lo: 0x169c, Hi: 0x169c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2018, Hi: 0x2018, Stride: 0x1},
+		unicode.Range16{Lo: 0x2019, Hi: 0x2019, Stride: 0x1},
+		unicode.Range16{Lo: 0x201a, Hi: 0x201a, Stride: 0x1},
+		unicode.Range16{Lo: 0x201b, Hi: 0x201c, Stride: 0x1},
+		unicode.Range16{Lo: 0x201d, Hi: 0x201d, Stride: 0x1},
+		unicode.Range16{Lo: 0x201e, Hi: 0x201e, Stride: 0x1},
+		unicode.Range16{Lo: 0x201f, Hi: 0x201f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2039, Hi: 0x2039, Stride: 0x1},
+		unicode.Range16{Lo: 0x203a, Hi: 0x203a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2045, Hi: 0x2045, Stride: 0x1},
+		unicode.Range16{Lo: 0x2046, Hi: 0x2046, Stride: 0x1},
+		unicode.Range16{Lo: 0x207d, Hi: 0x207d, Stride: 0x1},
+		unicode.Range16{Lo: 0x207e, Hi: 0x207e, Stride: 0x1},
+		unicode.Range16{Lo: 0x208d, Hi: 0x208d, Stride: 0x1},
+		unicode.Range16{Lo: 0x208e, Hi: 0x208e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2308, Hi: 0x2308, Stride: 0x1},
+		unicode.Range16{Lo: 0x2309, Hi: 0x2309, Stride: 0x1},
+		unicode.Range16{Lo: 0x230a, Hi: 0x230a, Stride: 0x1},
+		unicode.Range16{Lo: 0x230b, Hi: 0x230b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2329, Hi: 0x2329, Stride: 0x1},
+		unicode.Range16{Lo: 0x232a, Hi: 0x232a, Stride: 0x1},
+		unicode.Range16{Lo: 0x275b, Hi: 0x2760, Stride: 0x1},
+		unicode.Range16{Lo: 0x2768, Hi: 0x2768, Stride: 0x1},
+		unicode.Range16{Lo: 0x2769, Hi: 0x2769, Stride: 0x1},
+		unicode.Range16{Lo: 0x276a, Hi: 0x276a, Stride: 0x1},
+		unicode.Range16{Lo: 0x276b, Hi: 0x276b, Stride: 0x1},
+		unicode.Range16{Lo: 0x276c, Hi: 0x276c, Stride: 0x1},
+		unicode.Range16{Lo: 0x276d, Hi: 0x276d, Stride: 0x1},
+		unicode.Range16{Lo: 0x276e, Hi: 0x276e, Stride: 0x1},
+		unicode.Range16{Lo: 0x276f, Hi: 0x276f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2770, Hi: 0x2770, Stride: 0x1},
+		unicode.Range16{Lo: 0x2771, Hi: 0x2771, Stride: 0x1},
+		unicode.Range16{Lo: 0x2772, Hi: 0x2772, Stride: 0x1},
+		unicode.Range16{Lo: 0x2773, Hi: 0x2773, Stride: 0x1},
+		unicode.Range16{Lo: 0x2774, Hi: 0x2774, Stride: 0x1},
+		unicode.Range16{Lo: 0x2775, Hi: 0x2775, Stride: 0x1},
+		unicode.Range16{Lo: 0x27c5, Hi: 0x27c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x27c6, Hi: 0x27c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e6, Hi: 0x27e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e7, Hi: 0x27e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e8, Hi: 0x27e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e9, Hi: 0x27e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ea, Hi: 0x27ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x27eb, Hi: 0x27eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ec, Hi: 0x27ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ed, Hi: 0x27ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ee, Hi: 0x27ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ef, Hi: 0x27ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x2983, Hi: 0x2983, Stride: 0x1},
+		unicode.Range16{Lo: 0x2984, Hi: 0x2984, Stride: 0x1},
+		unicode.Range16{Lo: 0x2985, Hi: 0x2985, Stride: 0x1},
+		unicode.Range16{Lo: 0x2986, Hi: 0x2986, Stride: 0x1},
+		unicode.Range16{Lo: 0x2987, Hi: 0x2987, Stride: 0x1},
+		unicode.Range16{Lo: 0x2988, Hi: 0x2988, Stride: 0x1},
+		unicode.Range16{Lo: 0x2989, Hi: 0x2989, Stride: 0x1},
+		unicode.Range16{Lo: 0x298a, Hi: 0x298a, Stride: 0x1},
+		unicode.Range16{Lo: 0x298b, Hi: 0x298b, Stride: 0x1},
+		unicode.Range16{Lo: 0x298c, Hi: 0x298c, Stride: 0x1},
+		unicode.Range16{Lo: 0x298d, Hi: 0x298d, Stride: 0x1},
+		unicode.Range16{Lo: 0x298e, Hi: 0x298e, Stride: 0x1},
+		unicode.Range16{Lo: 0x298f, Hi: 0x298f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2990, Hi: 0x2990, Stride: 0x1},
+		unicode.Range16{Lo: 0x2991, Hi: 0x2991, Stride: 0x1},
+		unicode.Range16{Lo: 0x2992, Hi: 0x2992, Stride: 0x1},
+		unicode.Range16{Lo: 0x2993, Hi: 0x2993, Stride: 0x1},
+		unicode.Range16{Lo: 0x2994, Hi: 0x2994, Stride: 0x1},
+		unicode.Range16{Lo: 0x2995, Hi: 0x2995, Stride: 0x1},
+		unicode.Range16{Lo: 0x2996, Hi: 0x2996, Stride: 0x1},
+		unicode.Range16{Lo: 0x2997, Hi: 0x2997, Stride: 0x1},
+		unicode.Range16{Lo: 0x2998, Hi: 0x2998, Stride: 0x1},
+		unicode.Range16{Lo: 0x29d8, Hi: 0x29d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x29d9, Hi: 0x29d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x29da, Hi: 0x29da, Stride: 0x1},
+		unicode.Range16{Lo: 0x29db, Hi: 0x29db, Stride: 0x1},
+		unicode.Range16{Lo: 0x29fc, Hi: 0x29fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x29fd, Hi: 0x29fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e00, Hi: 0x2e01, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e02, Hi: 0x2e02, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e03, Hi: 0x2e03, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e04, Hi: 0x2e04, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e05, Hi: 0x2e05, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e06, Hi: 0x2e08, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e09, Hi: 0x2e09, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0a, Hi: 0x2e0a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0b, Hi: 0x2e0b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0c, Hi: 0x2e0c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0d, Hi: 0x2e0d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e1c, Hi: 0x2e1c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e1d, Hi: 0x2e1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e20, Hi: 0x2e20, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e21, Hi: 0x2e21, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e22, Hi: 0x2e22, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e23, Hi: 0x2e23, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e24, Hi: 0x2e24, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e25, Hi: 0x2e25, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e26, Hi: 0x2e26, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e27, Hi: 0x2e27, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e28, Hi: 0x2e28, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e29, Hi: 0x2e29, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e42, Hi: 0x2e42, Stride: 0x1},
+		unicode.Range16{Lo: 0x3008, Hi: 0x3008, Stride: 0x1},
+		unicode.Range16{Lo: 0x3009, Hi: 0x3009, Stride: 0x1},
+		unicode.Range16{Lo: 0x300a, Hi: 0x300a, Stride: 0x1},
+		unicode.Range16{Lo: 0x300b, Hi: 0x300b, Stride: 0x1},
+		unicode.Range16{Lo: 0x300c, Hi: 0x300c, Stride: 0x1},
+		unicode.Range16{Lo: 0x300d, Hi: 0x300d, Stride: 0x1},
+		unicode.Range16{Lo: 0x300e, Hi: 0x300e, Stride: 0x1},
+		unicode.Range16{Lo: 0x300f, Hi: 0x300f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3010, Hi: 0x3010, Stride: 0x1},
+		unicode.Range16{Lo: 0x3011, Hi: 0x3011, Stride: 0x1},
+		unicode.Range16{Lo: 0x3014, Hi: 0x3014, Stride: 0x1},
+		unicode.Range16{Lo: 0x3015, Hi: 0x3015, Stride: 0x1},
+		unicode.Range16{Lo: 0x3016, Hi: 0x3016, Stride: 0x1},
+		unicode.Range16{Lo: 0x3017, Hi: 0x3017, Stride: 0x1},
+		unicode.Range16{Lo: 0x3018, Hi: 0x3018, Stride: 0x1},
+		unicode.Range16{Lo: 0x3019, Hi: 0x3019, Stride: 0x1},
+		unicode.Range16{Lo: 0x301a, Hi: 0x301a, Stride: 0x1},
+		unicode.Range16{Lo: 0x301b, Hi: 0x301b, Stride: 0x1},
+		unicode.Range16{Lo: 0x301d, Hi: 0x301d, Stride: 0x1},
+		unicode.Range16{Lo: 0x301e, Hi: 0x301f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd3e, Hi: 0xfd3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd3f, Hi: 0xfd3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe17, Hi: 0xfe17, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe18, Hi: 0xfe18, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe35, Hi: 0xfe35, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe36, Hi: 0xfe36, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe37, Hi: 0xfe37, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe38, Hi: 0xfe38, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe39, Hi: 0xfe39, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3a, Hi: 0xfe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3b, Hi: 0xfe3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3c, Hi: 0xfe3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3d, Hi: 0xfe3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3e, Hi: 0xfe3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3f, Hi: 0xfe3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe40, Hi: 0xfe40, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe41, Hi: 0xfe41, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe42, Hi: 0xfe42, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe43, Hi: 0xfe43, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe44, Hi: 0xfe44, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe47, Hi: 0xfe47, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe48, Hi: 0xfe48, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe59, Hi: 0xfe59, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5a, Hi: 0xfe5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5b, Hi: 0xfe5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5c, Hi: 0xfe5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5d, Hi: 0xfe5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5e, Hi: 0xfe5e, Stride: 0x1},
+		unicode.Range16{Lo: 0xff08, Hi: 0xff08, Stride: 0x1},
+		unicode.Range16{Lo: 0xff09, Hi: 0xff09, Stride: 0x1},
+		unicode.Range16{Lo: 0xff3b, Hi: 0xff3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xff3d, Hi: 0xff3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xff5b, Hi: 0xff5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xff5d, Hi: 0xff5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xff5f, Hi: 0xff5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff60, Hi: 0xff60, Stride: 0x1},
+		unicode.Range16{Lo: 0xff62, Hi: 0xff62, Stride: 0x1},
+		unicode.Range16{Lo: 0xff63, Hi: 0xff63, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f676, Hi: 0x1f678, Stride: 0x1},
+	},
+	LatinOffset: 10,
+}
+
+var _SentenceExtend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x300, Hi: 0x36f, Stride: 0x1},
+		unicode.Range16{Lo: 0x483, Hi: 0x487, Stride: 0x1},
+		unicode.Range16{Lo: 0x488, Hi: 0x489, Stride: 0x1},
+		unicode.Range16{Lo: 0x591, Hi: 0x5bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x5bf, Hi: 0x5bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c1, Hi: 0x5c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c4, Hi: 0x5c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c7, Hi: 0x5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x610, Hi: 0x61a, Stride: 0x1},
+		unicode.Range16{Lo: 0x64b, Hi: 0x65f, Stride: 0x1},
+		unicode.Range16{Lo: 0x670, Hi: 0x670, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d6, Hi: 0x6dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6df, Hi: 0x6e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e7, Hi: 0x6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ea, Hi: 0x6ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x711, Hi: 0x711, Stride: 0x1},
+		unicode.Range16{Lo: 0x730, Hi: 0x74a, Stride: 0x1},
+		unicode.Range16{Lo: 0x7a6, Hi: 0x7b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x7eb, Hi: 0x7f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x816, Hi: 0x819, Stride: 0x1},
+		unicode.Range16{Lo: 0x81b, Hi: 0x823, Stride: 0x1},
+		unicode.Range16{Lo: 0x825, Hi: 0x827, Stride: 0x1},
+		unicode.Range16{Lo: 0x829, Hi: 0x82d, Stride: 0x1},
+		unicode.Range16{Lo: 0x859, Hi: 0x85b, Stride: 0x1},
+		unicode.Range16{Lo: 0x8d4, Hi: 0x8e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e3, Hi: 0x902, Stride: 0x1},
+		unicode.Range16{Lo: 0x903, Hi: 0x903, Stride: 0x1},
+		unicode.Range16{Lo: 0x93a, Hi: 0x93a, Stride: 0x1},
+		unicode.Range16{Lo: 0x93b, Hi: 0x93b, Stride: 0x1},
+		unicode.Range16{Lo: 0x93c, Hi: 0x93c, Stride: 0x1},
+		unicode.Range16{Lo: 0x93e, Hi: 0x940, Stride: 0x1},
+		unicode.Range16{Lo: 0x941, Hi: 0x948, Stride: 0x1},
+		unicode.Range16{Lo: 0x949, Hi: 0x94c, Stride: 0x1},
+		unicode.Range16{Lo: 0x94d, Hi: 0x94d, Stride: 0x1},
+		unicode.Range16{Lo: 0x94e, Hi: 0x94f, Stride: 0x1},
+		unicode.Range16{Lo: 0x951, Hi: 0x957, Stride: 0x1},
+		unicode.Range16{Lo: 0x962, Hi: 0x963, Stride: 0x1},
+		unicode.Range16{Lo: 0x981, Hi: 0x981, Stride: 0x1},
+		unicode.Range16{Lo: 0x982, Hi: 0x983, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bc, Hi: 0x9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9be, Hi: 0x9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c1, Hi: 0x9c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c7, Hi: 0x9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cb, Hi: 0x9cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cd, Hi: 0x9cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9d7, Hi: 0x9d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e2, Hi: 0x9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa01, Hi: 0xa02, Stride: 0x1},
+		unicode.Range16{Lo: 0xa03, Hi: 0xa03, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3c, Hi: 0xa3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3e, Hi: 0xa40, Stride: 0x1},
+		unicode.Range16{Lo: 0xa41, Hi: 0xa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xa47, Hi: 0xa48, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4b, Hi: 0xa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa51, Hi: 0xa51, Stride: 0x1},
+		unicode.Range16{Lo: 0xa70, Hi: 0xa71, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75, Hi: 0xa75, Stride: 0x1},
+		unicode.Range16{Lo: 0xa81, Hi: 0xa82, Stride: 0x1},
+		unicode.Range16{Lo: 0xa83, Hi: 0xa83, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc, Hi: 0xabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe, Hi: 0xac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1, Hi: 0xac5, Stride: 0x1},
+		unicode.Range16{Lo: 0xac7, Hi: 0xac8, Stride: 0x1},
+		unicode.Range16{Lo: 0xac9, Hi: 0xac9, Stride: 0x1},
+		unicode.Range16{Lo: 0xacb, Hi: 0xacc, Stride: 0x1},
+		unicode.Range16{Lo: 0xacd, Hi: 0xacd, Stride: 0x1},
+		unicode.Range16{Lo: 0xae2, Hi: 0xae3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb01, Hi: 0xb01, Stride: 0x1},
+		unicode.Range16{Lo: 0xb02, Hi: 0xb03, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c, Hi: 0xb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e, Hi: 0xb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3f, Hi: 0xb3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb40, Hi: 0xb40, Stride: 0x1},
+		unicode.Range16{Lo: 0xb41, Hi: 0xb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xb47, Hi: 0xb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4b, Hi: 0xb4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4d, Hi: 0xb4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb56, Hi: 0xb56, Stride: 0x1},
+		unicode.Range16{Lo: 0xb57, Hi: 0xb57, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62, Hi: 0xb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xb82, Hi: 0xb82, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbe, Hi: 0xbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc0, Hi: 0xbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc1, Hi: 0xbc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc6, Hi: 0xbc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca, Hi: 0xbcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd, Hi: 0xbcd, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd7, Hi: 0xbd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc00, Hi: 0xc00, Stride: 0x1},
+		unicode.Range16{Lo: 0xc01, Hi: 0xc03, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3e, Hi: 0xc40, Stride: 0x1},
+		unicode.Range16{Lo: 0xc41, Hi: 0xc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xc46, Hi: 0xc48, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4a, Hi: 0xc4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc55, Hi: 0xc56, Stride: 0x1},
+		unicode.Range16{Lo: 0xc62, Hi: 0xc63, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81, Hi: 0xc81, Stride: 0x1},
+		unicode.Range16{Lo: 0xc82, Hi: 0xc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbc, Hi: 0xcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbe, Hi: 0xcbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf, Hi: 0xcbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0, Hi: 0xcc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc6, Hi: 0xcc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7, Hi: 0xcc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcca, Hi: 0xccb, Stride: 0x1},
+		unicode.Range16{Lo: 0xccc, Hi: 0xccd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5, Hi: 0xcd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xce2, Hi: 0xce3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd01, Hi: 0xd01, Stride: 0x1},
+		unicode.Range16{Lo: 0xd02, Hi: 0xd03, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3e, Hi: 0xd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xd41, Hi: 0xd44, Stride: 0x1},
+		unicode.Range16{Lo: 0xd46, Hi: 0xd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4a, Hi: 0xd4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4d, Hi: 0xd4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd57, Hi: 0xd57, Stride: 0x1},
+		unicode.Range16{Lo: 0xd62, Hi: 0xd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xd82, Hi: 0xd83, Stride: 0x1},
+		unicode.Range16{Lo: 0xdca, Hi: 0xdca, Stride: 0x1},
+		unicode.Range16{Lo: 0xdcf, Hi: 0xdd1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd2, Hi: 0xdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd6, Hi: 0xdd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd8, Hi: 0xddf, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf2, Hi: 0xdf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xe31, Hi: 0xe31, Stride: 0x1},
+		unicode.Range16{Lo: 0xe34, Hi: 0xe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe47, Hi: 0xe4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb1, Hi: 0xeb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb4, Hi: 0xeb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xebb, Hi: 0xebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xec8, Hi: 0xecd, Stride: 0x1},
+		unicode.Range16{Lo: 0xf18, Hi: 0xf19, Stride: 0x1},
+		unicode.Range16{Lo: 0xf35, Hi: 0xf35, Stride: 0x1},
+		unicode.Range16{Lo: 0xf37, Hi: 0xf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xf39, Hi: 0xf39, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3e, Hi: 0xf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf71, Hi: 0xf7e, Stride: 0x1},
+		unicode.Range16{Lo: 0xf7f, Hi: 0xf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf80, Hi: 0xf84, Stride: 0x1},
+		unicode.Range16{Lo: 0xf86, Hi: 0xf87, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8d, Hi: 0xf97, Stride: 0x1},
+		unicode.Range16{Lo: 0xf99, Hi: 0xfbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xfc6, Hi: 0xfc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x102b, Hi: 0x102c, Stride: 0x1},
+		unicode.Range16{Lo: 0x102d, Hi: 0x1030, Stride: 0x1},
+		unicode.Range16{Lo: 0x1031, Hi: 0x1031, Stride: 0x1},
+		unicode.Range16{Lo: 0x1032, Hi: 0x1037, Stride: 0x1},
+		unicode.Range16{Lo: 0x1038, Hi: 0x1038, Stride: 0x1},
+		unicode.Range16{Lo: 0x1039, Hi: 0x103a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103b, Hi: 0x103c, Stride: 0x1},
+		unicode.Range16{Lo: 0x103d, Hi: 0x103e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1056, Hi: 0x1057, Stride: 0x1},
+		unicode.Range16{Lo: 0x1058, Hi: 0x1059, Stride: 0x1},
+		unicode.Range16{Lo: 0x105e, Hi: 0x1060, Stride: 0x1},
+		unicode.Range16{Lo: 0x1062, Hi: 0x1064, Stride: 0x1},
+		unicode.Range16{Lo: 0x1067, Hi: 0x106d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1071, Hi: 0x1074, Stride: 0x1},
+		unicode.Range16{Lo: 0x1082, Hi: 0x1082, Stride: 0x1},
+		unicode.Range16{Lo: 0x1083, Hi: 0x1084, Stride: 0x1},
+		unicode.Range16{Lo: 0x1085, Hi: 0x1086, Stride: 0x1},
+		unicode.Range16{Lo: 0x1087, Hi: 0x108c, Stride: 0x1},
+		unicode.Range16{Lo: 0x108d, Hi: 0x108d, Stride: 0x1},
+		unicode.Range16{Lo: 0x108f, Hi: 0x108f, Stride: 0x1},
+		unicode.Range16{Lo: 0x109a, Hi: 0x109c, Stride: 0x1},
+		unicode.Range16{Lo: 0x109d, Hi: 0x109d, Stride: 0x1},
+		unicode.Range16{Lo: 0x135d, Hi: 0x135f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1712, Hi: 0x1714, Stride: 0x1},
+		unicode.Range16{Lo: 0x1732, Hi: 0x1734, Stride: 0x1},
+		unicode.Range16{Lo: 0x1752, Hi: 0x1753, Stride: 0x1},
+		unicode.Range16{Lo: 0x1772, Hi: 0x1773, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b4, Hi: 0x17b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b6, Hi: 0x17b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b7, Hi: 0x17bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x17be, Hi: 0x17c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c6, Hi: 0x17c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c7, Hi: 0x17c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c9, Hi: 0x17d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dd, Hi: 0x17dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x180b, Hi: 0x180d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1885, Hi: 0x1886, Stride: 0x1},
+		unicode.Range16{Lo: 0x18a9, Hi: 0x18a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1920, Hi: 0x1922, Stride: 0x1},
+		unicode.Range16{Lo: 0x1923, Hi: 0x1926, Stride: 0x1},
+		unicode.Range16{Lo: 0x1927, Hi: 0x1928, Stride: 0x1},
+		unicode.Range16{Lo: 0x1929, Hi: 0x192b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1930, Hi: 0x1931, Stride: 0x1},
+		unicode.Range16{Lo: 0x1932, Hi: 0x1932, Stride: 0x1},
+		unicode.Range16{Lo: 0x1933, Hi: 0x1938, Stride: 0x1},
+		unicode.Range16{Lo: 0x1939, Hi: 0x193b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a17, Hi: 0x1a18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a19, Hi: 0x1a1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1b, Hi: 0x1a1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a55, Hi: 0x1a55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a56, Hi: 0x1a56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a57, Hi: 0x1a57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a58, Hi: 0x1a5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a60, Hi: 0x1a60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a61, Hi: 0x1a61, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a62, Hi: 0x1a62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a63, Hi: 0x1a64, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a65, Hi: 0x1a6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6d, Hi: 0x1a72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a73, Hi: 0x1a7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a7f, Hi: 0x1a7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ab0, Hi: 0x1abd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1abe, Hi: 0x1abe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b00, Hi: 0x1b03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b04, Hi: 0x1b04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b34, Hi: 0x1b34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b35, Hi: 0x1b35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b36, Hi: 0x1b3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3b, Hi: 0x1b3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3c, Hi: 0x1b3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3d, Hi: 0x1b41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b42, Hi: 0x1b42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b43, Hi: 0x1b44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6b, Hi: 0x1b73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b80, Hi: 0x1b81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b82, Hi: 0x1b82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba1, Hi: 0x1ba1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba2, Hi: 0x1ba5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba6, Hi: 0x1ba7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba8, Hi: 0x1ba9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1baa, Hi: 0x1baa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bab, Hi: 0x1bad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be6, Hi: 0x1be6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be7, Hi: 0x1be7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be8, Hi: 0x1be9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bea, Hi: 0x1bec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bed, Hi: 0x1bed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bee, Hi: 0x1bee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bef, Hi: 0x1bf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bf2, Hi: 0x1bf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c24, Hi: 0x1c2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c2c, Hi: 0x1c33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c34, Hi: 0x1c35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c36, Hi: 0x1c37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd0, Hi: 0x1cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd4, Hi: 0x1ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce1, Hi: 0x1ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce2, Hi: 0x1ce8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ced, Hi: 0x1ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf2, Hi: 0x1cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf4, Hi: 0x1cf4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf8, Hi: 0x1cf9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc0, Hi: 0x1df5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dfb, Hi: 0x1dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x200c, Hi: 0x200d, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d0, Hi: 0x20dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20dd, Hi: 0x20e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e1, Hi: 0x20e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e2, Hi: 0x20e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e5, Hi: 0x20f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cef, Hi: 0x2cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7f, Hi: 0x2d7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2de0, Hi: 0x2dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x302a, Hi: 0x302d, Stride: 0x1},
+		unicode.Range16{Lo: 0x302e, Hi: 0x302f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3099, Hi: 0x309a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66f, Hi: 0xa66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa670, Hi: 0xa672, Stride: 0x1},
+		unicode.Range16{Lo: 0xa674, Hi: 0xa67d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69e, Hi: 0xa69f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f0, Hi: 0xa6f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa802, Hi: 0xa802, Stride: 0x1},
+		unicode.Range16{Lo: 0xa806, Hi: 0xa806, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80b, Hi: 0xa80b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa823, Hi: 0xa824, Stride: 0x1},
+		unicode.Range16{Lo: 0xa825, Hi: 0xa826, Stride: 0x1},
+		unicode.Range16{Lo: 0xa827, Hi: 0xa827, Stride: 0x1},
+		unicode.Range16{Lo: 0xa880, Hi: 0xa881, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8b4, Hi: 0xa8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8c4, Hi: 0xa8c5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8e0, Hi: 0xa8f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa926, Hi: 0xa92d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa947, Hi: 0xa951, Stride: 0x1},
+		unicode.Range16{Lo: 0xa952, Hi: 0xa953, Stride: 0x1},
+		unicode.Range16{Lo: 0xa980, Hi: 0xa982, Stride: 0x1},
+		unicode.Range16{Lo: 0xa983, Hi: 0xa983, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b3, Hi: 0xa9b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b4, Hi: 0xa9b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b6, Hi: 0xa9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9ba, Hi: 0xa9bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bc, Hi: 0xa9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bd, Hi: 0xa9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e5, Hi: 0xa9e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa29, Hi: 0xaa2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa2f, Hi: 0xaa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa31, Hi: 0xaa32, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa33, Hi: 0xaa34, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa35, Hi: 0xaa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa43, Hi: 0xaa43, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4c, Hi: 0xaa4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4d, Hi: 0xaa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7b, Hi: 0xaa7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7c, Hi: 0xaa7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7d, Hi: 0xaa7d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab0, Hi: 0xaab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab2, Hi: 0xaab4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab7, Hi: 0xaab8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaabe, Hi: 0xaabf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac1, Hi: 0xaac1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaeb, Hi: 0xaaeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaec, Hi: 0xaaed, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaee, Hi: 0xaaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf5, Hi: 0xaaf5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf6, Hi: 0xaaf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe3, Hi: 0xabe4, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe5, Hi: 0xabe5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe6, Hi: 0xabe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe8, Hi: 0xabe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe9, Hi: 0xabea, Stride: 0x1},
+		unicode.Range16{Lo: 0xabec, Hi: 0xabec, Stride: 0x1},
+		unicode.Range16{Lo: 0xabed, Hi: 0xabed, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1e, Hi: 0xfb1e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe00, Hi: 0xfe0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe20, Hi: 0xfe2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff9e, Hi: 0xff9f, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x101fd, Hi: 0x101fd, Stride: 0x1},
+		unicode.Range32{Lo: 0x102e0, Hi: 0x102e0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10376, Hi: 0x1037a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a01, Hi: 0x10a03, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a05, Hi: 0x10a06, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a0c, Hi: 0x10a0f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a38, Hi: 0x10a3a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a3f, Hi: 0x10a3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ae5, Hi: 0x10ae6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11000, Hi: 0x11000, Stride: 0x1},
+		unicode.Range32{Lo: 0x11001, Hi: 0x11001, Stride: 0x1},
+		unicode.Range32{Lo: 0x11002, Hi: 0x11002, Stride: 0x1},
+		unicode.Range32{Lo: 0x11038, Hi: 0x11046, Stride: 0x1},
+		unicode.Range32{Lo: 0x1107f, Hi: 0x11081, Stride: 0x1},
+		unicode.Range32{Lo: 0x11082, Hi: 0x11082, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b0, Hi: 0x110b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b3, Hi: 0x110b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b7, Hi: 0x110b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b9, Hi: 0x110ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x11100, Hi: 0x11102, Stride: 0x1},
+		unicode.Range32{Lo: 0x11127, Hi: 0x1112b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112c, Hi: 0x1112c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112d, Hi: 0x11134, Stride: 0x1},
+		unicode.Range32{Lo: 0x11173, Hi: 0x11173, Stride: 0x1},
+		unicode.Range32{Lo: 0x11180, Hi: 0x11181, Stride: 0x1},
+		unicode.Range32{Lo: 0x11182, Hi: 0x11182, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b3, Hi: 0x111b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b6, Hi: 0x111be, Stride: 0x1},
+		unicode.Range32{Lo: 0x111bf, Hi: 0x111c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x111ca, Hi: 0x111cc, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122c, Hi: 0x1122e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122f, Hi: 0x11231, Stride: 0x1},
+		unicode.Range32{Lo: 0x11232, Hi: 0x11233, Stride: 0x1},
+		unicode.Range32{Lo: 0x11234, Hi: 0x11234, Stride: 0x1},
+		unicode.Range32{Lo: 0x11235, Hi: 0x11235, Stride: 0x1},
+		unicode.Range32{Lo: 0x11236, Hi: 0x11237, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123e, Hi: 0x1123e, Stride: 0x1},
+		unicode.Range32{Lo: 0x112df, Hi: 0x112df, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e0, Hi: 0x112e2, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e3, Hi: 0x112ea, Stride: 0x1},
+		unicode.Range32{Lo: 0x11300, Hi: 0x11301, Stride: 0x1},
+		unicode.Range32{Lo: 0x11302, Hi: 0x11303, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133c, Hi: 0x1133c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133e, Hi: 0x1133f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11340, Hi: 0x11340, Stride: 0x1},
+		unicode.Range32{Lo: 0x11341, Hi: 0x11344, Stride: 0x1},
+		unicode.Range32{Lo: 0x11347, Hi: 0x11348, Stride: 0x1},
+		unicode.Range32{Lo: 0x1134b, Hi: 0x1134d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11357, Hi: 0x11357, Stride: 0x1},
+		unicode.Range32{Lo: 0x11362, Hi: 0x11363, Stride: 0x1},
+		unicode.Range32{Lo: 0x11366, Hi: 0x1136c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11370, Hi: 0x11374, Stride: 0x1},
+		unicode.Range32{Lo: 0x11435, Hi: 0x11437, Stride: 0x1},
+		unicode.Range32{Lo: 0x11438, Hi: 0x1143f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11440, Hi: 0x11441, Stride: 0x1},
+		unicode.Range32{Lo: 0x11442, Hi: 0x11444, Stride: 0x1},
+		unicode.Range32{Lo: 0x11445, Hi: 0x11445, Stride: 0x1},
+		unicode.Range32{Lo: 0x11446, Hi: 0x11446, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b0, Hi: 0x114b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b3, Hi: 0x114b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b9, Hi: 0x114b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x114ba, Hi: 0x114ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bb, Hi: 0x114be, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bf, Hi: 0x114c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c1, Hi: 0x114c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c2, Hi: 0x114c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115af, Hi: 0x115b1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b2, Hi: 0x115b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b8, Hi: 0x115bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bc, Hi: 0x115bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x115be, Hi: 0x115be, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bf, Hi: 0x115c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x115dc, Hi: 0x115dd, Stride: 0x1},
+		unicode.Range32{Lo: 0x11630, Hi: 0x11632, Stride: 0x1},
+		unicode.Range32{Lo: 0x11633, Hi: 0x1163a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163b, Hi: 0x1163c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163d, Hi: 0x1163d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163e, Hi: 0x1163e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163f, Hi: 0x11640, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ab, Hi: 0x116ab, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ac, Hi: 0x116ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ad, Hi: 0x116ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ae, Hi: 0x116af, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b0, Hi: 0x116b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b6, Hi: 0x116b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b7, Hi: 0x116b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x1171d, Hi: 0x1171f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11720, Hi: 0x11721, Stride: 0x1},
+		unicode.Range32{Lo: 0x11722, Hi: 0x11725, Stride: 0x1},
+		unicode.Range32{Lo: 0x11726, Hi: 0x11726, Stride: 0x1},
+		unicode.Range32{Lo: 0x11727, Hi: 0x1172b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c2f, Hi: 0x11c2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c30, Hi: 0x11c36, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c38, Hi: 0x11c3d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3e, Hi: 0x11c3e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3f, Hi: 0x11c3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c92, Hi: 0x11ca7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ca9, Hi: 0x11ca9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11caa, Hi: 0x11cb0, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb1, Hi: 0x11cb1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb2, Hi: 0x11cb3, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb4, Hi: 0x11cb4, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb5, Hi: 0x11cb6, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af0, Hi: 0x16af4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b30, Hi: 0x16b36, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f51, Hi: 0x16f7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f8f, Hi: 0x16f92, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9d, Hi: 0x1bc9e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d165, Hi: 0x1d166, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d167, Hi: 0x1d169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16d, Hi: 0x1d172, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d17b, Hi: 0x1d182, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d185, Hi: 0x1d18b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d1aa, Hi: 0x1d1ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d242, Hi: 0x1d244, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da00, Hi: 0x1da36, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da3b, Hi: 0x1da6c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da75, Hi: 0x1da75, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da84, Hi: 0x1da84, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da9b, Hi: 0x1da9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1daa1, Hi: 0x1daaf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e000, Hi: 0x1e006, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e008, Hi: 0x1e018, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e01b, Hi: 0x1e021, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e023, Hi: 0x1e024, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e026, Hi: 0x1e02a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e8d0, Hi: 0x1e8d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e944, Hi: 0x1e94a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0020, Hi: 0xe007f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0100, Hi: 0xe01ef, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _SentenceFormat = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xad, Hi: 0xad, Stride: 0x1},
+		unicode.Range16{Lo: 0x600, Hi: 0x605, Stride: 0x1},
+		unicode.Range16{Lo: 0x61c, Hi: 0x61c, Stride: 0x1},
+		unicode.Range16{Lo: 0x6dd, Hi: 0x6dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x70f, Hi: 0x70f, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e2, Hi: 0x8e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x180e, Hi: 0x180e, Stride: 0x1},
+		unicode.Range16{Lo: 0x200b, Hi: 0x200b, Stride: 0x1},
+		unicode.Range16{Lo: 0x200e, Hi: 0x200f, Stride: 0x1},
+		unicode.Range16{Lo: 0x202a, Hi: 0x202e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2060, Hi: 0x2064, Stride: 0x1},
+		unicode.Range16{Lo: 0x2066, Hi: 0x206f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfeff, Hi: 0xfeff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff9, Hi: 0xfffb, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x110bd, Hi: 0x110bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bca0, Hi: 0x1bca3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d173, Hi: 0x1d17a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0001, Hi: 0xe0001, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceLF = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xa, Hi: 0xa, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceLower = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x61, Hi: 0x7a, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa, Hi: 0xaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5, Hi: 0xb5, Stride: 0x1},
+		unicode.Range16{Lo: 0xba, Hi: 0xba, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf, Hi: 0xf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8, Hi: 0xff, Stride: 0x1},
+		unicode.Range16{Lo: 0x101, Hi: 0x101, Stride: 0x1},
+		unicode.Range16{Lo: 0x103, Hi: 0x103, Stride: 0x1},
+		unicode.Range16{Lo: 0x105, Hi: 0x105, Stride: 0x1},
+		unicode.Range16{Lo: 0x107, Hi: 0x107, Stride: 0x1},
+		unicode.Range16{Lo: 0x109, Hi: 0x109, Stride: 0x1},
+		unicode.Range16{Lo: 0x10b, Hi: 0x10b, Stride: 0x1},
+		unicode.Range16{Lo: 0x10d, Hi: 0x10d, Stride: 0x1},
+		unicode.Range16{Lo: 0x10f, Hi: 0x10f, Stride: 0x1},
+		unicode.Range16{Lo: 0x111, Hi: 0x111, Stride: 0x1},
+		unicode.Range16{Lo: 0x113, Hi: 0x113, Stride: 0x1},
+		unicode.Range16{Lo: 0x115, Hi: 0x115, Stride: 0x1},
+		unicode.Range16{Lo: 0x117, Hi: 0x117, Stride: 0x1},
+		unicode.Range16{Lo: 0x119, Hi: 0x119, Stride: 0x1},
+		unicode.Range16{Lo: 0x11b, Hi: 0x11b, Stride: 0x1},
+		unicode.Range16{Lo: 0x11d, Hi: 0x11d, Stride: 0x1},
+		unicode.Range16{Lo: 0x11f, Hi: 0x11f, Stride: 0x1},
+		unicode.Range16{Lo: 0x121, Hi: 0x121, Stride: 0x1},
+		unicode.Range16{Lo: 0x123, Hi: 0x123, Stride: 0x1},
+		unicode.Range16{Lo: 0x125, Hi: 0x125, Stride: 0x1},
+		unicode.Range16{Lo: 0x127, Hi: 0x127, Stride: 0x1},
+		unicode.Range16{Lo: 0x129, Hi: 0x129, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b, Hi: 0x12b, Stride: 0x1},
+		unicode.Range16{Lo: 0x12d, Hi: 0x12d, Stride: 0x1},
+		unicode.Range16{Lo: 0x12f, Hi: 0x12f, Stride: 0x1},
+		unicode.Range16{Lo: 0x131, Hi: 0x131, Stride: 0x1},
+		unicode.Range16{Lo: 0x133, Hi: 0x133, Stride: 0x1},
+		unicode.Range16{Lo: 0x135, Hi: 0x135, Stride: 0x1},
+		unicode.Range16{Lo: 0x137, Hi: 0x138, Stride: 0x1},
+		unicode.Range16{Lo: 0x13a, Hi: 0x13a, Stride: 0x1},
+		unicode.Range16{Lo: 0x13c, Hi: 0x13c, Stride: 0x1},
+		unicode.Range16{Lo: 0x13e, Hi: 0x13e, Stride: 0x1},
+		unicode.Range16{Lo: 0x140, Hi: 0x140, Stride: 0x1},
+		unicode.Range16{Lo: 0x142, Hi: 0x142, Stride: 0x1},
+		unicode.Range16{Lo: 0x144, Hi: 0x144, Stride: 0x1},
+		unicode.Range16{Lo: 0x146, Hi: 0x146, Stride: 0x1},
+		unicode.Range16{Lo: 0x148, Hi: 0x149, Stride: 0x1},
+		unicode.Range16{Lo: 0x14b, Hi: 0x14b, Stride: 0x1},
+		unicode.Range16{Lo: 0x14d, Hi: 0x14d, Stride: 0x1},
+		unicode.Range16{Lo: 0x14f, Hi: 0x14f, Stride: 0x1},
+		unicode.Range16{Lo: 0x151, Hi: 0x151, Stride: 0x1},
+		unicode.Range16{Lo: 0x153, Hi: 0x153, Stride: 0x1},
+		unicode.Range16{Lo: 0x155, Hi: 0x155, Stride: 0x1},
+		unicode.Range16{Lo: 0x157, Hi: 0x157, Stride: 0x1},
+		unicode.Range16{Lo: 0x159, Hi: 0x159, Stride: 0x1},
+		unicode.Range16{Lo: 0x15b, Hi: 0x15b, Stride: 0x1},
+		unicode.Range16{Lo: 0x15d, Hi: 0x15d, Stride: 0x1},
+		unicode.Range16{Lo: 0x15f, Hi: 0x15f, Stride: 0x1},
+		unicode.Range16{Lo: 0x161, Hi: 0x161, Stride: 0x1},
+		unicode.Range16{Lo: 0x163, Hi: 0x163, Stride: 0x1},
+		unicode.Range16{Lo: 0x165, Hi: 0x165, Stride: 0x1},
+		unicode.Range16{Lo: 0x167, Hi: 0x167, Stride: 0x1},
+		unicode.Range16{Lo: 0x169, Hi: 0x169, Stride: 0x1},
+		unicode.Range16{Lo: 0x16b, Hi: 0x16b, Stride: 0x1},
+		unicode.Range16{Lo: 0x16d, Hi: 0x16d, Stride: 0x1},
+		unicode.Range16{Lo: 0x16f, Hi: 0x16f, Stride: 0x1},
+		unicode.Range16{Lo: 0x171, Hi: 0x171, Stride: 0x1},
+		unicode.Range16{Lo: 0x173, Hi: 0x173, Stride: 0x1},
+		unicode.Range16{Lo: 0x175, Hi: 0x175, Stride: 0x1},
+		unicode.Range16{Lo: 0x177, Hi: 0x177, Stride: 0x1},
+		unicode.Range16{Lo: 0x17a, Hi: 0x17a, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c, Hi: 0x17c, Stride: 0x1},
+		unicode.Range16{Lo: 0x17e, Hi: 0x180, Stride: 0x1},
+		unicode.Range16{Lo: 0x183, Hi: 0x183, Stride: 0x1},
+		unicode.Range16{Lo: 0x185, Hi: 0x185, Stride: 0x1},
+		unicode.Range16{Lo: 0x188, Hi: 0x188, Stride: 0x1},
+		unicode.Range16{Lo: 0x18c, Hi: 0x18d, Stride: 0x1},
+		unicode.Range16{Lo: 0x192, Hi: 0x192, Stride: 0x1},
+		unicode.Range16{Lo: 0x195, Hi: 0x195, Stride: 0x1},
+		unicode.Range16{Lo: 0x199, Hi: 0x19b, Stride: 0x1},
+		unicode.Range16{Lo: 0x19e, Hi: 0x19e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1, Hi: 0x1a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a3, Hi: 0x1a3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a5, Hi: 0x1a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a8, Hi: 0x1a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1aa, Hi: 0x1ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ad, Hi: 0x1ad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b0, Hi: 0x1b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b4, Hi: 0x1b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6, Hi: 0x1b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b9, Hi: 0x1ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bd, Hi: 0x1bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c6, Hi: 0x1c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c9, Hi: 0x1c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cc, Hi: 0x1cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce, Hi: 0x1ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d0, Hi: 0x1d0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d2, Hi: 0x1d2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d4, Hi: 0x1d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d6, Hi: 0x1d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d8, Hi: 0x1d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1da, Hi: 0x1da, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc, Hi: 0x1dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1df, Hi: 0x1df, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1, Hi: 0x1e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3, Hi: 0x1e3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5, Hi: 0x1e5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7, Hi: 0x1e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e9, Hi: 0x1e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb, Hi: 0x1eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed, Hi: 0x1ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef, Hi: 0x1f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f3, Hi: 0x1f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5, Hi: 0x1f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f9, Hi: 0x1f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb, Hi: 0x1fb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd, Hi: 0x1fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff, Hi: 0x1ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x201, Hi: 0x201, Stride: 0x1},
+		unicode.Range16{Lo: 0x203, Hi: 0x203, Stride: 0x1},
+		unicode.Range16{Lo: 0x205, Hi: 0x205, Stride: 0x1},
+		unicode.Range16{Lo: 0x207, Hi: 0x207, Stride: 0x1},
+		unicode.Range16{Lo: 0x209, Hi: 0x209, Stride: 0x1},
+		unicode.Range16{Lo: 0x20b, Hi: 0x20b, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d, Hi: 0x20d, Stride: 0x1},
+		unicode.Range16{Lo: 0x20f, Hi: 0x20f, Stride: 0x1},
+		unicode.Range16{Lo: 0x211, Hi: 0x211, Stride: 0x1},
+		unicode.Range16{Lo: 0x213, Hi: 0x213, Stride: 0x1},
+		unicode.Range16{Lo: 0x215, Hi: 0x215, Stride: 0x1},
+		unicode.Range16{Lo: 0x217, Hi: 0x217, Stride: 0x1},
+		unicode.Range16{Lo: 0x219, Hi: 0x219, Stride: 0x1},
+		unicode.Range16{Lo: 0x21b, Hi: 0x21b, Stride: 0x1},
+		unicode.Range16{Lo: 0x21d, Hi: 0x21d, Stride: 0x1},
+		unicode.Range16{Lo: 0x21f, Hi: 0x21f, Stride: 0x1},
+		unicode.Range16{Lo: 0x221, Hi: 0x221, Stride: 0x1},
+		unicode.Range16{Lo: 0x223, Hi: 0x223, Stride: 0x1},
+		unicode.Range16{Lo: 0x225, Hi: 0x225, Stride: 0x1},
+		unicode.Range16{Lo: 0x227, Hi: 0x227, Stride: 0x1},
+		unicode.Range16{Lo: 0x229, Hi: 0x229, Stride: 0x1},
+		unicode.Range16{Lo: 0x22b, Hi: 0x22b, Stride: 0x1},
+		unicode.Range16{Lo: 0x22d, Hi: 0x22d, Stride: 0x1},
+		unicode.Range16{Lo: 0x22f, Hi: 0x22f, Stride: 0x1},
+		unicode.Range16{Lo: 0x231, Hi: 0x231, Stride: 0x1},
+		unicode.Range16{Lo: 0x233, Hi: 0x239, Stride: 0x1},
+		unicode.Range16{Lo: 0x23c, Hi: 0x23c, Stride: 0x1},
+		unicode.Range16{Lo: 0x23f, Hi: 0x240, Stride: 0x1},
+		unicode.Range16{Lo: 0x242, Hi: 0x242, Stride: 0x1},
+		unicode.Range16{Lo: 0x247, Hi: 0x247, Stride: 0x1},
+		unicode.Range16{Lo: 0x249, Hi: 0x249, Stride: 0x1},
+		unicode.Range16{Lo: 0x24b, Hi: 0x24b, Stride: 0x1},
+		unicode.Range16{Lo: 0x24d, Hi: 0x24d, Stride: 0x1},
+		unicode.Range16{Lo: 0x24f, Hi: 0x293, Stride: 0x1},
+		unicode.Range16{Lo: 0x295, Hi: 0x2af, Stride: 0x1},
+		unicode.Range16{Lo: 0x2b0, Hi: 0x2b8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c0, Hi: 0x2c1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0, Hi: 0x2e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x371, Hi: 0x371, Stride: 0x1},
+		unicode.Range16{Lo: 0x373, Hi: 0x373, Stride: 0x1},
+		unicode.Range16{Lo: 0x377, Hi: 0x377, Stride: 0x1},
+		unicode.Range16{Lo: 0x37a, Hi: 0x37a, Stride: 0x1},
+		unicode.Range16{Lo: 0x37b, Hi: 0x37d, Stride: 0x1},
+		unicode.Range16{Lo: 0x390, Hi: 0x390, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ac, Hi: 0x3ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d0, Hi: 0x3d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d5, Hi: 0x3d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d9, Hi: 0x3d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x3db, Hi: 0x3db, Stride: 0x1},
+		unicode.Range16{Lo: 0x3dd, Hi: 0x3dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x3df, Hi: 0x3df, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e1, Hi: 0x3e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e3, Hi: 0x3e3, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e5, Hi: 0x3e5, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e7, Hi: 0x3e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e9, Hi: 0x3e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x3eb, Hi: 0x3eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ed, Hi: 0x3ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ef, Hi: 0x3f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f5, Hi: 0x3f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f8, Hi: 0x3f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x3fb, Hi: 0x3fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x430, Hi: 0x45f, Stride: 0x1},
+		unicode.Range16{Lo: 0x461, Hi: 0x461, Stride: 0x1},
+		unicode.Range16{Lo: 0x463, Hi: 0x463, Stride: 0x1},
+		unicode.Range16{Lo: 0x465, Hi: 0x465, Stride: 0x1},
+		unicode.Range16{Lo: 0x467, Hi: 0x467, Stride: 0x1},
+		unicode.Range16{Lo: 0x469, Hi: 0x469, Stride: 0x1},
+		unicode.Range16{Lo: 0x46b, Hi: 0x46b, Stride: 0x1},
+		unicode.Range16{Lo: 0x46d, Hi: 0x46d, Stride: 0x1},
+		unicode.Range16{Lo: 0x46f, Hi: 0x46f, Stride: 0x1},
+		unicode.Range16{Lo: 0x471, Hi: 0x471, Stride: 0x1},
+		unicode.Range16{Lo: 0x473, Hi: 0x473, Stride: 0x1},
+		unicode.Range16{Lo: 0x475, Hi: 0x475, Stride: 0x1},
+		unicode.Range16{Lo: 0x477, Hi: 0x477, Stride: 0x1},
+		unicode.Range16{Lo: 0x479, Hi: 0x479, Stride: 0x1},
+		unicode.Range16{Lo: 0x47b, Hi: 0x47b, Stride: 0x1},
+		unicode.Range16{Lo: 0x47d, Hi: 0x47d, Stride: 0x1},
+		unicode.Range16{Lo: 0x47f, Hi: 0x47f, Stride: 0x1},
+		unicode.Range16{Lo: 0x481, Hi: 0x481, Stride: 0x1},
+		unicode.Range16{Lo: 0x48b, Hi: 0x48b, Stride: 0x1},
+		unicode.Range16{Lo: 0x48d, Hi: 0x48d, Stride: 0x1},
+		unicode.Range16{Lo: 0x48f, Hi: 0x48f, Stride: 0x1},
+		unicode.Range16{Lo: 0x491, Hi: 0x491, Stride: 0x1},
+		unicode.Range16{Lo: 0x493, Hi: 0x493, Stride: 0x1},
+		unicode.Range16{Lo: 0x495, Hi: 0x495, Stride: 0x1},
+		unicode.Range16{Lo: 0x497, Hi: 0x497, Stride: 0x1},
+		unicode.Range16{Lo: 0x499, Hi: 0x499, Stride: 0x1},
+		unicode.Range16{Lo: 0x49b, Hi: 0x49b, Stride: 0x1},
+		unicode.Range16{Lo: 0x49d, Hi: 0x49d, Stride: 0x1},
+		unicode.Range16{Lo: 0x49f, Hi: 0x49f, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a1, Hi: 0x4a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a3, Hi: 0x4a3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a5, Hi: 0x4a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a7, Hi: 0x4a7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a9, Hi: 0x4a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ab, Hi: 0x4ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ad, Hi: 0x4ad, Stride: 0x1},
+		unicode.Range16{Lo: 0x4af, Hi: 0x4af, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b1, Hi: 0x4b1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b3, Hi: 0x4b3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b5, Hi: 0x4b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b7, Hi: 0x4b7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b9, Hi: 0x4b9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bb, Hi: 0x4bb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bd, Hi: 0x4bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bf, Hi: 0x4bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c2, Hi: 0x4c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c4, Hi: 0x4c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c6, Hi: 0x4c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c8, Hi: 0x4c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ca, Hi: 0x4ca, Stride: 0x1},
+		unicode.Range16{Lo: 0x4cc, Hi: 0x4cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ce, Hi: 0x4cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d1, Hi: 0x4d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d3, Hi: 0x4d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d5, Hi: 0x4d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d7, Hi: 0x4d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d9, Hi: 0x4d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4db, Hi: 0x4db, Stride: 0x1},
+		unicode.Range16{Lo: 0x4dd, Hi: 0x4dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4df, Hi: 0x4df, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e1, Hi: 0x4e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e3, Hi: 0x4e3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e5, Hi: 0x4e5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e7, Hi: 0x4e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e9, Hi: 0x4e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4eb, Hi: 0x4eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ed, Hi: 0x4ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ef, Hi: 0x4ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f1, Hi: 0x4f1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f3, Hi: 0x4f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f5, Hi: 0x4f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f7, Hi: 0x4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f9, Hi: 0x4f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fb, Hi: 0x4fb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fd, Hi: 0x4fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ff, Hi: 0x4ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x501, Hi: 0x501, Stride: 0x1},
+		unicode.Range16{Lo: 0x503, Hi: 0x503, Stride: 0x1},
+		unicode.Range16{Lo: 0x505, Hi: 0x505, Stride: 0x1},
+		unicode.Range16{Lo: 0x507, Hi: 0x507, Stride: 0x1},
+		unicode.Range16{Lo: 0x509, Hi: 0x509, Stride: 0x1},
+		unicode.Range16{Lo: 0x50b, Hi: 0x50b, Stride: 0x1},
+		unicode.Range16{Lo: 0x50d, Hi: 0x50d, Stride: 0x1},
+		unicode.Range16{Lo: 0x50f, Hi: 0x50f, Stride: 0x1},
+		unicode.Range16{Lo: 0x511, Hi: 0x511, Stride: 0x1},
+		unicode.Range16{Lo: 0x513, Hi: 0x513, Stride: 0x1},
+		unicode.Range16{Lo: 0x515, Hi: 0x515, Stride: 0x1},
+		unicode.Range16{Lo: 0x517, Hi: 0x517, Stride: 0x1},
+		unicode.Range16{Lo: 0x519, Hi: 0x519, Stride: 0x1},
+		unicode.Range16{Lo: 0x51b, Hi: 0x51b, Stride: 0x1},
+		unicode.Range16{Lo: 0x51d, Hi: 0x51d, Stride: 0x1},
+		unicode.Range16{Lo: 0x51f, Hi: 0x51f, Stride: 0x1},
+		unicode.Range16{Lo: 0x521, Hi: 0x521, Stride: 0x1},
+		unicode.Range16{Lo: 0x523, Hi: 0x523, Stride: 0x1},
+		unicode.Range16{Lo: 0x525, Hi: 0x525, Stride: 0x1},
+		unicode.Range16{Lo: 0x527, Hi: 0x527, Stride: 0x1},
+		unicode.Range16{Lo: 0x529, Hi: 0x529, Stride: 0x1},
+		unicode.Range16{Lo: 0x52b, Hi: 0x52b, Stride: 0x1},
+		unicode.Range16{Lo: 0x52d, Hi: 0x52d, Stride: 0x1},
+		unicode.Range16{Lo: 0x52f, Hi: 0x52f, Stride: 0x1},
+		unicode.Range16{Lo: 0x561, Hi: 0x587, Stride: 0x1},
+		unicode.Range16{Lo: 0x13f8, Hi: 0x13fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c80, Hi: 0x1c88, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d00, Hi: 0x1d2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d2c, Hi: 0x1d6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d6b, Hi: 0x1d77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d78, Hi: 0x1d78, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d79, Hi: 0x1d9a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d9b, Hi: 0x1dbf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e01, Hi: 0x1e01, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e03, Hi: 0x1e03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e05, Hi: 0x1e05, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e07, Hi: 0x1e07, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e09, Hi: 0x1e09, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0b, Hi: 0x1e0b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0d, Hi: 0x1e0d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0f, Hi: 0x1e0f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e11, Hi: 0x1e11, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e13, Hi: 0x1e13, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e15, Hi: 0x1e15, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e17, Hi: 0x1e17, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e19, Hi: 0x1e19, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1b, Hi: 0x1e1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1d, Hi: 0x1e1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1f, Hi: 0x1e1f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e21, Hi: 0x1e21, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e23, Hi: 0x1e23, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e25, Hi: 0x1e25, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e27, Hi: 0x1e27, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e29, Hi: 0x1e29, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2b, Hi: 0x1e2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2d, Hi: 0x1e2d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2f, Hi: 0x1e2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e31, Hi: 0x1e31, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e33, Hi: 0x1e33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e35, Hi: 0x1e35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e37, Hi: 0x1e37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e39, Hi: 0x1e39, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3b, Hi: 0x1e3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3d, Hi: 0x1e3d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3f, Hi: 0x1e3f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e41, Hi: 0x1e41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e43, Hi: 0x1e43, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e45, Hi: 0x1e45, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e47, Hi: 0x1e47, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e49, Hi: 0x1e49, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4b, Hi: 0x1e4b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4d, Hi: 0x1e4d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4f, Hi: 0x1e4f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e51, Hi: 0x1e51, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e53, Hi: 0x1e53, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e55, Hi: 0x1e55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e57, Hi: 0x1e57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e59, Hi: 0x1e59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5b, Hi: 0x1e5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5d, Hi: 0x1e5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5f, Hi: 0x1e5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e61, Hi: 0x1e61, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e63, Hi: 0x1e63, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e65, Hi: 0x1e65, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e67, Hi: 0x1e67, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e69, Hi: 0x1e69, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6b, Hi: 0x1e6b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6d, Hi: 0x1e6d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6f, Hi: 0x1e6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e71, Hi: 0x1e71, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e73, Hi: 0x1e73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e75, Hi: 0x1e75, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e77, Hi: 0x1e77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e79, Hi: 0x1e79, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7b, Hi: 0x1e7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7d, Hi: 0x1e7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7f, Hi: 0x1e7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e81, Hi: 0x1e81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e83, Hi: 0x1e83, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e85, Hi: 0x1e85, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e87, Hi: 0x1e87, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e89, Hi: 0x1e89, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8b, Hi: 0x1e8b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8d, Hi: 0x1e8d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8f, Hi: 0x1e8f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e91, Hi: 0x1e91, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e93, Hi: 0x1e93, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e95, Hi: 0x1e9d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e9f, Hi: 0x1e9f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea1, Hi: 0x1ea1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea3, Hi: 0x1ea3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea5, Hi: 0x1ea5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea7, Hi: 0x1ea7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea9, Hi: 0x1ea9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eab, Hi: 0x1eab, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ead, Hi: 0x1ead, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eaf, Hi: 0x1eaf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb1, Hi: 0x1eb1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb3, Hi: 0x1eb3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb5, Hi: 0x1eb5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb7, Hi: 0x1eb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb9, Hi: 0x1eb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebb, Hi: 0x1ebb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebd, Hi: 0x1ebd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebf, Hi: 0x1ebf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec1, Hi: 0x1ec1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec3, Hi: 0x1ec3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec5, Hi: 0x1ec5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec7, Hi: 0x1ec7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec9, Hi: 0x1ec9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecb, Hi: 0x1ecb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecd, Hi: 0x1ecd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecf, Hi: 0x1ecf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed1, Hi: 0x1ed1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed3, Hi: 0x1ed3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed5, Hi: 0x1ed5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed7, Hi: 0x1ed7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed9, Hi: 0x1ed9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edb, Hi: 0x1edb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edd, Hi: 0x1edd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edf, Hi: 0x1edf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee1, Hi: 0x1ee1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee3, Hi: 0x1ee3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee5, Hi: 0x1ee5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee7, Hi: 0x1ee7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee9, Hi: 0x1ee9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eeb, Hi: 0x1eeb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eed, Hi: 0x1eed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eef, Hi: 0x1eef, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef1, Hi: 0x1ef1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef3, Hi: 0x1ef3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef5, Hi: 0x1ef5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef7, Hi: 0x1ef7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef9, Hi: 0x1ef9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efb, Hi: 0x1efb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efd, Hi: 0x1efd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eff, Hi: 0x1f07, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f10, Hi: 0x1f15, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f20, Hi: 0x1f27, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f30, Hi: 0x1f37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f40, Hi: 0x1f45, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f50, Hi: 0x1f57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f60, Hi: 0x1f67, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f70, Hi: 0x1f7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f80, Hi: 0x1f87, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f90, Hi: 0x1f97, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fa0, Hi: 0x1fa7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb0, Hi: 0x1fb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb6, Hi: 0x1fb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fbe, Hi: 0x1fbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc2, Hi: 0x1fc4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc6, Hi: 0x1fc7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd0, Hi: 0x1fd3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd6, Hi: 0x1fd7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe0, Hi: 0x1fe7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff2, Hi: 0x1ff4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff6, Hi: 0x1ff7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2071, Hi: 0x2071, Stride: 0x1},
+		unicode.Range16{Lo: 0x207f, Hi: 0x207f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2090, Hi: 0x209c, Stride: 0x1},
+		unicode.Range16{Lo: 0x210a, Hi: 0x210a, Stride: 0x1},
+		unicode.Range16{Lo: 0x210e, Hi: 0x210f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2113, Hi: 0x2113, Stride: 0x1},
+		unicode.Range16{Lo: 0x212f, Hi: 0x212f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2134, Hi: 0x2134, Stride: 0x1},
+		unicode.Range16{Lo: 0x2139, Hi: 0x2139, Stride: 0x1},
+		unicode.Range16{Lo: 0x213c, Hi: 0x213d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2146, Hi: 0x2149, Stride: 0x1},
+		unicode.Range16{Lo: 0x214e, Hi: 0x214e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2170, Hi: 0x217f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2184, Hi: 0x2184, Stride: 0x1},
+		unicode.Range16{Lo: 0x24d0, Hi: 0x24e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c30, Hi: 0x2c5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c61, Hi: 0x2c61, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c65, Hi: 0x2c66, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c68, Hi: 0x2c68, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6a, Hi: 0x2c6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6c, Hi: 0x2c6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c71, Hi: 0x2c71, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c73, Hi: 0x2c74, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c76, Hi: 0x2c7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7c, Hi: 0x2c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c81, Hi: 0x2c81, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c83, Hi: 0x2c83, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c85, Hi: 0x2c85, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c87, Hi: 0x2c87, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c89, Hi: 0x2c89, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8b, Hi: 0x2c8b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8d, Hi: 0x2c8d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8f, Hi: 0x2c8f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c91, Hi: 0x2c91, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c93, Hi: 0x2c93, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c95, Hi: 0x2c95, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c97, Hi: 0x2c97, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c99, Hi: 0x2c99, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9b, Hi: 0x2c9b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9d, Hi: 0x2c9d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9f, Hi: 0x2c9f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca1, Hi: 0x2ca1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca3, Hi: 0x2ca3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca5, Hi: 0x2ca5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca7, Hi: 0x2ca7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca9, Hi: 0x2ca9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cab, Hi: 0x2cab, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cad, Hi: 0x2cad, Stride: 0x1},
+		unicode.Range16{Lo: 0x2caf, Hi: 0x2caf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb1, Hi: 0x2cb1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb3, Hi: 0x2cb3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb5, Hi: 0x2cb5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb7, Hi: 0x2cb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb9, Hi: 0x2cb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbb, Hi: 0x2cbb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbd, Hi: 0x2cbd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbf, Hi: 0x2cbf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc1, Hi: 0x2cc1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc3, Hi: 0x2cc3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc5, Hi: 0x2cc5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc7, Hi: 0x2cc7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc9, Hi: 0x2cc9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccb, Hi: 0x2ccb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccd, Hi: 0x2ccd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccf, Hi: 0x2ccf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd1, Hi: 0x2cd1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd3, Hi: 0x2cd3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd5, Hi: 0x2cd5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd7, Hi: 0x2cd7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd9, Hi: 0x2cd9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdb, Hi: 0x2cdb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdd, Hi: 0x2cdd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdf, Hi: 0x2cdf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce1, Hi: 0x2ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce3, Hi: 0x2ce4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cec, Hi: 0x2cec, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cee, Hi: 0x2cee, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cf3, Hi: 0x2cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d00, Hi: 0x2d25, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d27, Hi: 0x2d27, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d2d, Hi: 0x2d2d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa641, Hi: 0xa641, Stride: 0x1},
+		unicode.Range16{Lo: 0xa643, Hi: 0xa643, Stride: 0x1},
+		unicode.Range16{Lo: 0xa645, Hi: 0xa645, Stride: 0x1},
+		unicode.Range16{Lo: 0xa647, Hi: 0xa647, Stride: 0x1},
+		unicode.Range16{Lo: 0xa649, Hi: 0xa649, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64b, Hi: 0xa64b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64d, Hi: 0xa64d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64f, Hi: 0xa64f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa651, Hi: 0xa651, Stride: 0x1},
+		unicode.Range16{Lo: 0xa653, Hi: 0xa653, Stride: 0x1},
+		unicode.Range16{Lo: 0xa655, Hi: 0xa655, Stride: 0x1},
+		unicode.Range16{Lo: 0xa657, Hi: 0xa657, Stride: 0x1},
+		unicode.Range16{Lo: 0xa659, Hi: 0xa659, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65b, Hi: 0xa65b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65d, Hi: 0xa65d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65f, Hi: 0xa65f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa661, Hi: 0xa661, Stride: 0x1},
+		unicode.Range16{Lo: 0xa663, Hi: 0xa663, Stride: 0x1},
+		unicode.Range16{Lo: 0xa665, Hi: 0xa665, Stride: 0x1},
+		unicode.Range16{Lo: 0xa667, Hi: 0xa667, Stride: 0x1},
+		unicode.Range16{Lo: 0xa669, Hi: 0xa669, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66b, Hi: 0xa66b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66d, Hi: 0xa66d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa681, Hi: 0xa681, Stride: 0x1},
+		unicode.Range16{Lo: 0xa683, Hi: 0xa683, Stride: 0x1},
+		unicode.Range16{Lo: 0xa685, Hi: 0xa685, Stride: 0x1},
+		unicode.Range16{Lo: 0xa687, Hi: 0xa687, Stride: 0x1},
+		unicode.Range16{Lo: 0xa689, Hi: 0xa689, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68b, Hi: 0xa68b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68d, Hi: 0xa68d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68f, Hi: 0xa68f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa691, Hi: 0xa691, Stride: 0x1},
+		unicode.Range16{Lo: 0xa693, Hi: 0xa693, Stride: 0x1},
+		unicode.Range16{Lo: 0xa695, Hi: 0xa695, Stride: 0x1},
+		unicode.Range16{Lo: 0xa697, Hi: 0xa697, Stride: 0x1},
+		unicode.Range16{Lo: 0xa699, Hi: 0xa699, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69b, Hi: 0xa69b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69c, Hi: 0xa69d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa723, Hi: 0xa723, Stride: 0x1},
+		unicode.Range16{Lo: 0xa725, Hi: 0xa725, Stride: 0x1},
+		unicode.Range16{Lo: 0xa727, Hi: 0xa727, Stride: 0x1},
+		unicode.Range16{Lo: 0xa729, Hi: 0xa729, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72b, Hi: 0xa72b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72d, Hi: 0xa72d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72f, Hi: 0xa731, Stride: 0x1},
+		unicode.Range16{Lo: 0xa733, Hi: 0xa733, Stride: 0x1},
+		unicode.Range16{Lo: 0xa735, Hi: 0xa735, Stride: 0x1},
+		unicode.Range16{Lo: 0xa737, Hi: 0xa737, Stride: 0x1},
+		unicode.Range16{Lo: 0xa739, Hi: 0xa739, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73b, Hi: 0xa73b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73d, Hi: 0xa73d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73f, Hi: 0xa73f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa741, Hi: 0xa741, Stride: 0x1},
+		unicode.Range16{Lo: 0xa743, Hi: 0xa743, Stride: 0x1},
+		unicode.Range16{Lo: 0xa745, Hi: 0xa745, Stride: 0x1},
+		unicode.Range16{Lo: 0xa747, Hi: 0xa747, Stride: 0x1},
+		unicode.Range16{Lo: 0xa749, Hi: 0xa749, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74b, Hi: 0xa74b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74d, Hi: 0xa74d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74f, Hi: 0xa74f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa751, Hi: 0xa751, Stride: 0x1},
+		unicode.Range16{Lo: 0xa753, Hi: 0xa753, Stride: 0x1},
+		unicode.Range16{Lo: 0xa755, Hi: 0xa755, Stride: 0x1},
+		unicode.Range16{Lo: 0xa757, Hi: 0xa757, Stride: 0x1},
+		unicode.Range16{Lo: 0xa759, Hi: 0xa759, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75b, Hi: 0xa75b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75d, Hi: 0xa75d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75f, Hi: 0xa75f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa761, Hi: 0xa761, Stride: 0x1},
+		unicode.Range16{Lo: 0xa763, Hi: 0xa763, Stride: 0x1},
+		unicode.Range16{Lo: 0xa765, Hi: 0xa765, Stride: 0x1},
+		unicode.Range16{Lo: 0xa767, Hi: 0xa767, Stride: 0x1},
+		unicode.Range16{Lo: 0xa769, Hi: 0xa769, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76b, Hi: 0xa76b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76d, Hi: 0xa76d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76f, Hi: 0xa76f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa770, Hi: 0xa770, Stride: 0x1},
+		unicode.Range16{Lo: 0xa771, Hi: 0xa778, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77a, Hi: 0xa77a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77c, Hi: 0xa77c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77f, Hi: 0xa77f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa781, Hi: 0xa781, Stride: 0x1},
+		unicode.Range16{Lo: 0xa783, Hi: 0xa783, Stride: 0x1},
+		unicode.Range16{Lo: 0xa785, Hi: 0xa785, Stride: 0x1},
+		unicode.Range16{Lo: 0xa787, Hi: 0xa787, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78c, Hi: 0xa78c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78e, Hi: 0xa78e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa791, Hi: 0xa791, Stride: 0x1},
+		unicode.Range16{Lo: 0xa793, Hi: 0xa795, Stride: 0x1},
+		unicode.Range16{Lo: 0xa797, Hi: 0xa797, Stride: 0x1},
+		unicode.Range16{Lo: 0xa799, Hi: 0xa799, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79b, Hi: 0xa79b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79d, Hi: 0xa79d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79f, Hi: 0xa79f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a1, Hi: 0xa7a1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a3, Hi: 0xa7a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a5, Hi: 0xa7a5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a7, Hi: 0xa7a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a9, Hi: 0xa7a9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b5, Hi: 0xa7b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b7, Hi: 0xa7b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f8, Hi: 0xa7f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fa, Hi: 0xa7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0xab30, Hi: 0xab5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5c, Hi: 0xab5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xab60, Hi: 0xab65, Stride: 0x1},
+		unicode.Range16{Lo: 0xab70, Hi: 0xabbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb00, Hi: 0xfb06, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb13, Hi: 0xfb17, Stride: 0x1},
+		unicode.Range16{Lo: 0xff41, Hi: 0xff5a, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10428, Hi: 0x1044f, Stride: 0x1},
+		unicode.Range32{Lo: 0x104d8, Hi: 0x104fb, Stride: 0x1},
+		unicode.Range32{Lo: 0x10cc0, Hi: 0x10cf2, Stride: 0x1},
+		unicode.Range32{Lo: 0x118c0, Hi: 0x118df, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d41a, Hi: 0x1d433, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d44e, Hi: 0x1d454, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d456, Hi: 0x1d467, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d482, Hi: 0x1d49b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4b6, Hi: 0x1d4b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bb, Hi: 0x1d4bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bd, Hi: 0x1d4c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4c5, Hi: 0x1d4cf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4ea, Hi: 0x1d503, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d51e, Hi: 0x1d537, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d552, Hi: 0x1d56b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d586, Hi: 0x1d59f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5ba, Hi: 0x1d5d3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5ee, Hi: 0x1d607, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d622, Hi: 0x1d63b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d656, Hi: 0x1d66f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d68a, Hi: 0x1d6a5, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6c2, Hi: 0x1d6da, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6dc, Hi: 0x1d6e1, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6fc, Hi: 0x1d714, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d716, Hi: 0x1d71b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d736, Hi: 0x1d74e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d750, Hi: 0x1d755, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d770, Hi: 0x1d788, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d78a, Hi: 0x1d78f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7aa, Hi: 0x1d7c2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7c4, Hi: 0x1d7c9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7cb, Hi: 0x1d7cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e922, Hi: 0x1e943, Stride: 0x1},
+	},
+	LatinOffset: 6,
+}
+
+var _SentenceNumeric = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x30, Hi: 0x39, Stride: 0x1},
+		unicode.Range16{Lo: 0x660, Hi: 0x669, Stride: 0x1},
+		unicode.Range16{Lo: 0x66b, Hi: 0x66c, Stride: 0x1},
+		unicode.Range16{Lo: 0x6f0, Hi: 0x6f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x7c0, Hi: 0x7c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x966, Hi: 0x96f, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e6, Hi: 0x9ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66, Hi: 0xa6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xae6, Hi: 0xaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xb66, Hi: 0xb6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe6, Hi: 0xbef, Stride: 0x1},
+		unicode.Range16{Lo: 0xc66, Hi: 0xc6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce6, Hi: 0xcef, Stride: 0x1},
+		unicode.Range16{Lo: 0xd66, Hi: 0xd6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xde6, Hi: 0xdef, Stride: 0x1},
+		unicode.Range16{Lo: 0xe50, Hi: 0xe59, Stride: 0x1},
+		unicode.Range16{Lo: 0xed0, Hi: 0xed9, Stride: 0x1},
+		unicode.Range16{Lo: 0xf20, Hi: 0xf29, Stride: 0x1},
+		unicode.Range16{Lo: 0x1040, Hi: 0x1049, Stride: 0x1},
+		unicode.Range16{Lo: 0x1090, Hi: 0x1099, Stride: 0x1},
+		unicode.Range16{Lo: 0x17e0, Hi: 0x17e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1810, Hi: 0x1819, Stride: 0x1},
+		unicode.Range16{Lo: 0x1946, Hi: 0x194f, Stride: 0x1},
+		unicode.Range16{Lo: 0x19d0, Hi: 0x19d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a80, Hi: 0x1a89, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a90, Hi: 0x1a99, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b50, Hi: 0x1b59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bb0, Hi: 0x1bb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c40, Hi: 0x1c49, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c50, Hi: 0x1c59, Stride: 0x1},
+		unicode.Range16{Lo: 0xa620, Hi: 0xa629, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8d0, Hi: 0xa8d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa900, Hi: 0xa909, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9d0, Hi: 0xa9d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9f0, Hi: 0xa9f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa50, Hi: 0xaa59, Stride: 0x1},
+		unicode.Range16{Lo: 0xabf0, Hi: 0xabf9, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x104a0, Hi: 0x104a9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11066, Hi: 0x1106f, Stride: 0x1},
+		unicode.Range32{Lo: 0x110f0, Hi: 0x110f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11136, Hi: 0x1113f, Stride: 0x1},
+		unicode.Range32{Lo: 0x111d0, Hi: 0x111d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x112f0, Hi: 0x112f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11450, Hi: 0x11459, Stride: 0x1},
+		unicode.Range32{Lo: 0x114d0, Hi: 0x114d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11650, Hi: 0x11659, Stride: 0x1},
+		unicode.Range32{Lo: 0x116c0, Hi: 0x116c9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11730, Hi: 0x11739, Stride: 0x1},
+		unicode.Range32{Lo: 0x118e0, Hi: 0x118e9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c50, Hi: 0x11c59, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a60, Hi: 0x16a69, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b50, Hi: 0x16b59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7ce, Hi: 0x1d7ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e950, Hi: 0x1e959, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceOLetter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x1bb, Hi: 0x1bb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c0, Hi: 0x1c3, Stride: 0x1},
+		unicode.Range16{Lo: 0x294, Hi: 0x294, Stride: 0x1},
+		unicode.Range16{Lo: 0x2b9, Hi: 0x2bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6, Hi: 0x2d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ec, Hi: 0x2ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ee, Hi: 0x2ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x374, Hi: 0x374, Stride: 0x1},
+		unicode.Range16{Lo: 0x559, Hi: 0x559, Stride: 0x1},
+		unicode.Range16{Lo: 0x5d0, Hi: 0x5ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f0, Hi: 0x5f2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f3, Hi: 0x5f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x620, Hi: 0x63f, Stride: 0x1},
+		unicode.Range16{Lo: 0x640, Hi: 0x640, Stride: 0x1},
+		unicode.Range16{Lo: 0x641, Hi: 0x64a, Stride: 0x1},
+		unicode.Range16{Lo: 0x66e, Hi: 0x66f, Stride: 0x1},
+		unicode.Range16{Lo: 0x671, Hi: 0x6d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d5, Hi: 0x6d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e5, Hi: 0x6e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ee, Hi: 0x6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x6fa, Hi: 0x6fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ff, Hi: 0x6ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x710, Hi: 0x710, Stride: 0x1},
+		unicode.Range16{Lo: 0x712, Hi: 0x72f, Stride: 0x1},
+		unicode.Range16{Lo: 0x74d, Hi: 0x7a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7b1, Hi: 0x7b1, Stride: 0x1},
+		unicode.Range16{Lo: 0x7ca, Hi: 0x7ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f4, Hi: 0x7f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7fa, Hi: 0x7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x800, Hi: 0x815, Stride: 0x1},
+		unicode.Range16{Lo: 0x81a, Hi: 0x81a, Stride: 0x1},
+		unicode.Range16{Lo: 0x824, Hi: 0x824, Stride: 0x1},
+		unicode.Range16{Lo: 0x828, Hi: 0x828, Stride: 0x1},
+		unicode.Range16{Lo: 0x840, Hi: 0x858, Stride: 0x1},
+		unicode.Range16{Lo: 0x8a0, Hi: 0x8b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x8b6, Hi: 0x8bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x904, Hi: 0x939, Stride: 0x1},
+		unicode.Range16{Lo: 0x93d, Hi: 0x93d, Stride: 0x1},
+		unicode.Range16{Lo: 0x950, Hi: 0x950, Stride: 0x1},
+		unicode.Range16{Lo: 0x958, Hi: 0x961, Stride: 0x1},
+		unicode.Range16{Lo: 0x971, Hi: 0x971, Stride: 0x1},
+		unicode.Range16{Lo: 0x972, Hi: 0x980, Stride: 0x1},
+		unicode.Range16{Lo: 0x985, Hi: 0x98c, Stride: 0x1},
+		unicode.Range16{Lo: 0x98f, Hi: 0x990, Stride: 0x1},
+		unicode.Range16{Lo: 0x993, Hi: 0x9a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9aa, Hi: 0x9b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b2, Hi: 0x9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b6, Hi: 0x9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bd, Hi: 0x9bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9ce, Hi: 0x9ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x9dc, Hi: 0x9dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9df, Hi: 0x9e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x9f0, Hi: 0x9f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa05, Hi: 0xa0a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa0f, Hi: 0xa10, Stride: 0x1},
+		unicode.Range16{Lo: 0xa13, Hi: 0xa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xa2a, Hi: 0xa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xa32, Hi: 0xa33, Stride: 0x1},
+		unicode.Range16{Lo: 0xa35, Hi: 0xa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xa38, Hi: 0xa39, Stride: 0x1},
+		unicode.Range16{Lo: 0xa59, Hi: 0xa5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa5e, Hi: 0xa5e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72, Hi: 0xa74, Stride: 0x1},
+		unicode.Range16{Lo: 0xa85, Hi: 0xa8d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f, Hi: 0xa91, Stride: 0x1},
+		unicode.Range16{Lo: 0xa93, Hi: 0xaa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaa, Hi: 0xab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xab2, Hi: 0xab3, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5, Hi: 0xab9, Stride: 0x1},
+		unicode.Range16{Lo: 0xabd, Hi: 0xabd, Stride: 0x1},
+		unicode.Range16{Lo: 0xad0, Hi: 0xad0, Stride: 0x1},
+		unicode.Range16{Lo: 0xae0, Hi: 0xae1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9, Hi: 0xaf9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb05, Hi: 0xb0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0f, Hi: 0xb10, Stride: 0x1},
+		unicode.Range16{Lo: 0xb13, Hi: 0xb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2a, Hi: 0xb30, Stride: 0x1},
+		unicode.Range16{Lo: 0xb32, Hi: 0xb33, Stride: 0x1},
+		unicode.Range16{Lo: 0xb35, Hi: 0xb39, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3d, Hi: 0xb3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5c, Hi: 0xb5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f, Hi: 0xb61, Stride: 0x1},
+		unicode.Range16{Lo: 0xb71, Hi: 0xb71, Stride: 0x1},
+		unicode.Range16{Lo: 0xb83, Hi: 0xb83, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85, Hi: 0xb8a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e, Hi: 0xb90, Stride: 0x1},
+		unicode.Range16{Lo: 0xb92, Hi: 0xb95, Stride: 0x1},
+		unicode.Range16{Lo: 0xb99, Hi: 0xb9a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c, Hi: 0xb9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e, Hi: 0xb9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xba3, Hi: 0xba4, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8, Hi: 0xbaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae, Hi: 0xbb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd0, Hi: 0xbd0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc05, Hi: 0xc0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e, Hi: 0xc10, Stride: 0x1},
+		unicode.Range16{Lo: 0xc12, Hi: 0xc28, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a, Hi: 0xc39, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d, Hi: 0xc3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc58, Hi: 0xc5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xc60, Hi: 0xc61, Stride: 0x1},
+		unicode.Range16{Lo: 0xc80, Hi: 0xc80, Stride: 0x1},
+		unicode.Range16{Lo: 0xc85, Hi: 0xc8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e, Hi: 0xc90, Stride: 0x1},
+		unicode.Range16{Lo: 0xc92, Hi: 0xca8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa, Hi: 0xcb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb5, Hi: 0xcb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd, Hi: 0xcbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde, Hi: 0xcde, Stride: 0x1},
+		unicode.Range16{Lo: 0xce0, Hi: 0xce1, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1, Hi: 0xcf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xd05, Hi: 0xd0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0e, Hi: 0xd10, Stride: 0x1},
+		unicode.Range16{Lo: 0xd12, Hi: 0xd3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d, Hi: 0xd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e, Hi: 0xd4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xd54, Hi: 0xd56, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5f, Hi: 0xd61, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7a, Hi: 0xd7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd85, Hi: 0xd96, Stride: 0x1},
+		unicode.Range16{Lo: 0xd9a, Hi: 0xdb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdb3, Hi: 0xdbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xdbd, Hi: 0xdbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xdc0, Hi: 0xdc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xe01, Hi: 0xe30, Stride: 0x1},
+		unicode.Range16{Lo: 0xe32, Hi: 0xe33, Stride: 0x1},
+		unicode.Range16{Lo: 0xe40, Hi: 0xe45, Stride: 0x1},
+		unicode.Range16{Lo: 0xe46, Hi: 0xe46, Stride: 0x1},
+		unicode.Range16{Lo: 0xe81, Hi: 0xe82, Stride: 0x1},
+		unicode.Range16{Lo: 0xe84, Hi: 0xe84, Stride: 0x1},
+		unicode.Range16{Lo: 0xe87, Hi: 0xe88, Stride: 0x1},
+		unicode.Range16{Lo: 0xe8a, Hi: 0xe8a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe8d, Hi: 0xe8d, Stride: 0x1},
+		unicode.Range16{Lo: 0xe94, Hi: 0xe97, Stride: 0x1},
+		unicode.Range16{Lo: 0xe99, Hi: 0xe9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xea1, Hi: 0xea3, Stride: 0x1},
+		unicode.Range16{Lo: 0xea5, Hi: 0xea5, Stride: 0x1},
+		unicode.Range16{Lo: 0xea7, Hi: 0xea7, Stride: 0x1},
+		unicode.Range16{Lo: 0xeaa, Hi: 0xeab, Stride: 0x1},
+		unicode.Range16{Lo: 0xead, Hi: 0xeb0, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb2, Hi: 0xeb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xebd, Hi: 0xebd, Stride: 0x1},
+		unicode.Range16{Lo: 0xec0, Hi: 0xec4, Stride: 0x1},
+		unicode.Range16{Lo: 0xec6, Hi: 0xec6, Stride: 0x1},
+		unicode.Range16{Lo: 0xedc, Hi: 0xedf, Stride: 0x1},
+		unicode.Range16{Lo: 0xf00, Hi: 0xf00, Stride: 0x1},
+		unicode.Range16{Lo: 0xf40, Hi: 0xf47, Stride: 0x1},
+		unicode.Range16{Lo: 0xf49, Hi: 0xf6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xf88, Hi: 0xf8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1000, Hi: 0x102a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103f, Hi: 0x103f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1050, Hi: 0x1055, Stride: 0x1},
+		unicode.Range16{Lo: 0x105a, Hi: 0x105d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1061, Hi: 0x1061, Stride: 0x1},
+		unicode.Range16{Lo: 0x1065, Hi: 0x1066, Stride: 0x1},
+		unicode.Range16{Lo: 0x106e, Hi: 0x1070, Stride: 0x1},
+		unicode.Range16{Lo: 0x1075, Hi: 0x1081, Stride: 0x1},
+		unicode.Range16{Lo: 0x108e, Hi: 0x108e, Stride: 0x1},
+		unicode.Range16{Lo: 0x10d0, Hi: 0x10fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fc, Hi: 0x10fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fd, Hi: 0x1248, Stride: 0x1},
+		unicode.Range16{Lo: 0x124a, Hi: 0x124d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1250, Hi: 0x1256, Stride: 0x1},
+		unicode.Range16{Lo: 0x1258, Hi: 0x1258, Stride: 0x1},
+		unicode.Range16{Lo: 0x125a, Hi: 0x125d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1260, Hi: 0x1288, Stride: 0x1},
+		unicode.Range16{Lo: 0x128a, Hi: 0x128d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1290, Hi: 0x12b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b2, Hi: 0x12b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b8, Hi: 0x12be, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c0, Hi: 0x12c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c2, Hi: 0x12c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c8, Hi: 0x12d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x12d8, Hi: 0x1310, Stride: 0x1},
+		unicode.Range16{Lo: 0x1312, Hi: 0x1315, Stride: 0x1},
+		unicode.Range16{Lo: 0x1318, Hi: 0x135a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1380, Hi: 0x138f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1401, Hi: 0x166c, Stride: 0x1},
+		unicode.Range16{Lo: 0x166f, Hi: 0x167f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1681, Hi: 0x169a, Stride: 0x1},
+		unicode.Range16{Lo: 0x16a0, Hi: 0x16ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x16ee, Hi: 0x16f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x16f1, Hi: 0x16f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1700, Hi: 0x170c, Stride: 0x1},
+		unicode.Range16{Lo: 0x170e, Hi: 0x1711, Stride: 0x1},
+		unicode.Range16{Lo: 0x1720, Hi: 0x1731, Stride: 0x1},
+		unicode.Range16{Lo: 0x1740, Hi: 0x1751, Stride: 0x1},
+		unicode.Range16{Lo: 0x1760, Hi: 0x176c, Stride: 0x1},
+		unicode.Range16{Lo: 0x176e, Hi: 0x1770, Stride: 0x1},
+		unicode.Range16{Lo: 0x1780, Hi: 0x17b3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17d7, Hi: 0x17d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dc, Hi: 0x17dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1820, Hi: 0x1842, Stride: 0x1},
+		unicode.Range16{Lo: 0x1843, Hi: 0x1843, Stride: 0x1},
+		unicode.Range16{Lo: 0x1844, Hi: 0x1877, Stride: 0x1},
+		unicode.Range16{Lo: 0x1880, Hi: 0x1884, Stride: 0x1},
+		unicode.Range16{Lo: 0x1887, Hi: 0x18a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x18aa, Hi: 0x18aa, Stride: 0x1},
+		unicode.Range16{Lo: 0x18b0, Hi: 0x18f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1900, Hi: 0x191e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1950, Hi: 0x196d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1970, Hi: 0x1974, Stride: 0x1},
+		unicode.Range16{Lo: 0x1980, Hi: 0x19ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x19b0, Hi: 0x19c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a00, Hi: 0x1a16, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a20, Hi: 0x1a54, Stride: 0x1},
+		unicode.Range16{Lo: 0x1aa7, Hi: 0x1aa7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b05, Hi: 0x1b33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b45, Hi: 0x1b4b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b83, Hi: 0x1ba0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bae, Hi: 0x1baf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bba, Hi: 0x1be5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c00, Hi: 0x1c23, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4d, Hi: 0x1c4f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c5a, Hi: 0x1c77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c78, Hi: 0x1c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce9, Hi: 0x1cec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cee, Hi: 0x1cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf5, Hi: 0x1cf6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2135, Hi: 0x2138, Stride: 0x1},
+		unicode.Range16{Lo: 0x2180, Hi: 0x2182, Stride: 0x1},
+		unicode.Range16{Lo: 0x2185, Hi: 0x2188, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d30, Hi: 0x2d67, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d6f, Hi: 0x2d6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d80, Hi: 0x2d96, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da0, Hi: 0x2da6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da8, Hi: 0x2dae, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db0, Hi: 0x2db6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db8, Hi: 0x2dbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc0, Hi: 0x2dc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc8, Hi: 0x2dce, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd0, Hi: 0x2dd6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd8, Hi: 0x2dde, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e2f, Hi: 0x2e2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3005, Hi: 0x3005, Stride: 0x1},
+		unicode.Range16{Lo: 0x3006, Hi: 0x3006, Stride: 0x1},
+		unicode.Range16{Lo: 0x3007, Hi: 0x3007, Stride: 0x1},
+		unicode.Range16{Lo: 0x3021, Hi: 0x3029, Stride: 0x1},
+		unicode.Range16{Lo: 0x3031, Hi: 0x3035, Stride: 0x1},
+		unicode.Range16{Lo: 0x3038, Hi: 0x303a, Stride: 0x1},
+		unicode.Range16{Lo: 0x303b, Hi: 0x303b, Stride: 0x1},
+		unicode.Range16{Lo: 0x303c, Hi: 0x303c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3041, Hi: 0x3096, Stride: 0x1},
+		unicode.Range16{Lo: 0x309d, Hi: 0x309e, Stride: 0x1},
+		unicode.Range16{Lo: 0x309f, Hi: 0x309f, Stride: 0x1},
+		unicode.Range16{Lo: 0x30a1, Hi: 0x30fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x30fc, Hi: 0x30fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x30ff, Hi: 0x30ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x3105, Hi: 0x312d, Stride: 0x1},
+		unicode.Range16{Lo: 0x3131, Hi: 0x318e, Stride: 0x1},
+		unicode.Range16{Lo: 0x31a0, Hi: 0x31ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x31f0, Hi: 0x31ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x3400, Hi: 0x4db5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e00, Hi: 0x9fd5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa000, Hi: 0xa014, Stride: 0x1},
+		unicode.Range16{Lo: 0xa015, Hi: 0xa015, Stride: 0x1},
+		unicode.Range16{Lo: 0xa016, Hi: 0xa48c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4d0, Hi: 0xa4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4f8, Hi: 0xa4fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa500, Hi: 0xa60b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa60c, Hi: 0xa60c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa610, Hi: 0xa61f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa62a, Hi: 0xa62b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66e, Hi: 0xa66e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa67f, Hi: 0xa67f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6a0, Hi: 0xa6e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6e6, Hi: 0xa6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa717, Hi: 0xa71f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa788, Hi: 0xa788, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78f, Hi: 0xa78f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f7, Hi: 0xa7f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fb, Hi: 0xa801, Stride: 0x1},
+		unicode.Range16{Lo: 0xa803, Hi: 0xa805, Stride: 0x1},
+		unicode.Range16{Lo: 0xa807, Hi: 0xa80a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80c, Hi: 0xa822, Stride: 0x1},
+		unicode.Range16{Lo: 0xa840, Hi: 0xa873, Stride: 0x1},
+		unicode.Range16{Lo: 0xa882, Hi: 0xa8b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f2, Hi: 0xa8f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fb, Hi: 0xa8fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fd, Hi: 0xa8fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa90a, Hi: 0xa925, Stride: 0x1},
+		unicode.Range16{Lo: 0xa930, Hi: 0xa946, Stride: 0x1},
+		unicode.Range16{Lo: 0xa960, Hi: 0xa97c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa984, Hi: 0xa9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9cf, Hi: 0xa9cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e0, Hi: 0xa9e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e6, Hi: 0xa9e6, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e7, Hi: 0xa9ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9fa, Hi: 0xa9fe, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa00, Hi: 0xaa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa40, Hi: 0xaa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa44, Hi: 0xaa4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa60, Hi: 0xaa6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa70, Hi: 0xaa70, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa71, Hi: 0xaa76, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7a, Hi: 0xaa7a, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7e, Hi: 0xaaaf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab1, Hi: 0xaab1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab5, Hi: 0xaab6, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab9, Hi: 0xaabd, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac0, Hi: 0xaac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac2, Hi: 0xaac2, Stride: 0x1},
+		unicode.Range16{Lo: 0xaadb, Hi: 0xaadc, Stride: 0x1},
+		unicode.Range16{Lo: 0xaadd, Hi: 0xaadd, Stride: 0x1},
+		unicode.Range16{Lo: 0xaae0, Hi: 0xaaea, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf2, Hi: 0xaaf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf3, Hi: 0xaaf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xab01, Hi: 0xab06, Stride: 0x1},
+		unicode.Range16{Lo: 0xab09, Hi: 0xab0e, Stride: 0x1},
+		unicode.Range16{Lo: 0xab11, Hi: 0xab16, Stride: 0x1},
+		unicode.Range16{Lo: 0xab20, Hi: 0xab26, Stride: 0x1},
+		unicode.Range16{Lo: 0xab28, Hi: 0xab2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc0, Hi: 0xabe2, Stride: 0x1},
+		unicode.Range16{Lo: 0xac00, Hi: 0xd7a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7b0, Hi: 0xd7c6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7cb, Hi: 0xd7fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xf900, Hi: 0xfa6d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfa70, Hi: 0xfad9, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1d, Hi: 0xfb1d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1f, Hi: 0xfb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb2a, Hi: 0xfb36, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb38, Hi: 0xfb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb3e, Hi: 0xfb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb40, Hi: 0xfb41, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb43, Hi: 0xfb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb46, Hi: 0xfbb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xfbd3, Hi: 0xfd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd50, Hi: 0xfd8f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd92, Hi: 0xfdc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xfdf0, Hi: 0xfdfb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe70, Hi: 0xfe74, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe76, Hi: 0xfefc, Stride: 0x1},
+		unicode.Range16{Lo: 0xff66, Hi: 0xff6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff70, Hi: 0xff70, Stride: 0x1},
+		unicode.Range16{Lo: 0xff71, Hi: 0xff9d, Stride: 0x1},
+		unicode.Range16{Lo: 0xffa0, Hi: 0xffbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xffc2, Hi: 0xffc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffca, Hi: 0xffcf, Stride: 0x1},
+		unicode.Range16{Lo: 0xffd2, Hi: 0xffd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffda, Hi: 0xffdc, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10000, Hi: 0x1000b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1000d, Hi: 0x10026, Stride: 0x1},
+		unicode.Range32{Lo: 0x10028, Hi: 0x1003a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003c, Hi: 0x1003d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003f, Hi: 0x1004d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10050, Hi: 0x1005d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10080, Hi: 0x100fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x10140, Hi: 0x10174, Stride: 0x1},
+		unicode.Range32{Lo: 0x10280, Hi: 0x1029c, Stride: 0x1},
+		unicode.Range32{Lo: 0x102a0, Hi: 0x102d0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10300, Hi: 0x1031f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10330, Hi: 0x10340, Stride: 0x1},
+		unicode.Range32{Lo: 0x10341, Hi: 0x10341, Stride: 0x1},
+		unicode.Range32{Lo: 0x10342, Hi: 0x10349, Stride: 0x1},
+		unicode.Range32{Lo: 0x1034a, Hi: 0x1034a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10350, Hi: 0x10375, Stride: 0x1},
+		unicode.Range32{Lo: 0x10380, Hi: 0x1039d, Stride: 0x1},
+		unicode.Range32{Lo: 0x103a0, Hi: 0x103c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x103c8, Hi: 0x103cf, Stride: 0x1},
+		unicode.Range32{Lo: 0x103d1, Hi: 0x103d5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10450, Hi: 0x1049d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10500, Hi: 0x10527, Stride: 0x1},
+		unicode.Range32{Lo: 0x10530, Hi: 0x10563, Stride: 0x1},
+		unicode.Range32{Lo: 0x10600, Hi: 0x10736, Stride: 0x1},
+		unicode.Range32{Lo: 0x10740, Hi: 0x10755, Stride: 0x1},
+		unicode.Range32{Lo: 0x10760, Hi: 0x10767, Stride: 0x1},
+		unicode.Range32{Lo: 0x10800, Hi: 0x10805, Stride: 0x1},
+		unicode.Range32{Lo: 0x10808, Hi: 0x10808, Stride: 0x1},
+		unicode.Range32{Lo: 0x1080a, Hi: 0x10835, Stride: 0x1},
+		unicode.Range32{Lo: 0x10837, Hi: 0x10838, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083c, Hi: 0x1083c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083f, Hi: 0x10855, Stride: 0x1},
+		unicode.Range32{Lo: 0x10860, Hi: 0x10876, Stride: 0x1},
+		unicode.Range32{Lo: 0x10880, Hi: 0x1089e, Stride: 0x1},
+		unicode.Range32{Lo: 0x108e0, Hi: 0x108f2, Stride: 0x1},
+		unicode.Range32{Lo: 0x108f4, Hi: 0x108f5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10900, Hi: 0x10915, Stride: 0x1},
+		unicode.Range32{Lo: 0x10920, Hi: 0x10939, Stride: 0x1},
+		unicode.Range32{Lo: 0x10980, Hi: 0x109b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x109be, Hi: 0x109bf, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a00, Hi: 0x10a00, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a10, Hi: 0x10a13, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a15, Hi: 0x10a17, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a19, Hi: 0x10a33, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a60, Hi: 0x10a7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a80, Hi: 0x10a9c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac0, Hi: 0x10ac7, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac9, Hi: 0x10ae4, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b00, Hi: 0x10b35, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b40, Hi: 0x10b55, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b60, Hi: 0x10b72, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b80, Hi: 0x10b91, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c00, Hi: 0x10c48, Stride: 0x1},
+		unicode.Range32{Lo: 0x11003, Hi: 0x11037, Stride: 0x1},
+		unicode.Range32{Lo: 0x11083, Hi: 0x110af, Stride: 0x1},
+		unicode.Range32{Lo: 0x110d0, Hi: 0x110e8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11103, Hi: 0x11126, Stride: 0x1},
+		unicode.Range32{Lo: 0x11150, Hi: 0x11172, Stride: 0x1},
+		unicode.Range32{Lo: 0x11176, Hi: 0x11176, Stride: 0x1},
+		unicode.Range32{Lo: 0x11183, Hi: 0x111b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c1, Hi: 0x111c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x111da, Hi: 0x111da, Stride: 0x1},
+		unicode.Range32{Lo: 0x111dc, Hi: 0x111dc, Stride: 0x1},
+		unicode.Range32{Lo: 0x11200, Hi: 0x11211, Stride: 0x1},
+		unicode.Range32{Lo: 0x11213, Hi: 0x1122b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11280, Hi: 0x11286, Stride: 0x1},
+		unicode.Range32{Lo: 0x11288, Hi: 0x11288, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128a, Hi: 0x1128d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128f, Hi: 0x1129d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1129f, Hi: 0x112a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x112b0, Hi: 0x112de, Stride: 0x1},
+		unicode.Range32{Lo: 0x11305, Hi: 0x1130c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1130f, Hi: 0x11310, Stride: 0x1},
+		unicode.Range32{Lo: 0x11313, Hi: 0x11328, Stride: 0x1},
+		unicode.Range32{Lo: 0x1132a, Hi: 0x11330, Stride: 0x1},
+		unicode.Range32{Lo: 0x11332, Hi: 0x11333, Stride: 0x1},
+		unicode.Range32{Lo: 0x11335, Hi: 0x11339, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133d, Hi: 0x1133d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11350, Hi: 0x11350, Stride: 0x1},
+		unicode.Range32{Lo: 0x1135d, Hi: 0x11361, Stride: 0x1},
+		unicode.Range32{Lo: 0x11400, Hi: 0x11434, Stride: 0x1},
+		unicode.Range32{Lo: 0x11447, Hi: 0x1144a, Stride: 0x1},
+		unicode.Range32{Lo: 0x11480, Hi: 0x114af, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c4, Hi: 0x114c5, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c7, Hi: 0x114c7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11580, Hi: 0x115ae, Stride: 0x1},
+		unicode.Range32{Lo: 0x115d8, Hi: 0x115db, Stride: 0x1},
+		unicode.Range32{Lo: 0x11600, Hi: 0x1162f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11644, Hi: 0x11644, Stride: 0x1},
+		unicode.Range32{Lo: 0x11680, Hi: 0x116aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x11700, Hi: 0x11719, Stride: 0x1},
+		unicode.Range32{Lo: 0x118ff, Hi: 0x118ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ac0, Hi: 0x11af8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c00, Hi: 0x11c08, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c0a, Hi: 0x11c2e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c40, Hi: 0x11c40, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c72, Hi: 0x11c8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x12000, Hi: 0x12399, Stride: 0x1},
+		unicode.Range32{Lo: 0x12400, Hi: 0x1246e, Stride: 0x1},
+		unicode.Range32{Lo: 0x12480, Hi: 0x12543, Stride: 0x1},
+		unicode.Range32{Lo: 0x13000, Hi: 0x1342e, Stride: 0x1},
+		unicode.Range32{Lo: 0x14400, Hi: 0x14646, Stride: 0x1},
+		unicode.Range32{Lo: 0x16800, Hi: 0x16a38, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a40, Hi: 0x16a5e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16ad0, Hi: 0x16aed, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b00, Hi: 0x16b2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b40, Hi: 0x16b43, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b63, Hi: 0x16b77, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b7d, Hi: 0x16b8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f00, Hi: 0x16f44, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f50, Hi: 0x16f50, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f93, Hi: 0x16f9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16fe0, Hi: 0x16fe0, Stride: 0x1},
+		unicode.Range32{Lo: 0x17000, Hi: 0x187ec, Stride: 0x1},
+		unicode.Range32{Lo: 0x18800, Hi: 0x18af2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1b000, Hi: 0x1b001, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc00, Hi: 0x1bc6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc70, Hi: 0x1bc7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc80, Hi: 0x1bc88, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc90, Hi: 0x1bc99, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e800, Hi: 0x1e8c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee00, Hi: 0x1ee03, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee05, Hi: 0x1ee1f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee21, Hi: 0x1ee22, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee24, Hi: 0x1ee24, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee27, Hi: 0x1ee27, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee29, Hi: 0x1ee32, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee34, Hi: 0x1ee37, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee39, Hi: 0x1ee39, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee3b, Hi: 0x1ee3b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee42, Hi: 0x1ee42, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee47, Hi: 0x1ee47, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee49, Hi: 0x1ee49, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4b, Hi: 0x1ee4b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4d, Hi: 0x1ee4f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee51, Hi: 0x1ee52, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee54, Hi: 0x1ee54, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee57, Hi: 0x1ee57, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee59, Hi: 0x1ee59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5b, Hi: 0x1ee5b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5d, Hi: 0x1ee5d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5f, Hi: 0x1ee5f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee61, Hi: 0x1ee62, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee64, Hi: 0x1ee64, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee67, Hi: 0x1ee6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee6c, Hi: 0x1ee72, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee74, Hi: 0x1ee77, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee79, Hi: 0x1ee7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee7e, Hi: 0x1ee7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee80, Hi: 0x1ee89, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee8b, Hi: 0x1ee9b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea1, Hi: 0x1eea3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea5, Hi: 0x1eea9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eeab, Hi: 0x1eebb, Stride: 0x1},
+		unicode.Range32{Lo: 0x20000, Hi: 0x2a6d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x2a700, Hi: 0x2b734, Stride: 0x1},
+		unicode.Range32{Lo: 0x2b740, Hi: 0x2b81d, Stride: 0x1},
+		unicode.Range32{Lo: 0x2b820, Hi: 0x2cea1, Stride: 0x1},
+		unicode.Range32{Lo: 0x2f800, Hi: 0x2fa1d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _SentenceSContinue = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2c, Hi: 0x2c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d, Hi: 0x2d, Stride: 0x1},
+		unicode.Range16{Lo: 0x3a, Hi: 0x3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x55d, Hi: 0x55d, Stride: 0x1},
+		unicode.Range16{Lo: 0x60c, Hi: 0x60d, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f8, Hi: 0x7f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1802, Hi: 0x1802, Stride: 0x1},
+		unicode.Range16{Lo: 0x1808, Hi: 0x1808, Stride: 0x1},
+		unicode.Range16{Lo: 0x2013, Hi: 0x2014, Stride: 0x1},
+		unicode.Range16{Lo: 0x3001, Hi: 0x3001, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe10, Hi: 0xfe11, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe13, Hi: 0xfe13, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe31, Hi: 0xfe32, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe50, Hi: 0xfe51, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe55, Hi: 0xfe55, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe58, Hi: 0xfe58, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe63, Hi: 0xfe63, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0c, Hi: 0xff0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0d, Hi: 0xff0d, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1a, Hi: 0xff1a, Stride: 0x1},
+		unicode.Range16{Lo: 0xff64, Hi: 0xff64, Stride: 0x1},
+	},
+	LatinOffset: 3,
+}
+
+var _SentenceSTerm = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x21, Hi: 0x21, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f, Hi: 0x3f, Stride: 0x1},
+		unicode.Range16{Lo: 0x589, Hi: 0x589, Stride: 0x1},
+		unicode.Range16{Lo: 0x61f, Hi: 0x61f, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d4, Hi: 0x6d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x700, Hi: 0x702, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f9, Hi: 0x7f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x964, Hi: 0x965, Stride: 0x1},
+		unicode.Range16{Lo: 0x104a, Hi: 0x104b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1362, Hi: 0x1362, Stride: 0x1},
+		unicode.Range16{Lo: 0x1367, Hi: 0x1368, Stride: 0x1},
+		unicode.Range16{Lo: 0x166e, Hi: 0x166e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1735, Hi: 0x1736, Stride: 0x1},
+		unicode.Range16{Lo: 0x1803, Hi: 0x1803, Stride: 0x1},
+		unicode.Range16{Lo: 0x1809, Hi: 0x1809, Stride: 0x1},
+		unicode.Range16{Lo: 0x1944, Hi: 0x1945, Stride: 0x1},
+		unicode.Range16{Lo: 0x1aa8, Hi: 0x1aab, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b5a, Hi: 0x1b5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b5e, Hi: 0x1b5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c3b, Hi: 0x1c3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c7e, Hi: 0x1c7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x203c, Hi: 0x203d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2047, Hi: 0x2049, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e2e, Hi: 0x2e2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e3c, Hi: 0x2e3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3002, Hi: 0x3002, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4ff, Hi: 0xa4ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xa60e, Hi: 0xa60f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f3, Hi: 0xa6f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f7, Hi: 0xa6f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa876, Hi: 0xa877, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8ce, Hi: 0xa8cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xa92f, Hi: 0xa92f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9c8, Hi: 0xa9c9, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa5d, Hi: 0xaa5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf0, Hi: 0xaaf1, Stride: 0x1},
+		unicode.Range16{Lo: 0xabeb, Hi: 0xabeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe56, Hi: 0xfe57, Stride: 0x1},
+		unicode.Range16{Lo: 0xff01, Hi: 0xff01, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1f, Hi: 0xff1f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff61, Hi: 0xff61, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10a56, Hi: 0x10a57, Stride: 0x1},
+		unicode.Range32{Lo: 0x11047, Hi: 0x11048, Stride: 0x1},
+		unicode.Range32{Lo: 0x110be, Hi: 0x110c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11141, Hi: 0x11143, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c5, Hi: 0x111c6, Stride: 0x1},
+		unicode.Range32{Lo: 0x111cd, Hi: 0x111cd, Stride: 0x1},
+		unicode.Range32{Lo: 0x111de, Hi: 0x111df, Stride: 0x1},
+		unicode.Range32{Lo: 0x11238, Hi: 0x11239, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123b, Hi: 0x1123c, Stride: 0x1},
+		unicode.Range32{Lo: 0x112a9, Hi: 0x112a9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1144b, Hi: 0x1144c, Stride: 0x1},
+		unicode.Range32{Lo: 0x115c2, Hi: 0x115c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115c9, Hi: 0x115d7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11641, Hi: 0x11642, Stride: 0x1},
+		unicode.Range32{Lo: 0x1173c, Hi: 0x1173e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c41, Hi: 0x11c42, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a6e, Hi: 0x16a6f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af5, Hi: 0x16af5, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b37, Hi: 0x16b38, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b44, Hi: 0x16b44, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9f, Hi: 0x1bc9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da88, Hi: 0x1da88, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _SentenceSep = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x85, Hi: 0x85, Stride: 0x1},
+		unicode.Range16{Lo: 0x2028, Hi: 0x2028, Stride: 0x1},
+		unicode.Range16{Lo: 0x2029, Hi: 0x2029, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceSp = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x9, Hi: 0x9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb, Hi: 0xc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20, Hi: 0x20, Stride: 0x1},
+		unicode.Range16{Lo: 0xa0, Hi: 0xa0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1680, Hi: 0x1680, Stride: 0x1},
+		unicode.Range16{Lo: 0x2000, Hi: 0x200a, Stride: 0x1},
+		unicode.Range16{Lo: 0x202f, Hi: 0x202f, Stride: 0x1},
+		unicode.Range16{Lo: 0x205f, Hi: 0x205f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3000, Hi: 0x3000, Stride: 0x1},
+	},
+	LatinOffset: 4,
+}
+
+var _SentenceUpper = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x41, Hi: 0x5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0, Hi: 0xd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd8, Hi: 0xde, Stride: 0x1},
+		unicode.Range16{Lo: 0x100, Hi: 0x100, Stride: 0x1},
+		unicode.Range16{Lo: 0x102, Hi: 0x102, Stride: 0x1},
+		unicode.Range16{Lo: 0x104, Hi: 0x104, Stride: 0x1},
+		unicode.Range16{Lo: 0x106, Hi: 0x106, Stride: 0x1},
+		unicode.Range16{Lo: 0x108, Hi: 0x108, Stride: 0x1},
+		unicode.Range16{Lo: 0x10a, Hi: 0x10a, Stride: 0x1},
+		unicode.Range16{Lo: 0x10c, Hi: 0x10c, Stride: 0x1},
+		unicode.Range16{Lo: 0x10e, Hi: 0x10e, Stride: 0x1},
+		unicode.Range16{Lo: 0x110, Hi: 0x110, Stride: 0x1},
+		unicode.Range16{Lo: 0x112, Hi: 0x112, Stride: 0x1},
+		unicode.Range16{Lo: 0x114, Hi: 0x114, Stride: 0x1},
+		unicode.Range16{Lo: 0x116, Hi: 0x116, Stride: 0x1},
+		unicode.Range16{Lo: 0x118, Hi: 0x118, Stride: 0x1},
+		unicode.Range16{Lo: 0x11a, Hi: 0x11a, Stride: 0x1},
+		unicode.Range16{Lo: 0x11c, Hi: 0x11c, Stride: 0x1},
+		unicode.Range16{Lo: 0x11e, Hi: 0x11e, Stride: 0x1},
+		unicode.Range16{Lo: 0x120, Hi: 0x120, Stride: 0x1},
+		unicode.Range16{Lo: 0x122, Hi: 0x122, Stride: 0x1},
+		unicode.Range16{Lo: 0x124, Hi: 0x124, Stride: 0x1},
+		unicode.Range16{Lo: 0x126, Hi: 0x126, Stride: 0x1},
+		unicode.Range16{Lo: 0x128, Hi: 0x128, Stride: 0x1},
+		unicode.Range16{Lo: 0x12a, Hi: 0x12a, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c, Hi: 0x12c, Stride: 0x1},
+		unicode.Range16{Lo: 0x12e, Hi: 0x12e, Stride: 0x1},
+		unicode.Range16{Lo: 0x130, Hi: 0x130, Stride: 0x1},
+		unicode.Range16{Lo: 0x132, Hi: 0x132, Stride: 0x1},
+		unicode.Range16{Lo: 0x134, Hi: 0x134, Stride: 0x1},
+		unicode.Range16{Lo: 0x136, Hi: 0x136, Stride: 0x1},
+		unicode.Range16{Lo: 0x139, Hi: 0x139, Stride: 0x1},
+		unicode.Range16{Lo: 0x13b, Hi: 0x13b, Stride: 0x1},
+		unicode.Range16{Lo: 0x13d, Hi: 0x13d, Stride: 0x1},
+		unicode.Range16{Lo: 0x13f, Hi: 0x13f, Stride: 0x1},
+		unicode.Range16{Lo: 0x141, Hi: 0x141, Stride: 0x1},
+		unicode.Range16{Lo: 0x143, Hi: 0x143, Stride: 0x1},
+		unicode.Range16{Lo: 0x145, Hi: 0x145, Stride: 0x1},
+		unicode.Range16{Lo: 0x147, Hi: 0x147, Stride: 0x1},
+		unicode.Range16{Lo: 0x14a, Hi: 0x14a, Stride: 0x1},
+		unicode.Range16{Lo: 0x14c, Hi: 0x14c, Stride: 0x1},
+		unicode.Range16{Lo: 0x14e, Hi: 0x14e, Stride: 0x1},
+		unicode.Range16{Lo: 0x150, Hi: 0x150, Stride: 0x1},
+		unicode.Range16{Lo: 0x152, Hi: 0x152, Stride: 0x1},
+		unicode.Range16{Lo: 0x154, Hi: 0x154, Stride: 0x1},
+		unicode.Range16{Lo: 0x156, Hi: 0x156, Stride: 0x1},
+		unicode.Range16{Lo: 0x158, Hi: 0x158, Stride: 0x1},
+		unicode.Range16{Lo: 0x15a, Hi: 0x15a, Stride: 0x1},
+		unicode.Range16{Lo: 0x15c, Hi: 0x15c, Stride: 0x1},
+		unicode.Range16{Lo: 0x15e, Hi: 0x15e, Stride: 0x1},
+		unicode.Range16{Lo: 0x160, Hi: 0x160, Stride: 0x1},
+		unicode.Range16{Lo: 0x162, Hi: 0x162, Stride: 0x1},
+		unicode.Range16{Lo: 0x164, Hi: 0x164, Stride: 0x1},
+		unicode.Range16{Lo: 0x166, Hi: 0x166, Stride: 0x1},
+		unicode.Range16{Lo: 0x168, Hi: 0x168, Stride: 0x1},
+		unicode.Range16{Lo: 0x16a, Hi: 0x16a, Stride: 0x1},
+		unicode.Range16{Lo: 0x16c, Hi: 0x16c, Stride: 0x1},
+		unicode.Range16{Lo: 0x16e, Hi: 0x16e, Stride: 0x1},
+		unicode.Range16{Lo: 0x170, Hi: 0x170, Stride: 0x1},
+		unicode.Range16{Lo: 0x172, Hi: 0x172, Stride: 0x1},
+		unicode.Range16{Lo: 0x174, Hi: 0x174, Stride: 0x1},
+		unicode.Range16{Lo: 0x176, Hi: 0x176, Stride: 0x1},
+		unicode.Range16{Lo: 0x178, Hi: 0x179, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b, Hi: 0x17b, Stride: 0x1},
+		unicode.Range16{Lo: 0x17d, Hi: 0x17d, Stride: 0x1},
+		unicode.Range16{Lo: 0x181, Hi: 0x182, Stride: 0x1},
+		unicode.Range16{Lo: 0x184, Hi: 0x184, Stride: 0x1},
+		unicode.Range16{Lo: 0x186, Hi: 0x187, Stride: 0x1},
+		unicode.Range16{Lo: 0x189, Hi: 0x18b, Stride: 0x1},
+		unicode.Range16{Lo: 0x18e, Hi: 0x191, Stride: 0x1},
+		unicode.Range16{Lo: 0x193, Hi: 0x194, Stride: 0x1},
+		unicode.Range16{Lo: 0x196, Hi: 0x198, Stride: 0x1},
+		unicode.Range16{Lo: 0x19c, Hi: 0x19d, Stride: 0x1},
+		unicode.Range16{Lo: 0x19f, Hi: 0x1a0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a2, Hi: 0x1a2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a4, Hi: 0x1a4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6, Hi: 0x1a7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a9, Hi: 0x1a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ac, Hi: 0x1ac, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ae, Hi: 0x1af, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b1, Hi: 0x1b3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b5, Hi: 0x1b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b7, Hi: 0x1b8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bc, Hi: 0x1bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4, Hi: 0x1c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c7, Hi: 0x1c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ca, Hi: 0x1cb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd, Hi: 0x1cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf, Hi: 0x1cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d1, Hi: 0x1d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d3, Hi: 0x1d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d5, Hi: 0x1d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d7, Hi: 0x1d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d9, Hi: 0x1d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1db, Hi: 0x1db, Stride: 0x1},
+		unicode.Range16{Lo: 0x1de, Hi: 0x1de, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0, Hi: 0x1e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2, Hi: 0x1e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4, Hi: 0x1e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6, Hi: 0x1e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8, Hi: 0x1e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea, Hi: 0x1ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec, Hi: 0x1ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee, Hi: 0x1ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f1, Hi: 0x1f2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f4, Hi: 0x1f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f6, Hi: 0x1f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fa, Hi: 0x1fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc, Hi: 0x1fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe, Hi: 0x1fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x200, Hi: 0x200, Stride: 0x1},
+		unicode.Range16{Lo: 0x202, Hi: 0x202, Stride: 0x1},
+		unicode.Range16{Lo: 0x204, Hi: 0x204, Stride: 0x1},
+		unicode.Range16{Lo: 0x206, Hi: 0x206, Stride: 0x1},
+		unicode.Range16{Lo: 0x208, Hi: 0x208, Stride: 0x1},
+		unicode.Range16{Lo: 0x20a, Hi: 0x20a, Stride: 0x1},
+		unicode.Range16{Lo: 0x20c, Hi: 0x20c, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e, Hi: 0x20e, Stride: 0x1},
+		unicode.Range16{Lo: 0x210, Hi: 0x210, Stride: 0x1},
+		unicode.Range16{Lo: 0x212, Hi: 0x212, Stride: 0x1},
+		unicode.Range16{Lo: 0x214, Hi: 0x214, Stride: 0x1},
+		unicode.Range16{Lo: 0x216, Hi: 0x216, Stride: 0x1},
+		unicode.Range16{Lo: 0x218, Hi: 0x218, Stride: 0x1},
+		unicode.Range16{Lo: 0x21a, Hi: 0x21a, Stride: 0x1},
+		unicode.Range16{Lo: 0x21c, Hi: 0x21c, Stride: 0x1},
+		unicode.Range16{Lo: 0x21e, Hi: 0x21e, Stride: 0x1},
+		unicode.Range16{Lo: 0x220, Hi: 0x220, Stride: 0x1},
+		unicode.Range16{Lo: 0x222, Hi: 0x222, Stride: 0x1},
+		unicode.Range16{Lo: 0x224, Hi: 0x224, Stride: 0x1},
+		unicode.Range16{Lo: 0x226, Hi: 0x226, Stride: 0x1},
+		unicode.Range16{Lo: 0x228, Hi: 0x228, Stride: 0x1},
+		unicode.Range16{Lo: 0x22a, Hi: 0x22a, Stride: 0x1},
+		unicode.Range16{Lo: 0x22c, Hi: 0x22c, Stride: 0x1},
+		unicode.Range16{Lo: 0x22e, Hi: 0x22e, Stride: 0x1},
+		unicode.Range16{Lo: 0x230, Hi: 0x230, Stride: 0x1},
+		unicode.Range16{Lo: 0x232, Hi: 0x232, Stride: 0x1},
+		unicode.Range16{Lo: 0x23a, Hi: 0x23b, Stride: 0x1},
+		unicode.Range16{Lo: 0x23d, Hi: 0x23e, Stride: 0x1},
+		unicode.Range16{Lo: 0x241, Hi: 0x241, Stride: 0x1},
+		unicode.Range16{Lo: 0x243, Hi: 0x246, Stride: 0x1},
+		unicode.Range16{Lo: 0x248, Hi: 0x248, Stride: 0x1},
+		unicode.Range16{Lo: 0x24a, Hi: 0x24a, Stride: 0x1},
+		unicode.Range16{Lo: 0x24c, Hi: 0x24c, Stride: 0x1},
+		unicode.Range16{Lo: 0x24e, Hi: 0x24e, Stride: 0x1},
+		unicode.Range16{Lo: 0x370, Hi: 0x370, Stride: 0x1},
+		unicode.Range16{Lo: 0x372, Hi: 0x372, Stride: 0x1},
+		unicode.Range16{Lo: 0x376, Hi: 0x376, Stride: 0x1},
+		unicode.Range16{Lo: 0x37f, Hi: 0x37f, Stride: 0x1},
+		unicode.Range16{Lo: 0x386, Hi: 0x386, Stride: 0x1},
+		unicode.Range16{Lo: 0x388, Hi: 0x38a, Stride: 0x1},
+		unicode.Range16{Lo: 0x38c, Hi: 0x38c, Stride: 0x1},
+		unicode.Range16{Lo: 0x38e, Hi: 0x38f, Stride: 0x1},
+		unicode.Range16{Lo: 0x391, Hi: 0x3a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3a3, Hi: 0x3ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x3cf, Hi: 0x3cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d2, Hi: 0x3d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d8, Hi: 0x3d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x3da, Hi: 0x3da, Stride: 0x1},
+		unicode.Range16{Lo: 0x3dc, Hi: 0x3dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x3de, Hi: 0x3de, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e0, Hi: 0x3e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e2, Hi: 0x3e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e4, Hi: 0x3e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e6, Hi: 0x3e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e8, Hi: 0x3e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ea, Hi: 0x3ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ec, Hi: 0x3ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ee, Hi: 0x3ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f4, Hi: 0x3f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f7, Hi: 0x3f7, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f9, Hi: 0x3fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x3fd, Hi: 0x42f, Stride: 0x1},
+		unicode.Range16{Lo: 0x460, Hi: 0x460, Stride: 0x1},
+		unicode.Range16{Lo: 0x462, Hi: 0x462, Stride: 0x1},
+		unicode.Range16{Lo: 0x464, Hi: 0x464, Stride: 0x1},
+		unicode.Range16{Lo: 0x466, Hi: 0x466, Stride: 0x1},
+		unicode.Range16{Lo: 0x468, Hi: 0x468, Stride: 0x1},
+		unicode.Range16{Lo: 0x46a, Hi: 0x46a, Stride: 0x1},
+		unicode.Range16{Lo: 0x46c, Hi: 0x46c, Stride: 0x1},
+		unicode.Range16{Lo: 0x46e, Hi: 0x46e, Stride: 0x1},
+		unicode.Range16{Lo: 0x470, Hi: 0x470, Stride: 0x1},
+		unicode.Range16{Lo: 0x472, Hi: 0x472, Stride: 0x1},
+		unicode.Range16{Lo: 0x474, Hi: 0x474, Stride: 0x1},
+		unicode.Range16{Lo: 0x476, Hi: 0x476, Stride: 0x1},
+		unicode.Range16{Lo: 0x478, Hi: 0x478, Stride: 0x1},
+		unicode.Range16{Lo: 0x47a, Hi: 0x47a, Stride: 0x1},
+		unicode.Range16{Lo: 0x47c, Hi: 0x47c, Stride: 0x1},
+		unicode.Range16{Lo: 0x47e, Hi: 0x47e, Stride: 0x1},
+		unicode.Range16{Lo: 0x480, Hi: 0x480, Stride: 0x1},
+		unicode.Range16{Lo: 0x48a, Hi: 0x48a, Stride: 0x1},
+		unicode.Range16{Lo: 0x48c, Hi: 0x48c, Stride: 0x1},
+		unicode.Range16{Lo: 0x48e, Hi: 0x48e, Stride: 0x1},
+		unicode.Range16{Lo: 0x490, Hi: 0x490, Stride: 0x1},
+		unicode.Range16{Lo: 0x492, Hi: 0x492, Stride: 0x1},
+		unicode.Range16{Lo: 0x494, Hi: 0x494, Stride: 0x1},
+		unicode.Range16{Lo: 0x496, Hi: 0x496, Stride: 0x1},
+		unicode.Range16{Lo: 0x498, Hi: 0x498, Stride: 0x1},
+		unicode.Range16{Lo: 0x49a, Hi: 0x49a, Stride: 0x1},
+		unicode.Range16{Lo: 0x49c, Hi: 0x49c, Stride: 0x1},
+		unicode.Range16{Lo: 0x49e, Hi: 0x49e, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a0, Hi: 0x4a0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a2, Hi: 0x4a2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a4, Hi: 0x4a4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a6, Hi: 0x4a6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a8, Hi: 0x4a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4aa, Hi: 0x4aa, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ac, Hi: 0x4ac, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ae, Hi: 0x4ae, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b0, Hi: 0x4b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b2, Hi: 0x4b2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b4, Hi: 0x4b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b6, Hi: 0x4b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b8, Hi: 0x4b8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ba, Hi: 0x4ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bc, Hi: 0x4bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4be, Hi: 0x4be, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c0, Hi: 0x4c1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c3, Hi: 0x4c3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c5, Hi: 0x4c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c7, Hi: 0x4c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c9, Hi: 0x4c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4cb, Hi: 0x4cb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4cd, Hi: 0x4cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d0, Hi: 0x4d0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d2, Hi: 0x4d2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d4, Hi: 0x4d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d6, Hi: 0x4d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d8, Hi: 0x4d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4da, Hi: 0x4da, Stride: 0x1},
+		unicode.Range16{Lo: 0x4dc, Hi: 0x4dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4de, Hi: 0x4de, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e0, Hi: 0x4e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e2, Hi: 0x4e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e4, Hi: 0x4e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e6, Hi: 0x4e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e8, Hi: 0x4e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ea, Hi: 0x4ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ec, Hi: 0x4ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ee, Hi: 0x4ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f0, Hi: 0x4f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f2, Hi: 0x4f2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f4, Hi: 0x4f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f6, Hi: 0x4f6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f8, Hi: 0x4f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fa, Hi: 0x4fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fc, Hi: 0x4fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fe, Hi: 0x4fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x500, Hi: 0x500, Stride: 0x1},
+		unicode.Range16{Lo: 0x502, Hi: 0x502, Stride: 0x1},
+		unicode.Range16{Lo: 0x504, Hi: 0x504, Stride: 0x1},
+		unicode.Range16{Lo: 0x506, Hi: 0x506, Stride: 0x1},
+		unicode.Range16{Lo: 0x508, Hi: 0x508, Stride: 0x1},
+		unicode.Range16{Lo: 0x50a, Hi: 0x50a, Stride: 0x1},
+		unicode.Range16{Lo: 0x50c, Hi: 0x50c, Stride: 0x1},
+		unicode.Range16{Lo: 0x50e, Hi: 0x50e, Stride: 0x1},
+		unicode.Range16{Lo: 0x510, Hi: 0x510, Stride: 0x1},
+		unicode.Range16{Lo: 0x512, Hi: 0x512, Stride: 0x1},
+		unicode.Range16{Lo: 0x514, Hi: 0x514, Stride: 0x1},
+		unicode.Range16{Lo: 0x516, Hi: 0x516, Stride: 0x1},
+		unicode.Range16{Lo: 0x518, Hi: 0x518, Stride: 0x1},
+		unicode.Range16{Lo: 0x51a, Hi: 0x51a, Stride: 0x1},
+		unicode.Range16{Lo: 0x51c, Hi: 0x51c, Stride: 0x1},
+		unicode.Range16{Lo: 0x51e, Hi: 0x51e, Stride: 0x1},
+		unicode.Range16{Lo: 0x520, Hi: 0x520, Stride: 0x1},
+		unicode.Range16{Lo: 0x522, Hi: 0x522, Stride: 0x1},
+		unicode.Range16{Lo: 0x524, Hi: 0x524, Stride: 0x1},
+		unicode.Range16{Lo: 0x526, Hi: 0x526, Stride: 0x1},
+		unicode.Range16{Lo: 0x528, Hi: 0x528, Stride: 0x1},
+		unicode.Range16{Lo: 0x52a, Hi: 0x52a, Stride: 0x1},
+		unicode.Range16{Lo: 0x52c, Hi: 0x52c, Stride: 0x1},
+		unicode.Range16{Lo: 0x52e, Hi: 0x52e, Stride: 0x1},
+		unicode.Range16{Lo: 0x531, Hi: 0x556, Stride: 0x1},
+		unicode.Range16{Lo: 0x10a0, Hi: 0x10c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x10c7, Hi: 0x10c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x10cd, Hi: 0x10cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x13a0, Hi: 0x13f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e00, Hi: 0x1e00, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e02, Hi: 0x1e02, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e04, Hi: 0x1e04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e06, Hi: 0x1e06, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e08, Hi: 0x1e08, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0a, Hi: 0x1e0a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0c, Hi: 0x1e0c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0e, Hi: 0x1e0e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e10, Hi: 0x1e10, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e12, Hi: 0x1e12, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e14, Hi: 0x1e14, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e16, Hi: 0x1e16, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e18, Hi: 0x1e18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1a, Hi: 0x1e1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1c, Hi: 0x1e1c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1e, Hi: 0x1e1e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e20, Hi: 0x1e20, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e22, Hi: 0x1e22, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e24, Hi: 0x1e24, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e26, Hi: 0x1e26, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e28, Hi: 0x1e28, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2a, Hi: 0x1e2a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2c, Hi: 0x1e2c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2e, Hi: 0x1e2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e30, Hi: 0x1e30, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e32, Hi: 0x1e32, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e34, Hi: 0x1e34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e36, Hi: 0x1e36, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e38, Hi: 0x1e38, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3a, Hi: 0x1e3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3c, Hi: 0x1e3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3e, Hi: 0x1e3e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e40, Hi: 0x1e40, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e42, Hi: 0x1e42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e44, Hi: 0x1e44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e46, Hi: 0x1e46, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e48, Hi: 0x1e48, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4a, Hi: 0x1e4a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4c, Hi: 0x1e4c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4e, Hi: 0x1e4e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e50, Hi: 0x1e50, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e52, Hi: 0x1e52, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e54, Hi: 0x1e54, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e56, Hi: 0x1e56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e58, Hi: 0x1e58, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5a, Hi: 0x1e5a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5c, Hi: 0x1e5c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5e, Hi: 0x1e5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e60, Hi: 0x1e60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e62, Hi: 0x1e62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e64, Hi: 0x1e64, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e66, Hi: 0x1e66, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e68, Hi: 0x1e68, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6a, Hi: 0x1e6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6c, Hi: 0x1e6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6e, Hi: 0x1e6e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e70, Hi: 0x1e70, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e72, Hi: 0x1e72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e74, Hi: 0x1e74, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e76, Hi: 0x1e76, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e78, Hi: 0x1e78, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7a, Hi: 0x1e7a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7c, Hi: 0x1e7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7e, Hi: 0x1e7e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e80, Hi: 0x1e80, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e82, Hi: 0x1e82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e84, Hi: 0x1e84, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e86, Hi: 0x1e86, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e88, Hi: 0x1e88, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8a, Hi: 0x1e8a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8c, Hi: 0x1e8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8e, Hi: 0x1e8e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e90, Hi: 0x1e90, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e92, Hi: 0x1e92, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e94, Hi: 0x1e94, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e9e, Hi: 0x1e9e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea0, Hi: 0x1ea0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea2, Hi: 0x1ea2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea4, Hi: 0x1ea4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea6, Hi: 0x1ea6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea8, Hi: 0x1ea8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eaa, Hi: 0x1eaa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eac, Hi: 0x1eac, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eae, Hi: 0x1eae, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb0, Hi: 0x1eb0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb2, Hi: 0x1eb2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb4, Hi: 0x1eb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb6, Hi: 0x1eb6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb8, Hi: 0x1eb8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eba, Hi: 0x1eba, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebc, Hi: 0x1ebc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebe, Hi: 0x1ebe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec0, Hi: 0x1ec0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec2, Hi: 0x1ec2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec4, Hi: 0x1ec4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec6, Hi: 0x1ec6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec8, Hi: 0x1ec8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eca, Hi: 0x1eca, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecc, Hi: 0x1ecc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ece, Hi: 0x1ece, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed0, Hi: 0x1ed0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed2, Hi: 0x1ed2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed4, Hi: 0x1ed4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed6, Hi: 0x1ed6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed8, Hi: 0x1ed8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eda, Hi: 0x1eda, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edc, Hi: 0x1edc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ede, Hi: 0x1ede, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee0, Hi: 0x1ee0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee2, Hi: 0x1ee2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee4, Hi: 0x1ee4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee6, Hi: 0x1ee6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee8, Hi: 0x1ee8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eea, Hi: 0x1eea, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eec, Hi: 0x1eec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eee, Hi: 0x1eee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef0, Hi: 0x1ef0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef2, Hi: 0x1ef2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef4, Hi: 0x1ef4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef6, Hi: 0x1ef6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef8, Hi: 0x1ef8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efa, Hi: 0x1efa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efc, Hi: 0x1efc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efe, Hi: 0x1efe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f08, Hi: 0x1f0f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f18, Hi: 0x1f1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f28, Hi: 0x1f2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f38, Hi: 0x1f3f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f48, Hi: 0x1f4d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f59, Hi: 0x1f59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5b, Hi: 0x1f5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5d, Hi: 0x1f5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5f, Hi: 0x1f5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f68, Hi: 0x1f6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f88, Hi: 0x1f8f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f98, Hi: 0x1f9f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fa8, Hi: 0x1faf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb8, Hi: 0x1fbc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc8, Hi: 0x1fcc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd8, Hi: 0x1fdb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe8, Hi: 0x1fec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff8, Hi: 0x1ffc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2102, Hi: 0x2102, Stride: 0x1},
+		unicode.Range16{Lo: 0x2107, Hi: 0x2107, Stride: 0x1},
+		unicode.Range16{Lo: 0x210b, Hi: 0x210d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2110, Hi: 0x2112, Stride: 0x1},
+		unicode.Range16{Lo: 0x2115, Hi: 0x2115, Stride: 0x1},
+		unicode.Range16{Lo: 0x2119, Hi: 0x211d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2124, Hi: 0x2124, Stride: 0x1},
+		unicode.Range16{Lo: 0x2126, Hi: 0x2126, Stride: 0x1},
+		unicode.Range16{Lo: 0x2128, Hi: 0x2128, Stride: 0x1},
+		unicode.Range16{Lo: 0x212a, Hi: 0x212d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2130, Hi: 0x2133, Stride: 0x1},
+		unicode.Range16{Lo: 0x213e, Hi: 0x213f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2145, Hi: 0x2145, Stride: 0x1},
+		unicode.Range16{Lo: 0x2160, Hi: 0x216f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2183, Hi: 0x2183, Stride: 0x1},
+		unicode.Range16{Lo: 0x24b6, Hi: 0x24cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c00, Hi: 0x2c2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c60, Hi: 0x2c60, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c62, Hi: 0x2c64, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c67, Hi: 0x2c67, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c69, Hi: 0x2c69, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6b, Hi: 0x2c6b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6d, Hi: 0x2c70, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c72, Hi: 0x2c72, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c75, Hi: 0x2c75, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7e, Hi: 0x2c80, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c82, Hi: 0x2c82, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c84, Hi: 0x2c84, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c86, Hi: 0x2c86, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c88, Hi: 0x2c88, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8a, Hi: 0x2c8a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8c, Hi: 0x2c8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8e, Hi: 0x2c8e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c90, Hi: 0x2c90, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c92, Hi: 0x2c92, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c94, Hi: 0x2c94, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c96, Hi: 0x2c96, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c98, Hi: 0x2c98, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9a, Hi: 0x2c9a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9c, Hi: 0x2c9c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9e, Hi: 0x2c9e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca0, Hi: 0x2ca0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca2, Hi: 0x2ca2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca4, Hi: 0x2ca4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca6, Hi: 0x2ca6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca8, Hi: 0x2ca8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2caa, Hi: 0x2caa, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cac, Hi: 0x2cac, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cae, Hi: 0x2cae, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb0, Hi: 0x2cb0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb2, Hi: 0x2cb2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb4, Hi: 0x2cb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb6, Hi: 0x2cb6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb8, Hi: 0x2cb8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cba, Hi: 0x2cba, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbc, Hi: 0x2cbc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbe, Hi: 0x2cbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc0, Hi: 0x2cc0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc2, Hi: 0x2cc2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc4, Hi: 0x2cc4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc6, Hi: 0x2cc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc8, Hi: 0x2cc8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cca, Hi: 0x2cca, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccc, Hi: 0x2ccc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cce, Hi: 0x2cce, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd0, Hi: 0x2cd0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd2, Hi: 0x2cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd4, Hi: 0x2cd4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd6, Hi: 0x2cd6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd8, Hi: 0x2cd8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cda, Hi: 0x2cda, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdc, Hi: 0x2cdc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cde, Hi: 0x2cde, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce0, Hi: 0x2ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce2, Hi: 0x2ce2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ceb, Hi: 0x2ceb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ced, Hi: 0x2ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cf2, Hi: 0x2cf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa640, Hi: 0xa640, Stride: 0x1},
+		unicode.Range16{Lo: 0xa642, Hi: 0xa642, Stride: 0x1},
+		unicode.Range16{Lo: 0xa644, Hi: 0xa644, Stride: 0x1},
+		unicode.Range16{Lo: 0xa646, Hi: 0xa646, Stride: 0x1},
+		unicode.Range16{Lo: 0xa648, Hi: 0xa648, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64a, Hi: 0xa64a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64c, Hi: 0xa64c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64e, Hi: 0xa64e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa650, Hi: 0xa650, Stride: 0x1},
+		unicode.Range16{Lo: 0xa652, Hi: 0xa652, Stride: 0x1},
+		unicode.Range16{Lo: 0xa654, Hi: 0xa654, Stride: 0x1},
+		unicode.Range16{Lo: 0xa656, Hi: 0xa656, Stride: 0x1},
+		unicode.Range16{Lo: 0xa658, Hi: 0xa658, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65a, Hi: 0xa65a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65c, Hi: 0xa65c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65e, Hi: 0xa65e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa660, Hi: 0xa660, Stride: 0x1},
+		unicode.Range16{Lo: 0xa662, Hi: 0xa662, Stride: 0x1},
+		unicode.Range16{Lo: 0xa664, Hi: 0xa664, Stride: 0x1},
+		unicode.Range16{Lo: 0xa666, Hi: 0xa666, Stride: 0x1},
+		unicode.Range16{Lo: 0xa668, Hi: 0xa668, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66a, Hi: 0xa66a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66c, Hi: 0xa66c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa680, Hi: 0xa680, Stride: 0x1},
+		unicode.Range16{Lo: 0xa682, Hi: 0xa682, Stride: 0x1},
+		unicode.Range16{Lo: 0xa684, Hi: 0xa684, Stride: 0x1},
+		unicode.Range16{Lo: 0xa686, Hi: 0xa686, Stride: 0x1},
+		unicode.Range16{Lo: 0xa688, Hi: 0xa688, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68a, Hi: 0xa68a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68c, Hi: 0xa68c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68e, Hi: 0xa68e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa690, Hi: 0xa690, Stride: 0x1},
+		unicode.Range16{Lo: 0xa692, Hi: 0xa692, Stride: 0x1},
+		unicode.Range16{Lo: 0xa694, Hi: 0xa694, Stride: 0x1},
+		unicode.Range16{Lo: 0xa696, Hi: 0xa696, Stride: 0x1},
+		unicode.Range16{Lo: 0xa698, Hi: 0xa698, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69a, Hi: 0xa69a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa722, Hi: 0xa722, Stride: 0x1},
+		unicode.Range16{Lo: 0xa724, Hi: 0xa724, Stride: 0x1},
+		unicode.Range16{Lo: 0xa726, Hi: 0xa726, Stride: 0x1},
+		unicode.Range16{Lo: 0xa728, Hi: 0xa728, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72a, Hi: 0xa72a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72c, Hi: 0xa72c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72e, Hi: 0xa72e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa732, Hi: 0xa732, Stride: 0x1},
+		unicode.Range16{Lo: 0xa734, Hi: 0xa734, Stride: 0x1},
+		unicode.Range16{Lo: 0xa736, Hi: 0xa736, Stride: 0x1},
+		unicode.Range16{Lo: 0xa738, Hi: 0xa738, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73a, Hi: 0xa73a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73c, Hi: 0xa73c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73e, Hi: 0xa73e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa740, Hi: 0xa740, Stride: 0x1},
+		unicode.Range16{Lo: 0xa742, Hi: 0xa742, Stride: 0x1},
+		unicode.Range16{Lo: 0xa744, Hi: 0xa744, Stride: 0x1},
+		unicode.Range16{Lo: 0xa746, Hi: 0xa746, Stride: 0x1},
+		unicode.Range16{Lo: 0xa748, Hi: 0xa748, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74a, Hi: 0xa74a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74c, Hi: 0xa74c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74e, Hi: 0xa74e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa750, Hi: 0xa750, Stride: 0x1},
+		unicode.Range16{Lo: 0xa752, Hi: 0xa752, Stride: 0x1},
+		unicode.Range16{Lo: 0xa754, Hi: 0xa754, Stride: 0x1},
+		unicode.Range16{Lo: 0xa756, Hi: 0xa756, Stride: 0x1},
+		unicode.Range16{Lo: 0xa758, Hi: 0xa758, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75a, Hi: 0xa75a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75c, Hi: 0xa75c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75e, Hi: 0xa75e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa760, Hi: 0xa760, Stride: 0x1},
+		unicode.Range16{Lo: 0xa762, Hi: 0xa762, Stride: 0x1},
+		unicode.Range16{Lo: 0xa764, Hi: 0xa764, Stride: 0x1},
+		unicode.Range16{Lo: 0xa766, Hi: 0xa766, Stride: 0x1},
+		unicode.Range16{Lo: 0xa768, Hi: 0xa768, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76a, Hi: 0xa76a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76c, Hi: 0xa76c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76e, Hi: 0xa76e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa779, Hi: 0xa779, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77b, Hi: 0xa77b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77d, Hi: 0xa77e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa780, Hi: 0xa780, Stride: 0x1},
+		unicode.Range16{Lo: 0xa782, Hi: 0xa782, Stride: 0x1},
+		unicode.Range16{Lo: 0xa784, Hi: 0xa784, Stride: 0x1},
+		unicode.Range16{Lo: 0xa786, Hi: 0xa786, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78b, Hi: 0xa78b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78d, Hi: 0xa78d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa790, Hi: 0xa790, Stride: 0x1},
+		unicode.Range16{Lo: 0xa792, Hi: 0xa792, Stride: 0x1},
+		unicode.Range16{Lo: 0xa796, Hi: 0xa796, Stride: 0x1},
+		unicode.Range16{Lo: 0xa798, Hi: 0xa798, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79a, Hi: 0xa79a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79c, Hi: 0xa79c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79e, Hi: 0xa79e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a0, Hi: 0xa7a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a2, Hi: 0xa7a2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a4, Hi: 0xa7a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a6, Hi: 0xa7a6, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a8, Hi: 0xa7a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7aa, Hi: 0xa7ae, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b0, Hi: 0xa7b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b6, Hi: 0xa7b6, Stride: 0x1},
+		unicode.Range16{Lo: 0xff21, Hi: 0xff3a, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10400, Hi: 0x10427, Stride: 0x1},
+		unicode.Range32{Lo: 0x104b0, Hi: 0x104d3, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c80, Hi: 0x10cb2, Stride: 0x1},
+		unicode.Range32{Lo: 0x118a0, Hi: 0x118bf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d400, Hi: 0x1d419, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d434, Hi: 0x1d44d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d468, Hi: 0x1d481, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d49c, Hi: 0x1d49c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d49e, Hi: 0x1d49f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a2, Hi: 0x1d4a2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a5, Hi: 0x1d4a6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a9, Hi: 0x1d4ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4ae, Hi: 0x1d4b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4d0, Hi: 0x1d4e9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d504, Hi: 0x1d505, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d507, Hi: 0x1d50a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d50d, Hi: 0x1d514, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d516, Hi: 0x1d51c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d538, Hi: 0x1d539, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d53b, Hi: 0x1d53e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d540, Hi: 0x1d544, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d546, Hi: 0x1d546, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d54a, Hi: 0x1d550, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d56c, Hi: 0x1d585, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5a0, Hi: 0x1d5b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5d4, Hi: 0x1d5ed, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d608, Hi: 0x1d621, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d63c, Hi: 0x1d655, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d670, Hi: 0x1d689, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6a8, Hi: 0x1d6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6e2, Hi: 0x1d6fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d71c, Hi: 0x1d734, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d756, Hi: 0x1d76e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d790, Hi: 0x1d7a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7ca, Hi: 0x1d7ca, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e900, Hi: 0x1e921, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f130, Hi: 0x1f149, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f150, Hi: 0x1f169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f170, Hi: 0x1f189, Stride: 0x1},
+	},
+	LatinOffset: 3,
+}
+
+type _SentenceRuneRange unicode.RangeTable
+
+func _SentenceRuneType(r rune) *_SentenceRuneRange {
+	switch {
+	case unicode.Is(_SentenceATerm, r):
+		return (*_SentenceRuneRange)(_SentenceATerm)
+	case unicode.Is(_SentenceCR, r):
+		return (*_SentenceRuneRange)(_SentenceCR)
+	case unicode.Is(_SentenceClose, r):
+		return (*_SentenceRuneRange)(_SentenceClose)
+	case unicode.Is(_SentenceExtend, r):
+		return (*_SentenceRuneRange)(_SentenceExtend)
+	case unicode.Is(_SentenceFormat, r):
+		return (*_SentenceRuneRange)(_SentenceFormat)
+	case unicode.Is(_SentenceLF, r):
+		return (*_SentenceRuneRange)(_SentenceLF)
+	case unicode.Is(_SentenceLower, r):
+		return (*_SentenceRuneRange)(_SentenceLower)
+	case unicode.Is(_SentenceNumeric, r):
+		return (*_SentenceRuneRange)(_SentenceNumeric)
+	case unicode.Is(_SentenceOLetter, r):
+		return (*_SentenceRuneRange)(_SentenceOLetter)
+	case unicode.Is(_SentenceSContinue, r):
+		return (*_SentenceRuneRange)(_SentenceSContinue)
+	case unicode.Is(_SentenceSTerm, r):
+		return (*_SentenceRuneRange)(_SentenceSTerm)
+	case unicode.Is(_SentenceSep, r):
+		return (*_SentenceRuneRange)(_SentenceSep)
+	case unicode.Is(_SentenceSp, r):
+		return (*_SentenceRuneRange)(_SentenceSp)
+	case unicode.Is(_SentenceUpper, r):
+		return (*_SentenceRuneRange)(_SentenceUpper)
+	default:
+		return nil
+	}
+}
+func (rng *_SentenceRuneRange) String() string {
+	switch (*unicode.RangeTable)(rng) {
+	case _SentenceATerm:
+		return "ATerm"
+	case _SentenceCR:
+		return "CR"
+	case _SentenceClose:
+		return "Close"
+	case _SentenceExtend:
+		return "Extend"
+	case _SentenceFormat:
+		return "Format"
+	case _SentenceLF:
+		return "LF"
+	case _SentenceLower:
+		return "Lower"
+	case _SentenceNumeric:
+		return "Numeric"
+	case _SentenceOLetter:
+		return "OLetter"
+	case _SentenceSContinue:
+		return "SContinue"
+	case _SentenceSTerm:
+		return "STerm"
+	case _SentenceSep:
+		return "Sep"
+	case _SentenceSp:
+		return "Sp"
+	case _SentenceUpper:
+		return "Upper"
+	default:
+		return "Other"
+	}
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb b/vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb
new file mode 100644
index 000000000..422e4e5cc
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb
@@ -0,0 +1,335 @@
+#!/usr/bin/env ruby
+#
+# This scripted has been updated to accept more command-line arguments:
+#
+#    -u, --url                        URL to process
+#    -m, --machine                    Machine name
+#    -p, --properties                 Properties to add to the machine
+#    -o, --output                     Write output to file
+#
+# Updated by: Marty Schoch <marty.schoch@gmail.com>
+# 
+# This script uses the unicode spec to generate a Ragel state machine
+# that recognizes unicode alphanumeric characters.  It generates 5
+# character classes: uupper, ulower, ualpha, udigit, and ualnum.
+# Currently supported encodings are UTF-8 [default] and UCS-4.
+#
+# Usage: unicode2ragel.rb [options]
+#    -e, --encoding [ucs4 | utf8]     Data encoding
+#    -h, --help                       Show this message
+#
+# This script was originally written as part of the Ferret search
+# engine library.
+#
+# Author: Rakan El-Khalil <rakan@well.com>
+
+require 'optparse'
+require 'open-uri'
+
+ENCODINGS = [ :utf8, :ucs4 ]
+ALPHTYPES = { :utf8 => "byte", :ucs4 => "rune" }
+DEFAULT_CHART_URL = "http://www.unicode.org/Public/5.1.0/ucd/DerivedCoreProperties.txt"
+DEFAULT_MACHINE_NAME= "WChar"
+
+###
+# Display vars & default option
+
+TOTAL_WIDTH = 80
+RANGE_WIDTH = 23
+@encoding = :utf8
+@chart_url = DEFAULT_CHART_URL
+machine_name = DEFAULT_MACHINE_NAME
+properties = []
+@output = $stdout
+
+###
+# Option parsing
+
+cli_opts = OptionParser.new do |opts|
+  opts.on("-e", "--encoding [ucs4 | utf8]", "Data encoding") do |o|
+    @encoding = o.downcase.to_sym
+  end
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+  opts.on("-u", "--url URL", "URL to process") do |o|
+    @chart_url = o 
+  end
+  opts.on("-m", "--machine MACHINE_NAME", "Machine name") do |o|
+    machine_name = o
+  end
+  opts.on("-p", "--properties x,y,z", Array, "Properties to add to machine") do |o|
+    properties = o
+  end
+  opts.on("-o", "--output FILE", "output file") do |o|
+    @output = File.new(o, "w+")
+  end
+end
+
+cli_opts.parse(ARGV)
+unless ENCODINGS.member? @encoding
+  puts "Invalid encoding: #{@encoding}"
+  puts cli_opts
+  exit
+end
+
+##
+# Downloads the document at url and yields every alpha line's hex
+# range and description.
+
+def each_alpha( url, property ) 
+  open( url ) do |file|
+    file.each_line do |line|
+      next if line =~ /^#/;
+      next if line !~ /; #{property} #/;
+
+      range, description = line.split(/;/)
+      range.strip!
+      description.gsub!(/.*#/, '').strip!
+
+      if range =~ /\.\./
+           start, stop = range.split '..'
+      else start = stop = range
+      end
+
+      yield start.hex .. stop.hex, description
+    end
+  end
+end
+
+###
+# Formats to hex at minimum width
+
+def to_hex( n )
+  r = "%0X" % n
+  r = "0#{r}" unless (r.length % 2).zero?
+  r
+end
+
+###
+# UCS4 is just a straight hex conversion of the unicode codepoint.
+
+def to_ucs4( range )
+  rangestr  =   "0x" + to_hex(range.begin)
+  rangestr << "..0x" + to_hex(range.end) if range.begin != range.end
+  [ rangestr ]
+end
+
+##
+# 0x00     - 0x7f     -> 0zzzzzzz[7]
+# 0x80     - 0x7ff    -> 110yyyyy[5] 10zzzzzz[6]
+# 0x800    - 0xffff   -> 1110xxxx[4] 10yyyyyy[6] 10zzzzzz[6]
+# 0x010000 - 0x10ffff -> 11110www[3] 10xxxxxx[6] 10yyyyyy[6] 10zzzzzz[6] 
+
+UTF8_BOUNDARIES = [0x7f, 0x7ff, 0xffff, 0x10ffff]
+
+def to_utf8_enc( n )
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0x7ff
+    y = 0xc0 | (n >> 6)
+    z = 0x80 | (n & 0x3f)
+    r = y << 8 | z
+  elsif n <= 0xffff
+    x = 0xe0 | (n >> 12)
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = x << 16 | y << 8 | z
+  elsif n <= 0x10ffff
+    w = 0xf0 | (n >> 18)
+    x = 0x80 | (n >> 12) & 0x3f
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = w << 24 | x << 16 | y << 8 | z
+  end
+
+  to_hex(r)
+end
+
+def from_utf8_enc( n )
+  n = n.hex
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0xdfff
+    y = (n >> 8) & 0x1f
+    z =  n       & 0x3f
+    r = y << 6 | z
+  elsif n <= 0xefffff
+    x = (n >> 16) & 0x0f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = x << 10 | y << 6 | z
+  elsif n <= 0xf7ffffff
+    w = (n >> 24) & 0x07
+    x = (n >> 16) & 0x3f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = w << 18 | x << 12 | y << 6 | z
+  end
+  r
+end
+
+###
+# Given a range, splits it up into ranges that can be continuously
+# encoded into utf8.  Eg: 0x00 .. 0xff => [0x00..0x7f, 0x80..0xff]
+# This is not strictly needed since the current [5.1] unicode standard
+# doesn't have ranges that straddle utf8 boundaries.  This is included
+# for completeness as there is no telling if that will ever change.
+
+def utf8_ranges( range )
+  ranges = []
+  UTF8_BOUNDARIES.each do |max|
+    if range.begin <= max
+      if range.end <= max
+        ranges << range
+        return ranges
+      end
+
+      ranges << (range.begin .. max)
+      range = (max + 1) .. range.end
+    end
+  end
+  ranges
+end
+
+def build_range( start, stop )
+  size = start.size/2
+  left = size - 1
+  return [""] if size < 1
+
+  a = start[0..1]
+  b = stop[0..1]
+
+  ###
+  # Shared prefix
+
+  if a == b
+    return build_range(start[2..-1], stop[2..-1]).map do |elt|
+      "0x#{a} " + elt
+    end
+  end
+
+  ###
+  # Unshared prefix, end of run
+
+  return ["0x#{a}..0x#{b} "] if left.zero?
+  
+  ###
+  # Unshared prefix, not end of run
+  # Range can be 0x123456..0x56789A
+  # Which is equivalent to:
+  #     0x123456 .. 0x12FFFF
+  #     0x130000 .. 0x55FFFF
+  #     0x560000 .. 0x56789A
+
+  ret = []
+  ret << build_range(start, a + "FF" * left)
+
+  ###
+  # Only generate middle range if need be.
+
+  if a.hex+1 != b.hex
+    max = to_hex(b.hex - 1)
+    max = "FF" if b == "FF"
+    ret << "0x#{to_hex(a.hex+1)}..0x#{max} " + "0x00..0xFF " * left
+  end
+
+  ###
+  # Don't generate last range if it is covered by first range
+  
+  ret << build_range(b + "00" * left, stop) unless b == "FF"
+  ret.flatten!
+end
+
+def to_utf8( range )
+  utf8_ranges( range ).map do |r|   
+    begin_enc = to_utf8_enc(r.begin)
+    end_enc = to_utf8_enc(r.end)
+    build_range begin_enc, end_enc
+  end.flatten!
+end
+
+##
+# Perform a 3-way comparison of the number of codepoints advertised by
+# the unicode spec for the given range, the originally parsed range,
+# and the resulting utf8 encoded range.
+
+def count_codepoints( code )
+  code.split(' ').inject(1) do |acc, elt|
+    if elt =~ /0x(.+)\.\.0x(.+)/
+      if @encoding == :utf8
+        acc * (from_utf8_enc($2) - from_utf8_enc($1) + 1)
+      else
+        acc * ($2.hex - $1.hex + 1)
+      end
+    else
+      acc
+    end
+  end
+end
+
+def is_valid?( range, desc, codes )
+  spec_count  = 1
+  spec_count  = $1.to_i if desc =~ /\[(\d+)\]/
+  range_count = range.end - range.begin + 1
+
+  sum = codes.inject(0) { |acc, elt| acc + count_codepoints(elt) }
+  sum == spec_count and sum == range_count
+end
+
+##
+# Generate the state maching to stdout
+
+def generate_machine( name, property )
+  pipe = " "
+  @output.puts "    #{name} = "
+  each_alpha( @chart_url, property ) do |range, desc|
+
+    codes = (@encoding == :ucs4) ? to_ucs4(range) : to_utf8(range)
+
+    #raise "Invalid encoding of range #{range}: #{codes.inspect}" unless 
+    #  is_valid? range, desc, codes
+
+    range_width = codes.map { |a| a.size }.max
+    range_width = RANGE_WIDTH if range_width < RANGE_WIDTH
+
+    desc_width  = TOTAL_WIDTH - RANGE_WIDTH - 11
+    desc_width -= (range_width - RANGE_WIDTH) if range_width > RANGE_WIDTH
+
+    if desc.size > desc_width
+      desc = desc[0..desc_width - 4] + "..."
+    end
+
+    codes.each_with_index do |r, idx|
+      desc = "" unless idx.zero?
+      code = "%-#{range_width}s" % r
+      @output.puts "      #{pipe} #{code} ##{desc}"
+      pipe = "|"
+    end
+  end
+  @output.puts "      ;"
+  @output.puts ""
+end
+
+@output.puts <<EOF
+# The following Ragel file was autogenerated with #{$0} 
+# from: #{@chart_url}
+#
+# It defines #{properties}.
+#
+# To use this, make sure that your alphtype is set to #{ALPHTYPES[@encoding]},
+# and that your input is in #{@encoding}.
+
+%%{
+    machine #{machine_name};
+    
+EOF
+
+properties.each { |x| generate_machine( x, x ) }
+
+@output.puts <<EOF
+}%%
+EOF
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go b/vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go
new file mode 100644
index 000000000..6b14bef0e
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go
@@ -0,0 +1,19 @@
+package textseg
+
+import "unicode/utf8"
+
+// ScanGraphemeClusters is a split function for bufio.Scanner that splits
+// on UTF8 sequence boundaries.
+//
+// This is included largely for completeness, since this behavior is already
+// built in to Go when ranging over a string.
+func ScanUTF8Sequences(data []byte, atEOF bool) (int, []byte, error) {
+	if len(data) == 0 {
+		return 0, nil, nil
+	}
+	r, seqLen := utf8.DecodeRune(data)
+	if r == utf8.RuneError && !atEOF {
+		return 0, nil, nil
+	}
+	return seqLen, data[:seqLen], nil
+}
diff --git a/vendor/github.com/dylanmei/winrmtest/go.mod b/vendor/github.com/dylanmei/winrmtest/go.mod
new file mode 100644
index 000000000..f177921ec
--- /dev/null
+++ b/vendor/github.com/dylanmei/winrmtest/go.mod
@@ -0,0 +1,11 @@
+module github.com/dylanmei/winrmtest
+
+require (
+	github.com/antchfx/xpath v0.0.0-20190129040759-c8489ed3251e // indirect
+	github.com/antchfx/xquery v0.0.0-20180515051857-ad5b8c7a47b0
+	github.com/kr/pretty v0.1.0 // indirect
+	github.com/satori/go.uuid v1.2.0
+	golang.org/x/net v0.0.0-20190213061140-3a22650c66bd // indirect
+	golang.org/x/text v0.3.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+)
diff --git a/vendor/github.com/dylanmei/winrmtest/go.sum b/vendor/github.com/dylanmei/winrmtest/go.sum
new file mode 100644
index 000000000..74c6feec2
--- /dev/null
+++ b/vendor/github.com/dylanmei/winrmtest/go.sum
@@ -0,0 +1,17 @@
+github.com/antchfx/xpath v0.0.0-20190129040759-c8489ed3251e h1:ptBAamGVd6CfRsUtyHD+goy2JGhv1QC32v3gqM8mYAM=
+github.com/antchfx/xpath v0.0.0-20190129040759-c8489ed3251e/go.mod h1:Yee4kTMuNiPYJ7nSNorELQMr1J33uOpXDMByNYhvtNk=
+github.com/antchfx/xquery v0.0.0-20180515051857-ad5b8c7a47b0 h1:JaCC8jz0zdMLk2m+qCCVLLLM/PL93p84w4pK3aJWj60=
+github.com/antchfx/xquery v0.0.0-20180515051857-ad5b8c7a47b0/go.mod h1:LzD22aAzDP8/dyiCKFp31He4m2GPjl0AFyzDtZzUu9M=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww=
+github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd h1:HuTn7WObtcDo9uEEU7rEqL0jYthdXAmZ6PP+meazmaU=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/vendor/github.com/google/go-cmp/cmp/cmpopts/equate.go b/vendor/github.com/google/go-cmp/cmp/cmpopts/equate.go
new file mode 100644
index 000000000..41bbddc61
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/cmpopts/equate.go
@@ -0,0 +1,89 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+// Package cmpopts provides common options for the cmp package.
+package cmpopts
+
+import (
+	"math"
+	"reflect"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func equateAlways(_, _ interface{}) bool { return true }
+
+// EquateEmpty returns a Comparer option that determines all maps and slices
+// with a length of zero to be equal, regardless of whether they are nil.
+//
+// EquateEmpty can be used in conjunction with SortSlices and SortMaps.
+func EquateEmpty() cmp.Option {
+	return cmp.FilterValues(isEmpty, cmp.Comparer(equateAlways))
+}
+
+func isEmpty(x, y interface{}) bool {
+	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+	return (x != nil && y != nil && vx.Type() == vy.Type()) &&
+		(vx.Kind() == reflect.Slice || vx.Kind() == reflect.Map) &&
+		(vx.Len() == 0 && vy.Len() == 0)
+}
+
+// EquateApprox returns a Comparer option that determines float32 or float64
+// values to be equal if they are within a relative fraction or absolute margin.
+// This option is not used when either x or y is NaN or infinite.
+//
+// The fraction determines that the difference of two values must be within the
+// smaller fraction of the two values, while the margin determines that the two
+// values must be within some absolute margin.
+// To express only a fraction or only a margin, use 0 for the other parameter.
+// The fraction and margin must be non-negative.
+//
+// The mathematical expression used is equivalent to:
+//	|x-y| ≤ max(fraction*min(|x|, |y|), margin)
+//
+// EquateApprox can be used in conjunction with EquateNaNs.
+func EquateApprox(fraction, margin float64) cmp.Option {
+	if margin < 0 || fraction < 0 || math.IsNaN(margin) || math.IsNaN(fraction) {
+		panic("margin or fraction must be a non-negative number")
+	}
+	a := approximator{fraction, margin}
+	return cmp.Options{
+		cmp.FilterValues(areRealF64s, cmp.Comparer(a.compareF64)),
+		cmp.FilterValues(areRealF32s, cmp.Comparer(a.compareF32)),
+	}
+}
+
+type approximator struct{ frac, marg float64 }
+
+func areRealF64s(x, y float64) bool {
+	return !math.IsNaN(x) && !math.IsNaN(y) && !math.IsInf(x, 0) && !math.IsInf(y, 0)
+}
+func areRealF32s(x, y float32) bool {
+	return areRealF64s(float64(x), float64(y))
+}
+func (a approximator) compareF64(x, y float64) bool {
+	relMarg := a.frac * math.Min(math.Abs(x), math.Abs(y))
+	return math.Abs(x-y) <= math.Max(a.marg, relMarg)
+}
+func (a approximator) compareF32(x, y float32) bool {
+	return a.compareF64(float64(x), float64(y))
+}
+
+// EquateNaNs returns a Comparer option that determines float32 and float64
+// NaN values to be equal.
+//
+// EquateNaNs can be used in conjunction with EquateApprox.
+func EquateNaNs() cmp.Option {
+	return cmp.Options{
+		cmp.FilterValues(areNaNsF64s, cmp.Comparer(equateAlways)),
+		cmp.FilterValues(areNaNsF32s, cmp.Comparer(equateAlways)),
+	}
+}
+
+func areNaNsF64s(x, y float64) bool {
+	return math.IsNaN(x) && math.IsNaN(y)
+}
+func areNaNsF32s(x, y float32) bool {
+	return areNaNsF64s(float64(x), float64(y))
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/cmpopts/ignore.go b/vendor/github.com/google/go-cmp/cmp/cmpopts/ignore.go
new file mode 100644
index 000000000..ff8e785d4
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/cmpopts/ignore.go
@@ -0,0 +1,207 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package cmpopts
+
+import (
+	"fmt"
+	"reflect"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/internal/function"
+)
+
+// IgnoreFields returns an Option that ignores exported fields of the
+// given names on a single struct type.
+// The struct type is specified by passing in a value of that type.
+//
+// The name may be a dot-delimited string (e.g., "Foo.Bar") to ignore a
+// specific sub-field that is embedded or nested within the parent struct.
+//
+// This does not handle unexported fields; use IgnoreUnexported instead.
+func IgnoreFields(typ interface{}, names ...string) cmp.Option {
+	sf := newStructFilter(typ, names...)
+	return cmp.FilterPath(sf.filter, cmp.Ignore())
+}
+
+// IgnoreTypes returns an Option that ignores all values assignable to
+// certain types, which are specified by passing in a value of each type.
+func IgnoreTypes(typs ...interface{}) cmp.Option {
+	tf := newTypeFilter(typs...)
+	return cmp.FilterPath(tf.filter, cmp.Ignore())
+}
+
+type typeFilter []reflect.Type
+
+func newTypeFilter(typs ...interface{}) (tf typeFilter) {
+	for _, typ := range typs {
+		t := reflect.TypeOf(typ)
+		if t == nil {
+			// This occurs if someone tries to pass in sync.Locker(nil)
+			panic("cannot determine type; consider using IgnoreInterfaces")
+		}
+		tf = append(tf, t)
+	}
+	return tf
+}
+func (tf typeFilter) filter(p cmp.Path) bool {
+	if len(p) < 1 {
+		return false
+	}
+	t := p.Last().Type()
+	for _, ti := range tf {
+		if t.AssignableTo(ti) {
+			return true
+		}
+	}
+	return false
+}
+
+// IgnoreInterfaces returns an Option that ignores all values or references of
+// values assignable to certain interface types. These interfaces are specified
+// by passing in an anonymous struct with the interface types embedded in it.
+// For example, to ignore sync.Locker, pass in struct{sync.Locker}{}.
+func IgnoreInterfaces(ifaces interface{}) cmp.Option {
+	tf := newIfaceFilter(ifaces)
+	return cmp.FilterPath(tf.filter, cmp.Ignore())
+}
+
+type ifaceFilter []reflect.Type
+
+func newIfaceFilter(ifaces interface{}) (tf ifaceFilter) {
+	t := reflect.TypeOf(ifaces)
+	if ifaces == nil || t.Name() != "" || t.Kind() != reflect.Struct {
+		panic("input must be an anonymous struct")
+	}
+	for i := 0; i < t.NumField(); i++ {
+		fi := t.Field(i)
+		switch {
+		case !fi.Anonymous:
+			panic("struct cannot have named fields")
+		case fi.Type.Kind() != reflect.Interface:
+			panic("embedded field must be an interface type")
+		case fi.Type.NumMethod() == 0:
+			// This matches everything; why would you ever want this?
+			panic("cannot ignore empty interface")
+		default:
+			tf = append(tf, fi.Type)
+		}
+	}
+	return tf
+}
+func (tf ifaceFilter) filter(p cmp.Path) bool {
+	if len(p) < 1 {
+		return false
+	}
+	t := p.Last().Type()
+	for _, ti := range tf {
+		if t.AssignableTo(ti) {
+			return true
+		}
+		if t.Kind() != reflect.Ptr && reflect.PtrTo(t).AssignableTo(ti) {
+			return true
+		}
+	}
+	return false
+}
+
+// IgnoreUnexported returns an Option that only ignores the immediate unexported
+// fields of a struct, including anonymous fields of unexported types.
+// In particular, unexported fields within the struct's exported fields
+// of struct types, including anonymous fields, will not be ignored unless the
+// type of the field itself is also passed to IgnoreUnexported.
+//
+// Avoid ignoring unexported fields of a type which you do not control (i.e. a
+// type from another repository), as changes to the implementation of such types
+// may change how the comparison behaves. Prefer a custom Comparer instead.
+func IgnoreUnexported(typs ...interface{}) cmp.Option {
+	ux := newUnexportedFilter(typs...)
+	return cmp.FilterPath(ux.filter, cmp.Ignore())
+}
+
+type unexportedFilter struct{ m map[reflect.Type]bool }
+
+func newUnexportedFilter(typs ...interface{}) unexportedFilter {
+	ux := unexportedFilter{m: make(map[reflect.Type]bool)}
+	for _, typ := range typs {
+		t := reflect.TypeOf(typ)
+		if t == nil || t.Kind() != reflect.Struct {
+			panic(fmt.Sprintf("invalid struct type: %T", typ))
+		}
+		ux.m[t] = true
+	}
+	return ux
+}
+func (xf unexportedFilter) filter(p cmp.Path) bool {
+	sf, ok := p.Index(-1).(cmp.StructField)
+	if !ok {
+		return false
+	}
+	return xf.m[p.Index(-2).Type()] && !isExported(sf.Name())
+}
+
+// isExported reports whether the identifier is exported.
+func isExported(id string) bool {
+	r, _ := utf8.DecodeRuneInString(id)
+	return unicode.IsUpper(r)
+}
+
+// IgnoreSliceElements returns an Option that ignores elements of []V.
+// The discard function must be of the form "func(T) bool" which is used to
+// ignore slice elements of type V, where V is assignable to T.
+// Elements are ignored if the function reports true.
+func IgnoreSliceElements(discardFunc interface{}) cmp.Option {
+	vf := reflect.ValueOf(discardFunc)
+	if !function.IsType(vf.Type(), function.ValuePredicate) || vf.IsNil() {
+		panic(fmt.Sprintf("invalid discard function: %T", discardFunc))
+	}
+	return cmp.FilterPath(func(p cmp.Path) bool {
+		si, ok := p.Index(-1).(cmp.SliceIndex)
+		if !ok {
+			return false
+		}
+		if !si.Type().AssignableTo(vf.Type().In(0)) {
+			return false
+		}
+		vx, vy := si.Values()
+		if vx.IsValid() && vf.Call([]reflect.Value{vx})[0].Bool() {
+			return true
+		}
+		if vy.IsValid() && vf.Call([]reflect.Value{vy})[0].Bool() {
+			return true
+		}
+		return false
+	}, cmp.Ignore())
+}
+
+// IgnoreMapEntries returns an Option that ignores entries of map[K]V.
+// The discard function must be of the form "func(T, R) bool" which is used to
+// ignore map entries of type K and V, where K and V are assignable to T and R.
+// Entries are ignored if the function reports true.
+func IgnoreMapEntries(discardFunc interface{}) cmp.Option {
+	vf := reflect.ValueOf(discardFunc)
+	if !function.IsType(vf.Type(), function.KeyValuePredicate) || vf.IsNil() {
+		panic(fmt.Sprintf("invalid discard function: %T", discardFunc))
+	}
+	return cmp.FilterPath(func(p cmp.Path) bool {
+		mi, ok := p.Index(-1).(cmp.MapIndex)
+		if !ok {
+			return false
+		}
+		if !mi.Key().Type().AssignableTo(vf.Type().In(0)) || !mi.Type().AssignableTo(vf.Type().In(1)) {
+			return false
+		}
+		k := mi.Key()
+		vx, vy := mi.Values()
+		if vx.IsValid() && vf.Call([]reflect.Value{k, vx})[0].Bool() {
+			return true
+		}
+		if vy.IsValid() && vf.Call([]reflect.Value{k, vy})[0].Bool() {
+			return true
+		}
+		return false
+	}, cmp.Ignore())
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/cmpopts/sort.go b/vendor/github.com/google/go-cmp/cmp/cmpopts/sort.go
new file mode 100644
index 000000000..3a4804621
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/cmpopts/sort.go
@@ -0,0 +1,147 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package cmpopts
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/internal/function"
+)
+
+// SortSlices returns a Transformer option that sorts all []V.
+// The less function must be of the form "func(T, T) bool" which is used to
+// sort any slice with element type V that is assignable to T.
+//
+// The less function must be:
+//	• Deterministic: less(x, y) == less(x, y)
+//	• Irreflexive: !less(x, x)
+//	• Transitive: if !less(x, y) and !less(y, z), then !less(x, z)
+//
+// The less function does not have to be "total". That is, if !less(x, y) and
+// !less(y, x) for two elements x and y, their relative order is maintained.
+//
+// SortSlices can be used in conjunction with EquateEmpty.
+func SortSlices(lessFunc interface{}) cmp.Option {
+	vf := reflect.ValueOf(lessFunc)
+	if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
+		panic(fmt.Sprintf("invalid less function: %T", lessFunc))
+	}
+	ss := sliceSorter{vf.Type().In(0), vf}
+	return cmp.FilterValues(ss.filter, cmp.Transformer("cmpopts.SortSlices", ss.sort))
+}
+
+type sliceSorter struct {
+	in  reflect.Type  // T
+	fnc reflect.Value // func(T, T) bool
+}
+
+func (ss sliceSorter) filter(x, y interface{}) bool {
+	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+	if !(x != nil && y != nil && vx.Type() == vy.Type()) ||
+		!(vx.Kind() == reflect.Slice && vx.Type().Elem().AssignableTo(ss.in)) ||
+		(vx.Len() <= 1 && vy.Len() <= 1) {
+		return false
+	}
+	// Check whether the slices are already sorted to avoid an infinite
+	// recursion cycle applying the same transform to itself.
+	ok1 := sort.SliceIsSorted(x, func(i, j int) bool { return ss.less(vx, i, j) })
+	ok2 := sort.SliceIsSorted(y, func(i, j int) bool { return ss.less(vy, i, j) })
+	return !ok1 || !ok2
+}
+func (ss sliceSorter) sort(x interface{}) interface{} {
+	src := reflect.ValueOf(x)
+	dst := reflect.MakeSlice(src.Type(), src.Len(), src.Len())
+	for i := 0; i < src.Len(); i++ {
+		dst.Index(i).Set(src.Index(i))
+	}
+	sort.SliceStable(dst.Interface(), func(i, j int) bool { return ss.less(dst, i, j) })
+	ss.checkSort(dst)
+	return dst.Interface()
+}
+func (ss sliceSorter) checkSort(v reflect.Value) {
+	start := -1 // Start of a sequence of equal elements.
+	for i := 1; i < v.Len(); i++ {
+		if ss.less(v, i-1, i) {
+			// Check that first and last elements in v[start:i] are equal.
+			if start >= 0 && (ss.less(v, start, i-1) || ss.less(v, i-1, start)) {
+				panic(fmt.Sprintf("incomparable values detected: want equal elements: %v", v.Slice(start, i)))
+			}
+			start = -1
+		} else if start == -1 {
+			start = i
+		}
+	}
+}
+func (ss sliceSorter) less(v reflect.Value, i, j int) bool {
+	vx, vy := v.Index(i), v.Index(j)
+	return ss.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
+}
+
+// SortMaps returns a Transformer option that flattens map[K]V types to be a
+// sorted []struct{K, V}. The less function must be of the form
+// "func(T, T) bool" which is used to sort any map with key K that is
+// assignable to T.
+//
+// Flattening the map into a slice has the property that cmp.Equal is able to
+// use Comparers on K or the K.Equal method if it exists.
+//
+// The less function must be:
+//	• Deterministic: less(x, y) == less(x, y)
+//	• Irreflexive: !less(x, x)
+//	• Transitive: if !less(x, y) and !less(y, z), then !less(x, z)
+//	• Total: if x != y, then either less(x, y) or less(y, x)
+//
+// SortMaps can be used in conjunction with EquateEmpty.
+func SortMaps(lessFunc interface{}) cmp.Option {
+	vf := reflect.ValueOf(lessFunc)
+	if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
+		panic(fmt.Sprintf("invalid less function: %T", lessFunc))
+	}
+	ms := mapSorter{vf.Type().In(0), vf}
+	return cmp.FilterValues(ms.filter, cmp.Transformer("cmpopts.SortMaps", ms.sort))
+}
+
+type mapSorter struct {
+	in  reflect.Type  // T
+	fnc reflect.Value // func(T, T) bool
+}
+
+func (ms mapSorter) filter(x, y interface{}) bool {
+	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
+	return (x != nil && y != nil && vx.Type() == vy.Type()) &&
+		(vx.Kind() == reflect.Map && vx.Type().Key().AssignableTo(ms.in)) &&
+		(vx.Len() != 0 || vy.Len() != 0)
+}
+func (ms mapSorter) sort(x interface{}) interface{} {
+	src := reflect.ValueOf(x)
+	outType := reflect.StructOf([]reflect.StructField{
+		{Name: "K", Type: src.Type().Key()},
+		{Name: "V", Type: src.Type().Elem()},
+	})
+	dst := reflect.MakeSlice(reflect.SliceOf(outType), src.Len(), src.Len())
+	for i, k := range src.MapKeys() {
+		v := reflect.New(outType).Elem()
+		v.Field(0).Set(k)
+		v.Field(1).Set(src.MapIndex(k))
+		dst.Index(i).Set(v)
+	}
+	sort.Slice(dst.Interface(), func(i, j int) bool { return ms.less(dst, i, j) })
+	ms.checkSort(dst)
+	return dst.Interface()
+}
+func (ms mapSorter) checkSort(v reflect.Value) {
+	for i := 1; i < v.Len(); i++ {
+		if !ms.less(v, i-1, i) {
+			panic(fmt.Sprintf("partial order detected: want %v < %v", v.Index(i-1), v.Index(i)))
+		}
+	}
+}
+func (ms mapSorter) less(v reflect.Value, i, j int) bool {
+	vx, vy := v.Index(i).Field(0), v.Index(j).Field(0)
+	return ms.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/cmpopts/struct_filter.go b/vendor/github.com/google/go-cmp/cmp/cmpopts/struct_filter.go
new file mode 100644
index 000000000..97f707983
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/cmpopts/struct_filter.go
@@ -0,0 +1,182 @@
+// Copyright 2017, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package cmpopts
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+// filterField returns a new Option where opt is only evaluated on paths that
+// include a specific exported field on a single struct type.
+// The struct type is specified by passing in a value of that type.
+//
+// The name may be a dot-delimited string (e.g., "Foo.Bar") to select a
+// specific sub-field that is embedded or nested within the parent struct.
+func filterField(typ interface{}, name string, opt cmp.Option) cmp.Option {
+	// TODO: This is currently unexported over concerns of how helper filters
+	// can be composed together easily.
+	// TODO: Add tests for FilterField.
+
+	sf := newStructFilter(typ, name)
+	return cmp.FilterPath(sf.filter, opt)
+}
+
+type structFilter struct {
+	t  reflect.Type // The root struct type to match on
+	ft fieldTree    // Tree of fields to match on
+}
+
+func newStructFilter(typ interface{}, names ...string) structFilter {
+	// TODO: Perhaps allow * as a special identifier to allow ignoring any
+	// number of path steps until the next field match?
+	// This could be useful when a concrete struct gets transformed into
+	// an anonymous struct where it is not possible to specify that by type,
+	// but the transformer happens to provide guarantees about the names of
+	// the transformed fields.
+
+	t := reflect.TypeOf(typ)
+	if t == nil || t.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("%T must be a struct", typ))
+	}
+	var ft fieldTree
+	for _, name := range names {
+		cname, err := canonicalName(t, name)
+		if err != nil {
+			panic(fmt.Sprintf("%s: %v", strings.Join(cname, "."), err))
+		}
+		ft.insert(cname)
+	}
+	return structFilter{t, ft}
+}
+
+func (sf structFilter) filter(p cmp.Path) bool {
+	for i, ps := range p {
+		if ps.Type().AssignableTo(sf.t) && sf.ft.matchPrefix(p[i+1:]) {
+			return true
+		}
+	}
+	return false
+}
+
+// fieldTree represents a set of dot-separated identifiers.
+//
+// For example, inserting the following selectors:
+//	Foo
+//	Foo.Bar.Baz
+//	Foo.Buzz
+//	Nuka.Cola.Quantum
+//
+// Results in a tree of the form:
+//	{sub: {
+//		"Foo": {ok: true, sub: {
+//			"Bar": {sub: {
+//				"Baz": {ok: true},
+//			}},
+//			"Buzz": {ok: true},
+//		}},
+//		"Nuka": {sub: {
+//			"Cola": {sub: {
+//				"Quantum": {ok: true},
+//			}},
+//		}},
+//	}}
+type fieldTree struct {
+	ok  bool                 // Whether this is a specified node
+	sub map[string]fieldTree // The sub-tree of fields under this node
+}
+
+// insert inserts a sequence of field accesses into the tree.
+func (ft *fieldTree) insert(cname []string) {
+	if ft.sub == nil {
+		ft.sub = make(map[string]fieldTree)
+	}
+	if len(cname) == 0 {
+		ft.ok = true
+		return
+	}
+	sub := ft.sub[cname[0]]
+	sub.insert(cname[1:])
+	ft.sub[cname[0]] = sub
+}
+
+// matchPrefix reports whether any selector in the fieldTree matches
+// the start of path p.
+func (ft fieldTree) matchPrefix(p cmp.Path) bool {
+	for _, ps := range p {
+		switch ps := ps.(type) {
+		case cmp.StructField:
+			ft = ft.sub[ps.Name()]
+			if ft.ok {
+				return true
+			}
+			if len(ft.sub) == 0 {
+				return false
+			}
+		case cmp.Indirect:
+		default:
+			return false
+		}
+	}
+	return false
+}
+
+// canonicalName returns a list of identifiers where any struct field access
+// through an embedded field is expanded to include the names of the embedded
+// types themselves.
+//
+// For example, suppose field "Foo" is not directly in the parent struct,
+// but actually from an embedded struct of type "Bar". Then, the canonical name
+// of "Foo" is actually "Bar.Foo".
+//
+// Suppose field "Foo" is not directly in the parent struct, but actually
+// a field in two different embedded structs of types "Bar" and "Baz".
+// Then the selector "Foo" causes a panic since it is ambiguous which one it
+// refers to. The user must specify either "Bar.Foo" or "Baz.Foo".
+func canonicalName(t reflect.Type, sel string) ([]string, error) {
+	var name string
+	sel = strings.TrimPrefix(sel, ".")
+	if sel == "" {
+		return nil, fmt.Errorf("name must not be empty")
+	}
+	if i := strings.IndexByte(sel, '.'); i < 0 {
+		name, sel = sel, ""
+	} else {
+		name, sel = sel[:i], sel[i:]
+	}
+
+	// Type must be a struct or pointer to struct.
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	if t.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("%v must be a struct", t)
+	}
+
+	// Find the canonical name for this current field name.
+	// If the field exists in an embedded struct, then it will be expanded.
+	if !isExported(name) {
+		// Disallow unexported fields:
+		//	* To discourage people from actually touching unexported fields
+		//	* FieldByName is buggy (https://golang.org/issue/4876)
+		return []string{name}, fmt.Errorf("name must be exported")
+	}
+	sf, ok := t.FieldByName(name)
+	if !ok {
+		return []string{name}, fmt.Errorf("does not exist")
+	}
+	var ss []string
+	for i := range sf.Index {
+		ss = append(ss, t.FieldByIndex(sf.Index[:i+1]).Name)
+	}
+	if sel == "" {
+		return ss, nil
+	}
+	ssPost, err := canonicalName(sf.Type, sel)
+	return append(ss, ssPost...), err
+}
diff --git a/vendor/github.com/google/go-cmp/cmp/cmpopts/xform.go b/vendor/github.com/google/go-cmp/cmp/cmpopts/xform.go
new file mode 100644
index 000000000..9d651553d
--- /dev/null
+++ b/vendor/github.com/google/go-cmp/cmp/cmpopts/xform.go
@@ -0,0 +1,35 @@
+// Copyright 2018, The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE.md file.
+
+package cmpopts
+
+import (
+	"github.com/google/go-cmp/cmp"
+)
+
+type xformFilter struct{ xform cmp.Option }
+
+func (xf xformFilter) filter(p cmp.Path) bool {
+	for _, ps := range p {
+		if t, ok := ps.(cmp.Transform); ok && t.Option() == xf.xform {
+			return false
+		}
+	}
+	return true
+}
+
+// AcyclicTransformer returns a Transformer with a filter applied that ensures
+// that the transformer cannot be recursively applied upon its own output.
+//
+// An example use case is a transformer that splits a string by lines:
+//	AcyclicTransformer("SplitLines", func(s string) []string{
+//		return strings.Split(s, "\n")
+//	})
+//
+// Had this been an unfiltered Transformer instead, this would result in an
+// infinite cycle converting a string to []string to [][]string and so on.
+func AcyclicTransformer(name string, xformFunc interface{}) cmp.Option {
+	xf := xformFilter{cmp.Transformer(name, xformFunc)}
+	return cmp.FilterPath(xf.filter, xf.xform)
+}
diff --git a/vendor/github.com/google/uuid/go.mod b/vendor/github.com/google/uuid/go.mod
new file mode 100644
index 000000000..fc84cd79d
--- /dev/null
+++ b/vendor/github.com/google/uuid/go.mod
@@ -0,0 +1 @@
+module github.com/google/uuid
diff --git a/vendor/github.com/google/uuid/node.go b/vendor/github.com/google/uuid/node.go
index 3e4e90dc4..d651a2b06 100644
--- a/vendor/github.com/google/uuid/node.go
+++ b/vendor/github.com/google/uuid/node.go
@@ -48,6 +48,7 @@ func setNodeInterface(name string) bool {
 	// does not specify a specific interface generate a random Node ID
 	// (section 4.1.6)
 	if name == "" {
+		ifname = "random"
 		randomBits(nodeID[:])
 		return true
 	}
diff --git a/vendor/github.com/google/uuid/uuid.go b/vendor/github.com/google/uuid/uuid.go
index 7f3643fe9..524404cc5 100644
--- a/vendor/github.com/google/uuid/uuid.go
+++ b/vendor/github.com/google/uuid/uuid.go
@@ -1,4 +1,4 @@
-// Copyright 2016 Google Inc.  All rights reserved.
+// Copyright 2018 Google Inc.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
@@ -35,20 +35,43 @@ const (
 
 var rander = rand.Reader // random function
 
-// Parse decodes s into a UUID or returns an error.  Both the UUID form of
-// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx and
-// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx are decoded.
+// Parse decodes s into a UUID or returns an error.  Both the standard UUID
+// forms of xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx and
+// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx are decoded as well as the
+// Microsoft encoding {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} and the raw hex
+// encoding: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
 func Parse(s string) (UUID, error) {
 	var uuid UUID
-	if len(s) != 36 {
-		if len(s) != 36+9 {
-			return uuid, fmt.Errorf("invalid UUID length: %d", len(s))
-		}
+	switch len(s) {
+	// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	case 36:
+
+	// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	case 36 + 9:
 		if strings.ToLower(s[:9]) != "urn:uuid:" {
 			return uuid, fmt.Errorf("invalid urn prefix: %q", s[:9])
 		}
 		s = s[9:]
+
+	// {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+	case 36 + 2:
+		s = s[1:]
+
+	// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+	case 32:
+		var ok bool
+		for i := range uuid {
+			uuid[i], ok = xtob(s[i*2], s[i*2+1])
+			if !ok {
+				return uuid, errors.New("invalid UUID format")
+			}
+		}
+		return uuid, nil
+	default:
+		return uuid, fmt.Errorf("invalid UUID length: %d", len(s))
 	}
+	// s is now at least 36 bytes long
+	// it must be of the form  xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
 	if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
 		return uuid, errors.New("invalid UUID format")
 	}
@@ -70,15 +93,29 @@ func Parse(s string) (UUID, error) {
 // ParseBytes is like Parse, except it parses a byte slice instead of a string.
 func ParseBytes(b []byte) (UUID, error) {
 	var uuid UUID
-	if len(b) != 36 {
-		if len(b) != 36+9 {
-			return uuid, fmt.Errorf("invalid UUID length: %d", len(b))
-		}
+	switch len(b) {
+	case 36: // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	case 36 + 9: // urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
 		if !bytes.Equal(bytes.ToLower(b[:9]), []byte("urn:uuid:")) {
 			return uuid, fmt.Errorf("invalid urn prefix: %q", b[:9])
 		}
 		b = b[9:]
+	case 36 + 2: // {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+		b = b[1:]
+	case 32: // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+		var ok bool
+		for i := 0; i < 32; i += 2 {
+			uuid[i/2], ok = xtob(b[i], b[i+1])
+			if !ok {
+				return uuid, errors.New("invalid UUID format")
+			}
+		}
+		return uuid, nil
+	default:
+		return uuid, fmt.Errorf("invalid UUID length: %d", len(b))
 	}
+	// s is now at least 36 bytes long
+	// it must be of the form  xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
 	if b[8] != '-' || b[13] != '-' || b[18] != '-' || b[23] != '-' {
 		return uuid, errors.New("invalid UUID format")
 	}
@@ -97,6 +134,16 @@ func ParseBytes(b []byte) (UUID, error) {
 	return uuid, nil
 }
 
+// MustParse is like Parse but panics if the string cannot be parsed.
+// It simplifies safe initialization of global variables holding compiled UUIDs.
+func MustParse(s string) UUID {
+	uuid, err := Parse(s)
+	if err != nil {
+		panic(`uuid: Parse(` + s + `): ` + err.Error())
+	}
+	return uuid
+}
+
 // FromBytes creates a new UUID from a byte slice. Returns an error if the slice
 // does not have a length of 16. The bytes are copied from the slice.
 func FromBytes(b []byte) (uuid UUID, err error) {
@@ -130,7 +177,7 @@ func (uuid UUID) URN() string {
 }
 
 func encodeHex(dst []byte, uuid UUID) {
-	hex.Encode(dst[:], uuid[:4])
+	hex.Encode(dst, uuid[:4])
 	dst[8] = '-'
 	hex.Encode(dst[9:13], uuid[4:6])
 	dst[13] = '-'
diff --git a/vendor/github.com/gophercloud/utils/openstack/clientconfig/requests.go b/vendor/github.com/gophercloud/utils/openstack/clientconfig/requests.go
index 007939013..ad1c33d9a 100644
--- a/vendor/github.com/gophercloud/utils/openstack/clientconfig/requests.go
+++ b/vendor/github.com/gophercloud/utils/openstack/clientconfig/requests.go
@@ -545,7 +545,11 @@ func v3auth(cloud *Cloud, opts *ClientOpts) (*gophercloud.AuthOptions, error) {
 	scope := new(gophercloud.AuthScope)
 
 	// Application credentials don't support scope
-	if !isApplicationCredential(cloud.AuthInfo) {
+	if isApplicationCredential(cloud.AuthInfo) {
+		// If Domain* is set, but UserDomain* or ProjectDomain* aren't,
+		// then use Domain* as the default setting.
+		cloud = setDomainIfNeeded(cloud)
+	} else {
 		if !isProjectScoped(cloud.AuthInfo) {
 			if cloud.AuthInfo.DomainID != "" {
 				scope.DomainID = cloud.AuthInfo.DomainID
diff --git a/vendor/github.com/gophercloud/utils/openstack/clientconfig/results.go b/vendor/github.com/gophercloud/utils/openstack/clientconfig/results.go
index 3dc849c6c..292ff5dc4 100644
--- a/vendor/github.com/gophercloud/utils/openstack/clientconfig/results.go
+++ b/vendor/github.com/gophercloud/utils/openstack/clientconfig/results.go
@@ -4,118 +4,118 @@ package clientconfig
 // The format of the clouds-public.yml is documented at
 // https://docs.openstack.org/python-openstackclient/latest/configuration/
 type PublicClouds struct {
-	Clouds map[string]Cloud `yaml:"public-clouds"`
+	Clouds map[string]Cloud `yaml:"public-clouds" json:"public-clouds"`
 }
 
 // Clouds represents a collection of Cloud entries in a clouds.yaml file.
 // The format of clouds.yaml is documented at
 // https://docs.openstack.org/os-client-config/latest/user/configuration.html.
 type Clouds struct {
-	Clouds map[string]Cloud `yaml:"clouds"`
+	Clouds map[string]Cloud `yaml:"clouds" json:"clouds"`
 }
 
 // Cloud represents an entry in a clouds.yaml/public-clouds.yaml/secure.yaml file.
 type Cloud struct {
-	Cloud      string        `yaml:"cloud"`
-	Profile    string        `yaml:"profile"`
-	AuthInfo   *AuthInfo     `yaml:"auth"`
-	AuthType   AuthType      `yaml:"auth_type"`
-	RegionName string        `yaml:"region_name"`
-	Regions    []interface{} `yaml:"regions"`
+	Cloud      string        `yaml:"cloud" json:"cloud"`
+	Profile    string        `yaml:"profile" json:"profile"`
+	AuthInfo   *AuthInfo     `yaml:"auth" json:"auth"`
+	AuthType   AuthType      `yaml:"auth_type" json:"auth_type"`
+	RegionName string        `yaml:"region_name" json:"region_name"`
+	Regions    []interface{} `yaml:"regions" json:"regions"`
 
 	// API Version overrides.
-	IdentityAPIVersion string `yaml:"identity_api_version"`
-	VolumeAPIVersion   string `yaml:"volume_api_version"`
+	IdentityAPIVersion string `yaml:"identity_api_version" json:"identity_api_version"`
+	VolumeAPIVersion   string `yaml:"volume_api_version" json:"volume_api_version"`
 
 	// Verify whether or not SSL API requests should be verified.
-	Verify *bool `yaml:"verify"`
+	Verify *bool `yaml:"verify" json:"verify"`
 
 	// CACertFile a path to a CA Cert bundle that can be used as part of
 	// verifying SSL API requests.
-	CACertFile string `yaml:"cacert"`
+	CACertFile string `yaml:"cacert" json:"cacert"`
 
 	// ClientCertFile a path to a client certificate to use as part of the SSL
 	// transaction.
-	ClientCertFile string `yaml:"cert"`
+	ClientCertFile string `yaml:"cert" json:"cert"`
 
 	// ClientKeyFile a path to a client key to use as part of the SSL
 	// transaction.
-	ClientKeyFile string `yaml:"key"`
+	ClientKeyFile string `yaml:"key" json:"key"`
 }
 
 // AuthInfo represents the auth section of a cloud entry or
 // auth options entered explicitly in ClientOpts.
 type AuthInfo struct {
 	// AuthURL is the keystone/identity endpoint URL.
-	AuthURL string `yaml:"auth_url"`
+	AuthURL string `yaml:"auth_url" json:"auth_url"`
 
 	// Token is a pre-generated authentication token.
-	Token string `yaml:"token"`
+	Token string `yaml:"token" json:"token"`
 
 	// Username is the username of the user.
-	Username string `yaml:"username"`
+	Username string `yaml:"username" json:"username"`
 
 	// UserID is the unique ID of a user.
-	UserID string `yaml:"user_id"`
+	UserID string `yaml:"user_id" json:"user_id"`
 
 	// Password is the password of the user.
-	Password string `yaml:"password"`
+	Password string `yaml:"password" json:"password"`
 
 	// Application Credential ID to login with.
-	ApplicationCredentialID string `yaml:"application_credential_id"`
+	ApplicationCredentialID string `yaml:"application_credential_id" json:"application_credential_id"`
 
 	// Application Credential name to login with.
-	ApplicationCredentialName string `yaml:"application_credential_name"`
+	ApplicationCredentialName string `yaml:"application_credential_name" json:"application_credential_name"`
 
 	// Application Credential secret to login with.
-	ApplicationCredentialSecret string `yaml:"application_credential_secret"`
+	ApplicationCredentialSecret string `yaml:"application_credential_secret" json:"application_credential_secret"`
 
 	// ProjectName is the common/human-readable name of a project.
 	// Users can be scoped to a project.
 	// ProjectName on its own is not enough to ensure a unique scope. It must
 	// also be combined with either a ProjectDomainName or ProjectDomainID.
 	// ProjectName cannot be combined with ProjectID in a scope.
-	ProjectName string `yaml:"project_name"`
+	ProjectName string `yaml:"project_name" json:"project_name"`
 
 	// ProjectID is the unique ID of a project.
 	// It can be used to scope a user to a specific project.
-	ProjectID string `yaml:"project_id"`
+	ProjectID string `yaml:"project_id" json:"project_id"`
 
 	// UserDomainName is the name of the domain where a user resides.
 	// It is used to identify the source domain of a user.
-	UserDomainName string `yaml:"user_domain_name"`
+	UserDomainName string `yaml:"user_domain_name" json:"user_domain_name"`
 
 	// UserDomainID is the unique ID of the domain where a user resides.
 	// It is used to identify the source domain of a user.
-	UserDomainID string `yaml:"user_domain_id"`
+	UserDomainID string `yaml:"user_domain_id" json:"user_domain_id"`
 
 	// ProjectDomainName is the name of the domain where a project resides.
 	// It is used to identify the source domain of a project.
 	// ProjectDomainName can be used in addition to a ProjectName when scoping
 	// a user to a specific project.
-	ProjectDomainName string `yaml:"project_domain_name"`
+	ProjectDomainName string `yaml:"project_domain_name" json:"project_domain_name"`
 
 	// ProjectDomainID is the name of the domain where a project resides.
 	// It is used to identify the source domain of a project.
 	// ProjectDomainID can be used in addition to a ProjectName when scoping
 	// a user to a specific project.
-	ProjectDomainID string `yaml:"project_domain_id"`
+	ProjectDomainID string `yaml:"project_domain_id" json:"project_domain_id"`
 
 	// DomainName is the name of a domain which can be used to identify the
 	// source domain of either a user or a project.
 	// If UserDomainName and ProjectDomainName are not specified, then DomainName
 	// is used as a default choice.
 	// It can also be used be used to specify a domain-only scope.
-	DomainName string `yaml:"domain_name"`
+	DomainName string `yaml:"domain_name" json:"domain_name"`
 
 	// DomainID is the unique ID of a domain which can be used to identify the
 	// source domain of eitehr a user or a project.
 	// If UserDomainID and ProjectDomainID are not specified, then DomainID is
 	// used as a default choice.
 	// It can also be used be used to specify a domain-only scope.
-	DomainID string `yaml:"domain_id"`
+	DomainID string `yaml:"domain_id" json:"domain_id"`
 
 	// DefaultDomain is the domain ID to fall back on if no other domain has
 	// been specified and a domain is required for scope.
-	DefaultDomain string `yaml:"default_domain"`
+	DefaultDomain string `yaml:"default_domain" json:"default_domain"`
 }
diff --git a/vendor/github.com/gorilla/websocket/.gitignore b/vendor/github.com/gorilla/websocket/.gitignore
index ac710204f..cd3fcd1ef 100644
--- a/vendor/github.com/gorilla/websocket/.gitignore
+++ b/vendor/github.com/gorilla/websocket/.gitignore
@@ -22,4 +22,4 @@ _testmain.go
 *.exe
 
 .idea/
-*.iml
\ No newline at end of file
+*.iml
diff --git a/vendor/github.com/gorilla/websocket/.travis.yml b/vendor/github.com/gorilla/websocket/.travis.yml
index 3d8d29cf3..a49db51c4 100644
--- a/vendor/github.com/gorilla/websocket/.travis.yml
+++ b/vendor/github.com/gorilla/websocket/.travis.yml
@@ -3,11 +3,11 @@ sudo: false
 
 matrix:
   include:
-    - go: 1.4
-    - go: 1.5
-    - go: 1.6
-    - go: 1.7
-    - go: 1.8
+    - go: 1.7.x
+    - go: 1.8.x
+    - go: 1.9.x
+    - go: 1.10.x
+    - go: 1.11.x
     - go: tip
   allow_failures:
     - go: tip
diff --git a/vendor/github.com/gorilla/websocket/AUTHORS b/vendor/github.com/gorilla/websocket/AUTHORS
index b003eca0c..1931f4006 100644
--- a/vendor/github.com/gorilla/websocket/AUTHORS
+++ b/vendor/github.com/gorilla/websocket/AUTHORS
@@ -4,5 +4,6 @@
 # Please keep the list sorted.
 
 Gary Burd <gary@beagledreams.com>
+Google LLC (https://opensource.google.com/)
 Joachim Bauch <mail@joachim-bauch.de>
 
diff --git a/vendor/github.com/gorilla/websocket/README.md b/vendor/github.com/gorilla/websocket/README.md
index 33c3d2be3..20e391f86 100644
--- a/vendor/github.com/gorilla/websocket/README.md
+++ b/vendor/github.com/gorilla/websocket/README.md
@@ -51,7 +51,7 @@ subdirectory](https://github.com/gorilla/websocket/tree/master/examples/autobahn
 <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>
 
-Notes: 
+Notes:
 
 1. Large messages are fragmented in [Chrome's new WebSocket implementation](http://www.ietf.org/mail-archive/web/hybi/current/msg10503.html).
 2. The application can get the type of a received data message by implementing
diff --git a/vendor/github.com/gorilla/websocket/client.go b/vendor/github.com/gorilla/websocket/client.go
index 43a87c753..2e32fd506 100644
--- a/vendor/github.com/gorilla/websocket/client.go
+++ b/vendor/github.com/gorilla/websocket/client.go
@@ -5,15 +5,15 @@
 package websocket
 
 import (
-	"bufio"
 	"bytes"
+	"context"
 	"crypto/tls"
-	"encoding/base64"
 	"errors"
 	"io"
 	"io/ioutil"
 	"net"
 	"net/http"
+	"net/http/httptrace"
 	"net/url"
 	"strings"
 	"time"
@@ -53,6 +53,10 @@ type Dialer struct {
 	// NetDial is nil, net.Dial is used.
 	NetDial func(network, addr string) (net.Conn, error)
 
+	// NetDialContext specifies the dial function for creating TCP connections. If
+	// NetDialContext is nil, net.DialContext is used.
+	NetDialContext func(ctx context.Context, 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.
@@ -71,6 +75,17 @@ type Dialer struct {
 	// do not limit the size of the messages that can be sent or received.
 	ReadBufferSize, WriteBufferSize int
 
+	// WriteBufferPool is a pool of buffers for write operations. If the value
+	// is not set, then write buffers are allocated to the connection for the
+	// lifetime of the connection.
+	//
+	// A pool is most useful when the application has a modest volume of writes
+	// across a large number of connections.
+	//
+	// Applications should use a single pool for each unique value of
+	// WriteBufferSize.
+	WriteBufferPool BufferPool
+
 	// Subprotocols specifies the client's requested subprotocols.
 	Subprotocols []string
 
@@ -86,52 +101,13 @@ type Dialer struct {
 	Jar http.CookieJar
 }
 
-var errMalformedURL = errors.New("malformed ws or wss URL")
-
-// 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 ]
-	var u url.URL
-	switch {
-	case strings.HasPrefix(s, "ws://"):
-		u.Scheme = "ws"
-		s = s[len("ws://"):]
-	case strings.HasPrefix(s, "wss://"):
-		u.Scheme = "wss"
-		s = s[len("wss://"):]
-	default:
-		return nil, errMalformedURL
-	}
-
-	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, "@") {
-		// Don't bother parsing user information because user information is
-		// not allowed in websocket URIs.
-		return nil, errMalformedURL
-	}
-
-	return &u, nil
+// Dial creates a new client connection by calling DialContext with a background context.
+func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Response, error) {
+	return d.DialContext(context.Background(), urlStr, requestHeader)
 }
 
+var errMalformedURL = errors.New("malformed ws or wss URL")
+
 func hostPortNoPort(u *url.URL) (hostPort, hostNoPort string) {
 	hostPort = u.Host
 	hostNoPort = u.Host
@@ -150,26 +126,29 @@ func hostPortNoPort(u *url.URL) (hostPort, hostNoPort string) {
 	return hostPort, hostNoPort
 }
 
-// DefaultDialer is a dialer with all fields set to the default zero values.
+// DefaultDialer is a dialer with all fields set to the default values.
 var DefaultDialer = &Dialer{
-	Proxy: http.ProxyFromEnvironment,
+	Proxy:            http.ProxyFromEnvironment,
+	HandshakeTimeout: 45 * time.Second,
 }
 
-// Dial creates a new client connection. Use requestHeader to specify the
+// nilDialer is dialer to use when receiver is nil.
+var nilDialer = *DefaultDialer
+
+// DialContext creates a new client connection. Use requestHeader to specify the
 // origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies (Cookie).
 // Use the response.Header to get the selected subprotocol
 // (Sec-WebSocket-Protocol) and cookies (Set-Cookie).
 //
+// The context will be used in the request and in the Dialer
+//
 // If the WebSocket handshake fails, ErrBadHandshake is returned along with a
 // non-nil *http.Response so that callers can handle redirects, authentication,
 // 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) {
-
+func (d *Dialer) DialContext(ctx context.Context, urlStr string, requestHeader http.Header) (*Conn, *http.Response, error) {
 	if d == nil {
-		d = &Dialer{
-			Proxy: http.ProxyFromEnvironment,
-		}
+		d = &nilDialer
 	}
 
 	challengeKey, err := generateChallengeKey()
@@ -177,7 +156,7 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Re
 		return nil, nil, err
 	}
 
-	u, err := parseURL(urlStr)
+	u, err := url.Parse(urlStr)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -205,6 +184,7 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Re
 		Header:     make(http.Header),
 		Host:       u.Host,
 	}
+	req = req.WithContext(ctx)
 
 	// Set the cookies present in the cookie jar of the dialer
 	if d.Jar != nil {
@@ -237,45 +217,83 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Re
 			k == "Sec-Websocket-Extensions" ||
 			(k == "Sec-Websocket-Protocol" && len(d.Subprotocols) > 0):
 			return nil, nil, errors.New("websocket: duplicate header not allowed: " + k)
+		case k == "Sec-Websocket-Protocol":
+			req.Header["Sec-WebSocket-Protocol"] = vs
 		default:
 			req.Header[k] = vs
 		}
 	}
 
 	if d.EnableCompression {
-		req.Header.Set("Sec-Websocket-Extensions", "permessage-deflate; server_no_context_takeover; client_no_context_takeover")
+		req.Header["Sec-WebSocket-Extensions"] = []string{"permessage-deflate; server_no_context_takeover; client_no_context_takeover"}
+	}
+
+	if d.HandshakeTimeout != 0 {
+		var cancel func()
+		ctx, cancel = context.WithTimeout(ctx, d.HandshakeTimeout)
+		defer cancel()
+	}
+
+	// Get network dial function.
+	var netDial func(network, add string) (net.Conn, error)
+
+	if d.NetDialContext != nil {
+		netDial = func(network, addr string) (net.Conn, error) {
+			return d.NetDialContext(ctx, network, addr)
+		}
+	} else if d.NetDial != nil {
+		netDial = d.NetDial
+	} else {
+		netDialer := &net.Dialer{}
+		netDial = func(network, addr string) (net.Conn, error) {
+			return netDialer.DialContext(ctx, network, addr)
+		}
+	}
+
+	// If needed, wrap the dial function to set the connection deadline.
+	if deadline, ok := ctx.Deadline(); ok {
+		forwardDial := netDial
+		netDial = func(network, addr string) (net.Conn, error) {
+			c, err := forwardDial(network, addr)
+			if err != nil {
+				return nil, err
+			}
+			err = c.SetDeadline(deadline)
+			if err != nil {
+				c.Close()
+				return nil, err
+			}
+			return c, nil
+		}
+	}
+
+	// If needed, wrap the dial function to connect through a proxy.
+	if d.Proxy != nil {
+		proxyURL, err := d.Proxy(req)
+		if err != nil {
+			return nil, nil, err
+		}
+		if proxyURL != nil {
+			dialer, err := proxy_FromURL(proxyURL, netDialerFunc(netDial))
+			if err != nil {
+				return nil, nil, err
+			}
+			netDial = dialer.Dial
+		}
 	}
 
 	hostPort, hostNoPort := hostPortNoPort(u)
-
-	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
+	trace := httptrace.ContextClientTrace(ctx)
+	if trace != nil && trace.GetConn != nil {
+		trace.GetConn(hostPort)
 	}
 
-	var targetHostPort string
-	if proxyURL != nil {
-		targetHostPort, _ = hostPortNoPort(proxyURL)
-	} else {
-		targetHostPort = hostPort
+	netConn, err := netDial("tcp", hostPort)
+	if trace != nil && trace.GotConn != nil {
+		trace.GotConn(httptrace.GotConnInfo{
+			Conn: netConn,
+		})
 	}
-
-	var deadline time.Time
-	if d.HandshakeTimeout != 0 {
-		deadline = time.Now().Add(d.HandshakeTimeout)
-	}
-
-	netDial := d.NetDial
-	if netDial == nil {
-		netDialer := &net.Dialer{Deadline: deadline}
-		netDial = netDialer.Dial
-	}
-
-	netConn, err := netDial("tcp", targetHostPort)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -286,42 +304,6 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Re
 		}
 	}()
 
-	if err := netConn.SetDeadline(deadline); err != nil {
-		return nil, nil, err
-	}
-
-	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 == "" {
@@ -329,22 +311,31 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Re
 		}
 		tlsConn := tls.Client(netConn, cfg)
 		netConn = tlsConn
-		if err := tlsConn.Handshake(); err != nil {
-			return nil, nil, err
+
+		var err error
+		if trace != nil {
+			err = doHandshakeWithTrace(trace, tlsConn, cfg)
+		} else {
+			err = doHandshake(tlsConn, cfg)
 		}
-		if !cfg.InsecureSkipVerify {
-			if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
-				return nil, nil, err
-			}
+
+		if err != nil {
+			return nil, nil, err
 		}
 	}
 
-	conn := newConn(netConn, false, d.ReadBufferSize, d.WriteBufferSize)
+	conn := newConn(netConn, false, d.ReadBufferSize, d.WriteBufferSize, d.WriteBufferPool, nil, nil)
 
 	if err := req.Write(netConn); err != nil {
 		return nil, nil, err
 	}
 
+	if trace != nil && trace.GotFirstResponseByte != nil {
+		if peek, err := conn.br.Peek(1); err == nil && len(peek) == 1 {
+			trace.GotFirstResponseByte()
+		}
+	}
+
 	resp, err := http.ReadResponse(conn.br, req)
 	if err != nil {
 		return nil, nil, err
@@ -390,3 +381,15 @@ func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Re
 	netConn = nil // to avoid close in defer.
 	return conn, resp, nil
 }
+
+func doHandshake(tlsConn *tls.Conn, cfg *tls.Config) error {
+	if err := tlsConn.Handshake(); err != nil {
+		return err
+	}
+	if !cfg.InsecureSkipVerify {
+		if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/gorilla/websocket/conn.go b/vendor/github.com/gorilla/websocket/conn.go
index 97e1dbacb..d2a21c148 100644
--- a/vendor/github.com/gorilla/websocket/conn.go
+++ b/vendor/github.com/gorilla/websocket/conn.go
@@ -76,7 +76,7 @@ const (
 	// is UTF-8 encoded text.
 	PingMessage = 9
 
-	// PongMessage denotes a ping control message. The optional message payload
+	// PongMessage denotes a pong control message. The optional message payload
 	// is UTF-8 encoded text.
 	PongMessage = 10
 )
@@ -100,9 +100,8 @@ 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.
+// CloseError represents a close message.
 type CloseError struct {
-
 	// Code is defined in RFC 6455, section 11.7.
 	Code int
 
@@ -224,6 +223,20 @@ func isValidReceivedCloseCode(code int) bool {
 	return validReceivedCloseCodes[code] || (code >= 3000 && code <= 4999)
 }
 
+// BufferPool represents a pool of buffers. The *sync.Pool type satisfies this
+// interface.  The type of the value stored in a pool is not specified.
+type BufferPool interface {
+	// Get gets a value from the pool or returns nil if the pool is empty.
+	Get() interface{}
+	// Put adds a value to the pool.
+	Put(interface{})
+}
+
+// writePoolData is the type added to the write buffer pool. This wrapper is
+// used to prevent applications from peeking at and depending on the values
+// added to the pool.
+type writePoolData struct{ buf []byte }
+
 // The Conn type represents a WebSocket connection.
 type Conn struct {
 	conn        net.Conn
@@ -233,6 +246,8 @@ type Conn struct {
 	// Write fields
 	mu            chan bool // used as mutex to protect write to conn
 	writeBuf      []byte    // frame is constructed in this buffer.
+	writePool     BufferPool
+	writeBufSize  int
 	writeDeadline time.Time
 	writer        io.WriteCloser // the current writer returned to the application
 	isWriting     bool           // for best-effort concurrent write detection
@@ -264,64 +279,29 @@ type Conn struct {
 	newDecompressionReader func(io.Reader) io.ReadCloser
 }
 
-func newConn(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int) *Conn {
-	return newConnBRW(conn, isServer, readBufferSize, writeBufferSize, nil)
-}
+func newConn(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int, writeBufferPool BufferPool, br *bufio.Reader, writeBuf []byte) *Conn {
 
-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
-
-	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 br == nil {
 		if readBufferSize == 0 {
 			readBufferSize = defaultReadBufferSize
-		}
-		if readBufferSize < maxControlFramePayloadSize {
+		} else if readBufferSize < maxControlFramePayloadSize {
+			// must be large enough for control frame
 			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)
+	if writeBufferSize <= 0 {
+		writeBufferSize = defaultWriteBufferSize
+	}
+	writeBufferSize += maxFrameHeaderSize
+
+	if writeBuf == nil && writeBufferPool == nil {
+		writeBuf = make([]byte, writeBufferSize)
 	}
 
+	mu := make(chan bool, 1)
+	mu <- true
 	c := &Conn{
 		isServer:               isServer,
 		br:                     br,
@@ -329,6 +309,8 @@ func newConnBRW(conn net.Conn, isServer bool, readBufferSize, writeBufferSize in
 		mu:                     mu,
 		readFinal:              true,
 		writeBuf:               writeBuf,
+		writePool:              writeBufferPool,
+		writeBufSize:           writeBufferSize,
 		enableWriteCompression: true,
 		compressionLevel:       defaultCompressionLevel,
 	}
@@ -343,7 +325,8 @@ func (c *Conn) Subprotocol() string {
 	return c.subprotocol
 }
 
-// Close closes the underlying network connection without sending or waiting for a close frame.
+// Close closes the underlying network connection without sending or waiting
+// for a close message.
 func (c *Conn) Close() error {
 	return c.conn.Close()
 }
@@ -370,7 +353,16 @@ func (c *Conn) writeFatal(err error) error {
 	return err
 }
 
-func (c *Conn) write(frameType int, deadline time.Time, bufs ...[]byte) error {
+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
+}
+
+func (c *Conn) write(frameType int, deadline time.Time, buf0, buf1 []byte) error {
 	<-c.mu
 	defer func() { c.mu <- true }()
 
@@ -382,15 +374,14 @@ func (c *Conn) write(frameType int, deadline time.Time, bufs ...[]byte) error {
 	}
 
 	c.conn.SetWriteDeadline(deadline)
-	for _, buf := range bufs {
-		if len(buf) > 0 {
-			_, err := c.conn.Write(buf)
-			if err != nil {
-				return c.writeFatal(err)
-			}
-		}
+	if len(buf1) == 0 {
+		_, err = c.conn.Write(buf0)
+	} else {
+		err = c.writeBufs(buf0, buf1)
+	}
+	if err != nil {
+		return c.writeFatal(err)
 	}
-
 	if frameType == CloseMessage {
 		c.writeFatal(ErrCloseSent)
 	}
@@ -476,7 +467,19 @@ func (c *Conn) prepWrite(messageType int) error {
 	c.writeErrMu.Lock()
 	err := c.writeErr
 	c.writeErrMu.Unlock()
-	return err
+	if err != nil {
+		return err
+	}
+
+	if c.writeBuf == nil {
+		wpd, ok := c.writePool.Get().(writePoolData)
+		if ok {
+			c.writeBuf = wpd.buf
+		} else {
+			c.writeBuf = make([]byte, c.writeBufSize)
+		}
+	}
+	return nil
 }
 
 // NextWriter returns a writer for the next message to send. The writer's Close
@@ -484,6 +487,9 @@ func (c *Conn) prepWrite(messageType int) error {
 //
 // There can be at most one open writer on a connection. NextWriter closes the
 // previous writer if the application has not already done so.
+//
+// All message types (TextMessage, BinaryMessage, CloseMessage, PingMessage and
+// PongMessage) are supported.
 func (c *Conn) NextWriter(messageType int) (io.WriteCloser, error) {
 	if err := c.prepWrite(messageType); err != nil {
 		return nil, err
@@ -599,6 +605,10 @@ func (w *messageWriter) flushFrame(final bool, extra []byte) error {
 
 	if final {
 		c.writer = nil
+		if c.writePool != nil {
+			c.writePool.Put(writePoolData{buf: c.writeBuf})
+			c.writeBuf = nil
+		}
 		return nil
 	}
 
@@ -764,7 +774,6 @@ func (c *Conn) SetWriteDeadline(t time.Time) error {
 // Read methods
 
 func (c *Conn) advanceFrame() (int, error) {
-
 	// 1. Skip remainder of previous frame.
 
 	if c.readRemaining > 0 {
@@ -1033,7 +1042,7 @@ func (c *Conn) SetReadDeadline(t time.Time) error {
 }
 
 // SetReadLimit sets the maximum size for a message read from the peer. If a
-// message exceeds the limit, the connection sends a close frame to the peer
+// message exceeds the limit, the connection sends a close message to the peer
 // and returns ErrReadLimit to the application.
 func (c *Conn) SetReadLimit(limit int64) {
 	c.readLimit = limit
@@ -1046,24 +1055,22 @@ func (c *Conn) CloseHandler() func(code int, text string) error {
 
 // 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.
+// if the close message is empty. The default close handler sends a close
+// message back to the peer.
 //
-// The application must read the connection to process close messages as
-// described in the section on Control Frames above.
+// The handler function is called from the NextReader, ReadMessage and message
+// reader Read methods. The application must read the connection to process
+// close messages as described in the section on Control Messages above.
 //
-// The connection read methods return a CloseError when a close frame is
+// The connection read methods return a CloseError when a close message 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
+// application must perform some action before sending a close message 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, "")
-			}
+			message := FormatCloseMessage(code, "")
 			c.WriteControl(CloseMessage, message, time.Now().Add(writeWait))
 			return nil
 		}
@@ -1077,11 +1084,12 @@ func (c *Conn) PingHandler() func(appData string) error {
 }
 
 // SetPingHandler sets the handler for ping messages received from the peer.
-// The appData argument to h is the PING frame application data. The default
+// The appData argument to h is the PING message 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.
+// The handler function is called from the NextReader, ReadMessage and message
+// reader Read methods. The application must read the connection to process
+// ping messages as described in the section on Control Messages above.
 func (c *Conn) SetPingHandler(h func(appData string) error) {
 	if h == nil {
 		h = func(message string) error {
@@ -1103,11 +1111,12 @@ func (c *Conn) PongHandler() func(appData string) error {
 }
 
 // SetPongHandler sets the handler for pong messages received from the peer.
-// The appData argument to h is the PONG frame application data. The default
+// The appData argument to h is the PONG message 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.
+// The handler function is called from the NextReader, ReadMessage and message
+// reader Read methods. The application must read the connection to process
+// pong messages as described in the section on Control Messages above.
 func (c *Conn) SetPongHandler(h func(appData string) error) {
 	if h == nil {
 		h = func(string) error { return nil }
@@ -1141,7 +1150,14 @@ func (c *Conn) SetCompressionLevel(level int) error {
 }
 
 // FormatCloseMessage formats closeCode and text as a WebSocket close message.
+// An empty message is returned for code CloseNoStatusReceived.
 func FormatCloseMessage(closeCode int, text string) []byte {
+	if closeCode == CloseNoStatusReceived {
+		// Return empty message because it's illegal to send
+		// CloseNoStatusReceived. Return non-nil value in case application
+		// checks for nil.
+		return []byte{}
+	}
 	buf := make([]byte, 2+len(text))
 	binary.BigEndian.PutUint16(buf, uint16(closeCode))
 	copy(buf[2:], text)
diff --git a/vendor/github.com/gorilla/websocket/conn_read_legacy.go b/vendor/github.com/gorilla/websocket/conn_read_legacy.go
deleted file mode 100644
index 018541cf6..000000000
--- a/vendor/github.com/gorilla/websocket/conn_read_legacy.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// 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/conn_read.go b/vendor/github.com/gorilla/websocket/conn_write.go
similarity index 52%
rename from vendor/github.com/gorilla/websocket/conn_read.go
rename to vendor/github.com/gorilla/websocket/conn_write.go
index 1ea15059e..a509a21f8 100644
--- a/vendor/github.com/gorilla/websocket/conn_read.go
+++ b/vendor/github.com/gorilla/websocket/conn_write.go
@@ -2,17 +2,14 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build go1.5
+// +build go1.8
 
 package websocket
 
-import "io"
+import "net"
 
-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
+func (c *Conn) writeBufs(bufs ...[]byte) error {
+	b := net.Buffers(bufs)
+	_, err := b.WriteTo(c.conn)
+	return err
 }
diff --git a/vendor/github.com/gorilla/websocket/conn_write_legacy.go b/vendor/github.com/gorilla/websocket/conn_write_legacy.go
new file mode 100644
index 000000000..37edaff5a
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/conn_write_legacy.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.8
+
+package websocket
+
+func (c *Conn) writeBufs(bufs ...[]byte) error {
+	for _, buf := range bufs {
+		if len(buf) > 0 {
+			if _, err := c.conn.Write(buf); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/gorilla/websocket/doc.go b/vendor/github.com/gorilla/websocket/doc.go
index e291a952c..dcce1a63c 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,
@@ -31,10 +30,12 @@
 //  for {
 //      messageType, p, err := conn.ReadMessage()
 //      if err != nil {
+//          log.Println(err)
 //          return
 //      }
-//      if err = conn.WriteMessage(messageType, p); err != nil {
-//          return err
+//      if err := conn.WriteMessage(messageType, p); err != nil {
+//          log.Println(err)
+//          return
 //      }
 //  }
 //
@@ -85,20 +86,26 @@
 // and pong. Call the connection WriteControl, WriteMessage or NextWriter
 // methods to send a control message to the peer.
 //
-// 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 calling the handler function
+// set with the SetCloseHandler method and by returning a *CloseError from the
+// NextReader, ReadMessage or the message Read method. The default close
+// handler sends a close message to the peer.
 //
-// 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.
+// Connections handle received ping messages by calling the handler function
+// set with the SetPingHandler method. The default ping handler sends a pong
+// message to the peer.
 //
-// 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.
+// Connections handle received pong messages by calling the handler function
+// set with the SetPongHandler method. The default pong handler does nothing.
+// If an application sends ping messages, then the application should set a
+// pong handler to receive the corresponding pong.
 //
-// The application must read the connection to process ping, pong and close
+// The control message handler functions are called from the NextReader,
+// ReadMessage and message reader Read methods. The default close and ping
+// handlers can block these methods for a short time when the handler writes to
+// the connection.
+//
+// The application must read the connection to process close, ping and pong
 // 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:
@@ -137,19 +144,12 @@
 // method fails the WebSocket handshake with HTTP status 403.
 //
 // If the CheckOrigin field is nil, then the Upgrader uses a safe default: fail
-// the handshake if the Origin request header is present and not equal to the
-// Host request header.
+// the handshake if the Origin request header is present and the Origin host is
+// not equal to the Host request header.
 //
-// An application can allow connections from any origin by specifying a
-// function that always returns true:
-//
-//  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
 //
diff --git a/vendor/github.com/gorilla/websocket/json.go b/vendor/github.com/gorilla/websocket/json.go
index 4f0e36875..dc2c1f641 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)
 }
diff --git a/vendor/github.com/gorilla/websocket/mask.go b/vendor/github.com/gorilla/websocket/mask.go
index 6a88bbc74..577fce9ef 100644
--- a/vendor/github.com/gorilla/websocket/mask.go
+++ b/vendor/github.com/gorilla/websocket/mask.go
@@ -11,7 +11,6 @@ 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 {
diff --git a/vendor/github.com/gorilla/websocket/prepared.go b/vendor/github.com/gorilla/websocket/prepared.go
index 1efffbd1e..74ec565d2 100644
--- a/vendor/github.com/gorilla/websocket/prepared.go
+++ b/vendor/github.com/gorilla/websocket/prepared.go
@@ -19,7 +19,6 @@ import (
 type PreparedMessage struct {
 	messageType int
 	data        []byte
-	err         error
 	mu          sync.Mutex
 	frames      map[prepareKey]*preparedFrame
 }
diff --git a/vendor/github.com/gorilla/websocket/proxy.go b/vendor/github.com/gorilla/websocket/proxy.go
new file mode 100644
index 000000000..bf2478e43
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/proxy.go
@@ -0,0 +1,77 @@
+// 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 (
+	"bufio"
+	"encoding/base64"
+	"errors"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+type netDialerFunc func(network, addr string) (net.Conn, error)
+
+func (fn netDialerFunc) Dial(network, addr string) (net.Conn, error) {
+	return fn(network, addr)
+}
+
+func init() {
+	proxy_RegisterDialerType("http", func(proxyURL *url.URL, forwardDialer proxy_Dialer) (proxy_Dialer, error) {
+		return &httpProxyDialer{proxyURL: proxyURL, fowardDial: forwardDialer.Dial}, nil
+	})
+}
+
+type httpProxyDialer struct {
+	proxyURL   *url.URL
+	fowardDial func(network, addr string) (net.Conn, error)
+}
+
+func (hpd *httpProxyDialer) Dial(network string, addr string) (net.Conn, error) {
+	hostPort, _ := hostPortNoPort(hpd.proxyURL)
+	conn, err := hpd.fowardDial(network, hostPort)
+	if err != nil {
+		return nil, err
+	}
+
+	connectHeader := make(http.Header)
+	if user := hpd.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: addr},
+		Host:   addr,
+		Header: connectHeader,
+	}
+
+	if err := connectReq.Write(conn); err != nil {
+		conn.Close()
+		return nil, err
+	}
+
+	// Read response. It's OK to use and discard buffered reader here becaue
+	// the remote server does not speak until spoken to.
+	br := bufio.NewReader(conn)
+	resp, err := http.ReadResponse(br, connectReq)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+
+	if resp.StatusCode != 200 {
+		conn.Close()
+		f := strings.SplitN(resp.Status, " ", 2)
+		return nil, errors.New(f[1])
+	}
+	return conn, nil
+}
diff --git a/vendor/github.com/gorilla/websocket/server.go b/vendor/github.com/gorilla/websocket/server.go
index 3495e0f1a..a761824b3 100644
--- a/vendor/github.com/gorilla/websocket/server.go
+++ b/vendor/github.com/gorilla/websocket/server.go
@@ -7,7 +7,7 @@ package websocket
 import (
 	"bufio"
 	"errors"
-	"net"
+	"io"
 	"net/http"
 	"net/url"
 	"strings"
@@ -33,10 +33,23 @@ type Upgrader struct {
 	// or received.
 	ReadBufferSize, WriteBufferSize int
 
+	// WriteBufferPool is a pool of buffers for write operations. If the value
+	// is not set, then write buffers are allocated to the connection for the
+	// lifetime of the connection.
+	//
+	// A pool is most useful when the application has a modest volume of writes
+	// across a large number of connections.
+	//
+	// Applications should use a single pool for each unique value of
+	// WriteBufferSize.
+	WriteBufferPool BufferPool
+
 	// Subprotocols specifies the server's supported protocols in order of
-	// preference. If this field is set, then the Upgrade method negotiates a
+	// preference. If this field is not nil, then the Upgrade method negotiates a
 	// subprotocol by selecting the first match in this list with a protocol
-	// requested by the client.
+	// requested by the client. If there's no match, then no protocol is
+	// negotiated (the Sec-Websocket-Protocol header is not included in the
+	// handshake response).
 	Subprotocols []string
 
 	// Error specifies the function for generating HTTP error responses. If Error
@@ -44,8 +57,12 @@ type Upgrader struct {
 	Error func(w http.ResponseWriter, r *http.Request, status int, reason error)
 
 	// CheckOrigin returns true if the request Origin header is acceptable. If
-	// CheckOrigin is nil, the host in the Origin header must not be set or
-	// must match the host of the request.
+	// CheckOrigin is nil, then a safe default is used: return false if the
+	// Origin request header is present and the origin host is not equal to
+	// request Host header.
+	//
+	// A CheckOrigin function should carefully validate the request origin to
+	// prevent cross-site request forgery.
 	CheckOrigin func(r *http.Request) bool
 
 	// EnableCompression specify if the server should attempt to negotiate per
@@ -76,7 +93,7 @@ func checkSameOrigin(r *http.Request) bool {
 	if err != nil {
 		return false
 	}
-	return u.Host == r.Host
+	return equalASCIIFold(u.Host, r.Host)
 }
 
 func (u *Upgrader) selectSubprotocol(r *http.Request, responseHeader http.Header) string {
@@ -99,42 +116,44 @@ 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).
+// 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 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")
-	}
+	const badHandshake = "websocket: the client is not using the websocket protocol: "
 
 	if !tokenListContainsValue(r.Header, "Connection", "upgrade") {
-		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'upgrade' token not found in 'Connection' header")
+		return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'upgrade' token not found in 'Connection' header")
 	}
 
 	if !tokenListContainsValue(r.Header, "Upgrade", "websocket") {
-		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'websocket' token not found in 'Upgrade' header")
+		return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'websocket' token not found in 'Upgrade' header")
+	}
+
+	if r.Method != "GET" {
+		return u.returnError(w, r, http.StatusMethodNotAllowed, badHandshake+"request method is not GET")
 	}
 
 	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")
 	}
 
+	if _, ok := responseHeader["Sec-Websocket-Extensions"]; ok {
+		return u.returnError(w, r, http.StatusInternalServerError, "websocket: application specific 'Sec-WebSocket-Extensions' headers are unsupported")
+	}
+
 	checkOrigin := u.CheckOrigin
 	if checkOrigin == nil {
 		checkOrigin = checkSameOrigin
 	}
 	if !checkOrigin(r) {
-		return u.returnError(w, r, http.StatusForbidden, "websocket: 'Origin' header value not allowed")
+		return u.returnError(w, r, http.StatusForbidden, "websocket: request origin not allowed by Upgrader.CheckOrigin")
 	}
 
 	challengeKey := r.Header.Get("Sec-Websocket-Key")
 	if challengeKey == "" {
-		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: `Sec-Websocket-Key' header is 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)
@@ -151,17 +170,12 @@ func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeade
 		}
 	}
 
-	var (
-		netConn net.Conn
-		err     error
-	)
-
 	h, ok := w.(http.Hijacker)
 	if !ok {
 		return u.returnError(w, r, http.StatusInternalServerError, "websocket: response does not implement http.Hijacker")
 	}
 	var brw *bufio.ReadWriter
-	netConn, brw, err = h.Hijack()
+	netConn, brw, err := h.Hijack()
 	if err != nil {
 		return u.returnError(w, r, http.StatusInternalServerError, err.Error())
 	}
@@ -171,7 +185,21 @@ func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeade
 		return nil, errors.New("websocket: client sent data before handshake is complete")
 	}
 
-	c := newConnBRW(netConn, true, u.ReadBufferSize, u.WriteBufferSize, brw)
+	var br *bufio.Reader
+	if u.ReadBufferSize == 0 && bufioReaderSize(netConn, brw.Reader) > 256 {
+		// Reuse hijacked buffered reader as connection reader.
+		br = brw.Reader
+	}
+
+	buf := bufioWriterBuffer(netConn, brw.Writer)
+
+	var writeBuf []byte
+	if u.WriteBufferPool == nil && u.WriteBufferSize == 0 && len(buf) >= maxFrameHeaderSize+256 {
+		// Reuse hijacked write buffer as connection buffer.
+		writeBuf = buf
+	}
+
+	c := newConn(netConn, true, u.ReadBufferSize, u.WriteBufferSize, u.WriteBufferPool, br, writeBuf)
 	c.subprotocol = subprotocol
 
 	if compress {
@@ -179,17 +207,23 @@ func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeade
 		c.newDecompressionReader = decompressNoContextTakeover
 	}
 
-	p := c.writeBuf[:0]
+	// Use larger of hijacked buffer and connection write buffer for header.
+	p := buf
+	if len(c.writeBuf) > len(p) {
+		p = c.writeBuf
+	}
+	p = p[: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)...)
 	p = append(p, "\r\n"...)
 	if c.subprotocol != "" {
-		p = append(p, "Sec-Websocket-Protocol: "...)
+		p = append(p, "Sec-WebSocket-Protocol: "...)
 		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"...)
+		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" {
@@ -230,13 +264,14 @@ 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)
+//		http.Error(w, "Origin not allowed", http.StatusForbidden)
 //		return
 //	}
 //
@@ -289,3 +324,40 @@ func IsWebSocketUpgrade(r *http.Request) bool {
 	return tokenListContainsValue(r.Header, "Connection", "upgrade") &&
 		tokenListContainsValue(r.Header, "Upgrade", "websocket")
 }
+
+// bufioReaderSize size returns the size of a bufio.Reader.
+func bufioReaderSize(originalReader io.Reader, br *bufio.Reader) int {
+	// This code assumes that peek on a reset reader returns
+	// bufio.Reader.buf[:0].
+	// TODO: Use bufio.Reader.Size() after Go 1.10
+	br.Reset(originalReader)
+	if p, err := br.Peek(0); err == nil {
+		return cap(p)
+	}
+	return 0
+}
+
+// writeHook is an io.Writer that records the last slice passed to it vio
+// io.Writer.Write.
+type writeHook struct {
+	p []byte
+}
+
+func (wh *writeHook) Write(p []byte) (int, error) {
+	wh.p = p
+	return len(p), nil
+}
+
+// bufioWriterBuffer grabs the buffer from a bufio.Writer.
+func bufioWriterBuffer(originalWriter io.Writer, bw *bufio.Writer) []byte {
+	// This code assumes that bufio.Writer.buf[:1] is passed to the
+	// bufio.Writer's underlying writer.
+	var wh writeHook
+	bw.Reset(&wh)
+	bw.WriteByte(0)
+	bw.Flush()
+
+	bw.Reset(originalWriter)
+
+	return wh.p[:cap(wh.p)]
+}
diff --git a/vendor/github.com/gorilla/websocket/trace.go b/vendor/github.com/gorilla/websocket/trace.go
new file mode 100644
index 000000000..834f122a0
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/trace.go
@@ -0,0 +1,19 @@
+// +build go1.8
+
+package websocket
+
+import (
+	"crypto/tls"
+	"net/http/httptrace"
+)
+
+func doHandshakeWithTrace(trace *httptrace.ClientTrace, tlsConn *tls.Conn, cfg *tls.Config) error {
+	if trace.TLSHandshakeStart != nil {
+		trace.TLSHandshakeStart()
+	}
+	err := doHandshake(tlsConn, cfg)
+	if trace.TLSHandshakeDone != nil {
+		trace.TLSHandshakeDone(tlsConn.ConnectionState(), err)
+	}
+	return err
+}
diff --git a/vendor/github.com/gorilla/websocket/trace_17.go b/vendor/github.com/gorilla/websocket/trace_17.go
new file mode 100644
index 000000000..77d05a0b5
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/trace_17.go
@@ -0,0 +1,12 @@
+// +build !go1.8
+
+package websocket
+
+import (
+	"crypto/tls"
+	"net/http/httptrace"
+)
+
+func doHandshakeWithTrace(trace *httptrace.ClientTrace, tlsConn *tls.Conn, cfg *tls.Config) error {
+	return doHandshake(tlsConn, cfg)
+}
diff --git a/vendor/github.com/gorilla/websocket/util.go b/vendor/github.com/gorilla/websocket/util.go
index 9a4908df2..354001e1e 100644
--- a/vendor/github.com/gorilla/websocket/util.go
+++ b/vendor/github.com/gorilla/websocket/util.go
@@ -11,6 +11,7 @@ import (
 	"io"
 	"net/http"
 	"strings"
+	"unicode/utf8"
 )
 
 var keyGUID = []byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
@@ -111,14 +112,14 @@ func nextTokenOrQuoted(s string) (value string, rest string) {
 				case escape:
 					escape = false
 					p[j] = b
-					j += 1
+					j++
 				case b == '\\':
 					escape = true
 				case b == '"':
 					return string(p[:j]), s[i+1:]
 				default:
 					p[j] = b
-					j += 1
+					j++
 				}
 			}
 			return "", ""
@@ -127,8 +128,31 @@ func nextTokenOrQuoted(s string) (value string, rest string) {
 	return "", ""
 }
 
+// equalASCIIFold returns true if s is equal to t with ASCII case folding.
+func equalASCIIFold(s, t string) bool {
+	for s != "" && t != "" {
+		sr, size := utf8.DecodeRuneInString(s)
+		s = s[size:]
+		tr, size := utf8.DecodeRuneInString(t)
+		t = t[size:]
+		if sr == tr {
+			continue
+		}
+		if 'A' <= sr && sr <= 'Z' {
+			sr = sr + 'a' - 'A'
+		}
+		if 'A' <= tr && tr <= 'Z' {
+			tr = tr + 'a' - 'A'
+		}
+		if sr != tr {
+			return false
+		}
+	}
+	return s == t
+}
+
 // tokenListContainsValue returns true if the 1#token header with the given
-// name contains token.
+// name contains a token equal to value with ASCII case folding.
 func tokenListContainsValue(header http.Header, name string, value string) bool {
 headers:
 	for _, s := range header[name] {
@@ -142,7 +166,7 @@ headers:
 			if s != "" && s[0] != ',' {
 				continue headers
 			}
-			if strings.EqualFold(t, value) {
+			if equalASCIIFold(t, value) {
 				return true
 			}
 			if s == "" {
@@ -154,9 +178,8 @@ headers:
 	return false
 }
 
-// parseExtensiosn parses WebSocket extensions from a header.
+// parseExtensions parses WebSocket extensions from a header.
 func parseExtensions(header http.Header) []map[string]string {
-
 	// From RFC 6455:
 	//
 	//  Sec-WebSocket-Extensions = extension-list
diff --git a/vendor/github.com/gorilla/websocket/x_net_proxy.go b/vendor/github.com/gorilla/websocket/x_net_proxy.go
new file mode 100644
index 000000000..2e668f6b8
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/x_net_proxy.go
@@ -0,0 +1,473 @@
+// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.
+//go:generate bundle -o x_net_proxy.go golang.org/x/net/proxy
+
+// Package proxy provides support for a variety of protocols to proxy network
+// data.
+//
+
+package websocket
+
+import (
+	"errors"
+	"io"
+	"net"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+type proxy_direct struct{}
+
+// Direct is a direct proxy: one that makes network connections directly.
+var proxy_Direct = proxy_direct{}
+
+func (proxy_direct) Dial(network, addr string) (net.Conn, error) {
+	return net.Dial(network, addr)
+}
+
+// A PerHost directs connections to a default Dialer unless the host name
+// requested matches one of a number of exceptions.
+type proxy_PerHost struct {
+	def, bypass proxy_Dialer
+
+	bypassNetworks []*net.IPNet
+	bypassIPs      []net.IP
+	bypassZones    []string
+	bypassHosts    []string
+}
+
+// NewPerHost returns a PerHost Dialer that directs connections to either
+// defaultDialer or bypass, depending on whether the connection matches one of
+// the configured rules.
+func proxy_NewPerHost(defaultDialer, bypass proxy_Dialer) *proxy_PerHost {
+	return &proxy_PerHost{
+		def:    defaultDialer,
+		bypass: bypass,
+	}
+}
+
+// Dial connects to the address addr on the given network through either
+// defaultDialer or bypass.
+func (p *proxy_PerHost) Dial(network, addr string) (c net.Conn, err error) {
+	host, _, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	return p.dialerForRequest(host).Dial(network, addr)
+}
+
+func (p *proxy_PerHost) dialerForRequest(host string) proxy_Dialer {
+	if ip := net.ParseIP(host); ip != nil {
+		for _, net := range p.bypassNetworks {
+			if net.Contains(ip) {
+				return p.bypass
+			}
+		}
+		for _, bypassIP := range p.bypassIPs {
+			if bypassIP.Equal(ip) {
+				return p.bypass
+			}
+		}
+		return p.def
+	}
+
+	for _, zone := range p.bypassZones {
+		if strings.HasSuffix(host, zone) {
+			return p.bypass
+		}
+		if host == zone[1:] {
+			// For a zone ".example.com", we match "example.com"
+			// too.
+			return p.bypass
+		}
+	}
+	for _, bypassHost := range p.bypassHosts {
+		if bypassHost == host {
+			return p.bypass
+		}
+	}
+	return p.def
+}
+
+// AddFromString parses a string that contains comma-separated values
+// specifying hosts that should use the bypass proxy. Each value is either an
+// IP address, a CIDR range, a zone (*.example.com) or a host name
+// (localhost). A best effort is made to parse the string and errors are
+// ignored.
+func (p *proxy_PerHost) AddFromString(s string) {
+	hosts := strings.Split(s, ",")
+	for _, host := range hosts {
+		host = strings.TrimSpace(host)
+		if len(host) == 0 {
+			continue
+		}
+		if strings.Contains(host, "/") {
+			// We assume that it's a CIDR address like 127.0.0.0/8
+			if _, net, err := net.ParseCIDR(host); err == nil {
+				p.AddNetwork(net)
+			}
+			continue
+		}
+		if ip := net.ParseIP(host); ip != nil {
+			p.AddIP(ip)
+			continue
+		}
+		if strings.HasPrefix(host, "*.") {
+			p.AddZone(host[1:])
+			continue
+		}
+		p.AddHost(host)
+	}
+}
+
+// AddIP specifies an IP address that will use the bypass proxy. Note that
+// this will only take effect if a literal IP address is dialed. A connection
+// to a named host will never match an IP.
+func (p *proxy_PerHost) AddIP(ip net.IP) {
+	p.bypassIPs = append(p.bypassIPs, ip)
+}
+
+// AddNetwork specifies an IP range that will use the bypass proxy. Note that
+// this will only take effect if a literal IP address is dialed. A connection
+// to a named host will never match.
+func (p *proxy_PerHost) AddNetwork(net *net.IPNet) {
+	p.bypassNetworks = append(p.bypassNetworks, net)
+}
+
+// AddZone specifies a DNS suffix that will use the bypass proxy. A zone of
+// "example.com" matches "example.com" and all of its subdomains.
+func (p *proxy_PerHost) AddZone(zone string) {
+	if strings.HasSuffix(zone, ".") {
+		zone = zone[:len(zone)-1]
+	}
+	if !strings.HasPrefix(zone, ".") {
+		zone = "." + zone
+	}
+	p.bypassZones = append(p.bypassZones, zone)
+}
+
+// AddHost specifies a host name that will use the bypass proxy.
+func (p *proxy_PerHost) AddHost(host string) {
+	if strings.HasSuffix(host, ".") {
+		host = host[:len(host)-1]
+	}
+	p.bypassHosts = append(p.bypassHosts, host)
+}
+
+// A Dialer is a means to establish a connection.
+type proxy_Dialer interface {
+	// Dial connects to the given address via the proxy.
+	Dial(network, addr string) (c net.Conn, err error)
+}
+
+// Auth contains authentication parameters that specific Dialers may require.
+type proxy_Auth struct {
+	User, Password string
+}
+
+// FromEnvironment returns the dialer specified by the proxy related variables in
+// the environment.
+func proxy_FromEnvironment() proxy_Dialer {
+	allProxy := proxy_allProxyEnv.Get()
+	if len(allProxy) == 0 {
+		return proxy_Direct
+	}
+
+	proxyURL, err := url.Parse(allProxy)
+	if err != nil {
+		return proxy_Direct
+	}
+	proxy, err := proxy_FromURL(proxyURL, proxy_Direct)
+	if err != nil {
+		return proxy_Direct
+	}
+
+	noProxy := proxy_noProxyEnv.Get()
+	if len(noProxy) == 0 {
+		return proxy
+	}
+
+	perHost := proxy_NewPerHost(proxy, proxy_Direct)
+	perHost.AddFromString(noProxy)
+	return perHost
+}
+
+// proxySchemes is a map from URL schemes to a function that creates a Dialer
+// from a URL with such a scheme.
+var proxy_proxySchemes map[string]func(*url.URL, proxy_Dialer) (proxy_Dialer, error)
+
+// RegisterDialerType takes a URL scheme and a function to generate Dialers from
+// a URL with that scheme and a forwarding Dialer. Registered schemes are used
+// by FromURL.
+func proxy_RegisterDialerType(scheme string, f func(*url.URL, proxy_Dialer) (proxy_Dialer, error)) {
+	if proxy_proxySchemes == nil {
+		proxy_proxySchemes = make(map[string]func(*url.URL, proxy_Dialer) (proxy_Dialer, error))
+	}
+	proxy_proxySchemes[scheme] = f
+}
+
+// FromURL returns a Dialer given a URL specification and an underlying
+// Dialer for it to make network requests.
+func proxy_FromURL(u *url.URL, forward proxy_Dialer) (proxy_Dialer, error) {
+	var auth *proxy_Auth
+	if u.User != nil {
+		auth = new(proxy_Auth)
+		auth.User = u.User.Username()
+		if p, ok := u.User.Password(); ok {
+			auth.Password = p
+		}
+	}
+
+	switch u.Scheme {
+	case "socks5":
+		return proxy_SOCKS5("tcp", u.Host, auth, forward)
+	}
+
+	// If the scheme doesn't match any of the built-in schemes, see if it
+	// was registered by another package.
+	if proxy_proxySchemes != nil {
+		if f, ok := proxy_proxySchemes[u.Scheme]; ok {
+			return f(u, forward)
+		}
+	}
+
+	return nil, errors.New("proxy: unknown scheme: " + u.Scheme)
+}
+
+var (
+	proxy_allProxyEnv = &proxy_envOnce{
+		names: []string{"ALL_PROXY", "all_proxy"},
+	}
+	proxy_noProxyEnv = &proxy_envOnce{
+		names: []string{"NO_PROXY", "no_proxy"},
+	}
+)
+
+// envOnce looks up an environment variable (optionally by multiple
+// names) once. It mitigates expensive lookups on some platforms
+// (e.g. Windows).
+// (Borrowed from net/http/transport.go)
+type proxy_envOnce struct {
+	names []string
+	once  sync.Once
+	val   string
+}
+
+func (e *proxy_envOnce) Get() string {
+	e.once.Do(e.init)
+	return e.val
+}
+
+func (e *proxy_envOnce) init() {
+	for _, n := range e.names {
+		e.val = os.Getenv(n)
+		if e.val != "" {
+			return
+		}
+	}
+}
+
+// SOCKS5 returns a Dialer that makes SOCKSv5 connections to the given address
+// with an optional username and password. See RFC 1928 and RFC 1929.
+func proxy_SOCKS5(network, addr string, auth *proxy_Auth, forward proxy_Dialer) (proxy_Dialer, error) {
+	s := &proxy_socks5{
+		network: network,
+		addr:    addr,
+		forward: forward,
+	}
+	if auth != nil {
+		s.user = auth.User
+		s.password = auth.Password
+	}
+
+	return s, nil
+}
+
+type proxy_socks5 struct {
+	user, password string
+	network, addr  string
+	forward        proxy_Dialer
+}
+
+const proxy_socks5Version = 5
+
+const (
+	proxy_socks5AuthNone     = 0
+	proxy_socks5AuthPassword = 2
+)
+
+const proxy_socks5Connect = 1
+
+const (
+	proxy_socks5IP4    = 1
+	proxy_socks5Domain = 3
+	proxy_socks5IP6    = 4
+)
+
+var proxy_socks5Errors = []string{
+	"",
+	"general failure",
+	"connection forbidden",
+	"network unreachable",
+	"host unreachable",
+	"connection refused",
+	"TTL expired",
+	"command not supported",
+	"address type not supported",
+}
+
+// Dial connects to the address addr on the given network via the SOCKS5 proxy.
+func (s *proxy_socks5) Dial(network, addr string) (net.Conn, error) {
+	switch network {
+	case "tcp", "tcp6", "tcp4":
+	default:
+		return nil, errors.New("proxy: no support for SOCKS5 proxy connections of type " + network)
+	}
+
+	conn, err := s.forward.Dial(s.network, s.addr)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.connect(conn, addr); err != nil {
+		conn.Close()
+		return nil, err
+	}
+	return conn, nil
+}
+
+// connect takes an existing connection to a socks5 proxy server,
+// and commands the server to extend that connection to target,
+// which must be a canonical address with a host and port.
+func (s *proxy_socks5) connect(conn net.Conn, target string) error {
+	host, portStr, err := net.SplitHostPort(target)
+	if err != nil {
+		return err
+	}
+
+	port, err := strconv.Atoi(portStr)
+	if err != nil {
+		return errors.New("proxy: failed to parse port number: " + portStr)
+	}
+	if port < 1 || port > 0xffff {
+		return errors.New("proxy: port number out of range: " + portStr)
+	}
+
+	// the size here is just an estimate
+	buf := make([]byte, 0, 6+len(host))
+
+	buf = append(buf, proxy_socks5Version)
+	if len(s.user) > 0 && len(s.user) < 256 && len(s.password) < 256 {
+		buf = append(buf, 2 /* num auth methods */, proxy_socks5AuthNone, proxy_socks5AuthPassword)
+	} else {
+		buf = append(buf, 1 /* num auth methods */, proxy_socks5AuthNone)
+	}
+
+	if _, err := conn.Write(buf); err != nil {
+		return errors.New("proxy: failed to write greeting to SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	if _, err := io.ReadFull(conn, buf[:2]); err != nil {
+		return errors.New("proxy: failed to read greeting from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+	if buf[0] != 5 {
+		return errors.New("proxy: SOCKS5 proxy at " + s.addr + " has unexpected version " + strconv.Itoa(int(buf[0])))
+	}
+	if buf[1] == 0xff {
+		return errors.New("proxy: SOCKS5 proxy at " + s.addr + " requires authentication")
+	}
+
+	// See RFC 1929
+	if buf[1] == proxy_socks5AuthPassword {
+		buf = buf[:0]
+		buf = append(buf, 1 /* password protocol version */)
+		buf = append(buf, uint8(len(s.user)))
+		buf = append(buf, s.user...)
+		buf = append(buf, uint8(len(s.password)))
+		buf = append(buf, s.password...)
+
+		if _, err := conn.Write(buf); err != nil {
+			return errors.New("proxy: failed to write authentication request to SOCKS5 proxy at " + s.addr + ": " + err.Error())
+		}
+
+		if _, err := io.ReadFull(conn, buf[:2]); err != nil {
+			return errors.New("proxy: failed to read authentication reply from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+		}
+
+		if buf[1] != 0 {
+			return errors.New("proxy: SOCKS5 proxy at " + s.addr + " rejected username/password")
+		}
+	}
+
+	buf = buf[:0]
+	buf = append(buf, proxy_socks5Version, proxy_socks5Connect, 0 /* reserved */)
+
+	if ip := net.ParseIP(host); ip != nil {
+		if ip4 := ip.To4(); ip4 != nil {
+			buf = append(buf, proxy_socks5IP4)
+			ip = ip4
+		} else {
+			buf = append(buf, proxy_socks5IP6)
+		}
+		buf = append(buf, ip...)
+	} else {
+		if len(host) > 255 {
+			return errors.New("proxy: destination host name too long: " + host)
+		}
+		buf = append(buf, proxy_socks5Domain)
+		buf = append(buf, byte(len(host)))
+		buf = append(buf, host...)
+	}
+	buf = append(buf, byte(port>>8), byte(port))
+
+	if _, err := conn.Write(buf); err != nil {
+		return errors.New("proxy: failed to write connect request to SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	if _, err := io.ReadFull(conn, buf[:4]); err != nil {
+		return errors.New("proxy: failed to read connect reply from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	failure := "unknown error"
+	if int(buf[1]) < len(proxy_socks5Errors) {
+		failure = proxy_socks5Errors[buf[1]]
+	}
+
+	if len(failure) > 0 {
+		return errors.New("proxy: SOCKS5 proxy at " + s.addr + " failed to connect: " + failure)
+	}
+
+	bytesToDiscard := 0
+	switch buf[3] {
+	case proxy_socks5IP4:
+		bytesToDiscard = net.IPv4len
+	case proxy_socks5IP6:
+		bytesToDiscard = net.IPv6len
+	case proxy_socks5Domain:
+		_, err := io.ReadFull(conn, buf[:1])
+		if err != nil {
+			return errors.New("proxy: failed to read domain length from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+		}
+		bytesToDiscard = int(buf[0])
+	default:
+		return errors.New("proxy: got unknown address type " + strconv.Itoa(int(buf[3])) + " from SOCKS5 proxy at " + s.addr)
+	}
+
+	if cap(buf) < bytesToDiscard {
+		buf = make([]byte, bytesToDiscard)
+	} else {
+		buf = buf[:bytesToDiscard]
+	}
+	if _, err := io.ReadFull(conn, buf); err != nil {
+		return errors.New("proxy: failed to read address from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	// Also need to discard the port number
+	if _, err := io.ReadFull(conn, buf[:2]); err != nil {
+		return errors.New("proxy: failed to read port from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/hashicorp/go-checkpoint/checkpoint.go b/vendor/github.com/hashicorp/go-checkpoint/check.go
similarity index 70%
rename from vendor/github.com/hashicorp/go-checkpoint/checkpoint.go
rename to vendor/github.com/hashicorp/go-checkpoint/check.go
index 36e572999..109d0d352 100644
--- a/vendor/github.com/hashicorp/go-checkpoint/checkpoint.go
+++ b/vendor/github.com/hashicorp/go-checkpoint/check.go
@@ -1,11 +1,7 @@
-// checkpoint is a package for checking version information and alerts
-// for a HashiCorp product.
 package checkpoint
 
 import (
-	"bytes"
-	"context"
-	"crypto/rand"
+	crand "crypto/rand"
 	"encoding/binary"
 	"encoding/json"
 	"fmt"
@@ -23,112 +19,9 @@ import (
 	"time"
 
 	"github.com/hashicorp/go-cleanhttp"
-	uuid "github.com/hashicorp/go-uuid"
 )
 
-var magicBytes [4]byte = [4]byte{0x35, 0x77, 0x69, 0xFB}
-
-// ReportParams are the parameters for configuring a telemetry report.
-type ReportParams struct {
-	// Signature is some random signature that should be stored and used
-	// as a cookie-like value. This ensures that alerts aren't repeated.
-	// If the signature is changed, repeat alerts may be sent down. The
-	// signature should NOT be anything identifiable to a user (such as
-	// a MAC address). It should be random.
-	//
-	// If SignatureFile is given, then the signature will be read from this
-	// file. If the file doesn't exist, then a random signature will
-	// automatically be generated and stored here. SignatureFile will be
-	// ignored if Signature is given.
-	Signature     string `json:"signature"`
-	SignatureFile string `json:"-"`
-
-	StartTime     time.Time   `json:"start_time"`
-	EndTime       time.Time   `json:"end_time"`
-	Arch          string      `json:"arch"`
-	OS            string      `json:"os"`
-	Payload       interface{} `json:"payload,omitempty"`
-	Product       string      `json:"product"`
-	RunID         string      `json:"run_id"`
-	SchemaVersion string      `json:"schema_version"`
-	Version       string      `json:"version"`
-}
-
-func (i *ReportParams) signature() string {
-	signature := i.Signature
-	if i.Signature == "" && i.SignatureFile != "" {
-		var err error
-		signature, err = checkSignature(i.SignatureFile)
-		if err != nil {
-			return ""
-		}
-	}
-	return signature
-}
-
-// Report sends telemetry information to checkpoint
-func Report(ctx context.Context, r *ReportParams) error {
-	if disabled := os.Getenv("CHECKPOINT_DISABLE"); disabled != "" {
-		return nil
-	}
-
-	req, err := ReportRequest(r)
-	if err != nil {
-		return err
-	}
-
-	client := cleanhttp.DefaultClient()
-	resp, err := client.Do(req.WithContext(ctx))
-	if err != nil {
-		return err
-	}
-	if resp.StatusCode != 201 {
-		return fmt.Errorf("Unknown status: %d", resp.StatusCode)
-	}
-
-	return nil
-}
-
-// ReportRequest creates a request object for making a report
-func ReportRequest(r *ReportParams) (*http.Request, error) {
-	// Populate some fields automatically if we can
-	if r.RunID == "" {
-		uuid, err := uuid.GenerateUUID()
-		if err != nil {
-			return nil, err
-		}
-		r.RunID = uuid
-	}
-	if r.Arch == "" {
-		r.Arch = runtime.GOARCH
-	}
-	if r.OS == "" {
-		r.OS = runtime.GOOS
-	}
-	if r.Signature == "" {
-		r.Signature = r.signature()
-	}
-
-	b, err := json.Marshal(r)
-	if err != nil {
-		return nil, err
-	}
-
-	u := &url.URL{
-		Scheme: "https",
-		Host:   "checkpoint-api.hashicorp.com",
-		Path:   fmt.Sprintf("/v1/telemetry/%s", r.Product),
-	}
-
-	req, err := http.NewRequest("POST", u.String(), bytes.NewReader(b))
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Add("Accept", "application/json")
-	req.Header.Add("User-Agent", "HashiCorp/go-checkpoint")
-
-	return req, nil
-}
+var magicBytes = [4]byte{0x35, 0x77, 0x69, 0xFB}
 
 // CheckParams are the parameters for configuring a check request.
 type CheckParams struct {
@@ -177,14 +70,14 @@ type CheckParams struct {
 
 // CheckResponse is the response for a check request.
 type CheckResponse struct {
-	Product             string
-	CurrentVersion      string `json:"current_version"`
-	CurrentReleaseDate  int    `json:"current_release_date"`
-	CurrentDownloadURL  string `json:"current_download_url"`
-	CurrentChangelogURL string `json:"current_changelog_url"`
-	ProjectWebsite      string `json:"project_website"`
-	Outdated            bool   `json:"outdated"`
-	Alerts              []*CheckAlert
+	Product             string        `json:"product"`
+	CurrentVersion      string        `json:"current_version"`
+	CurrentReleaseDate  int           `json:"current_release_date"`
+	CurrentDownloadURL  string        `json:"current_download_url"`
+	CurrentChangelogURL string        `json:"current_changelog_url"`
+	ProjectWebsite      string        `json:"project_website"`
+	Outdated            bool          `json:"outdated"`
+	Alerts              []*CheckAlert `json:"alerts"`
 }
 
 // CheckAlert is a single alert message from a check request.
@@ -192,11 +85,11 @@ type CheckResponse struct {
 // These never have to be manually constructed, and are typically populated
 // into a CheckResponse as a result of the Check request.
 type CheckAlert struct {
-	ID      int
-	Date    int
-	Message string
-	URL     string
-	Level   string
+	ID      int    `json:"id"`
+	Date    int    `json:"date"`
+	Message string `json:"message"`
+	URL     string `json:"url"`
+	Level   string `json:"level"`
 }
 
 // Check checks for alerts and new version information.
@@ -205,7 +98,7 @@ func Check(p *CheckParams) (*CheckResponse, error) {
 		return &CheckResponse{}, nil
 	}
 
-	// set a default timeout of 3 sec for the check request (in milliseconds)
+	// Set a default timeout of 3 sec for the check request (in milliseconds)
 	timeout := 3000
 	if _, err := strconv.Atoi(os.Getenv("CHECKPOINT_TIMEOUT")); err == nil {
 		timeout, _ = strconv.Atoi(os.Getenv("CHECKPOINT_TIMEOUT"))
@@ -253,8 +146,8 @@ func Check(p *CheckParams) (*CheckResponse, error) {
 	if err != nil {
 		return nil, err
 	}
-	req.Header.Add("Accept", "application/json")
-	req.Header.Add("User-Agent", "HashiCorp/go-checkpoint")
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", "HashiCorp/go-checkpoint")
 
 	client := cleanhttp.DefaultClient()
 
@@ -266,6 +159,8 @@ func Check(p *CheckParams) (*CheckResponse, error) {
 	if err != nil {
 		return nil, err
 	}
+	defer resp.Body.Close()
+
 	if resp.StatusCode != 200 {
 		return nil, fmt.Errorf("Unknown status: %d", resp.StatusCode)
 	}
@@ -390,14 +285,11 @@ func checkCache(current string, path string, d time.Duration) (io.ReadCloser, er
 
 	return f, nil
 }
-
 func checkResult(r io.Reader) (*CheckResponse, error) {
 	var result CheckResponse
-	dec := json.NewDecoder(r)
-	if err := dec.Decode(&result); err != nil {
+	if err := json.NewDecoder(r).Decode(&result); err != nil {
 		return nil, err
 	}
-
 	return &result, nil
 }
 
@@ -426,7 +318,7 @@ func checkSignature(path string) (string, error) {
 	var b [16]byte
 	n := 0
 	for n < 16 {
-		n2, err := rand.Read(b[n:])
+		n2, err := crand.Read(b[n:])
 		if err != nil {
 			return "", err
 		}
@@ -456,7 +348,7 @@ func writeCacheHeader(f io.Writer, v string) error {
 	}
 
 	// Write out our current version length
-	var length uint32 = uint32(len(v))
+	length := uint32(len(v))
 	if err := binary.Write(f, binary.LittleEndian, length); err != nil {
 		return err
 	}
diff --git a/vendor/github.com/hashicorp/go-checkpoint/go.mod b/vendor/github.com/hashicorp/go-checkpoint/go.mod
new file mode 100644
index 000000000..be0c793e7
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-checkpoint/go.mod
@@ -0,0 +1,6 @@
+module github.com/hashicorp/go-checkpoint
+
+require (
+	github.com/hashicorp/go-cleanhttp v0.5.0
+	github.com/hashicorp/go-uuid v1.0.0
+)
diff --git a/vendor/github.com/hashicorp/go-checkpoint/go.sum b/vendor/github.com/hashicorp/go-checkpoint/go.sum
new file mode 100644
index 000000000..2128a0c8d
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-checkpoint/go.sum
@@ -0,0 +1,4 @@
+github.com/hashicorp/go-cleanhttp v0.5.0 h1:wvCrVc9TjDls6+YGAF2hAifE1E5U1+b4tH6KdvN3Gig=
+github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-uuid v1.0.0 h1:RS8zrF7PhGwyNPOtxSClXXj9HA8feRnJzgnI1RJCSnM=
+github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
diff --git a/vendor/github.com/hashicorp/go-checkpoint/telemetry.go b/vendor/github.com/hashicorp/go-checkpoint/telemetry.go
new file mode 100644
index 000000000..b9ee62983
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-checkpoint/telemetry.go
@@ -0,0 +1,118 @@
+package checkpoint
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/hashicorp/go-cleanhttp"
+	uuid "github.com/hashicorp/go-uuid"
+)
+
+// ReportParams are the parameters for configuring a telemetry report.
+type ReportParams struct {
+	// Signature is some random signature that should be stored and used
+	// as a cookie-like value. This ensures that alerts aren't repeated.
+	// If the signature is changed, repeat alerts may be sent down. The
+	// signature should NOT be anything identifiable to a user (such as
+	// a MAC address). It should be random.
+	//
+	// If SignatureFile is given, then the signature will be read from this
+	// file. If the file doesn't exist, then a random signature will
+	// automatically be generated and stored here. SignatureFile will be
+	// ignored if Signature is given.
+	Signature     string `json:"signature"`
+	SignatureFile string `json:"-"`
+
+	StartTime     time.Time   `json:"start_time"`
+	EndTime       time.Time   `json:"end_time"`
+	Arch          string      `json:"arch"`
+	OS            string      `json:"os"`
+	Payload       interface{} `json:"payload,omitempty"`
+	Product       string      `json:"product"`
+	RunID         string      `json:"run_id"`
+	SchemaVersion string      `json:"schema_version"`
+	Version       string      `json:"version"`
+}
+
+func (i *ReportParams) signature() string {
+	signature := i.Signature
+	if i.Signature == "" && i.SignatureFile != "" {
+		var err error
+		signature, err = checkSignature(i.SignatureFile)
+		if err != nil {
+			return ""
+		}
+	}
+	return signature
+}
+
+// Report sends telemetry information to checkpoint
+func Report(ctx context.Context, r *ReportParams) error {
+	if disabled := os.Getenv("CHECKPOINT_DISABLE"); disabled != "" {
+		return nil
+	}
+
+	req, err := ReportRequest(r)
+	if err != nil {
+		return err
+	}
+
+	client := cleanhttp.DefaultClient()
+	resp, err := client.Do(req.WithContext(ctx))
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 201 {
+		return fmt.Errorf("Unknown status: %d", resp.StatusCode)
+	}
+
+	return nil
+}
+
+// ReportRequest creates a request object for making a report
+func ReportRequest(r *ReportParams) (*http.Request, error) {
+	// Populate some fields automatically if we can
+	if r.RunID == "" {
+		uuid, err := uuid.GenerateUUID()
+		if err != nil {
+			return nil, err
+		}
+		r.RunID = uuid
+	}
+	if r.Arch == "" {
+		r.Arch = runtime.GOARCH
+	}
+	if r.OS == "" {
+		r.OS = runtime.GOOS
+	}
+	if r.Signature == "" {
+		r.Signature = r.signature()
+	}
+
+	b, err := json.Marshal(r)
+	if err != nil {
+		return nil, err
+	}
+
+	u := &url.URL{
+		Scheme: "https",
+		Host:   "checkpoint-api.hashicorp.com",
+		Path:   fmt.Sprintf("/v1/telemetry/%s", r.Product),
+	}
+
+	req, err := http.NewRequest("POST", u.String(), bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", "HashiCorp/go-checkpoint")
+
+	return req, nil
+}
diff --git a/vendor/github.com/hashicorp/go-checkpoint/versions.go b/vendor/github.com/hashicorp/go-checkpoint/versions.go
new file mode 100644
index 000000000..a5b0d3b32
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-checkpoint/versions.go
@@ -0,0 +1,90 @@
+package checkpoint
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/hashicorp/go-cleanhttp"
+)
+
+// VersionsParams are the parameters for a versions request.
+type VersionsParams struct {
+	// Service is used to lookup the correct service.
+	Service string
+
+	// Product is used to filter the version contraints.
+	Product string
+
+	// Force, if true, will force the check even if CHECKPOINT_DISABLE
+	// is set. Within HashiCorp products, this is ONLY USED when the user
+	// specifically requests it. This is never automatically done without
+	// the user's consent.
+	Force bool
+}
+
+// VersionsResponse is the response for a versions request.
+type VersionsResponse struct {
+	Service   string   `json:"service"`
+	Product   string   `json:"product"`
+	Minimum   string   `json:"minimum"`
+	Maximum   string   `json:"maximum"`
+	Excluding []string `json:"excluding"`
+}
+
+// Versions returns the version constrains for a given service and product.
+func Versions(p *VersionsParams) (*VersionsResponse, error) {
+	if disabled := os.Getenv("CHECKPOINT_DISABLE"); disabled != "" && !p.Force {
+		return &VersionsResponse{}, nil
+	}
+
+	// Set a default timeout of 1 sec for the versions request (in milliseconds)
+	timeout := 1000
+	if _, err := strconv.Atoi(os.Getenv("CHECKPOINT_TIMEOUT")); err == nil {
+		timeout, _ = strconv.Atoi(os.Getenv("CHECKPOINT_TIMEOUT"))
+	}
+
+	v := url.Values{}
+	v.Set("product", p.Product)
+
+	u := &url.URL{
+		Scheme:   "https",
+		Host:     "checkpoint-api.hashicorp.com",
+		Path:     fmt.Sprintf("/v1/versions/%s", p.Service),
+		RawQuery: v.Encode(),
+	}
+
+	req, err := http.NewRequest("GET", u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", "HashiCorp/go-checkpoint")
+
+	client := cleanhttp.DefaultClient()
+
+	// We use a short timeout since checking for new versions is not critical
+	// enough to block on if checkpoint is broken/slow.
+	client.Timeout = time.Duration(timeout) * time.Millisecond
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("Unknown status: %d", resp.StatusCode)
+	}
+
+	result := &VersionsResponse{}
+	if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
diff --git a/vendor/github.com/hashicorp/go-getter/get_git.go b/vendor/github.com/hashicorp/go-getter/get_git.go
index 67e8b2f49..bb1ec316d 100644
--- a/vendor/github.com/hashicorp/go-getter/get_git.go
+++ b/vendor/github.com/hashicorp/go-getter/get_git.go
@@ -37,6 +37,9 @@ func (g *GitGetter) Get(dst string, u *url.URL) error {
 	// The port number must be parseable as an integer. If not, the user
 	// was probably trying to use a scp-style address, in which case the
 	// ssh:// prefix must be removed to indicate that.
+	//
+	// This is not necessary in versions of Go which have patched
+	// CVE-2019-14809 (e.g. Go 1.12.8+)
 	if portStr := u.Port(); portStr != "" {
 		if _, err := strconv.ParseUint(portStr, 10, 16); err != nil {
 			return fmt.Errorf("invalid port number %q; if using the \"scp-like\" git address scheme where a colon introduces the path instead, remove the ssh:// portion and use just the git:: prefix", portStr)
diff --git a/vendor/github.com/hashicorp/go-rootcerts/go.mod b/vendor/github.com/hashicorp/go-rootcerts/go.mod
new file mode 100644
index 000000000..3c0e0e697
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-rootcerts/go.mod
@@ -0,0 +1,3 @@
+module github.com/hashicorp/go-rootcerts
+
+require github.com/mitchellh/go-homedir v1.0.0
diff --git a/vendor/github.com/hashicorp/go-rootcerts/go.sum b/vendor/github.com/hashicorp/go-rootcerts/go.sum
new file mode 100644
index 000000000..d12bb7594
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-rootcerts/go.sum
@@ -0,0 +1,2 @@
+github.com/mitchellh/go-homedir v1.0.0 h1:vKb8ShqSby24Yrqr/yDYkuFz8d0WUjys40rvnGC8aR0=
+github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
diff --git a/vendor/github.com/hashicorp/hcl/v2/CHANGELOG.md b/vendor/github.com/hashicorp/hcl/v2/CHANGELOG.md
new file mode 100644
index 000000000..ccb46bbd8
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/CHANGELOG.md
@@ -0,0 +1,23 @@
+# HCL Changelog
+
+## v2.0.0 (Oct 2, 2019)
+
+Initial release of HCL 2, which is a new implementating combining the HCL 1
+language with the HIL expression language to produce a single language
+supporting both nested configuration structures and arbitrary expressions.
+
+HCL 2 has an entirely new Go library API and so is _not_ a drop-in upgrade
+relative to HCL 1. It's possible to import both versions of HCL into a single
+program using Go's _semantic import versioning_ mechanism:
+
+```
+import (
+    hcl1 "github.com/hashicorp/hcl"
+    hcl2 "github.com/hashicorp/hcl/v2"
+)
+```
+
+---
+
+Prior to v2.0.0 there was not a curated changelog. Consult the git history
+from the latest v1.x.x tag for information on the changes to HCL 1.
diff --git a/vendor/github.com/hashicorp/hcl/v2/LICENSE b/vendor/github.com/hashicorp/hcl/v2/LICENSE
new file mode 100644
index 000000000..82b4de97c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/LICENSE
@@ -0,0 +1,353 @@
+Mozilla Public License, version 2.0
+
+1. Definitions
+
+1.1. “Contributor”
+
+     means each individual or legal entity that creates, contributes to the
+     creation of, or owns Covered Software.
+
+1.2. “Contributor Version”
+
+     means the combination of the Contributions of others (if any) used by a
+     Contributor and that particular Contributor’s Contribution.
+
+1.3. “Contribution”
+
+     means Covered Software of a particular Contributor.
+
+1.4. “Covered Software”
+
+     means Source Code Form to which the initial Contributor has attached the
+     notice in Exhibit A, the Executable Form of such Source Code Form, and
+     Modifications of such Source Code Form, in each case including portions
+     thereof.
+
+1.5. “Incompatible With Secondary Licenses”
+     means
+
+     a. that the initial Contributor has attached the notice described in
+        Exhibit B to the Covered Software; or
+
+     b. that the Covered Software was made available under the terms of version
+        1.1 or earlier of the License, but not also under the terms of a
+        Secondary License.
+
+1.6. “Executable Form”
+
+     means any form of the work other than Source Code Form.
+
+1.7. “Larger Work”
+
+     means a work that combines Covered Software with other material, in a separate
+     file or files, that is not Covered Software.
+
+1.8. “License”
+
+     means this document.
+
+1.9. “Licensable”
+
+     means having the right to grant, to the maximum extent possible, whether at the
+     time of the initial grant or subsequently, any and all of the rights conveyed by
+     this License.
+
+1.10. “Modifications”
+
+     means any of the following:
+
+     a. any file in Source Code Form that results from an addition to, deletion
+        from, or modification of the contents of Covered Software; or
+
+     b. any new file in Source Code Form that contains any Covered Software.
+
+1.11. “Patent Claims” of a Contributor
+
+      means any patent claim(s), including without limitation, method, process,
+      and apparatus claims, in any patent Licensable by such Contributor that
+      would be infringed, but for the grant of the License, by the making,
+      using, selling, offering for sale, having made, import, or transfer of
+      either its Contributions or its Contributor Version.
+
+1.12. “Secondary License”
+
+      means either the GNU General Public License, Version 2.0, the GNU Lesser
+      General Public License, Version 2.1, the GNU Affero General Public
+      License, Version 3.0, or any later versions of those licenses.
+
+1.13. “Source Code Form”
+
+      means the form of the work preferred for making modifications.
+
+1.14. “You” (or “Your”)
+
+      means an individual or a legal entity exercising rights under this
+      License. For legal entities, “You” includes any entity that controls, is
+      controlled by, or is under common control with You. For purposes of this
+      definition, “control” means (a) the power, direct or indirect, to cause
+      the direction or management of such entity, whether by contract or
+      otherwise, or (b) ownership of more than fifty percent (50%) of the
+      outstanding shares or beneficial ownership of such entity.
+
+
+2. License Grants and Conditions
+
+2.1. Grants
+
+     Each Contributor hereby grants You a world-wide, royalty-free,
+     non-exclusive license:
+
+     a. under intellectual property rights (other than patent or trademark)
+        Licensable by such Contributor to use, reproduce, make available,
+        modify, display, perform, distribute, and otherwise exploit its
+        Contributions, either on an unmodified basis, with Modifications, or as
+        part of a Larger Work; and
+
+     b. under Patent Claims of such Contributor to make, use, sell, offer for
+        sale, have made, import, and otherwise transfer either its Contributions
+        or its Contributor Version.
+
+2.2. Effective Date
+
+     The licenses granted in Section 2.1 with respect to any Contribution become
+     effective for each Contribution on the date the Contributor first distributes
+     such Contribution.
+
+2.3. Limitations on Grant Scope
+
+     The licenses granted in this Section 2 are the only rights granted under this
+     License. No additional rights or licenses will be implied from the distribution
+     or licensing of Covered Software under this License. Notwithstanding Section
+     2.1(b) above, no patent license is granted by a Contributor:
+
+     a. for any code that a Contributor has removed from Covered Software; or
+
+     b. for infringements caused by: (i) Your and any other third party’s
+        modifications of Covered Software, or (ii) the combination of its
+        Contributions with other software (except as part of its Contributor
+        Version); or
+
+     c. under Patent Claims infringed by Covered Software in the absence of its
+        Contributions.
+
+     This License does not grant any rights in the trademarks, service marks, or
+     logos of any Contributor (except as may be necessary to comply with the
+     notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+     No Contributor makes additional grants as a result of Your choice to
+     distribute the Covered Software under a subsequent version of this License
+     (see Section 10.2) or under the terms of a Secondary License (if permitted
+     under the terms of Section 3.3).
+
+2.5. Representation
+
+     Each Contributor represents that the Contributor believes its Contributions
+     are its original creation(s) or it has sufficient rights to grant the
+     rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+     This License is not intended to limit any rights You have under applicable
+     copyright doctrines of fair use, fair dealing, or other equivalents.
+
+2.7. Conditions
+
+     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
+     Section 2.1.
+
+
+3. Responsibilities
+
+3.1. Distribution of Source Form
+
+     All distribution of Covered Software in Source Code Form, including any
+     Modifications that You create or to which You contribute, must be under the
+     terms of this License. You must inform recipients that the Source Code Form
+     of the Covered Software is governed by the terms of this License, and how
+     they can obtain a copy of this License. You may not attempt to alter or
+     restrict the recipients’ rights in the Source Code Form.
+
+3.2. Distribution of Executable Form
+
+     If You distribute Covered Software in Executable Form then:
+
+     a. such Covered Software must also be made available in Source Code Form,
+        as described in Section 3.1, and You must inform recipients of the
+        Executable Form how they can obtain a copy of such Source Code Form by
+        reasonable means in a timely manner, at a charge no more than the cost
+        of distribution to the recipient; and
+
+     b. You may distribute such Executable Form under the terms of this License,
+        or sublicense it under different terms, provided that the license for
+        the Executable Form does not attempt to limit or alter the recipients’
+        rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+     You may create and distribute a Larger Work under terms of Your choice,
+     provided that You also comply with the requirements of this License for the
+     Covered Software. If the Larger Work is a combination of Covered Software
+     with a work governed by one or more Secondary Licenses, and the Covered
+     Software is not Incompatible With Secondary Licenses, this License permits
+     You to additionally distribute such Covered Software under the terms of
+     such Secondary License(s), so that the recipient of the Larger Work may, at
+     their option, further distribute the Covered Software under the terms of
+     either this License or such Secondary License(s).
+
+3.4. Notices
+
+     You may not remove or alter the substance of any license notices (including
+     copyright notices, patent notices, disclaimers of warranty, or limitations
+     of liability) contained within the Source Code Form of the Covered
+     Software, except that You may alter any license notices to the extent
+     required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+     You may choose to offer, and to charge a fee for, warranty, support,
+     indemnity or liability obligations to one or more recipients of Covered
+     Software. However, You may do so only on Your own behalf, and not on behalf
+     of any Contributor. You must make it absolutely clear that any such
+     warranty, support, indemnity, or liability obligation is offered by You
+     alone, and You hereby agree to indemnify every Contributor for any
+     liability incurred by such Contributor as a result of warranty, support,
+     indemnity or liability terms You offer. You may include additional
+     disclaimers of warranty and limitations of liability specific to any
+     jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+   If it is impossible for You to comply with any of the terms of this License
+   with respect to some or all of the Covered Software due to statute, judicial
+   order, or regulation then You must: (a) comply with the terms of this License
+   to the maximum extent possible; and (b) describe the limitations and the code
+   they affect. Such description must be placed in a text file included with all
+   distributions of the Covered Software under this License. Except to the
+   extent prohibited by statute or regulation, such description must be
+   sufficiently detailed for a recipient of ordinary skill to be able to
+   understand it.
+
+5. Termination
+
+5.1. The rights granted under this License will terminate automatically if You
+     fail to comply with any of its terms. However, if You become compliant,
+     then the rights granted under this License from a particular Contributor
+     are reinstated (a) provisionally, unless and until such Contributor
+     explicitly and finally terminates Your grants, and (b) on an ongoing basis,
+     if such Contributor fails to notify You of the non-compliance by some
+     reasonable means prior to 60 days after You have come back into compliance.
+     Moreover, Your grants from a particular Contributor are reinstated on an
+     ongoing basis if such Contributor notifies You of the non-compliance by
+     some reasonable means, this is the first time You have received notice of
+     non-compliance with this License from such Contributor, and You become
+     compliant prior to 30 days after Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+     infringement claim (excluding declaratory judgment actions, counter-claims,
+     and cross-claims) alleging that a Contributor Version directly or
+     indirectly infringes any patent, then the rights granted to You by any and
+     all Contributors for the Covered Software under Section 2.1 of this License
+     shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
+     license agreements (excluding distributors and resellers) which have been
+     validly granted by You or Your distributors under this License prior to
+     termination shall survive termination.
+
+6. Disclaimer of Warranty
+
+   Covered Software is provided under this License on an “as is” basis, without
+   warranty of any kind, either expressed, implied, or statutory, including,
+   without limitation, warranties that the Covered Software is free of defects,
+   merchantable, fit for a particular purpose or non-infringing. The entire
+   risk as to the quality and performance of the Covered Software is with You.
+   Should any Covered Software prove defective in any respect, You (not any
+   Contributor) assume the cost of any necessary servicing, repair, or
+   correction. This disclaimer of warranty constitutes an essential part of this
+   License. No use of  any Covered Software is authorized under this License
+   except under this disclaimer.
+
+7. Limitation of Liability
+
+   Under no circumstances and under no legal theory, whether tort (including
+   negligence), contract, or otherwise, shall any Contributor, or anyone who
+   distributes Covered Software as permitted above, be liable to You for any
+   direct, indirect, special, incidental, or consequential damages of any
+   character including, without limitation, damages for lost profits, loss of
+   goodwill, work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses, even if such party shall have been
+   informed of the possibility of such damages. This limitation of liability
+   shall not apply to liability for death or personal injury resulting from such
+   party’s negligence to the extent applicable law prohibits such limitation.
+   Some jurisdictions do not allow the exclusion or limitation of incidental or
+   consequential damages, so this exclusion and limitation may not apply to You.
+
+8. Litigation
+
+   Any litigation relating to this License may be brought only in the courts of
+   a jurisdiction where the defendant maintains its principal place of business
+   and such litigation shall be governed by laws of that jurisdiction, without
+   reference to its conflict-of-law provisions. Nothing in this Section shall
+   prevent a party’s ability to bring cross-claims or counter-claims.
+
+9. Miscellaneous
+
+   This License represents the complete agreement concerning the subject matter
+   hereof. If any provision of this License is held to be unenforceable, such
+   provision shall be reformed only to the extent necessary to make it
+   enforceable. Any law or regulation which provides that the language of a
+   contract shall be construed against the drafter shall not be used to construe
+   this License against a Contributor.
+
+
+10. Versions of the License
+
+10.1. New Versions
+
+      Mozilla Foundation is the license steward. Except as provided in Section
+      10.3, no one other than the license steward has the right to modify or
+      publish new versions of this License. Each version will be given a
+      distinguishing version number.
+
+10.2. Effect of New Versions
+
+      You may distribute the Covered Software under the terms of the version of
+      the License under which You originally received the Covered Software, or
+      under the terms of any subsequent version published by the license
+      steward.
+
+10.3. Modified Versions
+
+      If you create software not governed by this License, and you want to
+      create a new license for such software, you may create and use a modified
+      version of this License if you rename the license and remove any
+      references to the name of the license steward (except to note that such
+      modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses
+      If You choose to distribute Source Code Form that is Incompatible With
+      Secondary Licenses under the terms of this version of the License, the
+      notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+
+      This Source Code Form is subject to the
+      terms of the Mozilla Public License, v.
+      2.0. If a copy of the MPL was not
+      distributed with this file, You can
+      obtain one at
+      http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular file, then
+You may include the notice in a location (such as a LICENSE file in a relevant
+directory) where a recipient would be likely to look for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - “Incompatible With Secondary Licenses” Notice
+
+      This Source Code Form is “Incompatible
+      With Secondary Licenses”, as defined by
+      the Mozilla Public License, v. 2.0.
diff --git a/vendor/github.com/hashicorp/hcl/v2/README.md b/vendor/github.com/hashicorp/hcl/v2/README.md
new file mode 100644
index 000000000..d807a4245
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/README.md
@@ -0,0 +1,204 @@
+# HCL
+
+HCL is a toolkit for creating structured configuration languages that are
+both human- and machine-friendly, for use with command-line tools.
+Although intended to be generally useful, it is primarily targeted
+towards devops tools, servers, etc.
+
+> **NOTE:** This is major version 2 of HCL, whose Go API is incompatible with
+> major version 1. Both versions are available for selection in Go Modules
+> projects. HCL 2 _cannot_ be imported from Go projects that are not using Go Modules. For more information, see
+> [our version selection guide](https://github.com/golang/go/wiki/Version-Selection).
+
+HCL has both a _native syntax_, intended to be pleasant to read and write for
+humans, and a JSON-based variant that is easier for machines to generate
+and parse.
+
+The HCL native syntax is inspired by [libucl](https://github.com/vstakhov/libucl),
+[nginx configuration](http://nginx.org/en/docs/beginners_guide.html#conf_structure),
+and others.
+
+It includes an expression syntax that allows basic inline computation and,
+with support from the calling application, use of variables and functions
+for more dynamic configuration languages.
+
+HCL provides a set of constructs that can be used by a calling application to
+construct a configuration language. The application defines which attribute
+names and nested block types are expected, and HCL parses the configuration
+file, verifies that it conforms to the expected structure, and returns
+high-level objects that the application can use for further processing.
+
+```go
+package main
+
+import (
+	"log"
+	"github.com/hashicorp/hcl/v2/hclsimple"
+)
+
+type Config struct {
+	LogLevel string `hcl:"log_level"`
+}
+
+func main() {
+	var config Config
+	err := hclsimple.DecodeFile("config.hcl", nil, &config)
+	if err != nil {
+		log.Fatalf("Failed to load configuration: %s", err)
+	}
+	log.Printf("Configuration is %#v", config)
+}
+```
+
+A lower-level API is available for applications that need more control over
+the parsing, decoding, and evaluation of configuration.
+
+## Why?
+
+Newcomers to HCL often ask: why not JSON, YAML, etc?
+
+Whereas JSON and YAML are formats for serializing data structures, HCL is
+a syntax and API specifically designed for building structured configuration
+formats.
+
+HCL attempts to strike a compromise between generic serialization formats
+such as JSON and configuration formats built around full programming languages
+such as Ruby. HCL syntax is designed to be easily read and written by humans,
+and allows _declarative_ logic to permit its use in more complex applications.
+
+HCL is intended as a base syntax for configuration formats built
+around key-value pairs and hierarchical blocks whose structure is well-defined
+by the calling application, and this definition of the configuration structure
+allows for better error messages and more convenient definition within the
+calling application.
+
+It can't be denied that JSON is very convenient as a _lingua franca_
+for interoperability between different pieces of software. Because of this,
+HCL defines a common configuration model that can be parsed from either its
+native syntax or from a well-defined equivalent JSON structure. This allows
+configuration to be provided as a mixture of human-authored configuration
+files in the native syntax and machine-generated files in JSON.
+
+## Information Model and Syntax
+
+HCL is built around two primary concepts: _attributes_ and _blocks_. In
+native syntax, a configuration file for a hypothetical application might look
+something like this:
+
+```hcl
+io_mode = "async"
+
+service "http" "web_proxy" {
+  listen_addr = "127.0.0.1:8080"
+  
+  process "main" {
+    command = ["/usr/local/bin/awesome-app", "server"]
+  }
+
+  process "mgmt" {
+    command = ["/usr/local/bin/awesome-app", "mgmt"]
+  }
+}
+```
+
+The JSON equivalent of this configuration is the following:
+
+```json
+{
+  "io_mode": "async",
+  "service": {
+    "http": {
+      "web_proxy": {
+        "listen_addr": "127.0.0.1:8080",
+        "process": {
+          "main": {
+            "command": ["/usr/local/bin/awesome-app", "server"]
+          },
+          "mgmt": {
+            "command": ["/usr/local/bin/awesome-app", "mgmt"]
+          },
+        }
+      }
+    }
+  }
+}
+```
+
+Regardless of which syntax is used, the API within the calling application
+is the same. It can either work directly with the low-level attributes and
+blocks, for more advanced use-cases, or it can use one of the _decoder_
+packages to declaratively extract into either Go structs or dynamic value
+structures.
+
+Attribute values can be expressions as well as just literal values:
+
+```hcl
+# Arithmetic with literals and application-provided variables
+sum = 1 + addend
+
+# String interpolation and templates
+message = "Hello, ${name}!"
+
+# Application-provided functions
+shouty_message = upper(message)
+```
+
+Although JSON syntax doesn't permit direct use of expressions, the interpolation
+syntax allows use of arbitrary expressions within JSON strings:
+
+```json
+{
+  "sum": "${1 + addend}",
+  "message": "Hello, ${name}!",
+  "shouty_message": "${upper(message)}"
+}
+```
+
+For more information, see the detailed specifications:
+
+* [Syntax-agnostic Information Model](hcl/spec.md)
+* [HCL Native Syntax](hcl/hclsyntax/spec.md)
+* [JSON Representation](hcl/json/spec.md)
+
+## Changes in 2.0
+
+Version 2.0 of HCL combines the features of HCL 1.0 with those of the
+interpolation language HIL to produce a single configuration language that
+supports arbitrary expressions.
+
+This new version has a completely new parser and Go API, with no direct
+migration path. Although the syntax is similar, the implementation takes some
+very different approaches to improve on some "rough edges" that existed with
+the original implementation and to allow for more robust error handling.
+
+It's possible to import both HCL 1 and HCL 2 into the same program using Go's
+_semantic import versioning_ mechanism:
+
+```go
+import (
+    hcl1 "github.com/hashicorp/hcl"
+    hcl2 "github.com/hashicorp/hcl/v2"
+)
+```
+
+## Acknowledgements
+
+HCL was heavily inspired by [libucl](https://github.com/vstakhov/libucl),
+by [Vsevolod Stakhov](https://github.com/vstakhov).
+
+HCL and HIL originate in [HashiCorp Terraform](https://terraform.io/),
+with the original parsers for each written by
+[Mitchell Hashimoto](https://github.com/mitchellh).
+
+The original HCL parser was ported to pure Go (from yacc) by
+[Fatih Arslan](https://github.com/fatih). The structure-related portions of
+the new native syntax parser build on that work.
+
+The original HIL parser was ported to pure Go (from yacc) by
+[Martin Atkins](https://github.com/apparentlymart). The expression-related
+portions of the new native syntax parser build on that work.
+
+HCL 2, which merged the original HCL and HIL languages into this single new
+language, builds on design and prototyping work by
+[Martin Atkins](https://github.com/apparentlymart) in
+[zcl](https://github.com/zclconf/go-zcl).
diff --git a/vendor/github.com/hashicorp/hcl/v2/diagnostic.go b/vendor/github.com/hashicorp/hcl/v2/diagnostic.go
new file mode 100644
index 000000000..c320961e1
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/diagnostic.go
@@ -0,0 +1,143 @@
+package hcl
+
+import (
+	"fmt"
+)
+
+// DiagnosticSeverity represents the severity of a diagnostic.
+type DiagnosticSeverity int
+
+const (
+	// DiagInvalid is the invalid zero value of DiagnosticSeverity
+	DiagInvalid DiagnosticSeverity = iota
+
+	// DiagError indicates that the problem reported by a diagnostic prevents
+	// further progress in parsing and/or evaluating the subject.
+	DiagError
+
+	// DiagWarning indicates that the problem reported by a diagnostic warrants
+	// user attention but does not prevent further progress. It is most
+	// commonly used for showing deprecation notices.
+	DiagWarning
+)
+
+// Diagnostic represents information to be presented to a user about an
+// error or anomoly in parsing or evaluating configuration.
+type Diagnostic struct {
+	Severity DiagnosticSeverity
+
+	// Summary and Detail contain the English-language description of the
+	// problem. Summary is a terse description of the general problem and
+	// detail is a more elaborate, often-multi-sentence description of
+	// the probem and what might be done to solve it.
+	Summary string
+	Detail  string
+
+	// Subject and Context are both source ranges relating to the diagnostic.
+	//
+	// Subject is a tight range referring to exactly the construct that
+	// is problematic, while Context is an optional broader range (which should
+	// fully contain Subject) that ought to be shown around Subject when
+	// generating isolated source-code snippets in diagnostic messages.
+	// If Context is nil, the Subject is also the Context.
+	//
+	// Some diagnostics have no source ranges at all. If Context is set then
+	// Subject should always also be set.
+	Subject *Range
+	Context *Range
+
+	// For diagnostics that occur when evaluating an expression, Expression
+	// may refer to that expression and EvalContext may point to the
+	// EvalContext that was active when evaluating it. This may allow for the
+	// inclusion of additional useful information when rendering a diagnostic
+	// message to the user.
+	//
+	// It is not always possible to select a single EvalContext for a
+	// diagnostic, and so in some cases this field may be nil even when an
+	// expression causes a problem.
+	//
+	// EvalContexts form a tree, so the given EvalContext may refer to a parent
+	// which in turn refers to another parent, etc. For a full picture of all
+	// of the active variables and functions the caller must walk up this
+	// chain, preferring definitions that are "closer" to the expression in
+	// case of colliding names.
+	Expression  Expression
+	EvalContext *EvalContext
+}
+
+// Diagnostics is a list of Diagnostic instances.
+type Diagnostics []*Diagnostic
+
+// error implementation, so that diagnostics can be returned via APIs
+// that normally deal in vanilla Go errors.
+//
+// This presents only minimal context about the error, for compatibility
+// with usual expectations about how errors will present as strings.
+func (d *Diagnostic) Error() string {
+	return fmt.Sprintf("%s: %s; %s", d.Subject, d.Summary, d.Detail)
+}
+
+// error implementation, so that sets of diagnostics can be returned via
+// APIs that normally deal in vanilla Go errors.
+func (d Diagnostics) Error() string {
+	count := len(d)
+	switch {
+	case count == 0:
+		return "no diagnostics"
+	case count == 1:
+		return d[0].Error()
+	default:
+		return fmt.Sprintf("%s, and %d other diagnostic(s)", d[0].Error(), count-1)
+	}
+}
+
+// Append appends a new error to a Diagnostics and return the whole Diagnostics.
+//
+// This is provided as a convenience for returning from a function that
+// collects and then returns a set of diagnostics:
+//
+//     return nil, diags.Append(&hcl.Diagnostic{ ... })
+//
+// Note that this modifies the array underlying the diagnostics slice, so
+// must be used carefully within a single codepath. It is incorrect (and rude)
+// to extend a diagnostics created by a different subsystem.
+func (d Diagnostics) Append(diag *Diagnostic) Diagnostics {
+	return append(d, diag)
+}
+
+// Extend concatenates the given Diagnostics with the receiver and returns
+// the whole new Diagnostics.
+//
+// This is similar to Append but accepts multiple diagnostics to add. It has
+// all the same caveats and constraints.
+func (d Diagnostics) Extend(diags Diagnostics) Diagnostics {
+	return append(d, diags...)
+}
+
+// HasErrors returns true if the receiver contains any diagnostics of
+// severity DiagError.
+func (d Diagnostics) HasErrors() bool {
+	for _, diag := range d {
+		if diag.Severity == DiagError {
+			return true
+		}
+	}
+	return false
+}
+
+func (d Diagnostics) Errs() []error {
+	var errs []error
+	for _, diag := range d {
+		if diag.Severity == DiagError {
+			errs = append(errs, diag)
+		}
+	}
+
+	return errs
+}
+
+// A DiagnosticWriter emits diagnostics somehow.
+type DiagnosticWriter interface {
+	WriteDiagnostic(*Diagnostic) error
+	WriteDiagnostics(Diagnostics) error
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/diagnostic_text.go b/vendor/github.com/hashicorp/hcl/v2/diagnostic_text.go
new file mode 100644
index 000000000..0b4a2629b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/diagnostic_text.go
@@ -0,0 +1,311 @@
+package hcl
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"sort"
+
+	wordwrap "github.com/mitchellh/go-wordwrap"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type diagnosticTextWriter struct {
+	files map[string]*File
+	wr    io.Writer
+	width uint
+	color bool
+}
+
+// NewDiagnosticTextWriter creates a DiagnosticWriter that writes diagnostics
+// to the given writer as formatted text.
+//
+// It is designed to produce text appropriate to print in a monospaced font
+// in a terminal of a particular width, or optionally with no width limit.
+//
+// The given width may be zero to disable word-wrapping of the detail text
+// and truncation of source code snippets.
+//
+// If color is set to true, the output will include VT100 escape sequences to
+// color-code the severity indicators. It is suggested to turn this off if
+// the target writer is not a terminal.
+func NewDiagnosticTextWriter(wr io.Writer, files map[string]*File, width uint, color bool) DiagnosticWriter {
+	return &diagnosticTextWriter{
+		files: files,
+		wr:    wr,
+		width: width,
+		color: color,
+	}
+}
+
+func (w *diagnosticTextWriter) WriteDiagnostic(diag *Diagnostic) error {
+	if diag == nil {
+		return errors.New("nil diagnostic")
+	}
+
+	var colorCode, highlightCode, resetCode string
+	if w.color {
+		switch diag.Severity {
+		case DiagError:
+			colorCode = "\x1b[31m"
+		case DiagWarning:
+			colorCode = "\x1b[33m"
+		}
+		resetCode = "\x1b[0m"
+		highlightCode = "\x1b[1;4m"
+	}
+
+	var severityStr string
+	switch diag.Severity {
+	case DiagError:
+		severityStr = "Error"
+	case DiagWarning:
+		severityStr = "Warning"
+	default:
+		// should never happen
+		severityStr = "???????"
+	}
+
+	fmt.Fprintf(w.wr, "%s%s%s: %s\n\n", colorCode, severityStr, resetCode, diag.Summary)
+
+	if diag.Subject != nil {
+		snipRange := *diag.Subject
+		highlightRange := snipRange
+		if diag.Context != nil {
+			// Show enough of the source code to include both the subject
+			// and context ranges, which overlap in all reasonable
+			// situations.
+			snipRange = RangeOver(snipRange, *diag.Context)
+		}
+		// We can't illustrate an empty range, so we'll turn such ranges into
+		// single-character ranges, which might not be totally valid (may point
+		// off the end of a line, or off the end of the file) but are good
+		// enough for the bounds checks we do below.
+		if snipRange.Empty() {
+			snipRange.End.Byte++
+			snipRange.End.Column++
+		}
+		if highlightRange.Empty() {
+			highlightRange.End.Byte++
+			highlightRange.End.Column++
+		}
+
+		file := w.files[diag.Subject.Filename]
+		if file == nil || file.Bytes == nil {
+			fmt.Fprintf(w.wr, "  on %s line %d:\n  (source code not available)\n\n", diag.Subject.Filename, diag.Subject.Start.Line)
+		} else {
+
+			var contextLine string
+			if diag.Subject != nil {
+				contextLine = contextString(file, diag.Subject.Start.Byte)
+				if contextLine != "" {
+					contextLine = ", in " + contextLine
+				}
+			}
+
+			fmt.Fprintf(w.wr, "  on %s line %d%s:\n", diag.Subject.Filename, diag.Subject.Start.Line, contextLine)
+
+			src := file.Bytes
+			sc := NewRangeScanner(src, diag.Subject.Filename, bufio.ScanLines)
+
+			for sc.Scan() {
+				lineRange := sc.Range()
+				if !lineRange.Overlaps(snipRange) {
+					continue
+				}
+
+				beforeRange, highlightedRange, afterRange := lineRange.PartitionAround(highlightRange)
+				if highlightedRange.Empty() {
+					fmt.Fprintf(w.wr, "%4d: %s\n", lineRange.Start.Line, sc.Bytes())
+				} else {
+					before := beforeRange.SliceBytes(src)
+					highlighted := highlightedRange.SliceBytes(src)
+					after := afterRange.SliceBytes(src)
+					fmt.Fprintf(
+						w.wr, "%4d: %s%s%s%s%s\n",
+						lineRange.Start.Line,
+						before,
+						highlightCode, highlighted, resetCode,
+						after,
+					)
+				}
+
+			}
+
+			w.wr.Write([]byte{'\n'})
+		}
+
+		if diag.Expression != nil && diag.EvalContext != nil {
+			// We will attempt to render the values for any variables
+			// referenced in the given expression as additional context, for
+			// situations where the same expression is evaluated multiple
+			// times in different scopes.
+			expr := diag.Expression
+			ctx := diag.EvalContext
+
+			vars := expr.Variables()
+			stmts := make([]string, 0, len(vars))
+			seen := make(map[string]struct{}, len(vars))
+			for _, traversal := range vars {
+				val, diags := traversal.TraverseAbs(ctx)
+				if diags.HasErrors() {
+					// Skip anything that generates errors, since we probably
+					// already have the same error in our diagnostics set
+					// already.
+					continue
+				}
+
+				traversalStr := w.traversalStr(traversal)
+				if _, exists := seen[traversalStr]; exists {
+					continue // don't show duplicates when the same variable is referenced multiple times
+				}
+				switch {
+				case !val.IsKnown():
+					// Can't say anything about this yet, then.
+					continue
+				case val.IsNull():
+					stmts = append(stmts, fmt.Sprintf("%s set to null", traversalStr))
+				default:
+					stmts = append(stmts, fmt.Sprintf("%s as %s", traversalStr, w.valueStr(val)))
+				}
+				seen[traversalStr] = struct{}{}
+			}
+
+			sort.Strings(stmts) // FIXME: Should maybe use a traversal-aware sort that can sort numeric indexes properly?
+			last := len(stmts) - 1
+
+			for i, stmt := range stmts {
+				switch i {
+				case 0:
+					w.wr.Write([]byte{'w', 'i', 't', 'h', ' '})
+				default:
+					w.wr.Write([]byte{' ', ' ', ' ', ' ', ' '})
+				}
+				w.wr.Write([]byte(stmt))
+				switch i {
+				case last:
+					w.wr.Write([]byte{'.', '\n', '\n'})
+				default:
+					w.wr.Write([]byte{',', '\n'})
+				}
+			}
+		}
+	}
+
+	if diag.Detail != "" {
+		detail := diag.Detail
+		if w.width != 0 {
+			detail = wordwrap.WrapString(detail, w.width)
+		}
+		fmt.Fprintf(w.wr, "%s\n\n", detail)
+	}
+
+	return nil
+}
+
+func (w *diagnosticTextWriter) WriteDiagnostics(diags Diagnostics) error {
+	for _, diag := range diags {
+		err := w.WriteDiagnostic(diag)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (w *diagnosticTextWriter) traversalStr(traversal Traversal) string {
+	// This is a specialized subset of traversal rendering tailored to
+	// producing helpful contextual messages in diagnostics. It is not
+	// comprehensive nor intended to be used for other purposes.
+
+	var buf bytes.Buffer
+	for _, step := range traversal {
+		switch tStep := step.(type) {
+		case TraverseRoot:
+			buf.WriteString(tStep.Name)
+		case TraverseAttr:
+			buf.WriteByte('.')
+			buf.WriteString(tStep.Name)
+		case TraverseIndex:
+			buf.WriteByte('[')
+			if keyTy := tStep.Key.Type(); keyTy.IsPrimitiveType() {
+				buf.WriteString(w.valueStr(tStep.Key))
+			} else {
+				// We'll just use a placeholder for more complex values,
+				// since otherwise our result could grow ridiculously long.
+				buf.WriteString("...")
+			}
+			buf.WriteByte(']')
+		}
+	}
+	return buf.String()
+}
+
+func (w *diagnosticTextWriter) valueStr(val cty.Value) string {
+	// This is a specialized subset of value rendering tailored to producing
+	// helpful but concise messages in diagnostics. It is not comprehensive
+	// nor intended to be used for other purposes.
+
+	ty := val.Type()
+	switch {
+	case val.IsNull():
+		return "null"
+	case !val.IsKnown():
+		// Should never happen here because we should filter before we get
+		// in here, but we'll do something reasonable rather than panic.
+		return "(not yet known)"
+	case ty == cty.Bool:
+		if val.True() {
+			return "true"
+		}
+		return "false"
+	case ty == cty.Number:
+		bf := val.AsBigFloat()
+		return bf.Text('g', 10)
+	case ty == cty.String:
+		// Go string syntax is not exactly the same as HCL native string syntax,
+		// but we'll accept the minor edge-cases where this is different here
+		// for now, just to get something reasonable here.
+		return fmt.Sprintf("%q", val.AsString())
+	case ty.IsCollectionType() || ty.IsTupleType():
+		l := val.LengthInt()
+		switch l {
+		case 0:
+			return "empty " + ty.FriendlyName()
+		case 1:
+			return ty.FriendlyName() + " with 1 element"
+		default:
+			return fmt.Sprintf("%s with %d elements", ty.FriendlyName(), l)
+		}
+	case ty.IsObjectType():
+		atys := ty.AttributeTypes()
+		l := len(atys)
+		switch l {
+		case 0:
+			return "object with no attributes"
+		case 1:
+			var name string
+			for k := range atys {
+				name = k
+			}
+			return fmt.Sprintf("object with 1 attribute %q", name)
+		default:
+			return fmt.Sprintf("object with %d attributes", l)
+		}
+	default:
+		return ty.FriendlyName()
+	}
+}
+
+func contextString(file *File, offset int) string {
+	type contextStringer interface {
+		ContextString(offset int) string
+	}
+
+	if cser, ok := file.Nav.(contextStringer); ok {
+		return cser.ContextString(offset)
+	}
+	return ""
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/didyoumean.go b/vendor/github.com/hashicorp/hcl/v2/didyoumean.go
new file mode 100644
index 000000000..c12833440
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/didyoumean.go
@@ -0,0 +1,24 @@
+package hcl
+
+import (
+	"github.com/agext/levenshtein"
+)
+
+// nameSuggestion tries to find a name from the given slice of suggested names
+// that is close to the given name and returns it if found. If no suggestion
+// is close enough, returns the empty string.
+//
+// The suggestions are tried in order, so earlier suggestions take precedence
+// if the given string is similar to two or more suggestions.
+//
+// This function is intended to be used with a relatively-small number of
+// suggestions. It's not optimized for hundreds or thousands of them.
+func nameSuggestion(given string, suggestions []string) string {
+	for _, suggestion := range suggestions {
+		dist := levenshtein.Distance(given, suggestion, nil)
+		if dist < 3 { // threshold determined experimentally
+			return suggestion
+		}
+	}
+	return ""
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/doc.go b/vendor/github.com/hashicorp/hcl/v2/doc.go
new file mode 100644
index 000000000..0d43fb2c7
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/doc.go
@@ -0,0 +1,34 @@
+// Package hcl contains the main modelling types and general utility functions
+// for HCL.
+//
+// For a simple entry point into HCL, see the package in the subdirectory
+// "hclsimple", which has an opinionated function Decode that can decode HCL
+// configurations in either native HCL syntax or JSON syntax into a Go struct
+// type:
+//
+//     package main
+//
+//     import (
+//     	"log"
+//     	"github.com/hashicorp/hcl/v2/hclsimple"
+//     )
+//
+//     type Config struct {
+//     	LogLevel string `hcl:"log_level"`
+//     }
+//
+//     func main() {
+//     	var config Config
+//     	err := hclsimple.DecodeFile("config.hcl", nil, &config)
+//     	if err != nil {
+//     		log.Fatalf("Failed to load configuration: %s", err)
+//     	}
+//     	log.Printf("Configuration is %#v", config)
+//     }
+//
+// If your application needs more control over the evaluation of the
+// configuration, you can use the functions in the subdirectories hclparse,
+// gohcl, hcldec, etc. Splitting the handling of configuration into multiple
+// phases allows for advanced patterns such as allowing expressions in one
+// part of the configuration to refer to data defined in another part.
+package hcl
diff --git a/vendor/github.com/hashicorp/hcl/v2/eval_context.go b/vendor/github.com/hashicorp/hcl/v2/eval_context.go
new file mode 100644
index 000000000..915910ad8
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/eval_context.go
@@ -0,0 +1,25 @@
+package hcl
+
+import (
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+// An EvalContext provides the variables and functions that should be used
+// to evaluate an expression.
+type EvalContext struct {
+	Variables map[string]cty.Value
+	Functions map[string]function.Function
+	parent    *EvalContext
+}
+
+// NewChild returns a new EvalContext that is a child of the receiver.
+func (ctx *EvalContext) NewChild() *EvalContext {
+	return &EvalContext{parent: ctx}
+}
+
+// Parent returns the parent of the receiver, or nil if the receiver has
+// no parent.
+func (ctx *EvalContext) Parent() *EvalContext {
+	return ctx.parent
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/expr_call.go b/vendor/github.com/hashicorp/hcl/v2/expr_call.go
new file mode 100644
index 000000000..6963fbae3
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/expr_call.go
@@ -0,0 +1,46 @@
+package hcl
+
+// ExprCall tests if the given expression is a function call and,
+// if so, extracts the function name and the expressions that represent
+// the arguments. If the given expression is not statically a function call,
+// error diagnostics are returned.
+//
+// A particular Expression implementation can support this function by
+// offering a method called ExprCall that takes no arguments and returns
+// *StaticCall. This method should return nil if a static call cannot
+// be extracted.  Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+func ExprCall(expr Expression) (*StaticCall, Diagnostics) {
+	type exprCall interface {
+		ExprCall() *StaticCall
+	}
+
+	physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+		_, supported := expr.(exprCall)
+		return supported
+	})
+
+	if exC, supported := physExpr.(exprCall); supported {
+		if call := exC.ExprCall(); call != nil {
+			return call, nil
+		}
+	}
+	return nil, Diagnostics{
+		&Diagnostic{
+			Severity: DiagError,
+			Summary:  "Invalid expression",
+			Detail:   "A static function call is required.",
+			Subject:  expr.StartRange().Ptr(),
+		},
+	}
+}
+
+// StaticCall represents a function call that was extracted statically from
+// an expression using ExprCall.
+type StaticCall struct {
+	Name      string
+	NameRange Range
+	Arguments []Expression
+	ArgsRange Range
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/expr_list.go b/vendor/github.com/hashicorp/hcl/v2/expr_list.go
new file mode 100644
index 000000000..d05cca0b9
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/expr_list.go
@@ -0,0 +1,37 @@
+package hcl
+
+// ExprList tests if the given expression is a static list construct and,
+// if so, extracts the expressions that represent the list elements.
+// If the given expression is not a static list, error diagnostics are
+// returned.
+//
+// A particular Expression implementation can support this function by
+// offering a method called ExprList that takes no arguments and returns
+// []Expression. This method should return nil if a static list cannot
+// be extracted.  Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+func ExprList(expr Expression) ([]Expression, Diagnostics) {
+	type exprList interface {
+		ExprList() []Expression
+	}
+
+	physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+		_, supported := expr.(exprList)
+		return supported
+	})
+
+	if exL, supported := physExpr.(exprList); supported {
+		if list := exL.ExprList(); list != nil {
+			return list, nil
+		}
+	}
+	return nil, Diagnostics{
+		&Diagnostic{
+			Severity: DiagError,
+			Summary:  "Invalid expression",
+			Detail:   "A static list expression is required.",
+			Subject:  expr.StartRange().Ptr(),
+		},
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/expr_map.go b/vendor/github.com/hashicorp/hcl/v2/expr_map.go
new file mode 100644
index 000000000..96d1ce4bf
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/expr_map.go
@@ -0,0 +1,44 @@
+package hcl
+
+// ExprMap tests if the given expression is a static map construct and,
+// if so, extracts the expressions that represent the map elements.
+// If the given expression is not a static map, error diagnostics are
+// returned.
+//
+// A particular Expression implementation can support this function by
+// offering a method called ExprMap that takes no arguments and returns
+// []KeyValuePair. This method should return nil if a static map cannot
+// be extracted.  Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+func ExprMap(expr Expression) ([]KeyValuePair, Diagnostics) {
+	type exprMap interface {
+		ExprMap() []KeyValuePair
+	}
+
+	physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+		_, supported := expr.(exprMap)
+		return supported
+	})
+
+	if exM, supported := physExpr.(exprMap); supported {
+		if pairs := exM.ExprMap(); pairs != nil {
+			return pairs, nil
+		}
+	}
+	return nil, Diagnostics{
+		&Diagnostic{
+			Severity: DiagError,
+			Summary:  "Invalid expression",
+			Detail:   "A static map expression is required.",
+			Subject:  expr.StartRange().Ptr(),
+		},
+	}
+}
+
+// KeyValuePair represents a pair of expressions that serve as a single item
+// within a map or object definition construct.
+type KeyValuePair struct {
+	Key   Expression
+	Value Expression
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/expr_unwrap.go b/vendor/github.com/hashicorp/hcl/v2/expr_unwrap.go
new file mode 100644
index 000000000..6d5d205c4
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/expr_unwrap.go
@@ -0,0 +1,68 @@
+package hcl
+
+type unwrapExpression interface {
+	UnwrapExpression() Expression
+}
+
+// UnwrapExpression removes any "wrapper" expressions from the given expression,
+// to recover the representation of the physical expression given in source
+// code.
+//
+// Sometimes wrapping expressions are used to modify expression behavior, e.g.
+// in extensions that need to make some local variables available to certain
+// sub-trees of the configuration. This can make it difficult to reliably
+// type-assert on the physical AST types used by the underlying syntax.
+//
+// Unwrapping an expression may modify its behavior by stripping away any
+// additional constraints or capabilities being applied to the Value and
+// Variables methods, so this function should generally only be used prior
+// to operations that concern themselves with the static syntax of the input
+// configuration, and not with the effective value of the expression.
+//
+// Wrapper expression types must support unwrapping by implementing a method
+// called UnwrapExpression that takes no arguments and returns the embedded
+// Expression. Implementations of this method should peel away only one level
+// of wrapping, if multiple are present. This method may return nil to
+// indicate _dynamically_ that no wrapped expression is available, for
+// expression types that might only behave as wrappers in certain cases.
+func UnwrapExpression(expr Expression) Expression {
+	for {
+		unwrap, wrapped := expr.(unwrapExpression)
+		if !wrapped {
+			return expr
+		}
+		innerExpr := unwrap.UnwrapExpression()
+		if innerExpr == nil {
+			return expr
+		}
+		expr = innerExpr
+	}
+}
+
+// UnwrapExpressionUntil is similar to UnwrapExpression except it gives the
+// caller an opportunity to test each level of unwrapping to see each a
+// particular expression is accepted.
+//
+// This could be used, for example, to unwrap until a particular other
+// interface is satisfied, regardless of wrap wrapping level it is satisfied
+// at.
+//
+// The given callback function must return false to continue wrapping, or
+// true to accept and return the proposed expression given. If the callback
+// function rejects even the final, physical expression then the result of
+// this function is nil.
+func UnwrapExpressionUntil(expr Expression, until func(Expression) bool) Expression {
+	for {
+		if until(expr) {
+			return expr
+		}
+		unwrap, wrapped := expr.(unwrapExpression)
+		if !wrapped {
+			return nil
+		}
+		expr = unwrap.UnwrapExpression()
+		if expr == nil {
+			return nil
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/go.mod b/vendor/github.com/hashicorp/hcl/v2/go.mod
new file mode 100644
index 000000000..c152e6016
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/go.mod
@@ -0,0 +1,21 @@
+module github.com/hashicorp/hcl/v2
+
+require (
+	github.com/agext/levenshtein v1.2.1
+	github.com/apparentlymart/go-dump v0.0.0-20180507223929-23540a00eaa3
+	github.com/apparentlymart/go-textseg v1.0.0
+	github.com/davecgh/go-spew v1.1.1
+	github.com/go-test/deep v1.0.3
+	github.com/google/go-cmp v0.2.0
+	github.com/kr/pretty v0.1.0
+	github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348
+	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/sergi/go-diff v1.0.0
+	github.com/spf13/pflag v1.0.2
+	github.com/stretchr/testify v1.2.2 // indirect
+	github.com/zclconf/go-cty v1.1.0
+	golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734
+	golang.org/x/sys v0.0.0-20190502175342-a43fa875dd82 // indirect
+	golang.org/x/text v0.3.2 // indirect
+)
diff --git a/vendor/github.com/hashicorp/hcl/v2/go.sum b/vendor/github.com/hashicorp/hcl/v2/go.sum
new file mode 100644
index 000000000..b3b95415f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/go.sum
@@ -0,0 +1,51 @@
+github.com/agext/levenshtein v1.2.1 h1:QmvMAjj2aEICytGiWzmxoE0x2KZvE0fvmqMOfy2tjT8=
+github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
+github.com/apparentlymart/go-dump v0.0.0-20180507223929-23540a00eaa3 h1:ZSTrOEhiM5J5RFxEaFvMZVEAM1KvT1YzbEOwB2EAGjA=
+github.com/apparentlymart/go-dump v0.0.0-20180507223929-23540a00eaa3/go.mod h1:oL81AME2rN47vu18xqj1S1jPIPuN7afo62yKTNn3XMM=
+github.com/apparentlymart/go-textseg v1.0.0 h1:rRmlIsPEEhUTIKQb7T++Nz/A5Q6C9IuX2wFoYVvnCs0=
+github.com/apparentlymart/go-textseg v1.0.0/go.mod h1:z96Txxhf3xSFMPmb5X/1W05FF/Nj9VFpLOpjS5yuumk=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
+github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
+github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
+github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k=
+github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
+github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/spf13/pflag v1.0.2 h1:Fy0orTDgHdbnzHcsOgfCN4LtHf0ec3wwtiwJqwvf3Gc=
+github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/vmihailenco/msgpack v3.3.3+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
+github.com/zclconf/go-cty v1.1.0 h1:uJwc9HiBOCpoKIObTQaLR+tsEXx1HBHnOsOOpcdhZgw=
+github.com/zclconf/go-cty v1.1.0/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734 h1:p/H982KKEjUnLJkM3tt/LemDnOc1GiZL5FCVlORJ5zo=
+golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/net v0.0.0-20180811021610-c39426892332/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502175342-a43fa875dd82 h1:vsphBvatvfbhlb4PO1BYSr9dzugGxJ/SQHoNufZJq1w=
+golang.org/x/sys v0.0.0-20190502175342-a43fa875dd82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/decode.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/decode.go
new file mode 100644
index 000000000..7ba08eee0
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/decode.go
@@ -0,0 +1,304 @@
+package gohcl
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// DecodeBody extracts the configuration within the given body into the given
+// value. This value must be a non-nil pointer to either a struct or
+// a map, where in the former case the configuration will be decoded using
+// struct tags and in the latter case only attributes are allowed and their
+// values are decoded into the map.
+//
+// The given EvalContext is used to resolve any variables or functions in
+// expressions encountered while decoding. This may be nil to require only
+// constant values, for simple applications that do not support variables or
+// functions.
+//
+// The returned diagnostics should be inspected with its HasErrors method to
+// determine if the populated value is valid and complete. If error diagnostics
+// are returned then the given value may have been partially-populated but
+// may still be accessed by a careful caller for static analysis and editor
+// integration use-cases.
+func DecodeBody(body hcl.Body, ctx *hcl.EvalContext, val interface{}) hcl.Diagnostics {
+	rv := reflect.ValueOf(val)
+	if rv.Kind() != reflect.Ptr {
+		panic(fmt.Sprintf("target value must be a pointer, not %s", rv.Type().String()))
+	}
+
+	return decodeBodyToValue(body, ctx, rv.Elem())
+}
+
+func decodeBodyToValue(body hcl.Body, ctx *hcl.EvalContext, val reflect.Value) hcl.Diagnostics {
+	et := val.Type()
+	switch et.Kind() {
+	case reflect.Struct:
+		return decodeBodyToStruct(body, ctx, val)
+	case reflect.Map:
+		return decodeBodyToMap(body, ctx, val)
+	default:
+		panic(fmt.Sprintf("target value must be pointer to struct or map, not %s", et.String()))
+	}
+}
+
+func decodeBodyToStruct(body hcl.Body, ctx *hcl.EvalContext, val reflect.Value) hcl.Diagnostics {
+	schema, partial := ImpliedBodySchema(val.Interface())
+
+	var content *hcl.BodyContent
+	var leftovers hcl.Body
+	var diags hcl.Diagnostics
+	if partial {
+		content, leftovers, diags = body.PartialContent(schema)
+	} else {
+		content, diags = body.Content(schema)
+	}
+	if content == nil {
+		return diags
+	}
+
+	tags := getFieldTags(val.Type())
+
+	if tags.Remain != nil {
+		fieldIdx := *tags.Remain
+		field := val.Type().Field(fieldIdx)
+		fieldV := val.Field(fieldIdx)
+		switch {
+		case bodyType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(leftovers))
+		case attrsType.AssignableTo(field.Type):
+			attrs, attrsDiags := leftovers.JustAttributes()
+			if len(attrsDiags) > 0 {
+				diags = append(diags, attrsDiags...)
+			}
+			fieldV.Set(reflect.ValueOf(attrs))
+		default:
+			diags = append(diags, decodeBodyToValue(leftovers, ctx, fieldV)...)
+		}
+	}
+
+	for name, fieldIdx := range tags.Attributes {
+		attr := content.Attributes[name]
+		field := val.Type().Field(fieldIdx)
+		fieldV := val.Field(fieldIdx)
+
+		if attr == nil {
+			if !exprType.AssignableTo(field.Type) {
+				continue
+			}
+
+			// As a special case, if the target is of type hcl.Expression then
+			// we'll assign an actual expression that evalues to a cty null,
+			// so the caller can deal with it within the cty realm rather
+			// than within the Go realm.
+			synthExpr := hcl.StaticExpr(cty.NullVal(cty.DynamicPseudoType), body.MissingItemRange())
+			fieldV.Set(reflect.ValueOf(synthExpr))
+			continue
+		}
+
+		switch {
+		case attrType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(attr))
+		case exprType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(attr.Expr))
+		default:
+			diags = append(diags, DecodeExpression(
+				attr.Expr, ctx, fieldV.Addr().Interface(),
+			)...)
+		}
+	}
+
+	blocksByType := content.Blocks.ByType()
+
+	for typeName, fieldIdx := range tags.Blocks {
+		blocks := blocksByType[typeName]
+		field := val.Type().Field(fieldIdx)
+
+		ty := field.Type
+		isSlice := false
+		isPtr := false
+		if ty.Kind() == reflect.Slice {
+			isSlice = true
+			ty = ty.Elem()
+		}
+		if ty.Kind() == reflect.Ptr {
+			isPtr = true
+			ty = ty.Elem()
+		}
+
+		if len(blocks) > 1 && !isSlice {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", typeName),
+				Detail: fmt.Sprintf(
+					"Only one %s block is allowed. Another was defined at %s.",
+					typeName, blocks[0].DefRange.String(),
+				),
+				Subject: &blocks[1].DefRange,
+			})
+			continue
+		}
+
+		if len(blocks) == 0 {
+			if isSlice || isPtr {
+				val.Field(fieldIdx).Set(reflect.Zero(field.Type))
+			} else {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Missing %s block", typeName),
+					Detail:   fmt.Sprintf("A %s block is required.", typeName),
+					Subject:  body.MissingItemRange().Ptr(),
+				})
+			}
+			continue
+		}
+
+		switch {
+
+		case isSlice:
+			elemType := ty
+			if isPtr {
+				elemType = reflect.PtrTo(ty)
+			}
+			sli := reflect.MakeSlice(reflect.SliceOf(elemType), len(blocks), len(blocks))
+
+			for i, block := range blocks {
+				if isPtr {
+					v := reflect.New(ty)
+					diags = append(diags, decodeBlockToValue(block, ctx, v.Elem())...)
+					sli.Index(i).Set(v)
+				} else {
+					diags = append(diags, decodeBlockToValue(block, ctx, sli.Index(i))...)
+				}
+			}
+
+			val.Field(fieldIdx).Set(sli)
+
+		default:
+			block := blocks[0]
+			if isPtr {
+				v := reflect.New(ty)
+				diags = append(diags, decodeBlockToValue(block, ctx, v.Elem())...)
+				val.Field(fieldIdx).Set(v)
+			} else {
+				diags = append(diags, decodeBlockToValue(block, ctx, val.Field(fieldIdx))...)
+			}
+
+		}
+
+	}
+
+	return diags
+}
+
+func decodeBodyToMap(body hcl.Body, ctx *hcl.EvalContext, v reflect.Value) hcl.Diagnostics {
+	attrs, diags := body.JustAttributes()
+	if attrs == nil {
+		return diags
+	}
+
+	mv := reflect.MakeMap(v.Type())
+
+	for k, attr := range attrs {
+		switch {
+		case attrType.AssignableTo(v.Type().Elem()):
+			mv.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(attr))
+		case exprType.AssignableTo(v.Type().Elem()):
+			mv.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(attr.Expr))
+		default:
+			ev := reflect.New(v.Type().Elem())
+			diags = append(diags, DecodeExpression(attr.Expr, ctx, ev.Interface())...)
+			mv.SetMapIndex(reflect.ValueOf(k), ev.Elem())
+		}
+	}
+
+	v.Set(mv)
+
+	return diags
+}
+
+func decodeBlockToValue(block *hcl.Block, ctx *hcl.EvalContext, v reflect.Value) hcl.Diagnostics {
+	var diags hcl.Diagnostics
+
+	ty := v.Type()
+
+	switch {
+	case blockType.AssignableTo(ty):
+		v.Elem().Set(reflect.ValueOf(block))
+	case bodyType.AssignableTo(ty):
+		v.Elem().Set(reflect.ValueOf(block.Body))
+	case attrsType.AssignableTo(ty):
+		attrs, attrsDiags := block.Body.JustAttributes()
+		if len(attrsDiags) > 0 {
+			diags = append(diags, attrsDiags...)
+		}
+		v.Elem().Set(reflect.ValueOf(attrs))
+	default:
+		diags = append(diags, decodeBodyToValue(block.Body, ctx, v)...)
+
+		if len(block.Labels) > 0 {
+			blockTags := getFieldTags(ty)
+			for li, lv := range block.Labels {
+				lfieldIdx := blockTags.Labels[li].FieldIndex
+				v.Field(lfieldIdx).Set(reflect.ValueOf(lv))
+			}
+		}
+
+	}
+
+	return diags
+}
+
+// DecodeExpression extracts the value of the given expression into the given
+// value. This value must be something that gocty is able to decode into,
+// since the final decoding is delegated to that package.
+//
+// The given EvalContext is used to resolve any variables or functions in
+// expressions encountered while decoding. This may be nil to require only
+// constant values, for simple applications that do not support variables or
+// functions.
+//
+// The returned diagnostics should be inspected with its HasErrors method to
+// determine if the populated value is valid and complete. If error diagnostics
+// are returned then the given value may have been partially-populated but
+// may still be accessed by a careful caller for static analysis and editor
+// integration use-cases.
+func DecodeExpression(expr hcl.Expression, ctx *hcl.EvalContext, val interface{}) hcl.Diagnostics {
+	srcVal, diags := expr.Value(ctx)
+
+	convTy, err := gocty.ImpliedType(val)
+	if err != nil {
+		panic(fmt.Sprintf("unsuitable DecodeExpression target: %s", err))
+	}
+
+	srcVal, err = convert.Convert(srcVal, convTy)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Unsuitable value type",
+			Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
+			Subject:  expr.StartRange().Ptr(),
+			Context:  expr.Range().Ptr(),
+		})
+		return diags
+	}
+
+	err = gocty.FromCtyValue(srcVal, val)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Unsuitable value type",
+			Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
+			Subject:  expr.StartRange().Ptr(),
+			Context:  expr.Range().Ptr(),
+		})
+	}
+
+	return diags
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/doc.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/doc.go
new file mode 100644
index 000000000..aa3c6ea9e
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/doc.go
@@ -0,0 +1,53 @@
+// Package gohcl allows decoding HCL configurations into Go data structures.
+//
+// It provides a convenient and concise way of describing the schema for
+// configuration and then accessing the resulting data via native Go
+// types.
+//
+// A struct field tag scheme is used, similar to other decoding and
+// unmarshalling libraries. The tags are formatted as in the following example:
+//
+//    ThingType string `hcl:"thing_type,attr"`
+//
+// Within each tag there are two comma-separated tokens. The first is the
+// name of the corresponding construct in configuration, while the second
+// is a keyword giving the kind of construct expected. The following
+// kind keywords are supported:
+//
+//    attr (the default) indicates that the value is to be populated from an attribute
+//    block indicates that the value is to populated from a block
+//    label indicates that the value is to populated from a block label
+//    remain indicates that the value is to be populated from the remaining body after populating other fields
+//
+// "attr" fields may either be of type *hcl.Expression, in which case the raw
+// expression is assigned, or of any type accepted by gocty, in which case
+// gocty will be used to assign the value to a native Go type.
+//
+// "block" fields may be of type *hcl.Block or hcl.Body, in which case the
+// corresponding raw value is assigned, or may be a struct that recursively
+// uses the same tags. Block fields may also be slices of any of these types,
+// in which case multiple blocks of the corresponding type are decoded into
+// the slice.
+//
+// "label" fields are considered only in a struct used as the type of a field
+// marked as "block", and are used sequentially to capture the labels of
+// the blocks being decoded. In this case, the name token is used only as
+// an identifier for the label in diagnostic messages.
+//
+// "remain" can be placed on a single field that may be either of type
+// hcl.Body or hcl.Attributes, in which case any remaining body content is
+// placed into this field for delayed processing. If no "remain" field is
+// present then any attributes or blocks not matched by another valid tag
+// will cause an error diagnostic.
+//
+// Only a subset of this tagging/typing vocabulary is supported for the
+// "Encode" family of functions. See the EncodeIntoBody docs for full details
+// on the constraints there.
+//
+// Broadly-speaking this package deals with two types of error. The first is
+// errors in the configuration itself, which are returned as diagnostics
+// written with the configuration author as the target audience. The second
+// is bugs in the calling program, such as invalid struct tags, which are
+// surfaced via panics since there can be no useful runtime handling of such
+// errors and they should certainly not be returned to the user as diagnostics.
+package gohcl
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/encode.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/encode.go
new file mode 100644
index 000000000..d612e09c9
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/encode.go
@@ -0,0 +1,191 @@
+package gohcl
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+
+	"github.com/hashicorp/hcl/v2/hclwrite"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// EncodeIntoBody replaces the contents of the given hclwrite Body with
+// attributes and blocks derived from the given value, which must be a
+// struct value or a pointer to a struct value with the struct tags defined
+// in this package.
+//
+// This function can work only with fully-decoded data. It will ignore any
+// fields tagged as "remain", any fields that decode attributes into either
+// hcl.Attribute or hcl.Expression values, and any fields that decode blocks
+// into hcl.Attributes values. This function does not have enough information
+// to complete the decoding of these types.
+//
+// Any fields tagged as "label" are ignored by this function. Use EncodeAsBlock
+// to produce a whole hclwrite.Block including block labels.
+//
+// As long as a suitable value is given to encode and the destination body
+// is non-nil, this function will always complete. It will panic in case of
+// any errors in the calling program, such as passing an inappropriate type
+// or a nil body.
+//
+// The layout of the resulting HCL source is derived from the ordering of
+// the struct fields, with blank lines around nested blocks of different types.
+// Fields representing attributes should usually precede those representing
+// blocks so that the attributes can group togather in the result. For more
+// control, use the hclwrite API directly.
+func EncodeIntoBody(val interface{}, dst *hclwrite.Body) {
+	rv := reflect.ValueOf(val)
+	ty := rv.Type()
+	if ty.Kind() == reflect.Ptr {
+		rv = rv.Elem()
+		ty = rv.Type()
+	}
+	if ty.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("value is %s, not struct", ty.Kind()))
+	}
+
+	tags := getFieldTags(ty)
+	populateBody(rv, ty, tags, dst)
+}
+
+// EncodeAsBlock creates a new hclwrite.Block populated with the data from
+// the given value, which must be a struct or pointer to struct with the
+// struct tags defined in this package.
+//
+// If the given struct type has fields tagged with "label" tags then they
+// will be used in order to annotate the created block with labels.
+//
+// This function has the same constraints as EncodeIntoBody and will panic
+// if they are violated.
+func EncodeAsBlock(val interface{}, blockType string) *hclwrite.Block {
+	rv := reflect.ValueOf(val)
+	ty := rv.Type()
+	if ty.Kind() == reflect.Ptr {
+		rv = rv.Elem()
+		ty = rv.Type()
+	}
+	if ty.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("value is %s, not struct", ty.Kind()))
+	}
+
+	tags := getFieldTags(ty)
+	labels := make([]string, len(tags.Labels))
+	for i, lf := range tags.Labels {
+		lv := rv.Field(lf.FieldIndex)
+		// We just stringify whatever we find. It should always be a string
+		// but if not then we'll still do something reasonable.
+		labels[i] = fmt.Sprintf("%s", lv.Interface())
+	}
+
+	block := hclwrite.NewBlock(blockType, labels)
+	populateBody(rv, ty, tags, block.Body())
+	return block
+}
+
+func populateBody(rv reflect.Value, ty reflect.Type, tags *fieldTags, dst *hclwrite.Body) {
+	nameIdxs := make(map[string]int, len(tags.Attributes)+len(tags.Blocks))
+	namesOrder := make([]string, 0, len(tags.Attributes)+len(tags.Blocks))
+	for n, i := range tags.Attributes {
+		nameIdxs[n] = i
+		namesOrder = append(namesOrder, n)
+	}
+	for n, i := range tags.Blocks {
+		nameIdxs[n] = i
+		namesOrder = append(namesOrder, n)
+	}
+	sort.SliceStable(namesOrder, func(i, j int) bool {
+		ni, nj := namesOrder[i], namesOrder[j]
+		return nameIdxs[ni] < nameIdxs[nj]
+	})
+
+	dst.Clear()
+
+	prevWasBlock := false
+	for _, name := range namesOrder {
+		fieldIdx := nameIdxs[name]
+		field := ty.Field(fieldIdx)
+		fieldTy := field.Type
+		fieldVal := rv.Field(fieldIdx)
+
+		if fieldTy.Kind() == reflect.Ptr {
+			fieldTy = fieldTy.Elem()
+			fieldVal = fieldVal.Elem()
+		}
+
+		if _, isAttr := tags.Attributes[name]; isAttr {
+
+			if exprType.AssignableTo(fieldTy) || attrType.AssignableTo(fieldTy) {
+				continue // ignore undecoded fields
+			}
+			if !fieldVal.IsValid() {
+				continue // ignore (field value is nil pointer)
+			}
+			if fieldTy.Kind() == reflect.Ptr && fieldVal.IsNil() {
+				continue // ignore
+			}
+			if prevWasBlock {
+				dst.AppendNewline()
+				prevWasBlock = false
+			}
+
+			valTy, err := gocty.ImpliedType(fieldVal.Interface())
+			if err != nil {
+				panic(fmt.Sprintf("cannot encode %T as HCL expression: %s", fieldVal.Interface(), err))
+			}
+
+			val, err := gocty.ToCtyValue(fieldVal.Interface(), valTy)
+			if err != nil {
+				// This should never happen, since we should always be able
+				// to decode into the implied type.
+				panic(fmt.Sprintf("failed to encode %T as %#v: %s", fieldVal.Interface(), valTy, err))
+			}
+
+			dst.SetAttributeValue(name, val)
+
+		} else { // must be a block, then
+			elemTy := fieldTy
+			isSeq := false
+			if elemTy.Kind() == reflect.Slice || elemTy.Kind() == reflect.Array {
+				isSeq = true
+				elemTy = elemTy.Elem()
+			}
+
+			if bodyType.AssignableTo(elemTy) || attrsType.AssignableTo(elemTy) {
+				continue // ignore undecoded fields
+			}
+			prevWasBlock = false
+
+			if isSeq {
+				l := fieldVal.Len()
+				for i := 0; i < l; i++ {
+					elemVal := fieldVal.Index(i)
+					if !elemVal.IsValid() {
+						continue // ignore (elem value is nil pointer)
+					}
+					if elemTy.Kind() == reflect.Ptr && elemVal.IsNil() {
+						continue // ignore
+					}
+					block := EncodeAsBlock(elemVal.Interface(), name)
+					if !prevWasBlock {
+						dst.AppendNewline()
+						prevWasBlock = true
+					}
+					dst.AppendBlock(block)
+				}
+			} else {
+				if !fieldVal.IsValid() {
+					continue // ignore (field value is nil pointer)
+				}
+				if elemTy.Kind() == reflect.Ptr && fieldVal.IsNil() {
+					continue // ignore
+				}
+				block := EncodeAsBlock(fieldVal.Interface(), name)
+				if !prevWasBlock {
+					dst.AppendNewline()
+					prevWasBlock = true
+				}
+				dst.AppendBlock(block)
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/schema.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/schema.go
new file mode 100644
index 000000000..ecf6ddbac
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/schema.go
@@ -0,0 +1,174 @@
+package gohcl
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// ImpliedBodySchema produces a hcl.BodySchema derived from the type of the
+// given value, which must be a struct value or a pointer to one. If an
+// inappropriate value is passed, this function will panic.
+//
+// The second return argument indicates whether the given struct includes
+// a "remain" field, and thus the returned schema is non-exhaustive.
+//
+// This uses the tags on the fields of the struct to discover how each
+// field's value should be expressed within configuration. If an invalid
+// mapping is attempted, this function will panic.
+func ImpliedBodySchema(val interface{}) (schema *hcl.BodySchema, partial bool) {
+	ty := reflect.TypeOf(val)
+
+	if ty.Kind() == reflect.Ptr {
+		ty = ty.Elem()
+	}
+
+	if ty.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("given value must be struct, not %T", val))
+	}
+
+	var attrSchemas []hcl.AttributeSchema
+	var blockSchemas []hcl.BlockHeaderSchema
+
+	tags := getFieldTags(ty)
+
+	attrNames := make([]string, 0, len(tags.Attributes))
+	for n := range tags.Attributes {
+		attrNames = append(attrNames, n)
+	}
+	sort.Strings(attrNames)
+	for _, n := range attrNames {
+		idx := tags.Attributes[n]
+		optional := tags.Optional[n]
+		field := ty.Field(idx)
+
+		var required bool
+
+		switch {
+		case field.Type.AssignableTo(exprType):
+			// If we're decoding to hcl.Expression then absense can be
+			// indicated via a null value, so we don't specify that
+			// the field is required during decoding.
+			required = false
+		case field.Type.Kind() != reflect.Ptr && !optional:
+			required = true
+		default:
+			required = false
+		}
+
+		attrSchemas = append(attrSchemas, hcl.AttributeSchema{
+			Name:     n,
+			Required: required,
+		})
+	}
+
+	blockNames := make([]string, 0, len(tags.Blocks))
+	for n := range tags.Blocks {
+		blockNames = append(blockNames, n)
+	}
+	sort.Strings(blockNames)
+	for _, n := range blockNames {
+		idx := tags.Blocks[n]
+		field := ty.Field(idx)
+		fty := field.Type
+		if fty.Kind() == reflect.Slice {
+			fty = fty.Elem()
+		}
+		if fty.Kind() == reflect.Ptr {
+			fty = fty.Elem()
+		}
+		if fty.Kind() != reflect.Struct {
+			panic(fmt.Sprintf(
+				"hcl 'block' tag kind cannot be applied to %s field %s: struct required", field.Type.String(), field.Name,
+			))
+		}
+		ftags := getFieldTags(fty)
+		var labelNames []string
+		if len(ftags.Labels) > 0 {
+			labelNames = make([]string, len(ftags.Labels))
+			for i, l := range ftags.Labels {
+				labelNames[i] = l.Name
+			}
+		}
+
+		blockSchemas = append(blockSchemas, hcl.BlockHeaderSchema{
+			Type:       n,
+			LabelNames: labelNames,
+		})
+	}
+
+	partial = tags.Remain != nil
+	schema = &hcl.BodySchema{
+		Attributes: attrSchemas,
+		Blocks:     blockSchemas,
+	}
+	return schema, partial
+}
+
+type fieldTags struct {
+	Attributes map[string]int
+	Blocks     map[string]int
+	Labels     []labelField
+	Remain     *int
+	Optional   map[string]bool
+}
+
+type labelField struct {
+	FieldIndex int
+	Name       string
+}
+
+func getFieldTags(ty reflect.Type) *fieldTags {
+	ret := &fieldTags{
+		Attributes: map[string]int{},
+		Blocks:     map[string]int{},
+		Optional:   map[string]bool{},
+	}
+
+	ct := ty.NumField()
+	for i := 0; i < ct; i++ {
+		field := ty.Field(i)
+		tag := field.Tag.Get("hcl")
+		if tag == "" {
+			continue
+		}
+
+		comma := strings.Index(tag, ",")
+		var name, kind string
+		if comma != -1 {
+			name = tag[:comma]
+			kind = tag[comma+1:]
+		} else {
+			name = tag
+			kind = "attr"
+		}
+
+		switch kind {
+		case "attr":
+			ret.Attributes[name] = i
+		case "block":
+			ret.Blocks[name] = i
+		case "label":
+			ret.Labels = append(ret.Labels, labelField{
+				FieldIndex: i,
+				Name:       name,
+			})
+		case "remain":
+			if ret.Remain != nil {
+				panic("only one 'remain' tag is permitted")
+			}
+			idx := i // copy, because this loop will continue assigning to i
+			ret.Remain = &idx
+		case "optional":
+			ret.Attributes[name] = i
+			ret.Optional[name] = true
+		default:
+			panic(fmt.Sprintf("invalid hcl field tag kind %q on %s %q", kind, field.Type.String(), field.Name))
+		}
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/gohcl/types.go b/vendor/github.com/hashicorp/hcl/v2/gohcl/types.go
new file mode 100644
index 000000000..a8d00f8ff
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/gohcl/types.go
@@ -0,0 +1,16 @@
+package gohcl
+
+import (
+	"reflect"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+var victimExpr hcl.Expression
+var victimBody hcl.Body
+
+var exprType = reflect.TypeOf(&victimExpr).Elem()
+var bodyType = reflect.TypeOf(&victimBody).Elem()
+var blockType = reflect.TypeOf((*hcl.Block)(nil))
+var attrType = reflect.TypeOf((*hcl.Attribute)(nil))
+var attrsType = reflect.TypeOf(hcl.Attributes(nil))
diff --git a/vendor/github.com/hashicorp/hcl/v2/hcldec/block_labels.go b/vendor/github.com/hashicorp/hcl/v2/hcldec/block_labels.go
new file mode 100644
index 000000000..71de45193
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hcldec/block_labels.go
@@ -0,0 +1,21 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+type blockLabel struct {
+	Value string
+	Range hcl.Range
+}
+
+func labelsForBlock(block *hcl.Block) []blockLabel {
+	ret := make([]blockLabel, len(block.Labels))
+	for i := range block.Labels {
+		ret[i] = blockLabel{
+			Value: block.Labels[i],
+			Range: block.LabelRanges[i],
+		}
+	}
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hcldec/decode.go b/vendor/github.com/hashicorp/hcl/v2/hcldec/decode.go
new file mode 100644
index 000000000..c6e42236d
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hcldec/decode.go
@@ -0,0 +1,36 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+func decode(body hcl.Body, blockLabels []blockLabel, ctx *hcl.EvalContext, spec Spec, partial bool) (cty.Value, hcl.Body, hcl.Diagnostics) {
+	schema := ImpliedSchema(spec)
+
+	var content *hcl.BodyContent
+	var diags hcl.Diagnostics
+	var leftovers hcl.Body
+
+	if partial {
+		content, leftovers, diags = body.PartialContent(schema)
+	} else {
+		content, diags = body.Content(schema)
+	}
+
+	val, valDiags := spec.decode(content, blockLabels, ctx)
+	diags = append(diags, valDiags...)
+
+	return val, leftovers, diags
+}
+
+func impliedType(spec Spec) cty.Type {
+	return spec.impliedType()
+}
+
+func sourceRange(body hcl.Body, blockLabels []blockLabel, spec Spec) hcl.Range {
+	schema := ImpliedSchema(spec)
+	content, _, _ := body.PartialContent(schema)
+
+	return spec.sourceRange(content, blockLabels)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hcldec/doc.go b/vendor/github.com/hashicorp/hcl/v2/hcldec/doc.go
new file mode 100644
index 000000000..23bfe542b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hcldec/doc.go
@@ -0,0 +1,12 @@
+// Package hcldec provides a higher-level API for unpacking the content of
+// HCL bodies, implemented in terms of the low-level "Content" API exposed
+// by the bodies themselves.
+//
+// It allows decoding an entire nested configuration in a single operation
+// by providing a description of the intended structure.
+//
+// For some applications it may be more convenient to use the "gohcl"
+// package, which has a similar purpose but decodes directly into native
+// Go data types. hcldec instead targets the cty type system, and thus allows
+// a cty-driven application to remain within that type system.
+package hcldec
diff --git a/vendor/github.com/hashicorp/hcl/v2/hcldec/gob.go b/vendor/github.com/hashicorp/hcl/v2/hcldec/gob.go
new file mode 100644
index 000000000..e2027cfd2
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hcldec/gob.go
@@ -0,0 +1,23 @@
+package hcldec
+
+import (
+	"encoding/gob"
+)
+
+func init() {
+	// Every Spec implementation should be registered with gob, so that
+	// specs can be sent over gob channels, such as using
+	// github.com/hashicorp/go-plugin with plugins that need to describe
+	// what shape of configuration they are expecting.
+	gob.Register(ObjectSpec(nil))
+	gob.Register(TupleSpec(nil))
+	gob.Register((*AttrSpec)(nil))
+	gob.Register((*LiteralSpec)(nil))
+	gob.Register((*ExprSpec)(nil))
+	gob.Register((*BlockSpec)(nil))
+	gob.Register((*BlockListSpec)(nil))
+	gob.Register((*BlockSetSpec)(nil))
+	gob.Register((*BlockMapSpec)(nil))
+	gob.Register((*BlockLabelSpec)(nil))
+	gob.Register((*DefaultSpec)(nil))
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hcldec/public.go b/vendor/github.com/hashicorp/hcl/v2/hcldec/public.go
new file mode 100644
index 000000000..1fa548d0c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hcldec/public.go
@@ -0,0 +1,81 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Decode interprets the given body using the given specification and returns
+// the resulting value. If the given body is not valid per the spec, error
+// diagnostics are returned and the returned value is likely to be incomplete.
+//
+// The ctx argument may be nil, in which case any references to variables or
+// functions will produce error diagnostics.
+func Decode(body hcl.Body, spec Spec, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	val, _, diags := decode(body, nil, ctx, spec, false)
+	return val, diags
+}
+
+// PartialDecode is like Decode except that it permits "leftover" items in
+// the top-level body, which are returned as a new body to allow for
+// further processing.
+//
+// Any descendent block bodies are _not_ decoded partially and thus must
+// be fully described by the given specification.
+func PartialDecode(body hcl.Body, spec Spec, ctx *hcl.EvalContext) (cty.Value, hcl.Body, hcl.Diagnostics) {
+	return decode(body, nil, ctx, spec, true)
+}
+
+// ImpliedType returns the value type that should result from decoding the
+// given spec.
+func ImpliedType(spec Spec) cty.Type {
+	return impliedType(spec)
+}
+
+// SourceRange interprets the given body using the given specification and
+// then returns the source range of the value that would be used to
+// fulfill the spec.
+//
+// This can be used if application-level validation detects value errors, to
+// obtain a reasonable SourceRange to use for generated diagnostics. It works
+// best when applied to specific body items (e.g. using AttrSpec, BlockSpec, ...)
+// as opposed to entire bodies using ObjectSpec, TupleSpec. The result will
+// be less useful the broader the specification, so e.g. a spec that returns
+// the entirety of all of the blocks of a given type is likely to be
+// _particularly_ arbitrary and useless.
+//
+// If the given body is not valid per the given spec, the result is best-effort
+// and may not actually be something ideal. It's expected that an application
+// will already have used Decode or PartialDecode earlier and thus had an
+// opportunity to detect and report spec violations.
+func SourceRange(body hcl.Body, spec Spec) hcl.Range {
+	return sourceRange(body, nil, spec)
+}
+
+// ChildBlockTypes returns a map of all of the child block types declared
+// by the given spec, with block type names as keys and the associated
+// nested body specs as values.
+func ChildBlockTypes(spec Spec) map[string]Spec {
+	ret := map[string]Spec{}
+
+	// visitSameBodyChildren walks through the spec structure, calling
+	// the given callback for each descendent spec encountered. We are
+	// interested in the specs that reference attributes and blocks.
+	var visit visitFunc
+	visit = func(s Spec) {
+		if bs, ok := s.(blockSpec); ok {
+			for _, blockS := range bs.blockHeaderSchemata() {
+				nested := bs.nestedSpec()
+				if nested != nil { // nil can be returned to dynamically opt out of this interface
+					ret[blockS.Type] = nested
+				}
+			}
+		}
+
+		s.visitSameBodyChildren(visit)
+	}
+
+	visit(spec)
+
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hcldec/schema.go b/vendor/github.com/hashicorp/hcl/v2/hcldec/schema.go
new file mode 100644
index 000000000..ddbe7fa4a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hcldec/schema.go
@@ -0,0 +1,36 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// ImpliedSchema returns the *hcl.BodySchema implied by the given specification.
+// This is the schema that the Decode function will use internally to
+// access the content of a given body.
+func ImpliedSchema(spec Spec) *hcl.BodySchema {
+	var attrs []hcl.AttributeSchema
+	var blocks []hcl.BlockHeaderSchema
+
+	// visitSameBodyChildren walks through the spec structure, calling
+	// the given callback for each descendent spec encountered. We are
+	// interested in the specs that reference attributes and blocks.
+	var visit visitFunc
+	visit = func(s Spec) {
+		if as, ok := s.(attrSpec); ok {
+			attrs = append(attrs, as.attrSchemata()...)
+		}
+
+		if bs, ok := s.(blockSpec); ok {
+			blocks = append(blocks, bs.blockHeaderSchemata()...)
+		}
+
+		s.visitSameBodyChildren(visit)
+	}
+
+	visit(spec)
+
+	return &hcl.BodySchema{
+		Attributes: attrs,
+		Blocks:     blocks,
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hcldec/spec.go b/vendor/github.com/hashicorp/hcl/v2/hcldec/spec.go
new file mode 100644
index 000000000..6f2d9732c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hcldec/spec.go
@@ -0,0 +1,1567 @@
+package hcldec
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+// A Spec is a description of how to decode a hcl.Body to a cty.Value.
+//
+// The various other types in this package whose names end in "Spec" are
+// the spec implementations. The most common top-level spec is ObjectSpec,
+// which decodes body content into a cty.Value of an object type.
+type Spec interface {
+	// Perform the decode operation on the given body, in the context of
+	// the given block (which might be null), using the given eval context.
+	//
+	// "block" is provided only by the nested calls performed by the spec
+	// types that work on block bodies.
+	decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics)
+
+	// Return the cty.Type that should be returned when decoding a body with
+	// this spec.
+	impliedType() cty.Type
+
+	// Call the given callback once for each of the nested specs that would
+	// get decoded with the same body and block as the receiver. This should
+	// not descend into the nested specs used when decoding blocks.
+	visitSameBodyChildren(cb visitFunc)
+
+	// Determine the source range of the value that would be returned for the
+	// spec in the given content, in the context of the given block
+	// (which might be null). If the corresponding item is missing, return
+	// a place where it might be inserted.
+	sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range
+}
+
+type visitFunc func(spec Spec)
+
+// An ObjectSpec is a Spec that produces a cty.Value of an object type whose
+// attributes correspond to the keys of the spec map.
+type ObjectSpec map[string]Spec
+
+// attrSpec is implemented by specs that require attributes from the body.
+type attrSpec interface {
+	attrSchemata() []hcl.AttributeSchema
+}
+
+// blockSpec is implemented by specs that require blocks from the body.
+type blockSpec interface {
+	blockHeaderSchemata() []hcl.BlockHeaderSchema
+	nestedSpec() Spec
+}
+
+// specNeedingVariables is implemented by specs that can use variables
+// from the EvalContext, to declare which variables they need.
+type specNeedingVariables interface {
+	variablesNeeded(content *hcl.BodyContent) []hcl.Traversal
+}
+
+func (s ObjectSpec) visitSameBodyChildren(cb visitFunc) {
+	for _, c := range s {
+		cb(c)
+	}
+}
+
+func (s ObjectSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	vals := make(map[string]cty.Value, len(s))
+	var diags hcl.Diagnostics
+
+	for k, spec := range s {
+		var kd hcl.Diagnostics
+		vals[k], kd = spec.decode(content, blockLabels, ctx)
+		diags = append(diags, kd...)
+	}
+
+	return cty.ObjectVal(vals), diags
+}
+
+func (s ObjectSpec) impliedType() cty.Type {
+	if len(s) == 0 {
+		return cty.EmptyObject
+	}
+
+	attrTypes := make(map[string]cty.Type)
+	for k, childSpec := range s {
+		attrTypes[k] = childSpec.impliedType()
+	}
+	return cty.Object(attrTypes)
+}
+
+func (s ObjectSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// This is not great, but the best we can do. In practice, it's rather
+	// strange to ask for the source range of an entire top-level body, since
+	// that's already readily available to the caller.
+	return content.MissingItemRange
+}
+
+// A TupleSpec is a Spec that produces a cty.Value of a tuple type whose
+// elements correspond to the elements of the spec slice.
+type TupleSpec []Spec
+
+func (s TupleSpec) visitSameBodyChildren(cb visitFunc) {
+	for _, c := range s {
+		cb(c)
+	}
+}
+
+func (s TupleSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	vals := make([]cty.Value, len(s))
+	var diags hcl.Diagnostics
+
+	for i, spec := range s {
+		var ed hcl.Diagnostics
+		vals[i], ed = spec.decode(content, blockLabels, ctx)
+		diags = append(diags, ed...)
+	}
+
+	return cty.TupleVal(vals), diags
+}
+
+func (s TupleSpec) impliedType() cty.Type {
+	if len(s) == 0 {
+		return cty.EmptyTuple
+	}
+
+	attrTypes := make([]cty.Type, len(s))
+	for i, childSpec := range s {
+		attrTypes[i] = childSpec.impliedType()
+	}
+	return cty.Tuple(attrTypes)
+}
+
+func (s TupleSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// This is not great, but the best we can do. In practice, it's rather
+	// strange to ask for the source range of an entire top-level body, since
+	// that's already readily available to the caller.
+	return content.MissingItemRange
+}
+
+// An AttrSpec is a Spec that evaluates a particular attribute expression in
+// the body and returns its resulting value converted to the requested type,
+// or produces a diagnostic if the type is incorrect.
+type AttrSpec struct {
+	Name     string
+	Type     cty.Type
+	Required bool
+}
+
+func (s *AttrSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node
+}
+
+// specNeedingVariables implementation
+func (s *AttrSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	attr, exists := content.Attributes[s.Name]
+	if !exists {
+		return nil
+	}
+
+	return attr.Expr.Variables()
+}
+
+// attrSpec implementation
+func (s *AttrSpec) attrSchemata() []hcl.AttributeSchema {
+	return []hcl.AttributeSchema{
+		{
+			Name:     s.Name,
+			Required: s.Required,
+		},
+	}
+}
+
+func (s *AttrSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	attr, exists := content.Attributes[s.Name]
+	if !exists {
+		return content.MissingItemRange
+	}
+
+	return attr.Expr.Range()
+}
+
+func (s *AttrSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	attr, exists := content.Attributes[s.Name]
+	if !exists {
+		// We don't need to check required and emit a diagnostic here, because
+		// that would already have happened when building "content".
+		return cty.NullVal(s.Type), nil
+	}
+
+	val, diags := attr.Expr.Value(ctx)
+
+	convVal, err := convert.Convert(val, s.Type)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Incorrect attribute value type",
+			Detail: fmt.Sprintf(
+				"Inappropriate value for attribute %q: %s.",
+				s.Name, err.Error(),
+			),
+			Subject: attr.Expr.StartRange().Ptr(),
+			Context: hcl.RangeBetween(attr.NameRange, attr.Expr.StartRange()).Ptr(),
+		})
+		// We'll return an unknown value of the _correct_ type so that the
+		// incomplete result can still be used for some analysis use-cases.
+		val = cty.UnknownVal(s.Type)
+	} else {
+		val = convVal
+	}
+
+	return val, diags
+}
+
+func (s *AttrSpec) impliedType() cty.Type {
+	return s.Type
+}
+
+// A LiteralSpec is a Spec that produces the given literal value, ignoring
+// the given body.
+type LiteralSpec struct {
+	Value cty.Value
+}
+
+func (s *LiteralSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node
+}
+
+func (s *LiteralSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return s.Value, nil
+}
+
+func (s *LiteralSpec) impliedType() cty.Type {
+	return s.Value.Type()
+}
+
+func (s *LiteralSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// No sensible range to return for a literal, so the caller had better
+	// ensure it doesn't cause any diagnostics.
+	return hcl.Range{
+		Filename: "<unknown>",
+	}
+}
+
+// An ExprSpec is a Spec that evaluates the given expression, ignoring the
+// given body.
+type ExprSpec struct {
+	Expr hcl.Expression
+}
+
+func (s *ExprSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node
+}
+
+// specNeedingVariables implementation
+func (s *ExprSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	return s.Expr.Variables()
+}
+
+func (s *ExprSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return s.Expr.Value(ctx)
+}
+
+func (s *ExprSpec) impliedType() cty.Type {
+	// We can't know the type of our expression until we evaluate it
+	return cty.DynamicPseudoType
+}
+
+func (s *ExprSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	return s.Expr.Range()
+}
+
+// A BlockSpec is a Spec that produces a cty.Value by decoding the contents
+// of a single nested block of a given type, using a nested spec.
+//
+// If the Required flag is not set, the nested block may be omitted, in which
+// case a null value is produced. If it _is_ set, an error diagnostic is
+// produced if there are no nested blocks of the given type.
+type BlockSpec struct {
+	TypeName string
+	Nested   Spec
+	Required bool
+}
+
+func (s *BlockSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: findLabelSpecs(s.Nested),
+		},
+	}
+}
+
+// blockSpec implementation
+func (s *BlockSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
+// specNeedingVariables implementation
+func (s *BlockSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return nil
+	}
+
+	return Variables(childBlock.Body, s.Nested)
+}
+
+func (s *BlockSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		if childBlock != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", s.TypeName),
+				Detail: fmt.Sprintf(
+					"Only one block of type %q is allowed. Previous definition was at %s.",
+					s.TypeName, childBlock.DefRange.String(),
+				),
+				Subject: &candidate.DefRange,
+			})
+			break
+		}
+
+		childBlock = candidate
+	}
+
+	if childBlock == nil {
+		if s.Required {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Missing %s block", s.TypeName),
+				Detail: fmt.Sprintf(
+					"A block of type %q is required here.", s.TypeName,
+				),
+				Subject: &content.MissingItemRange,
+			})
+		}
+		return cty.NullVal(s.Nested.impliedType()), diags
+	}
+
+	if s.Nested == nil {
+		panic("BlockSpec with no Nested Spec")
+	}
+	val, _, childDiags := decode(childBlock.Body, labelsForBlock(childBlock), ctx, s.Nested, false)
+	diags = append(diags, childDiags...)
+	return val, diags
+}
+
+func (s *BlockSpec) impliedType() cty.Type {
+	return s.Nested.impliedType()
+}
+
+func (s *BlockSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockListSpec is a Spec that produces a cty list of the results of
+// decoding all of the nested blocks of a given type, using a nested spec.
+type BlockListSpec struct {
+	TypeName string
+	Nested   Spec
+	MinItems int
+	MaxItems int
+}
+
+func (s *BlockListSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockListSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: findLabelSpecs(s.Nested),
+		},
+	}
+}
+
+// blockSpec implementation
+func (s *BlockListSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
+// specNeedingVariables implementation
+func (s *BlockListSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
+func (s *BlockListSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockListSpec with no Nested Spec")
+	}
+
+	var elems []cty.Value
+	var sourceRanges []hcl.Range
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		val, _, childDiags := decode(childBlock.Body, labelsForBlock(childBlock), ctx, s.Nested, false)
+		diags = append(diags, childDiags...)
+		elems = append(elems, val)
+		sourceRanges = append(sourceRanges, sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested))
+	}
+
+	if len(elems) < s.MinItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Insufficient %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("At least %d %q blocks are required.", s.MinItems, s.TypeName),
+			Subject:  &content.MissingItemRange,
+		})
+	} else if s.MaxItems > 0 && len(elems) > s.MaxItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Too many %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("No more than %d %q blocks are allowed", s.MaxItems, s.TypeName),
+			Subject:  &sourceRanges[s.MaxItems],
+		})
+	}
+
+	var ret cty.Value
+
+	if len(elems) == 0 {
+		ret = cty.ListValEmpty(s.Nested.impliedType())
+	} else {
+		// Since our target is a list, all of the decoded elements must have the
+		// same type or cty.ListVal will panic below. Different types can arise
+		// if there is an attribute spec of type cty.DynamicPseudoType in the
+		// nested spec; all given values must be convertable to a single type
+		// in order for the result to be considered valid.
+		etys := make([]cty.Type, len(elems))
+		for i, v := range elems {
+			etys[i] = v.Type()
+		}
+		ety, convs := convert.UnifyUnsafe(etys)
+		if ety == cty.NilType {
+			// FIXME: This is a pretty terrible error message.
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Unconsistent argument types in %s blocks", s.TypeName),
+				Detail:   "Corresponding attributes in all blocks of this type must be the same.",
+				Subject:  &sourceRanges[0],
+			})
+			return cty.DynamicVal, diags
+		}
+		for i, v := range elems {
+			if convs[i] != nil {
+				newV, err := convs[i](v)
+				if err != nil {
+					// FIXME: This is a pretty terrible error message.
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  fmt.Sprintf("Unconsistent argument types in %s blocks", s.TypeName),
+						Detail:   fmt.Sprintf("Block with index %d has inconsistent argument types: %s.", i, err),
+						Subject:  &sourceRanges[i],
+					})
+					// Bail early here so we won't panic below in cty.ListVal
+					return cty.DynamicVal, diags
+				}
+				elems[i] = newV
+			}
+		}
+
+		ret = cty.ListVal(elems)
+	}
+
+	return ret, diags
+}
+
+func (s *BlockListSpec) impliedType() cty.Type {
+	return cty.List(s.Nested.impliedType())
+}
+
+func (s *BlockListSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We return the source range of the _first_ block of the given type,
+	// since they are not guaranteed to form a contiguous range.
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockTupleSpec is a Spec that produces a cty tuple of the results of
+// decoding all of the nested blocks of a given type, using a nested spec.
+//
+// This is similar to BlockListSpec, but it permits the nested blocks to have
+// different result types in situations where cty.DynamicPseudoType attributes
+// are present.
+type BlockTupleSpec struct {
+	TypeName string
+	Nested   Spec
+	MinItems int
+	MaxItems int
+}
+
+func (s *BlockTupleSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockTupleSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: findLabelSpecs(s.Nested),
+		},
+	}
+}
+
+// blockSpec implementation
+func (s *BlockTupleSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
+// specNeedingVariables implementation
+func (s *BlockTupleSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
+func (s *BlockTupleSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockListSpec with no Nested Spec")
+	}
+
+	var elems []cty.Value
+	var sourceRanges []hcl.Range
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		val, _, childDiags := decode(childBlock.Body, labelsForBlock(childBlock), ctx, s.Nested, false)
+		diags = append(diags, childDiags...)
+		elems = append(elems, val)
+		sourceRanges = append(sourceRanges, sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested))
+	}
+
+	if len(elems) < s.MinItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Insufficient %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("At least %d %q blocks are required.", s.MinItems, s.TypeName),
+			Subject:  &content.MissingItemRange,
+		})
+	} else if s.MaxItems > 0 && len(elems) > s.MaxItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Too many %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("No more than %d %q blocks are allowed", s.MaxItems, s.TypeName),
+			Subject:  &sourceRanges[s.MaxItems],
+		})
+	}
+
+	var ret cty.Value
+
+	if len(elems) == 0 {
+		ret = cty.EmptyTupleVal
+	} else {
+		ret = cty.TupleVal(elems)
+	}
+
+	return ret, diags
+}
+
+func (s *BlockTupleSpec) impliedType() cty.Type {
+	// We can't predict our type, because we don't know how many blocks
+	// there will be until we decode.
+	return cty.DynamicPseudoType
+}
+
+func (s *BlockTupleSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We return the source range of the _first_ block of the given type,
+	// since they are not guaranteed to form a contiguous range.
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockSetSpec is a Spec that produces a cty set of the results of
+// decoding all of the nested blocks of a given type, using a nested spec.
+type BlockSetSpec struct {
+	TypeName string
+	Nested   Spec
+	MinItems int
+	MaxItems int
+}
+
+func (s *BlockSetSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockSetSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: findLabelSpecs(s.Nested),
+		},
+	}
+}
+
+// blockSpec implementation
+func (s *BlockSetSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
+// specNeedingVariables implementation
+func (s *BlockSetSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
+func (s *BlockSetSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockSetSpec with no Nested Spec")
+	}
+
+	var elems []cty.Value
+	var sourceRanges []hcl.Range
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		val, _, childDiags := decode(childBlock.Body, labelsForBlock(childBlock), ctx, s.Nested, false)
+		diags = append(diags, childDiags...)
+		elems = append(elems, val)
+		sourceRanges = append(sourceRanges, sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested))
+	}
+
+	if len(elems) < s.MinItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Insufficient %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("At least %d %q blocks are required.", s.MinItems, s.TypeName),
+			Subject:  &content.MissingItemRange,
+		})
+	} else if s.MaxItems > 0 && len(elems) > s.MaxItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Too many %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("No more than %d %q blocks are allowed", s.MaxItems, s.TypeName),
+			Subject:  &sourceRanges[s.MaxItems],
+		})
+	}
+
+	var ret cty.Value
+
+	if len(elems) == 0 {
+		ret = cty.SetValEmpty(s.Nested.impliedType())
+	} else {
+		// Since our target is a set, all of the decoded elements must have the
+		// same type or cty.SetVal will panic below. Different types can arise
+		// if there is an attribute spec of type cty.DynamicPseudoType in the
+		// nested spec; all given values must be convertable to a single type
+		// in order for the result to be considered valid.
+		etys := make([]cty.Type, len(elems))
+		for i, v := range elems {
+			etys[i] = v.Type()
+		}
+		ety, convs := convert.UnifyUnsafe(etys)
+		if ety == cty.NilType {
+			// FIXME: This is a pretty terrible error message.
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Unconsistent argument types in %s blocks", s.TypeName),
+				Detail:   "Corresponding attributes in all blocks of this type must be the same.",
+				Subject:  &sourceRanges[0],
+			})
+			return cty.DynamicVal, diags
+		}
+		for i, v := range elems {
+			if convs[i] != nil {
+				newV, err := convs[i](v)
+				if err != nil {
+					// FIXME: This is a pretty terrible error message.
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  fmt.Sprintf("Unconsistent argument types in %s blocks", s.TypeName),
+						Detail:   fmt.Sprintf("Block with index %d has inconsistent argument types: %s.", i, err),
+						Subject:  &sourceRanges[i],
+					})
+					// Bail early here so we won't panic below in cty.ListVal
+					return cty.DynamicVal, diags
+				}
+				elems[i] = newV
+			}
+		}
+
+		ret = cty.SetVal(elems)
+	}
+
+	return ret, diags
+}
+
+func (s *BlockSetSpec) impliedType() cty.Type {
+	return cty.Set(s.Nested.impliedType())
+}
+
+func (s *BlockSetSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We return the source range of the _first_ block of the given type,
+	// since they are not guaranteed to form a contiguous range.
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockMapSpec is a Spec that produces a cty map of the results of
+// decoding all of the nested blocks of a given type, using a nested spec.
+//
+// One level of map structure is created for each of the given label names.
+// There must be at least one given label name.
+type BlockMapSpec struct {
+	TypeName   string
+	LabelNames []string
+	Nested     Spec
+}
+
+func (s *BlockMapSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockMapSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: append(s.LabelNames, findLabelSpecs(s.Nested)...),
+		},
+	}
+}
+
+// blockSpec implementation
+func (s *BlockMapSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
+// specNeedingVariables implementation
+func (s *BlockMapSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
+func (s *BlockMapSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockMapSpec with no Nested Spec")
+	}
+	if ImpliedType(s).HasDynamicTypes() {
+		panic("cty.DynamicPseudoType attributes may not be used inside a BlockMapSpec")
+	}
+
+	elems := map[string]interface{}{}
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		childLabels := labelsForBlock(childBlock)
+		val, _, childDiags := decode(childBlock.Body, childLabels[len(s.LabelNames):], ctx, s.Nested, false)
+		targetMap := elems
+		for _, key := range childBlock.Labels[:len(s.LabelNames)-1] {
+			if _, exists := targetMap[key]; !exists {
+				targetMap[key] = make(map[string]interface{})
+			}
+			targetMap = targetMap[key].(map[string]interface{})
+		}
+
+		diags = append(diags, childDiags...)
+
+		key := childBlock.Labels[len(s.LabelNames)-1]
+		if _, exists := targetMap[key]; exists {
+			labelsBuf := bytes.Buffer{}
+			for _, label := range childBlock.Labels {
+				fmt.Fprintf(&labelsBuf, " %q", label)
+			}
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", s.TypeName),
+				Detail: fmt.Sprintf(
+					"A block for %s%s was already defined. The %s labels must be unique.",
+					s.TypeName, labelsBuf.String(), s.TypeName,
+				),
+				Subject: &childBlock.DefRange,
+			})
+			continue
+		}
+
+		targetMap[key] = val
+	}
+
+	if len(elems) == 0 {
+		return cty.MapValEmpty(s.Nested.impliedType()), diags
+	}
+
+	var ctyMap func(map[string]interface{}, int) cty.Value
+	ctyMap = func(raw map[string]interface{}, depth int) cty.Value {
+		vals := make(map[string]cty.Value, len(raw))
+		if depth == 1 {
+			for k, v := range raw {
+				vals[k] = v.(cty.Value)
+			}
+		} else {
+			for k, v := range raw {
+				vals[k] = ctyMap(v.(map[string]interface{}), depth-1)
+			}
+		}
+		return cty.MapVal(vals)
+	}
+
+	return ctyMap(elems, len(s.LabelNames)), diags
+}
+
+func (s *BlockMapSpec) impliedType() cty.Type {
+	ret := s.Nested.impliedType()
+	for _ = range s.LabelNames {
+		ret = cty.Map(ret)
+	}
+	return ret
+}
+
+func (s *BlockMapSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We return the source range of the _first_ block of the given type,
+	// since they are not guaranteed to form a contiguous range.
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockObjectSpec is a Spec that produces a cty object of the results of
+// decoding all of the nested blocks of a given type, using a nested spec.
+//
+// One level of object structure is created for each of the given label names.
+// There must be at least one given label name.
+//
+// This is similar to BlockMapSpec, but it permits the nested blocks to have
+// different result types in situations where cty.DynamicPseudoType attributes
+// are present.
+type BlockObjectSpec struct {
+	TypeName   string
+	LabelNames []string
+	Nested     Spec
+}
+
+func (s *BlockObjectSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockObjectSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: append(s.LabelNames, findLabelSpecs(s.Nested)...),
+		},
+	}
+}
+
+// blockSpec implementation
+func (s *BlockObjectSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
+// specNeedingVariables implementation
+func (s *BlockObjectSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
+func (s *BlockObjectSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockObjectSpec with no Nested Spec")
+	}
+
+	elems := map[string]interface{}{}
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		childLabels := labelsForBlock(childBlock)
+		val, _, childDiags := decode(childBlock.Body, childLabels[len(s.LabelNames):], ctx, s.Nested, false)
+		targetMap := elems
+		for _, key := range childBlock.Labels[:len(s.LabelNames)-1] {
+			if _, exists := targetMap[key]; !exists {
+				targetMap[key] = make(map[string]interface{})
+			}
+			targetMap = targetMap[key].(map[string]interface{})
+		}
+
+		diags = append(diags, childDiags...)
+
+		key := childBlock.Labels[len(s.LabelNames)-1]
+		if _, exists := targetMap[key]; exists {
+			labelsBuf := bytes.Buffer{}
+			for _, label := range childBlock.Labels {
+				fmt.Fprintf(&labelsBuf, " %q", label)
+			}
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", s.TypeName),
+				Detail: fmt.Sprintf(
+					"A block for %s%s was already defined. The %s labels must be unique.",
+					s.TypeName, labelsBuf.String(), s.TypeName,
+				),
+				Subject: &childBlock.DefRange,
+			})
+			continue
+		}
+
+		targetMap[key] = val
+	}
+
+	if len(elems) == 0 {
+		return cty.EmptyObjectVal, diags
+	}
+
+	var ctyObj func(map[string]interface{}, int) cty.Value
+	ctyObj = func(raw map[string]interface{}, depth int) cty.Value {
+		vals := make(map[string]cty.Value, len(raw))
+		if depth == 1 {
+			for k, v := range raw {
+				vals[k] = v.(cty.Value)
+			}
+		} else {
+			for k, v := range raw {
+				vals[k] = ctyObj(v.(map[string]interface{}), depth-1)
+			}
+		}
+		return cty.ObjectVal(vals)
+	}
+
+	return ctyObj(elems, len(s.LabelNames)), diags
+}
+
+func (s *BlockObjectSpec) impliedType() cty.Type {
+	// We can't predict our type, since we don't know how many blocks are
+	// present and what labels they have until we decode.
+	return cty.DynamicPseudoType
+}
+
+func (s *BlockObjectSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We return the source range of the _first_ block of the given type,
+	// since they are not guaranteed to form a contiguous range.
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockAttrsSpec is a Spec that interprets a single block as if it were
+// a map of some element type. That is, each attribute within the block
+// becomes a key in the resulting map and the attribute's value becomes the
+// element value, after conversion to the given element type. The resulting
+// value is a cty.Map of the given element type.
+//
+// This spec imposes a validation constraint that there be exactly one block
+// of the given type name and that this block may contain only attributes. The
+// block does not accept any labels.
+//
+// This is an alternative to an AttrSpec of a map type for situations where
+// block syntax is desired. Note that block syntax does not permit dynamic
+// keys, construction of the result via a "for" expression, etc. In most cases
+// an AttrSpec is preferred if the desired result is a map whose keys are
+// chosen by the user rather than by schema.
+type BlockAttrsSpec struct {
+	TypeName    string
+	ElementType cty.Type
+	Required    bool
+}
+
+func (s *BlockAttrsSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node
+}
+
+// blockSpec implementation
+func (s *BlockAttrsSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: nil,
+		},
+	}
+}
+
+// blockSpec implementation
+func (s *BlockAttrsSpec) nestedSpec() Spec {
+	// This is an odd case: we aren't actually going to apply a nested spec
+	// in this case, since we're going to interpret the body directly as
+	// attributes, but we need to return something non-nil so that the
+	// decoder will recognize this as a block spec. We won't actually be
+	// using this for anything at decode time.
+	return noopSpec{}
+}
+
+// specNeedingVariables implementation
+func (s *BlockAttrsSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+
+	block, _ := s.findBlock(content)
+	if block == nil {
+		return nil
+	}
+
+	var vars []hcl.Traversal
+
+	attrs, diags := block.Body.JustAttributes()
+	if diags.HasErrors() {
+		return nil
+	}
+
+	for _, attr := range attrs {
+		vars = append(vars, attr.Expr.Variables()...)
+	}
+
+	// We'll return the variables references in source order so that any
+	// error messages that result are also in source order.
+	sort.Slice(vars, func(i, j int) bool {
+		return vars[i].SourceRange().Start.Byte < vars[j].SourceRange().Start.Byte
+	})
+
+	return vars
+}
+
+func (s *BlockAttrsSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	block, other := s.findBlock(content)
+	if block == nil {
+		if s.Required {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Missing %s block", s.TypeName),
+				Detail: fmt.Sprintf(
+					"A block of type %q is required here.", s.TypeName,
+				),
+				Subject: &content.MissingItemRange,
+			})
+		}
+		return cty.NullVal(cty.Map(s.ElementType)), diags
+	}
+	if other != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Duplicate %s block", s.TypeName),
+			Detail: fmt.Sprintf(
+				"Only one block of type %q is allowed. Previous definition was at %s.",
+				s.TypeName, block.DefRange.String(),
+			),
+			Subject: &other.DefRange,
+		})
+	}
+
+	attrs, attrDiags := block.Body.JustAttributes()
+	diags = append(diags, attrDiags...)
+
+	if len(attrs) == 0 {
+		return cty.MapValEmpty(s.ElementType), diags
+	}
+
+	vals := make(map[string]cty.Value, len(attrs))
+	for name, attr := range attrs {
+		attrVal, attrDiags := attr.Expr.Value(ctx)
+		diags = append(diags, attrDiags...)
+
+		attrVal, err := convert.Convert(attrVal, s.ElementType)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid attribute value",
+				Detail:   fmt.Sprintf("Invalid value for attribute of %q block: %s.", s.TypeName, err),
+				Subject:  attr.Expr.Range().Ptr(),
+			})
+			attrVal = cty.UnknownVal(s.ElementType)
+		}
+
+		vals[name] = attrVal
+	}
+
+	return cty.MapVal(vals), diags
+}
+
+func (s *BlockAttrsSpec) impliedType() cty.Type {
+	return cty.Map(s.ElementType)
+}
+
+func (s *BlockAttrsSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	block, _ := s.findBlock(content)
+	if block == nil {
+		return content.MissingItemRange
+	}
+	return block.DefRange
+}
+
+func (s *BlockAttrsSpec) findBlock(content *hcl.BodyContent) (block *hcl.Block, other *hcl.Block) {
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+		if block != nil {
+			return block, candidate
+		}
+		block = candidate
+	}
+
+	return block, nil
+}
+
+// A BlockLabelSpec is a Spec that returns a cty.String representing the
+// label of the block its given body belongs to, if indeed its given body
+// belongs to a block. It is a programming error to use this in a non-block
+// context, so this spec will panic in that case.
+//
+// This spec only works in the nested spec within a BlockSpec, BlockListSpec,
+// BlockSetSpec or BlockMapSpec.
+//
+// The full set of label specs used against a particular block must have a
+// consecutive set of indices starting at zero. The maximum index found
+// defines how many labels the corresponding blocks must have in cty source.
+type BlockLabelSpec struct {
+	Index int
+	Name  string
+}
+
+func (s *BlockLabelSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node
+}
+
+func (s *BlockLabelSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	if s.Index >= len(blockLabels) {
+		panic("BlockListSpec used in non-block context")
+	}
+
+	return cty.StringVal(blockLabels[s.Index].Value), nil
+}
+
+func (s *BlockLabelSpec) impliedType() cty.Type {
+	return cty.String // labels are always strings
+}
+
+func (s *BlockLabelSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	if s.Index >= len(blockLabels) {
+		panic("BlockListSpec used in non-block context")
+	}
+
+	return blockLabels[s.Index].Range
+}
+
+func findLabelSpecs(spec Spec) []string {
+	maxIdx := -1
+	var names map[int]string
+
+	var visit visitFunc
+	visit = func(s Spec) {
+		if ls, ok := s.(*BlockLabelSpec); ok {
+			if maxIdx < ls.Index {
+				maxIdx = ls.Index
+			}
+			if names == nil {
+				names = make(map[int]string)
+			}
+			names[ls.Index] = ls.Name
+		}
+		s.visitSameBodyChildren(visit)
+	}
+
+	visit(spec)
+
+	if maxIdx < 0 {
+		return nil // no labels at all
+	}
+
+	ret := make([]string, maxIdx+1)
+	for i := range ret {
+		name := names[i]
+		if name == "" {
+			// Should never happen if the spec is conformant, since we require
+			// consecutive indices starting at zero.
+			name = fmt.Sprintf("missing%02d", i)
+		}
+		ret[i] = name
+	}
+
+	return ret
+}
+
+// DefaultSpec is a spec that wraps two specs, evaluating the primary first
+// and then evaluating the default if the primary returns a null value.
+//
+// The two specifications must have the same implied result type for correct
+// operation. If not, the result is undefined.
+//
+// Any requirements imposed by the "Default" spec apply even if "Primary" does
+// not return null. For example, if the "Default" spec is for a required
+// attribute then that attribute is always required, regardless of the result
+// of the "Primary" spec.
+//
+// The "Default" spec must not describe a nested block, since otherwise the
+// result of ChildBlockTypes would not be decidable without evaluation. If
+// the default spec _does_ describe a nested block then the result is
+// undefined.
+type DefaultSpec struct {
+	Primary Spec
+	Default Spec
+}
+
+func (s *DefaultSpec) visitSameBodyChildren(cb visitFunc) {
+	cb(s.Primary)
+	cb(s.Default)
+}
+
+func (s *DefaultSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	val, diags := s.Primary.decode(content, blockLabels, ctx)
+	if val.IsNull() {
+		var moreDiags hcl.Diagnostics
+		val, moreDiags = s.Default.decode(content, blockLabels, ctx)
+		diags = append(diags, moreDiags...)
+	}
+	return val, diags
+}
+
+func (s *DefaultSpec) impliedType() cty.Type {
+	return s.Primary.impliedType()
+}
+
+// attrSpec implementation
+func (s *DefaultSpec) attrSchemata() []hcl.AttributeSchema {
+	// We must pass through the union of both of our nested specs so that
+	// we'll have both values available in the result.
+	var ret []hcl.AttributeSchema
+	if as, ok := s.Primary.(attrSpec); ok {
+		ret = append(ret, as.attrSchemata()...)
+	}
+	if as, ok := s.Default.(attrSpec); ok {
+		ret = append(ret, as.attrSchemata()...)
+	}
+	return ret
+}
+
+// blockSpec implementation
+func (s *DefaultSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	// Only the primary spec may describe a block, since otherwise
+	// our nestedSpec method below can't know which to return.
+	if bs, ok := s.Primary.(blockSpec); ok {
+		return bs.blockHeaderSchemata()
+	}
+	return nil
+}
+
+// blockSpec implementation
+func (s *DefaultSpec) nestedSpec() Spec {
+	if bs, ok := s.Primary.(blockSpec); ok {
+		return bs.nestedSpec()
+	}
+	return nil
+}
+
+func (s *DefaultSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We can't tell from here which of the two specs will ultimately be used
+	// in our result, so we'll just assume the first. This is usually the right
+	// choice because the default is often a literal spec that doesn't have a
+	// reasonable source range to return anyway.
+	return s.Primary.sourceRange(content, blockLabels)
+}
+
+// TransformExprSpec is a spec that wraps another and then evaluates a given
+// hcl.Expression on the result.
+//
+// The implied type of this spec is determined by evaluating the expression
+// with an unknown value of the nested spec's implied type, which may cause
+// the result to be imprecise. This spec should not be used in situations where
+// precise result type information is needed.
+type TransformExprSpec struct {
+	Wrapped      Spec
+	Expr         hcl.Expression
+	TransformCtx *hcl.EvalContext
+	VarName      string
+}
+
+func (s *TransformExprSpec) visitSameBodyChildren(cb visitFunc) {
+	cb(s.Wrapped)
+}
+
+func (s *TransformExprSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	wrappedVal, diags := s.Wrapped.decode(content, blockLabels, ctx)
+	if diags.HasErrors() {
+		// We won't try to run our function in this case, because it'll probably
+		// generate confusing additional errors that will distract from the
+		// root cause.
+		return cty.UnknownVal(s.impliedType()), diags
+	}
+
+	chiCtx := s.TransformCtx.NewChild()
+	chiCtx.Variables = map[string]cty.Value{
+		s.VarName: wrappedVal,
+	}
+	resultVal, resultDiags := s.Expr.Value(chiCtx)
+	diags = append(diags, resultDiags...)
+	return resultVal, diags
+}
+
+func (s *TransformExprSpec) impliedType() cty.Type {
+	wrappedTy := s.Wrapped.impliedType()
+	chiCtx := s.TransformCtx.NewChild()
+	chiCtx.Variables = map[string]cty.Value{
+		s.VarName: cty.UnknownVal(wrappedTy),
+	}
+	resultVal, _ := s.Expr.Value(chiCtx)
+	return resultVal.Type()
+}
+
+func (s *TransformExprSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We'll just pass through our wrapped range here, even though that's
+	// not super-accurate, because there's nothing better to return.
+	return s.Wrapped.sourceRange(content, blockLabels)
+}
+
+// TransformFuncSpec is a spec that wraps another and then evaluates a given
+// cty function with the result. The given function must expect exactly one
+// argument, where the result of the wrapped spec will be passed.
+//
+// The implied type of this spec is determined by type-checking the function
+// with an unknown value of the nested spec's implied type, which may cause
+// the result to be imprecise. This spec should not be used in situations where
+// precise result type information is needed.
+//
+// If the given function produces an error when run, this spec will produce
+// a non-user-actionable diagnostic message. It's the caller's responsibility
+// to ensure that the given function cannot fail for any non-error result
+// of the wrapped spec.
+type TransformFuncSpec struct {
+	Wrapped Spec
+	Func    function.Function
+}
+
+func (s *TransformFuncSpec) visitSameBodyChildren(cb visitFunc) {
+	cb(s.Wrapped)
+}
+
+func (s *TransformFuncSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	wrappedVal, diags := s.Wrapped.decode(content, blockLabels, ctx)
+	if diags.HasErrors() {
+		// We won't try to run our function in this case, because it'll probably
+		// generate confusing additional errors that will distract from the
+		// root cause.
+		return cty.UnknownVal(s.impliedType()), diags
+	}
+
+	resultVal, err := s.Func.Call([]cty.Value{wrappedVal})
+	if err != nil {
+		// This is not a good example of a diagnostic because it is reporting
+		// a programming error in the calling application, rather than something
+		// an end-user could act on.
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Transform function failed",
+			Detail:   fmt.Sprintf("Decoder transform returned an error: %s", err),
+			Subject:  s.sourceRange(content, blockLabels).Ptr(),
+		})
+		return cty.UnknownVal(s.impliedType()), diags
+	}
+
+	return resultVal, diags
+}
+
+func (s *TransformFuncSpec) impliedType() cty.Type {
+	wrappedTy := s.Wrapped.impliedType()
+	resultTy, err := s.Func.ReturnType([]cty.Type{wrappedTy})
+	if err != nil {
+		// Should never happen with a correctly-configured spec
+		return cty.DynamicPseudoType
+	}
+
+	return resultTy
+}
+
+func (s *TransformFuncSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We'll just pass through our wrapped range here, even though that's
+	// not super-accurate, because there's nothing better to return.
+	return s.Wrapped.sourceRange(content, blockLabels)
+}
+
+// noopSpec is a placeholder spec that does nothing, used in situations where
+// a non-nil placeholder spec is required. It is not exported because there is
+// no reason to use it directly; it is always an implementation detail only.
+type noopSpec struct {
+}
+
+func (s noopSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return cty.NullVal(cty.DynamicPseudoType), nil
+}
+
+func (s noopSpec) impliedType() cty.Type {
+	return cty.DynamicPseudoType
+}
+
+func (s noopSpec) visitSameBodyChildren(cb visitFunc) {
+	// nothing to do
+}
+
+func (s noopSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// No useful range for a noopSpec, and nobody should be calling this anyway.
+	return hcl.Range{
+		Filename: "noopSpec",
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hcldec/variables.go b/vendor/github.com/hashicorp/hcl/v2/hcldec/variables.go
new file mode 100644
index 000000000..f8440eb60
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hcldec/variables.go
@@ -0,0 +1,36 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// Variables processes the given body with the given spec and returns a
+// list of the variable traversals that would be required to decode
+// the same pairing of body and spec.
+//
+// This can be used to conditionally populate the variables in the EvalContext
+// passed to Decode, for applications where a static scope is insufficient.
+//
+// If the given body is not compliant with the given schema, the result may
+// be incomplete, but that's assumed to be okay because the eventual call
+// to Decode will produce error diagnostics anyway.
+func Variables(body hcl.Body, spec Spec) []hcl.Traversal {
+	var vars []hcl.Traversal
+	schema := ImpliedSchema(spec)
+	content, _, _ := body.PartialContent(schema)
+
+	if vs, ok := spec.(specNeedingVariables); ok {
+		vars = append(vars, vs.variablesNeeded(content)...)
+	}
+
+	var visitFn visitFunc
+	visitFn = func(s Spec) {
+		if vs, ok := s.(specNeedingVariables); ok {
+			vars = append(vars, vs.variablesNeeded(content)...)
+		}
+		s.visitSameBodyChildren(visitFn)
+	}
+	spec.visitSameBodyChildren(visitFn)
+
+	return vars
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclparse/parser.go b/vendor/github.com/hashicorp/hcl/v2/hclparse/parser.go
new file mode 100644
index 000000000..1dc2eccd8
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclparse/parser.go
@@ -0,0 +1,135 @@
+// Package hclparse has the main API entry point for parsing both HCL native
+// syntax and HCL JSON.
+//
+// The main HCL package also includes SimpleParse and SimpleParseFile which
+// can be a simpler interface for the common case where an application just
+// needs to parse a single file. The gohcl package simplifies that further
+// in its SimpleDecode function, which combines hcl.SimpleParse with decoding
+// into Go struct values
+//
+// Package hclparse, then, is useful for applications that require more fine
+// control over parsing or which need to load many separate files and keep
+// track of them for possible error reporting or other analysis.
+package hclparse
+
+import (
+	"fmt"
+	"io/ioutil"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/hashicorp/hcl/v2/json"
+)
+
+// NOTE: This is the public interface for parsing. The actual parsers are
+// in other packages alongside this one, with this package just wrapping them
+// to provide a unified interface for the caller across all supported formats.
+
+// Parser is the main interface for parsing configuration files. As well as
+// parsing files, a parser also retains a registry of all of the files it
+// has parsed so that multiple attempts to parse the same file will return
+// the same object and so the collected files can be used when printing
+// diagnostics.
+//
+// Any diagnostics for parsing a file are only returned once on the first
+// call to parse that file. Callers are expected to collect up diagnostics
+// and present them together, so returning diagnostics for the same file
+// multiple times would create a confusing result.
+type Parser struct {
+	files map[string]*hcl.File
+}
+
+// NewParser creates a new parser, ready to parse configuration files.
+func NewParser() *Parser {
+	return &Parser{
+		files: map[string]*hcl.File{},
+	}
+}
+
+// ParseHCL parses the given buffer (which is assumed to have been loaded from
+// the given filename) as a native-syntax configuration file and returns the
+// hcl.File object representing it.
+func (p *Parser) ParseHCL(src []byte, filename string) (*hcl.File, hcl.Diagnostics) {
+	if existing := p.files[filename]; existing != nil {
+		return existing, nil
+	}
+
+	file, diags := hclsyntax.ParseConfig(src, filename, hcl.Pos{Byte: 0, Line: 1, Column: 1})
+	p.files[filename] = file
+	return file, diags
+}
+
+// ParseHCLFile reads the given filename and parses it as a native-syntax HCL
+// configuration file. An error diagnostic is returned if the given file
+// cannot be read.
+func (p *Parser) ParseHCLFile(filename string) (*hcl.File, hcl.Diagnostics) {
+	if existing := p.files[filename]; existing != nil {
+		return existing, nil
+	}
+
+	src, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Failed to read file",
+				Detail:   fmt.Sprintf("The configuration file %q could not be read.", filename),
+			},
+		}
+	}
+
+	return p.ParseHCL(src, filename)
+}
+
+// ParseJSON parses the given JSON buffer (which is assumed to have been loaded
+// from the given filename) and returns the hcl.File object representing it.
+func (p *Parser) ParseJSON(src []byte, filename string) (*hcl.File, hcl.Diagnostics) {
+	if existing := p.files[filename]; existing != nil {
+		return existing, nil
+	}
+
+	file, diags := json.Parse(src, filename)
+	p.files[filename] = file
+	return file, diags
+}
+
+// ParseJSONFile reads the given filename and parses it as JSON, similarly to
+// ParseJSON. An error diagnostic is returned if the given file cannot be read.
+func (p *Parser) ParseJSONFile(filename string) (*hcl.File, hcl.Diagnostics) {
+	if existing := p.files[filename]; existing != nil {
+		return existing, nil
+	}
+
+	file, diags := json.ParseFile(filename)
+	p.files[filename] = file
+	return file, diags
+}
+
+// AddFile allows a caller to record in a parser a file that was parsed some
+// other way, thus allowing it to be included in the registry of sources.
+func (p *Parser) AddFile(filename string, file *hcl.File) {
+	p.files[filename] = file
+}
+
+// Sources returns a map from filenames to the raw source code that was
+// read from them. This is intended to be used, for example, to print
+// diagnostics with contextual information.
+//
+// The arrays underlying the returned slices should not be modified.
+func (p *Parser) Sources() map[string][]byte {
+	ret := make(map[string][]byte)
+	for fn, f := range p.files {
+		ret[fn] = f.Bytes
+	}
+	return ret
+}
+
+// Files returns a map from filenames to the File objects produced from them.
+// This is intended to be used, for example, to print diagnostics with
+// contextual information.
+//
+// The returned map and all of the objects it refers to directly or indirectly
+// must not be modified.
+func (p *Parser) Files() map[string]*hcl.File {
+	return p.files
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/diagnostics.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/diagnostics.go
new file mode 100644
index 000000000..8c20286b2
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/diagnostics.go
@@ -0,0 +1,23 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// setDiagEvalContext is an internal helper that will impose a particular
+// EvalContext on a set of diagnostics in-place, for any diagnostic that
+// does not already have an EvalContext set.
+//
+// We generally expect diagnostics to be immutable, but this is safe to use
+// on any Diagnostics where none of the contained Diagnostic objects have yet
+// been seen by a caller. Its purpose is to apply additional context to a
+// set of diagnostics produced by a "deeper" component as the stack unwinds
+// during expression evaluation.
+func setDiagEvalContext(diags hcl.Diagnostics, expr hcl.Expression, ctx *hcl.EvalContext) {
+	for _, diag := range diags {
+		if diag.Expression == nil {
+			diag.Expression = expr
+			diag.EvalContext = ctx
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/didyoumean.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/didyoumean.go
new file mode 100644
index 000000000..ccc1c0ae2
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/didyoumean.go
@@ -0,0 +1,24 @@
+package hclsyntax
+
+import (
+	"github.com/agext/levenshtein"
+)
+
+// nameSuggestion tries to find a name from the given slice of suggested names
+// that is close to the given name and returns it if found. If no suggestion
+// is close enough, returns the empty string.
+//
+// The suggestions are tried in order, so earlier suggestions take precedence
+// if the given string is similar to two or more suggestions.
+//
+// This function is intended to be used with a relatively-small number of
+// suggestions. It's not optimized for hundreds or thousands of them.
+func nameSuggestion(given string, suggestions []string) string {
+	for _, suggestion := range suggestions {
+		dist := levenshtein.Distance(given, suggestion, nil)
+		if dist < 3 { // threshold determined experimentally
+			return suggestion
+		}
+	}
+	return ""
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/doc.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/doc.go
new file mode 100644
index 000000000..617bc29dc
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/doc.go
@@ -0,0 +1,7 @@
+// Package hclsyntax contains the parser, AST, etc for HCL's native language,
+// as opposed to the JSON variant.
+//
+// In normal use applications should rarely depend on this package directly,
+// instead preferring the higher-level interface of the main hcl package and
+// its companion package hclparse.
+package hclsyntax
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression.go
new file mode 100644
index 000000000..963ed7752
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression.go
@@ -0,0 +1,1477 @@
+package hclsyntax
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+// Expression is the abstract type for nodes that behave as HCL expressions.
+type Expression interface {
+	Node
+
+	// The hcl.Expression methods are duplicated here, rather than simply
+	// embedded, because both Node and hcl.Expression have a Range method
+	// and so they conflict.
+
+	Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics)
+	Variables() []hcl.Traversal
+	StartRange() hcl.Range
+}
+
+// Assert that Expression implements hcl.Expression
+var assertExprImplExpr hcl.Expression = Expression(nil)
+
+// LiteralValueExpr is an expression that just always returns a given value.
+type LiteralValueExpr struct {
+	Val      cty.Value
+	SrcRange hcl.Range
+}
+
+func (e *LiteralValueExpr) walkChildNodes(w internalWalkFunc) {
+	// Literal values have no child nodes
+}
+
+func (e *LiteralValueExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return e.Val, nil
+}
+
+func (e *LiteralValueExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *LiteralValueExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *LiteralValueExpr) AsTraversal() hcl.Traversal {
+	// This one's a little weird: the contract for AsTraversal is to interpret
+	// an expression as if it were traversal syntax, and traversal syntax
+	// doesn't have the special keywords "null", "true", and "false" so these
+	// are expected to be treated like variables in that case.
+	// Since our parser already turned them into LiteralValueExpr by the time
+	// we get here, we need to undo this and infer the name that would've
+	// originally led to our value.
+	// We don't do anything for any other values, since they don't overlap
+	// with traversal roots.
+
+	if e.Val.IsNull() {
+		// In practice the parser only generates null values of the dynamic
+		// pseudo-type for literals, so we can safely assume that any null
+		// was orignally the keyword "null".
+		return hcl.Traversal{
+			hcl.TraverseRoot{
+				Name:     "null",
+				SrcRange: e.SrcRange,
+			},
+		}
+	}
+
+	switch e.Val {
+	case cty.True:
+		return hcl.Traversal{
+			hcl.TraverseRoot{
+				Name:     "true",
+				SrcRange: e.SrcRange,
+			},
+		}
+	case cty.False:
+		return hcl.Traversal{
+			hcl.TraverseRoot{
+				Name:     "false",
+				SrcRange: e.SrcRange,
+			},
+		}
+	default:
+		// No traversal is possible for any other value.
+		return nil
+	}
+}
+
+// ScopeTraversalExpr is an Expression that retrieves a value from the scope
+// using a traversal.
+type ScopeTraversalExpr struct {
+	Traversal hcl.Traversal
+	SrcRange  hcl.Range
+}
+
+func (e *ScopeTraversalExpr) walkChildNodes(w internalWalkFunc) {
+	// Scope traversals have no child nodes
+}
+
+func (e *ScopeTraversalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	val, diags := e.Traversal.TraverseAbs(ctx)
+	setDiagEvalContext(diags, e, ctx)
+	return val, diags
+}
+
+func (e *ScopeTraversalExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *ScopeTraversalExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *ScopeTraversalExpr) AsTraversal() hcl.Traversal {
+	return e.Traversal
+}
+
+// RelativeTraversalExpr is an Expression that retrieves a value from another
+// value using a _relative_ traversal.
+type RelativeTraversalExpr struct {
+	Source    Expression
+	Traversal hcl.Traversal
+	SrcRange  hcl.Range
+}
+
+func (e *RelativeTraversalExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Source)
+}
+
+func (e *RelativeTraversalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	src, diags := e.Source.Value(ctx)
+	ret, travDiags := e.Traversal.TraverseRel(src)
+	setDiagEvalContext(travDiags, e, ctx)
+	diags = append(diags, travDiags...)
+	return ret, diags
+}
+
+func (e *RelativeTraversalExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *RelativeTraversalExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *RelativeTraversalExpr) AsTraversal() hcl.Traversal {
+	// We can produce a traversal only if our source can.
+	st, diags := hcl.AbsTraversalForExpr(e.Source)
+	if diags.HasErrors() {
+		return nil
+	}
+
+	ret := make(hcl.Traversal, len(st)+len(e.Traversal))
+	copy(ret, st)
+	copy(ret[len(st):], e.Traversal)
+	return ret
+}
+
+// FunctionCallExpr is an Expression that calls a function from the EvalContext
+// and returns its result.
+type FunctionCallExpr struct {
+	Name string
+	Args []Expression
+
+	// If true, the final argument should be a tuple, list or set which will
+	// expand to be one argument per element.
+	ExpandFinal bool
+
+	NameRange       hcl.Range
+	OpenParenRange  hcl.Range
+	CloseParenRange hcl.Range
+}
+
+func (e *FunctionCallExpr) walkChildNodes(w internalWalkFunc) {
+	for _, arg := range e.Args {
+		w(arg)
+	}
+}
+
+func (e *FunctionCallExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	var f function.Function
+	exists := false
+	hasNonNilMap := false
+	thisCtx := ctx
+	for thisCtx != nil {
+		if thisCtx.Functions == nil {
+			thisCtx = thisCtx.Parent()
+			continue
+		}
+		hasNonNilMap = true
+		f, exists = thisCtx.Functions[e.Name]
+		if exists {
+			break
+		}
+		thisCtx = thisCtx.Parent()
+	}
+
+	if !exists {
+		if !hasNonNilMap {
+			return cty.DynamicVal, hcl.Diagnostics{
+				{
+					Severity:    hcl.DiagError,
+					Summary:     "Function calls not allowed",
+					Detail:      "Functions may not be called here.",
+					Subject:     e.Range().Ptr(),
+					Expression:  e,
+					EvalContext: ctx,
+				},
+			}
+		}
+
+		avail := make([]string, 0, len(ctx.Functions))
+		for name := range ctx.Functions {
+			avail = append(avail, name)
+		}
+		suggestion := nameSuggestion(e.Name, avail)
+		if suggestion != "" {
+			suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+		}
+
+		return cty.DynamicVal, hcl.Diagnostics{
+			{
+				Severity:    hcl.DiagError,
+				Summary:     "Call to unknown function",
+				Detail:      fmt.Sprintf("There is no function named %q.%s", e.Name, suggestion),
+				Subject:     &e.NameRange,
+				Context:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			},
+		}
+	}
+
+	params := f.Params()
+	varParam := f.VarParam()
+
+	args := e.Args
+	if e.ExpandFinal {
+		if len(args) < 1 {
+			// should never happen if the parser is behaving
+			panic("ExpandFinal set on function call with no arguments")
+		}
+		expandExpr := args[len(args)-1]
+		expandVal, expandDiags := expandExpr.Value(ctx)
+		diags = append(diags, expandDiags...)
+		if expandDiags.HasErrors() {
+			return cty.DynamicVal, diags
+		}
+
+		switch {
+		case expandVal.Type().IsTupleType() || expandVal.Type().IsListType() || expandVal.Type().IsSetType():
+			if expandVal.IsNull() {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity:    hcl.DiagError,
+					Summary:     "Invalid expanding argument value",
+					Detail:      "The expanding argument (indicated by ...) must not be null.",
+					Subject:     expandExpr.Range().Ptr(),
+					Context:     e.Range().Ptr(),
+					Expression:  expandExpr,
+					EvalContext: ctx,
+				})
+				return cty.DynamicVal, diags
+			}
+			if !expandVal.IsKnown() {
+				return cty.DynamicVal, diags
+			}
+
+			newArgs := make([]Expression, 0, (len(args)-1)+expandVal.LengthInt())
+			newArgs = append(newArgs, args[:len(args)-1]...)
+			it := expandVal.ElementIterator()
+			for it.Next() {
+				_, val := it.Element()
+				newArgs = append(newArgs, &LiteralValueExpr{
+					Val:      val,
+					SrcRange: expandExpr.Range(),
+				})
+			}
+			args = newArgs
+		default:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Invalid expanding argument value",
+				Detail:      "The expanding argument (indicated by ...) must be of a tuple, list, or set type.",
+				Subject:     expandExpr.Range().Ptr(),
+				Context:     e.Range().Ptr(),
+				Expression:  expandExpr,
+				EvalContext: ctx,
+			})
+			return cty.DynamicVal, diags
+		}
+	}
+
+	if len(args) < len(params) {
+		missing := params[len(args)]
+		qual := ""
+		if varParam != nil {
+			qual = " at least"
+		}
+		return cty.DynamicVal, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Not enough function arguments",
+				Detail: fmt.Sprintf(
+					"Function %q expects%s %d argument(s). Missing value for %q.",
+					e.Name, qual, len(params), missing.Name,
+				),
+				Subject:     &e.CloseParenRange,
+				Context:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			},
+		}
+	}
+
+	if varParam == nil && len(args) > len(params) {
+		return cty.DynamicVal, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Too many function arguments",
+				Detail: fmt.Sprintf(
+					"Function %q expects only %d argument(s).",
+					e.Name, len(params),
+				),
+				Subject:     args[len(params)].StartRange().Ptr(),
+				Context:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			},
+		}
+	}
+
+	argVals := make([]cty.Value, len(args))
+
+	for i, argExpr := range args {
+		var param *function.Parameter
+		if i < len(params) {
+			param = &params[i]
+		} else {
+			param = varParam
+		}
+
+		val, argDiags := argExpr.Value(ctx)
+		if len(argDiags) > 0 {
+			diags = append(diags, argDiags...)
+		}
+
+		// Try to convert our value to the parameter type
+		val, err := convert.Convert(val, param.Type)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid function argument",
+				Detail: fmt.Sprintf(
+					"Invalid value for %q parameter: %s.",
+					param.Name, err,
+				),
+				Subject:     argExpr.StartRange().Ptr(),
+				Context:     e.Range().Ptr(),
+				Expression:  argExpr,
+				EvalContext: ctx,
+			})
+		}
+
+		argVals[i] = val
+	}
+
+	if diags.HasErrors() {
+		// Don't try to execute the function if we already have errors with
+		// the arguments, because the result will probably be a confusing
+		// error message.
+		return cty.DynamicVal, diags
+	}
+
+	resultVal, err := f.Call(argVals)
+	if err != nil {
+		switch terr := err.(type) {
+		case function.ArgError:
+			i := terr.Index
+			var param *function.Parameter
+			if i < len(params) {
+				param = &params[i]
+			} else {
+				param = varParam
+			}
+			argExpr := e.Args[i]
+
+			// TODO: we should also unpick a PathError here and show the
+			// path to the deep value where the error was detected.
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid function argument",
+				Detail: fmt.Sprintf(
+					"Invalid value for %q parameter: %s.",
+					param.Name, err,
+				),
+				Subject:     argExpr.StartRange().Ptr(),
+				Context:     e.Range().Ptr(),
+				Expression:  argExpr,
+				EvalContext: ctx,
+			})
+
+		default:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Error in function call",
+				Detail: fmt.Sprintf(
+					"Call to function %q failed: %s.",
+					e.Name, err,
+				),
+				Subject:     e.StartRange().Ptr(),
+				Context:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			})
+		}
+
+		return cty.DynamicVal, diags
+	}
+
+	return resultVal, diags
+}
+
+func (e *FunctionCallExpr) Range() hcl.Range {
+	return hcl.RangeBetween(e.NameRange, e.CloseParenRange)
+}
+
+func (e *FunctionCallExpr) StartRange() hcl.Range {
+	return hcl.RangeBetween(e.NameRange, e.OpenParenRange)
+}
+
+// Implementation for hcl.ExprCall.
+func (e *FunctionCallExpr) ExprCall() *hcl.StaticCall {
+	ret := &hcl.StaticCall{
+		Name:      e.Name,
+		NameRange: e.NameRange,
+		Arguments: make([]hcl.Expression, len(e.Args)),
+		ArgsRange: hcl.RangeBetween(e.OpenParenRange, e.CloseParenRange),
+	}
+	// Need to convert our own Expression objects into hcl.Expression.
+	for i, arg := range e.Args {
+		ret.Arguments[i] = arg
+	}
+	return ret
+}
+
+type ConditionalExpr struct {
+	Condition   Expression
+	TrueResult  Expression
+	FalseResult Expression
+
+	SrcRange hcl.Range
+}
+
+func (e *ConditionalExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Condition)
+	w(e.TrueResult)
+	w(e.FalseResult)
+}
+
+func (e *ConditionalExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	trueResult, trueDiags := e.TrueResult.Value(ctx)
+	falseResult, falseDiags := e.FalseResult.Value(ctx)
+	var diags hcl.Diagnostics
+
+	resultType := cty.DynamicPseudoType
+	convs := make([]convert.Conversion, 2)
+
+	switch {
+	// If either case is a dynamic null value (which would result from a
+	// literal null in the config), we know that it can convert to the expected
+	// type of the opposite case, and we don't need to speculatively reduce the
+	// final result type to DynamicPseudoType.
+
+	// If we know that either Type is a DynamicPseudoType, we can be certain
+	// that the other value can convert since it's a pass-through, and we don't
+	// need to unify the types. If the final evaluation results in the dynamic
+	// value being returned, there's no conversion we can do, so we return the
+	// value directly.
+	case trueResult.RawEquals(cty.NullVal(cty.DynamicPseudoType)):
+		resultType = falseResult.Type()
+		convs[0] = convert.GetConversionUnsafe(cty.DynamicPseudoType, resultType)
+	case falseResult.RawEquals(cty.NullVal(cty.DynamicPseudoType)):
+		resultType = trueResult.Type()
+		convs[1] = convert.GetConversionUnsafe(cty.DynamicPseudoType, resultType)
+	case trueResult.Type() == cty.DynamicPseudoType, falseResult.Type() == cty.DynamicPseudoType:
+		// the final resultType type is still unknown
+		// we don't need to get the conversion, because both are a noop.
+
+	default:
+		// Try to find a type that both results can be converted to.
+		resultType, convs = convert.UnifyUnsafe([]cty.Type{trueResult.Type(), falseResult.Type()})
+	}
+
+	if resultType == cty.NilType {
+		return cty.DynamicVal, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Inconsistent conditional result types",
+				Detail: fmt.Sprintf(
+					// FIXME: Need a helper function for showing natural-language type diffs,
+					// since this will generate some useless messages in some cases, like
+					// "These expressions are object and object respectively" if the
+					// object types don't exactly match.
+					"The true and false result expressions must have consistent types. The given expressions are %s and %s, respectively.",
+					trueResult.Type().FriendlyName(), falseResult.Type().FriendlyName(),
+				),
+				Subject:     hcl.RangeBetween(e.TrueResult.Range(), e.FalseResult.Range()).Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  e,
+				EvalContext: ctx,
+			},
+		}
+	}
+
+	condResult, condDiags := e.Condition.Value(ctx)
+	diags = append(diags, condDiags...)
+	if condResult.IsNull() {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Null condition",
+			Detail:      "The condition value is null. Conditions must either be true or false.",
+			Subject:     e.Condition.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.Condition,
+			EvalContext: ctx,
+		})
+		return cty.UnknownVal(resultType), diags
+	}
+	if !condResult.IsKnown() {
+		return cty.UnknownVal(resultType), diags
+	}
+	condResult, err := convert.Convert(condResult, cty.Bool)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Incorrect condition type",
+			Detail:      fmt.Sprintf("The condition expression must be of type bool."),
+			Subject:     e.Condition.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.Condition,
+			EvalContext: ctx,
+		})
+		return cty.UnknownVal(resultType), diags
+	}
+
+	if condResult.True() {
+		diags = append(diags, trueDiags...)
+		if convs[0] != nil {
+			var err error
+			trueResult, err = convs[0](trueResult)
+			if err != nil {
+				// Unsafe conversion failed with the concrete result value
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Inconsistent conditional result types",
+					Detail: fmt.Sprintf(
+						"The true result value has the wrong type: %s.",
+						err.Error(),
+					),
+					Subject:     e.TrueResult.Range().Ptr(),
+					Context:     &e.SrcRange,
+					Expression:  e.TrueResult,
+					EvalContext: ctx,
+				})
+				trueResult = cty.UnknownVal(resultType)
+			}
+		}
+		return trueResult, diags
+	} else {
+		diags = append(diags, falseDiags...)
+		if convs[1] != nil {
+			var err error
+			falseResult, err = convs[1](falseResult)
+			if err != nil {
+				// Unsafe conversion failed with the concrete result value
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Inconsistent conditional result types",
+					Detail: fmt.Sprintf(
+						"The false result value has the wrong type: %s.",
+						err.Error(),
+					),
+					Subject:     e.FalseResult.Range().Ptr(),
+					Context:     &e.SrcRange,
+					Expression:  e.FalseResult,
+					EvalContext: ctx,
+				})
+				falseResult = cty.UnknownVal(resultType)
+			}
+		}
+		return falseResult, diags
+	}
+}
+
+func (e *ConditionalExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *ConditionalExpr) StartRange() hcl.Range {
+	return e.Condition.StartRange()
+}
+
+type IndexExpr struct {
+	Collection Expression
+	Key        Expression
+
+	SrcRange  hcl.Range
+	OpenRange hcl.Range
+}
+
+func (e *IndexExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Collection)
+	w(e.Key)
+}
+
+func (e *IndexExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	coll, collDiags := e.Collection.Value(ctx)
+	key, keyDiags := e.Key.Value(ctx)
+	diags = append(diags, collDiags...)
+	diags = append(diags, keyDiags...)
+
+	val, indexDiags := hcl.Index(coll, key, &e.SrcRange)
+	setDiagEvalContext(indexDiags, e, ctx)
+	diags = append(diags, indexDiags...)
+	return val, diags
+}
+
+func (e *IndexExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *IndexExpr) StartRange() hcl.Range {
+	return e.OpenRange
+}
+
+type TupleConsExpr struct {
+	Exprs []Expression
+
+	SrcRange  hcl.Range
+	OpenRange hcl.Range
+}
+
+func (e *TupleConsExpr) walkChildNodes(w internalWalkFunc) {
+	for _, expr := range e.Exprs {
+		w(expr)
+	}
+}
+
+func (e *TupleConsExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var vals []cty.Value
+	var diags hcl.Diagnostics
+
+	vals = make([]cty.Value, len(e.Exprs))
+	for i, expr := range e.Exprs {
+		val, valDiags := expr.Value(ctx)
+		vals[i] = val
+		diags = append(diags, valDiags...)
+	}
+
+	return cty.TupleVal(vals), diags
+}
+
+func (e *TupleConsExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *TupleConsExpr) StartRange() hcl.Range {
+	return e.OpenRange
+}
+
+// Implementation for hcl.ExprList
+func (e *TupleConsExpr) ExprList() []hcl.Expression {
+	ret := make([]hcl.Expression, len(e.Exprs))
+	for i, expr := range e.Exprs {
+		ret[i] = expr
+	}
+	return ret
+}
+
+type ObjectConsExpr struct {
+	Items []ObjectConsItem
+
+	SrcRange  hcl.Range
+	OpenRange hcl.Range
+}
+
+type ObjectConsItem struct {
+	KeyExpr   Expression
+	ValueExpr Expression
+}
+
+func (e *ObjectConsExpr) walkChildNodes(w internalWalkFunc) {
+	for _, item := range e.Items {
+		w(item.KeyExpr)
+		w(item.ValueExpr)
+	}
+}
+
+func (e *ObjectConsExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var vals map[string]cty.Value
+	var diags hcl.Diagnostics
+
+	// This will get set to true if we fail to produce any of our keys,
+	// either because they are actually unknown or if the evaluation produces
+	// errors. In all of these case we must return DynamicPseudoType because
+	// we're unable to know the full set of keys our object has, and thus
+	// we can't produce a complete value of the intended type.
+	//
+	// We still evaluate all of the item keys and values to make sure that we
+	// get as complete as possible a set of diagnostics.
+	known := true
+
+	vals = make(map[string]cty.Value, len(e.Items))
+	for _, item := range e.Items {
+		key, keyDiags := item.KeyExpr.Value(ctx)
+		diags = append(diags, keyDiags...)
+
+		val, valDiags := item.ValueExpr.Value(ctx)
+		diags = append(diags, valDiags...)
+
+		if keyDiags.HasErrors() {
+			known = false
+			continue
+		}
+
+		if key.IsNull() {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Null value as key",
+				Detail:      "Can't use a null value as a key.",
+				Subject:     item.ValueExpr.Range().Ptr(),
+				Expression:  item.KeyExpr,
+				EvalContext: ctx,
+			})
+			known = false
+			continue
+		}
+
+		var err error
+		key, err = convert.Convert(key, cty.String)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Incorrect key type",
+				Detail:      fmt.Sprintf("Can't use this value as a key: %s.", err.Error()),
+				Subject:     item.KeyExpr.Range().Ptr(),
+				Expression:  item.KeyExpr,
+				EvalContext: ctx,
+			})
+			known = false
+			continue
+		}
+
+		if !key.IsKnown() {
+			known = false
+			continue
+		}
+
+		keyStr := key.AsString()
+
+		vals[keyStr] = val
+	}
+
+	if !known {
+		return cty.DynamicVal, diags
+	}
+
+	return cty.ObjectVal(vals), diags
+}
+
+func (e *ObjectConsExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *ObjectConsExpr) StartRange() hcl.Range {
+	return e.OpenRange
+}
+
+// Implementation for hcl.ExprMap
+func (e *ObjectConsExpr) ExprMap() []hcl.KeyValuePair {
+	ret := make([]hcl.KeyValuePair, len(e.Items))
+	for i, item := range e.Items {
+		ret[i] = hcl.KeyValuePair{
+			Key:   item.KeyExpr,
+			Value: item.ValueExpr,
+		}
+	}
+	return ret
+}
+
+// ObjectConsKeyExpr is a special wrapper used only for ObjectConsExpr keys,
+// which deals with the special case that a naked identifier in that position
+// must be interpreted as a literal string rather than evaluated directly.
+type ObjectConsKeyExpr struct {
+	Wrapped         Expression
+	ForceNonLiteral bool
+}
+
+func (e *ObjectConsKeyExpr) literalName() string {
+	// This is our logic for deciding whether to behave like a literal string.
+	// We lean on our AbsTraversalForExpr implementation here, which already
+	// deals with some awkward cases like the expression being the result
+	// of the keywords "null", "true" and "false" which we'd want to interpret
+	// as keys here too.
+	return hcl.ExprAsKeyword(e.Wrapped)
+}
+
+func (e *ObjectConsKeyExpr) walkChildNodes(w internalWalkFunc) {
+	// We only treat our wrapped expression as a real expression if we're
+	// not going to interpret it as a literal.
+	if e.literalName() == "" {
+		w(e.Wrapped)
+	}
+}
+
+func (e *ObjectConsKeyExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	// Because we accept a naked identifier as a literal key rather than a
+	// reference, it's confusing to accept a traversal containing periods
+	// here since we can't tell if the user intends to create a key with
+	// periods or actually reference something. To avoid confusing downstream
+	// errors we'll just prohibit a naked multi-step traversal here and
+	// require the user to state their intent more clearly.
+	// (This is handled at evaluation time rather than parse time because
+	// an application using static analysis _can_ accept a naked multi-step
+	// traversal here, if desired.)
+	if !e.ForceNonLiteral {
+		if travExpr, isTraversal := e.Wrapped.(*ScopeTraversalExpr); isTraversal && len(travExpr.Traversal) > 1 {
+			var diags hcl.Diagnostics
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Ambiguous attribute key",
+				Detail:   "If this expression is intended to be a reference, wrap it in parentheses. If it's instead intended as a literal name containing periods, wrap it in quotes to create a string literal.",
+				Subject:  e.Range().Ptr(),
+			})
+			return cty.DynamicVal, diags
+		}
+
+		if ln := e.literalName(); ln != "" {
+			return cty.StringVal(ln), nil
+		}
+	}
+	return e.Wrapped.Value(ctx)
+}
+
+func (e *ObjectConsKeyExpr) Range() hcl.Range {
+	return e.Wrapped.Range()
+}
+
+func (e *ObjectConsKeyExpr) StartRange() hcl.Range {
+	return e.Wrapped.StartRange()
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *ObjectConsKeyExpr) AsTraversal() hcl.Traversal {
+	// If we're forcing a non-literal then we can never be interpreted
+	// as a traversal.
+	if e.ForceNonLiteral {
+		return nil
+	}
+
+	// We can produce a traversal only if our wrappee can.
+	st, diags := hcl.AbsTraversalForExpr(e.Wrapped)
+	if diags.HasErrors() {
+		return nil
+	}
+
+	return st
+}
+
+func (e *ObjectConsKeyExpr) UnwrapExpression() Expression {
+	return e.Wrapped
+}
+
+// ForExpr represents iteration constructs:
+//
+//     tuple = [for i, v in list: upper(v) if i > 2]
+//     object = {for k, v in map: k => upper(v)}
+//     object_of_tuples = {for v in list: v.key: v...}
+type ForExpr struct {
+	KeyVar string // empty if ignoring the key
+	ValVar string
+
+	CollExpr Expression
+
+	KeyExpr  Expression // nil when producing a tuple
+	ValExpr  Expression
+	CondExpr Expression // null if no "if" clause is present
+
+	Group bool // set if the ellipsis is used on the value in an object for
+
+	SrcRange   hcl.Range
+	OpenRange  hcl.Range
+	CloseRange hcl.Range
+}
+
+func (e *ForExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	collVal, collDiags := e.CollExpr.Value(ctx)
+	diags = append(diags, collDiags...)
+
+	if collVal.IsNull() {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Iteration over null value",
+			Detail:      "A null value cannot be used as the collection in a 'for' expression.",
+			Subject:     e.CollExpr.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.CollExpr,
+			EvalContext: ctx,
+		})
+		return cty.DynamicVal, diags
+	}
+	if collVal.Type() == cty.DynamicPseudoType {
+		return cty.DynamicVal, diags
+	}
+	if !collVal.CanIterateElements() {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Iteration over non-iterable value",
+			Detail: fmt.Sprintf(
+				"A value of type %s cannot be used as the collection in a 'for' expression.",
+				collVal.Type().FriendlyName(),
+			),
+			Subject:     e.CollExpr.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.CollExpr,
+			EvalContext: ctx,
+		})
+		return cty.DynamicVal, diags
+	}
+	if !collVal.IsKnown() {
+		return cty.DynamicVal, diags
+	}
+
+	// Before we start we'll do an early check to see if any CondExpr we've
+	// been given is of the wrong type. This isn't 100% reliable (it may
+	// be DynamicVal until real values are given) but it should catch some
+	// straightforward cases and prevent a barrage of repeated errors.
+	if e.CondExpr != nil {
+		childCtx := ctx.NewChild()
+		childCtx.Variables = map[string]cty.Value{}
+		if e.KeyVar != "" {
+			childCtx.Variables[e.KeyVar] = cty.DynamicVal
+		}
+		childCtx.Variables[e.ValVar] = cty.DynamicVal
+
+		result, condDiags := e.CondExpr.Value(childCtx)
+		diags = append(diags, condDiags...)
+		if result.IsNull() {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Condition is null",
+				Detail:      "The value of the 'if' clause must not be null.",
+				Subject:     e.CondExpr.Range().Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  e.CondExpr,
+				EvalContext: ctx,
+			})
+			return cty.DynamicVal, diags
+		}
+		_, err := convert.Convert(result, cty.Bool)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity:    hcl.DiagError,
+				Summary:     "Invalid 'for' condition",
+				Detail:      fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()),
+				Subject:     e.CondExpr.Range().Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  e.CondExpr,
+				EvalContext: ctx,
+			})
+			return cty.DynamicVal, diags
+		}
+		if condDiags.HasErrors() {
+			return cty.DynamicVal, diags
+		}
+	}
+
+	if e.KeyExpr != nil {
+		// Producing an object
+		var vals map[string]cty.Value
+		var groupVals map[string][]cty.Value
+		if e.Group {
+			groupVals = map[string][]cty.Value{}
+		} else {
+			vals = map[string]cty.Value{}
+		}
+
+		it := collVal.ElementIterator()
+
+		known := true
+		for it.Next() {
+			k, v := it.Element()
+			childCtx := ctx.NewChild()
+			childCtx.Variables = map[string]cty.Value{}
+			if e.KeyVar != "" {
+				childCtx.Variables[e.KeyVar] = k
+			}
+			childCtx.Variables[e.ValVar] = v
+
+			if e.CondExpr != nil {
+				includeRaw, condDiags := e.CondExpr.Value(childCtx)
+				diags = append(diags, condDiags...)
+				if includeRaw.IsNull() {
+					if known {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity:    hcl.DiagError,
+							Summary:     "Invalid 'for' condition",
+							Detail:      "The value of the 'if' clause must not be null.",
+							Subject:     e.CondExpr.Range().Ptr(),
+							Context:     &e.SrcRange,
+							Expression:  e.CondExpr,
+							EvalContext: childCtx,
+						})
+					}
+					known = false
+					continue
+				}
+				include, err := convert.Convert(includeRaw, cty.Bool)
+				if err != nil {
+					if known {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity:    hcl.DiagError,
+							Summary:     "Invalid 'for' condition",
+							Detail:      fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()),
+							Subject:     e.CondExpr.Range().Ptr(),
+							Context:     &e.SrcRange,
+							Expression:  e.CondExpr,
+							EvalContext: childCtx,
+						})
+					}
+					known = false
+					continue
+				}
+				if !include.IsKnown() {
+					known = false
+					continue
+				}
+
+				if include.False() {
+					// Skip this element
+					continue
+				}
+			}
+
+			keyRaw, keyDiags := e.KeyExpr.Value(childCtx)
+			diags = append(diags, keyDiags...)
+			if keyRaw.IsNull() {
+				if known {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity:    hcl.DiagError,
+						Summary:     "Invalid object key",
+						Detail:      "Key expression in 'for' expression must not produce a null value.",
+						Subject:     e.KeyExpr.Range().Ptr(),
+						Context:     &e.SrcRange,
+						Expression:  e.KeyExpr,
+						EvalContext: childCtx,
+					})
+				}
+				known = false
+				continue
+			}
+			if !keyRaw.IsKnown() {
+				known = false
+				continue
+			}
+
+			key, err := convert.Convert(keyRaw, cty.String)
+			if err != nil {
+				if known {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity:    hcl.DiagError,
+						Summary:     "Invalid object key",
+						Detail:      fmt.Sprintf("The key expression produced an invalid result: %s.", err.Error()),
+						Subject:     e.KeyExpr.Range().Ptr(),
+						Context:     &e.SrcRange,
+						Expression:  e.KeyExpr,
+						EvalContext: childCtx,
+					})
+				}
+				known = false
+				continue
+			}
+
+			val, valDiags := e.ValExpr.Value(childCtx)
+			diags = append(diags, valDiags...)
+
+			if e.Group {
+				k := key.AsString()
+				groupVals[k] = append(groupVals[k], val)
+			} else {
+				k := key.AsString()
+				if _, exists := vals[k]; exists {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Duplicate object key",
+						Detail: fmt.Sprintf(
+							"Two different items produced the key %q in this 'for' expression. If duplicates are expected, use the ellipsis (...) after the value expression to enable grouping by key.",
+							k,
+						),
+						Subject:     e.KeyExpr.Range().Ptr(),
+						Context:     &e.SrcRange,
+						Expression:  e.KeyExpr,
+						EvalContext: childCtx,
+					})
+				} else {
+					vals[key.AsString()] = val
+				}
+			}
+		}
+
+		if !known {
+			return cty.DynamicVal, diags
+		}
+
+		if e.Group {
+			vals = map[string]cty.Value{}
+			for k, gvs := range groupVals {
+				vals[k] = cty.TupleVal(gvs)
+			}
+		}
+
+		return cty.ObjectVal(vals), diags
+
+	} else {
+		// Producing a tuple
+		vals := []cty.Value{}
+
+		it := collVal.ElementIterator()
+
+		known := true
+		for it.Next() {
+			k, v := it.Element()
+			childCtx := ctx.NewChild()
+			childCtx.Variables = map[string]cty.Value{}
+			if e.KeyVar != "" {
+				childCtx.Variables[e.KeyVar] = k
+			}
+			childCtx.Variables[e.ValVar] = v
+
+			if e.CondExpr != nil {
+				includeRaw, condDiags := e.CondExpr.Value(childCtx)
+				diags = append(diags, condDiags...)
+				if includeRaw.IsNull() {
+					if known {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity:    hcl.DiagError,
+							Summary:     "Invalid 'for' condition",
+							Detail:      "The value of the 'if' clause must not be null.",
+							Subject:     e.CondExpr.Range().Ptr(),
+							Context:     &e.SrcRange,
+							Expression:  e.CondExpr,
+							EvalContext: childCtx,
+						})
+					}
+					known = false
+					continue
+				}
+				if !includeRaw.IsKnown() {
+					// We will eventually return DynamicVal, but we'll continue
+					// iterating in case there are other diagnostics to gather
+					// for later elements.
+					known = false
+					continue
+				}
+
+				include, err := convert.Convert(includeRaw, cty.Bool)
+				if err != nil {
+					if known {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity:    hcl.DiagError,
+							Summary:     "Invalid 'for' condition",
+							Detail:      fmt.Sprintf("The 'if' clause value is invalid: %s.", err.Error()),
+							Subject:     e.CondExpr.Range().Ptr(),
+							Context:     &e.SrcRange,
+							Expression:  e.CondExpr,
+							EvalContext: childCtx,
+						})
+					}
+					known = false
+					continue
+				}
+
+				if include.False() {
+					// Skip this element
+					continue
+				}
+			}
+
+			val, valDiags := e.ValExpr.Value(childCtx)
+			diags = append(diags, valDiags...)
+			vals = append(vals, val)
+		}
+
+		if !known {
+			return cty.DynamicVal, diags
+		}
+
+		return cty.TupleVal(vals), diags
+	}
+}
+
+func (e *ForExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.CollExpr)
+
+	scopeNames := map[string]struct{}{}
+	if e.KeyVar != "" {
+		scopeNames[e.KeyVar] = struct{}{}
+	}
+	if e.ValVar != "" {
+		scopeNames[e.ValVar] = struct{}{}
+	}
+
+	if e.KeyExpr != nil {
+		w(ChildScope{
+			LocalNames: scopeNames,
+			Expr:       e.KeyExpr,
+		})
+	}
+	w(ChildScope{
+		LocalNames: scopeNames,
+		Expr:       e.ValExpr,
+	})
+	if e.CondExpr != nil {
+		w(ChildScope{
+			LocalNames: scopeNames,
+			Expr:       e.CondExpr,
+		})
+	}
+}
+
+func (e *ForExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *ForExpr) StartRange() hcl.Range {
+	return e.OpenRange
+}
+
+type SplatExpr struct {
+	Source Expression
+	Each   Expression
+	Item   *AnonSymbolExpr
+
+	SrcRange    hcl.Range
+	MarkerRange hcl.Range
+}
+
+func (e *SplatExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	sourceVal, diags := e.Source.Value(ctx)
+	if diags.HasErrors() {
+		// We'll evaluate our "Each" expression here just to see if it
+		// produces any more diagnostics we can report. Since we're not
+		// assigning a value to our AnonSymbolExpr here it will return
+		// DynamicVal, which should short-circuit any use of it.
+		_, itemDiags := e.Item.Value(ctx)
+		diags = append(diags, itemDiags...)
+		return cty.DynamicVal, diags
+	}
+
+	sourceTy := sourceVal.Type()
+	if sourceTy == cty.DynamicPseudoType {
+		// If we don't even know the _type_ of our source value yet then
+		// we'll need to defer all processing, since we can't decide our
+		// result type either.
+		return cty.DynamicVal, diags
+	}
+
+	// A "special power" of splat expressions is that they can be applied
+	// both to tuples/lists and to other values, and in the latter case
+	// the value will be treated as an implicit single-item tuple, or as
+	// an empty tuple if the value is null.
+	autoUpgrade := !(sourceTy.IsTupleType() || sourceTy.IsListType() || sourceTy.IsSetType())
+
+	if sourceVal.IsNull() {
+		if autoUpgrade {
+			return cty.EmptyTupleVal, diags
+		}
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Splat of null value",
+			Detail:      "Splat expressions (with the * symbol) cannot be applied to null sequences.",
+			Subject:     e.Source.Range().Ptr(),
+			Context:     hcl.RangeBetween(e.Source.Range(), e.MarkerRange).Ptr(),
+			Expression:  e.Source,
+			EvalContext: ctx,
+		})
+		return cty.DynamicVal, diags
+	}
+
+	if autoUpgrade {
+		sourceVal = cty.TupleVal([]cty.Value{sourceVal})
+		sourceTy = sourceVal.Type()
+	}
+
+	// We'll compute our result type lazily if we need it. In the normal case
+	// it's inferred automatically from the value we construct.
+	resultTy := func() (cty.Type, hcl.Diagnostics) {
+		chiCtx := ctx.NewChild()
+		var diags hcl.Diagnostics
+		switch {
+		case sourceTy.IsListType() || sourceTy.IsSetType():
+			ety := sourceTy.ElementType()
+			e.Item.setValue(chiCtx, cty.UnknownVal(ety))
+			val, itemDiags := e.Each.Value(chiCtx)
+			diags = append(diags, itemDiags...)
+			e.Item.clearValue(chiCtx) // clean up our temporary value
+			return cty.List(val.Type()), diags
+		case sourceTy.IsTupleType():
+			etys := sourceTy.TupleElementTypes()
+			resultTys := make([]cty.Type, 0, len(etys))
+			for _, ety := range etys {
+				e.Item.setValue(chiCtx, cty.UnknownVal(ety))
+				val, itemDiags := e.Each.Value(chiCtx)
+				diags = append(diags, itemDiags...)
+				e.Item.clearValue(chiCtx) // clean up our temporary value
+				resultTys = append(resultTys, val.Type())
+			}
+			return cty.Tuple(resultTys), diags
+		default:
+			// Should never happen because of our promotion to list above.
+			return cty.DynamicPseudoType, diags
+		}
+	}
+
+	if !sourceVal.IsKnown() {
+		// We can't produce a known result in this case, but we'll still
+		// indicate what the result type would be, allowing any downstream type
+		// checking to proceed.
+		ty, tyDiags := resultTy()
+		diags = append(diags, tyDiags...)
+		return cty.UnknownVal(ty), diags
+	}
+
+	vals := make([]cty.Value, 0, sourceVal.LengthInt())
+	it := sourceVal.ElementIterator()
+	if ctx == nil {
+		// we need a context to use our AnonSymbolExpr, so we'll just
+		// make an empty one here to use as a placeholder.
+		ctx = ctx.NewChild()
+	}
+	isKnown := true
+	for it.Next() {
+		_, sourceItem := it.Element()
+		e.Item.setValue(ctx, sourceItem)
+		newItem, itemDiags := e.Each.Value(ctx)
+		diags = append(diags, itemDiags...)
+		if itemDiags.HasErrors() {
+			isKnown = false
+		}
+		vals = append(vals, newItem)
+	}
+	e.Item.clearValue(ctx) // clean up our temporary value
+
+	if !isKnown {
+		// We'll ingore the resultTy diagnostics in this case since they
+		// will just be the same errors we saw while iterating above.
+		ty, _ := resultTy()
+		return cty.UnknownVal(ty), diags
+	}
+
+	switch {
+	case sourceTy.IsListType() || sourceTy.IsSetType():
+		if len(vals) == 0 {
+			ty, tyDiags := resultTy()
+			diags = append(diags, tyDiags...)
+			return cty.ListValEmpty(ty.ElementType()), diags
+		}
+		return cty.ListVal(vals), diags
+	default:
+		return cty.TupleVal(vals), diags
+	}
+}
+
+func (e *SplatExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Source)
+	w(e.Each)
+}
+
+func (e *SplatExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *SplatExpr) StartRange() hcl.Range {
+	return e.MarkerRange
+}
+
+// AnonSymbolExpr is used as a placeholder for a value in an expression that
+// can be applied dynamically to any value at runtime.
+//
+// This is a rather odd, synthetic expression. It is used as part of the
+// representation of splat expressions as a placeholder for the current item
+// being visited in the splat evaluation.
+//
+// AnonSymbolExpr cannot be evaluated in isolation. If its Value is called
+// directly then cty.DynamicVal will be returned. Instead, it is evaluated
+// in terms of another node (i.e. a splat expression) which temporarily
+// assigns it a value.
+type AnonSymbolExpr struct {
+	SrcRange hcl.Range
+
+	// values and its associated lock are used to isolate concurrent
+	// evaluations of a symbol from one another. It is the calling application's
+	// responsibility to ensure that the same splat expression is not evalauted
+	// concurrently within the _same_ EvalContext, but it is fine and safe to
+	// do cuncurrent evaluations with distinct EvalContexts.
+	values     map[*hcl.EvalContext]cty.Value
+	valuesLock sync.RWMutex
+}
+
+func (e *AnonSymbolExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	if ctx == nil {
+		return cty.DynamicVal, nil
+	}
+
+	e.valuesLock.RLock()
+	defer e.valuesLock.RUnlock()
+
+	val, exists := e.values[ctx]
+	if !exists {
+		return cty.DynamicVal, nil
+	}
+	return val, nil
+}
+
+// setValue sets a temporary local value for the expression when evaluated
+// in the given context, which must be non-nil.
+func (e *AnonSymbolExpr) setValue(ctx *hcl.EvalContext, val cty.Value) {
+	e.valuesLock.Lock()
+	defer e.valuesLock.Unlock()
+
+	if e.values == nil {
+		e.values = make(map[*hcl.EvalContext]cty.Value)
+	}
+	if ctx == nil {
+		panic("can't setValue for a nil EvalContext")
+	}
+	e.values[ctx] = val
+}
+
+func (e *AnonSymbolExpr) clearValue(ctx *hcl.EvalContext) {
+	e.valuesLock.Lock()
+	defer e.valuesLock.Unlock()
+
+	if e.values == nil {
+		return
+	}
+	if ctx == nil {
+		panic("can't clearValue for a nil EvalContext")
+	}
+	delete(e.values, ctx)
+}
+
+func (e *AnonSymbolExpr) walkChildNodes(w internalWalkFunc) {
+	// AnonSymbolExpr is a leaf node in the tree
+}
+
+func (e *AnonSymbolExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *AnonSymbolExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_ops.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_ops.go
new file mode 100644
index 000000000..c1db0cecc
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_ops.go
@@ -0,0 +1,268 @@
+package hclsyntax
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/function/stdlib"
+)
+
+type Operation struct {
+	Impl function.Function
+	Type cty.Type
+}
+
+var (
+	OpLogicalOr = &Operation{
+		Impl: stdlib.OrFunc,
+		Type: cty.Bool,
+	}
+	OpLogicalAnd = &Operation{
+		Impl: stdlib.AndFunc,
+		Type: cty.Bool,
+	}
+	OpLogicalNot = &Operation{
+		Impl: stdlib.NotFunc,
+		Type: cty.Bool,
+	}
+
+	OpEqual = &Operation{
+		Impl: stdlib.EqualFunc,
+		Type: cty.Bool,
+	}
+	OpNotEqual = &Operation{
+		Impl: stdlib.NotEqualFunc,
+		Type: cty.Bool,
+	}
+
+	OpGreaterThan = &Operation{
+		Impl: stdlib.GreaterThanFunc,
+		Type: cty.Bool,
+	}
+	OpGreaterThanOrEqual = &Operation{
+		Impl: stdlib.GreaterThanOrEqualToFunc,
+		Type: cty.Bool,
+	}
+	OpLessThan = &Operation{
+		Impl: stdlib.LessThanFunc,
+		Type: cty.Bool,
+	}
+	OpLessThanOrEqual = &Operation{
+		Impl: stdlib.LessThanOrEqualToFunc,
+		Type: cty.Bool,
+	}
+
+	OpAdd = &Operation{
+		Impl: stdlib.AddFunc,
+		Type: cty.Number,
+	}
+	OpSubtract = &Operation{
+		Impl: stdlib.SubtractFunc,
+		Type: cty.Number,
+	}
+	OpMultiply = &Operation{
+		Impl: stdlib.MultiplyFunc,
+		Type: cty.Number,
+	}
+	OpDivide = &Operation{
+		Impl: stdlib.DivideFunc,
+		Type: cty.Number,
+	}
+	OpModulo = &Operation{
+		Impl: stdlib.ModuloFunc,
+		Type: cty.Number,
+	}
+	OpNegate = &Operation{
+		Impl: stdlib.NegateFunc,
+		Type: cty.Number,
+	}
+)
+
+var binaryOps []map[TokenType]*Operation
+
+func init() {
+	// This operation table maps from the operator's token type
+	// to the AST operation type. All expressions produced from
+	// binary operators are BinaryOp nodes.
+	//
+	// Binary operator groups are listed in order of precedence, with
+	// the *lowest* precedence first. Operators within the same group
+	// have left-to-right associativity.
+	binaryOps = []map[TokenType]*Operation{
+		{
+			TokenOr: OpLogicalOr,
+		},
+		{
+			TokenAnd: OpLogicalAnd,
+		},
+		{
+			TokenEqualOp:  OpEqual,
+			TokenNotEqual: OpNotEqual,
+		},
+		{
+			TokenGreaterThan:   OpGreaterThan,
+			TokenGreaterThanEq: OpGreaterThanOrEqual,
+			TokenLessThan:      OpLessThan,
+			TokenLessThanEq:    OpLessThanOrEqual,
+		},
+		{
+			TokenPlus:  OpAdd,
+			TokenMinus: OpSubtract,
+		},
+		{
+			TokenStar:    OpMultiply,
+			TokenSlash:   OpDivide,
+			TokenPercent: OpModulo,
+		},
+	}
+}
+
+type BinaryOpExpr struct {
+	LHS Expression
+	Op  *Operation
+	RHS Expression
+
+	SrcRange hcl.Range
+}
+
+func (e *BinaryOpExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.LHS)
+	w(e.RHS)
+}
+
+func (e *BinaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	impl := e.Op.Impl // assumed to be a function taking exactly two arguments
+	params := impl.Params()
+	lhsParam := params[0]
+	rhsParam := params[1]
+
+	var diags hcl.Diagnostics
+
+	givenLHSVal, lhsDiags := e.LHS.Value(ctx)
+	givenRHSVal, rhsDiags := e.RHS.Value(ctx)
+	diags = append(diags, lhsDiags...)
+	diags = append(diags, rhsDiags...)
+
+	lhsVal, err := convert.Convert(givenLHSVal, lhsParam.Type)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Invalid operand",
+			Detail:      fmt.Sprintf("Unsuitable value for left operand: %s.", err),
+			Subject:     e.LHS.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.LHS,
+			EvalContext: ctx,
+		})
+	}
+	rhsVal, err := convert.Convert(givenRHSVal, rhsParam.Type)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Invalid operand",
+			Detail:      fmt.Sprintf("Unsuitable value for right operand: %s.", err),
+			Subject:     e.RHS.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.RHS,
+			EvalContext: ctx,
+		})
+	}
+
+	if diags.HasErrors() {
+		// Don't actually try the call if we have errors already, since the
+		// this will probably just produce a confusing duplicative diagnostic.
+		return cty.UnknownVal(e.Op.Type), diags
+	}
+
+	args := []cty.Value{lhsVal, rhsVal}
+	result, err := impl.Call(args)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			// FIXME: This diagnostic is useless.
+			Severity:    hcl.DiagError,
+			Summary:     "Operation failed",
+			Detail:      fmt.Sprintf("Error during operation: %s.", err),
+			Subject:     &e.SrcRange,
+			Expression:  e,
+			EvalContext: ctx,
+		})
+		return cty.UnknownVal(e.Op.Type), diags
+	}
+
+	return result, diags
+}
+
+func (e *BinaryOpExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *BinaryOpExpr) StartRange() hcl.Range {
+	return e.LHS.StartRange()
+}
+
+type UnaryOpExpr struct {
+	Op  *Operation
+	Val Expression
+
+	SrcRange    hcl.Range
+	SymbolRange hcl.Range
+}
+
+func (e *UnaryOpExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Val)
+}
+
+func (e *UnaryOpExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	impl := e.Op.Impl // assumed to be a function taking exactly one argument
+	params := impl.Params()
+	param := params[0]
+
+	givenVal, diags := e.Val.Value(ctx)
+
+	val, err := convert.Convert(givenVal, param.Type)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity:    hcl.DiagError,
+			Summary:     "Invalid operand",
+			Detail:      fmt.Sprintf("Unsuitable value for unary operand: %s.", err),
+			Subject:     e.Val.Range().Ptr(),
+			Context:     &e.SrcRange,
+			Expression:  e.Val,
+			EvalContext: ctx,
+		})
+	}
+
+	if diags.HasErrors() {
+		// Don't actually try the call if we have errors already, since the
+		// this will probably just produce a confusing duplicative diagnostic.
+		return cty.UnknownVal(e.Op.Type), diags
+	}
+
+	args := []cty.Value{val}
+	result, err := impl.Call(args)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			// FIXME: This diagnostic is useless.
+			Severity:    hcl.DiagError,
+			Summary:     "Operation failed",
+			Detail:      fmt.Sprintf("Error during operation: %s.", err),
+			Subject:     &e.SrcRange,
+			Expression:  e,
+			EvalContext: ctx,
+		})
+		return cty.UnknownVal(e.Op.Type), diags
+	}
+
+	return result, diags
+}
+
+func (e *UnaryOpExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *UnaryOpExpr) StartRange() hcl.Range {
+	return e.SymbolRange
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_template.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_template.go
new file mode 100644
index 000000000..9d425115f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_template.go
@@ -0,0 +1,220 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+type TemplateExpr struct {
+	Parts []Expression
+
+	SrcRange hcl.Range
+}
+
+func (e *TemplateExpr) walkChildNodes(w internalWalkFunc) {
+	for _, part := range e.Parts {
+		w(part)
+	}
+}
+
+func (e *TemplateExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	buf := &bytes.Buffer{}
+	var diags hcl.Diagnostics
+	isKnown := true
+
+	for _, part := range e.Parts {
+		partVal, partDiags := part.Value(ctx)
+		diags = append(diags, partDiags...)
+
+		if partVal.IsNull() {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid template interpolation value",
+				Detail: fmt.Sprintf(
+					"The expression result is null. Cannot include a null value in a string template.",
+				),
+				Subject:     part.Range().Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  part,
+				EvalContext: ctx,
+			})
+			continue
+		}
+
+		if !partVal.IsKnown() {
+			// If any part is unknown then the result as a whole must be
+			// unknown too. We'll keep on processing the rest of the parts
+			// anyway, because we want to still emit any diagnostics resulting
+			// from evaluating those.
+			isKnown = false
+			continue
+		}
+
+		strVal, err := convert.Convert(partVal, cty.String)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid template interpolation value",
+				Detail: fmt.Sprintf(
+					"Cannot include the given value in a string template: %s.",
+					err.Error(),
+				),
+				Subject:     part.Range().Ptr(),
+				Context:     &e.SrcRange,
+				Expression:  part,
+				EvalContext: ctx,
+			})
+			continue
+		}
+
+		buf.WriteString(strVal.AsString())
+	}
+
+	if !isKnown {
+		return cty.UnknownVal(cty.String), diags
+	}
+
+	return cty.StringVal(buf.String()), diags
+}
+
+func (e *TemplateExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *TemplateExpr) StartRange() hcl.Range {
+	return e.Parts[0].StartRange()
+}
+
+// IsStringLiteral returns true if and only if the template consists only of
+// single string literal, as would be created for a simple quoted string like
+// "foo".
+//
+// If this function returns true, then calling Value on the same expression
+// with a nil EvalContext will return the literal value.
+//
+// Note that "${"foo"}", "${1}", etc aren't considered literal values for the
+// purposes of this method, because the intent of this method is to identify
+// situations where the user seems to be explicitly intending literal string
+// interpretation, not situations that result in literals as a technicality
+// of the template expression unwrapping behavior.
+func (e *TemplateExpr) IsStringLiteral() bool {
+	if len(e.Parts) != 1 {
+		return false
+	}
+	_, ok := e.Parts[0].(*LiteralValueExpr)
+	return ok
+}
+
+// TemplateJoinExpr is used to convert tuples of strings produced by template
+// constructs (i.e. for loops) into flat strings, by converting the values
+// tos strings and joining them. This AST node is not used directly; it's
+// produced as part of the AST of a "for" loop in a template.
+type TemplateJoinExpr struct {
+	Tuple Expression
+}
+
+func (e *TemplateJoinExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Tuple)
+}
+
+func (e *TemplateJoinExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	tuple, diags := e.Tuple.Value(ctx)
+
+	if tuple.IsNull() {
+		// This indicates a bug in the code that constructed the AST.
+		panic("TemplateJoinExpr got null tuple")
+	}
+	if tuple.Type() == cty.DynamicPseudoType {
+		return cty.UnknownVal(cty.String), diags
+	}
+	if !tuple.Type().IsTupleType() {
+		// This indicates a bug in the code that constructed the AST.
+		panic("TemplateJoinExpr got non-tuple tuple")
+	}
+	if !tuple.IsKnown() {
+		return cty.UnknownVal(cty.String), diags
+	}
+
+	buf := &bytes.Buffer{}
+	it := tuple.ElementIterator()
+	for it.Next() {
+		_, val := it.Element()
+
+		if val.IsNull() {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid template interpolation value",
+				Detail: fmt.Sprintf(
+					"An iteration result is null. Cannot include a null value in a string template.",
+				),
+				Subject:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			})
+			continue
+		}
+		if val.Type() == cty.DynamicPseudoType {
+			return cty.UnknownVal(cty.String), diags
+		}
+		strVal, err := convert.Convert(val, cty.String)
+		if err != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid template interpolation value",
+				Detail: fmt.Sprintf(
+					"Cannot include one of the interpolation results into the string template: %s.",
+					err.Error(),
+				),
+				Subject:     e.Range().Ptr(),
+				Expression:  e,
+				EvalContext: ctx,
+			})
+			continue
+		}
+		if !val.IsKnown() {
+			return cty.UnknownVal(cty.String), diags
+		}
+
+		buf.WriteString(strVal.AsString())
+	}
+
+	return cty.StringVal(buf.String()), diags
+}
+
+func (e *TemplateJoinExpr) Range() hcl.Range {
+	return e.Tuple.Range()
+}
+
+func (e *TemplateJoinExpr) StartRange() hcl.Range {
+	return e.Tuple.StartRange()
+}
+
+// TemplateWrapExpr is used instead of a TemplateExpr when a template
+// consists _only_ of a single interpolation sequence. In that case, the
+// template's result is the single interpolation's result, verbatim with
+// no type conversions.
+type TemplateWrapExpr struct {
+	Wrapped Expression
+
+	SrcRange hcl.Range
+}
+
+func (e *TemplateWrapExpr) walkChildNodes(w internalWalkFunc) {
+	w(e.Wrapped)
+}
+
+func (e *TemplateWrapExpr) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return e.Wrapped.Value(ctx)
+}
+
+func (e *TemplateWrapExpr) Range() hcl.Range {
+	return e.SrcRange
+}
+
+func (e *TemplateWrapExpr) StartRange() hcl.Range {
+	return e.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_vars.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_vars.go
new file mode 100644
index 000000000..a82bf790e
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/expression_vars.go
@@ -0,0 +1,76 @@
+package hclsyntax
+
+// Generated by expression_vars_get.go. DO NOT EDIT.
+// Run 'go generate' on this package to update the set of functions here.
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+func (e *AnonSymbolExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *BinaryOpExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ConditionalExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ForExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *FunctionCallExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *IndexExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *LiteralValueExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ObjectConsExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ObjectConsKeyExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *RelativeTraversalExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *ScopeTraversalExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *SplatExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *TemplateExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *TemplateJoinExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *TemplateWrapExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *TupleConsExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
+
+func (e *UnaryOpExpr) Variables() []hcl.Traversal {
+	return Variables(e)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/file.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/file.go
new file mode 100644
index 000000000..f55e9ce2c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/file.go
@@ -0,0 +1,20 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// File is the top-level object resulting from parsing a configuration file.
+type File struct {
+	Body  *Body
+	Bytes []byte
+}
+
+func (f *File) AsHCLFile() *hcl.File {
+	return &hcl.File{
+		Body:  f.Body,
+		Bytes: f.Bytes,
+
+		// TODO: The Nav object, once we have an implementation of it
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/generate.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/generate.go
new file mode 100644
index 000000000..841656a6a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/generate.go
@@ -0,0 +1,9 @@
+package hclsyntax
+
+//go:generate go run expression_vars_gen.go
+//go:generate ruby unicode2ragel.rb --url=http://www.unicode.org/Public/9.0.0/ucd/DerivedCoreProperties.txt -m UnicodeDerived -p ID_Start,ID_Continue -o unicode_derived.rl
+//go:generate ragel -Z scan_tokens.rl
+//go:generate gofmt -w scan_tokens.go
+//go:generate ragel -Z scan_string_lit.rl
+//go:generate gofmt -w scan_string_lit.go
+//go:generate stringer -type TokenType -output token_type_string.go
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/keywords.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/keywords.go
new file mode 100644
index 000000000..eef8b9626
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/keywords.go
@@ -0,0 +1,21 @@
+package hclsyntax
+
+import (
+	"bytes"
+)
+
+type Keyword []byte
+
+var forKeyword = Keyword([]byte{'f', 'o', 'r'})
+var inKeyword = Keyword([]byte{'i', 'n'})
+var ifKeyword = Keyword([]byte{'i', 'f'})
+var elseKeyword = Keyword([]byte{'e', 'l', 's', 'e'})
+var endifKeyword = Keyword([]byte{'e', 'n', 'd', 'i', 'f'})
+var endforKeyword = Keyword([]byte{'e', 'n', 'd', 'f', 'o', 'r'})
+
+func (kw Keyword) TokenMatches(token Token) bool {
+	if token.Type != TokenIdent {
+		return false
+	}
+	return bytes.Equal([]byte(kw), token.Bytes)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/navigation.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/navigation.go
new file mode 100644
index 000000000..af98ef045
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/navigation.go
@@ -0,0 +1,59 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+type navigation struct {
+	root *Body
+}
+
+// Implementation of hcled.ContextString
+func (n navigation) ContextString(offset int) string {
+	// We will walk our top-level blocks until we find one that contains
+	// the given offset, and then construct a representation of the header
+	// of the block.
+
+	var block *Block
+	for _, candidate := range n.root.Blocks {
+		if candidate.Range().ContainsOffset(offset) {
+			block = candidate
+			break
+		}
+	}
+
+	if block == nil {
+		return ""
+	}
+
+	if len(block.Labels) == 0 {
+		// Easy case!
+		return block.Type
+	}
+
+	buf := &bytes.Buffer{}
+	buf.WriteString(block.Type)
+	for _, label := range block.Labels {
+		fmt.Fprintf(buf, " %q", label)
+	}
+	return buf.String()
+}
+
+func (n navigation) ContextDefRange(offset int) hcl.Range {
+	var block *Block
+	for _, candidate := range n.root.Blocks {
+		if candidate.Range().ContainsOffset(offset) {
+			block = candidate
+			break
+		}
+	}
+
+	if block == nil {
+		return hcl.Range{}
+	}
+
+	return block.DefRange()
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/node.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/node.go
new file mode 100644
index 000000000..41b35e53f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/node.go
@@ -0,0 +1,22 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// Node is the abstract type that every AST node implements.
+//
+// This is a closed interface, so it cannot be implemented from outside of
+// this package.
+type Node interface {
+	// This is the mechanism by which the public-facing walk functions
+	// are implemented. Implementations should call the given function
+	// for each child node and then replace that node with its return value.
+	// The return value might just be the same node, for non-transforming
+	// walks.
+	walkChildNodes(w internalWalkFunc)
+
+	Range() hcl.Range
+}
+
+type internalWalkFunc func(Node)
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser.go
new file mode 100644
index 000000000..6fb284a8f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser.go
@@ -0,0 +1,2054 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"unicode/utf8"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type parser struct {
+	*peeker
+
+	// set to true if any recovery is attempted. The parser can use this
+	// to attempt to reduce error noise by suppressing "bad token" errors
+	// in recovery mode, assuming that the recovery heuristics have failed
+	// in this case and left the peeker in a wrong place.
+	recovery bool
+}
+
+func (p *parser) ParseBody(end TokenType) (*Body, hcl.Diagnostics) {
+	attrs := Attributes{}
+	blocks := Blocks{}
+	var diags hcl.Diagnostics
+
+	startRange := p.PrevRange()
+	var endRange hcl.Range
+
+Token:
+	for {
+		next := p.Peek()
+		if next.Type == end {
+			endRange = p.NextRange()
+			p.Read()
+			break Token
+		}
+
+		switch next.Type {
+		case TokenNewline:
+			p.Read()
+			continue
+		case TokenIdent:
+			item, itemDiags := p.ParseBodyItem()
+			diags = append(diags, itemDiags...)
+			switch titem := item.(type) {
+			case *Block:
+				blocks = append(blocks, titem)
+			case *Attribute:
+				if existing, exists := attrs[titem.Name]; exists {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Attribute redefined",
+						Detail: fmt.Sprintf(
+							"The argument %q was already set at %s. Each argument may be set only once.",
+							titem.Name, existing.NameRange.String(),
+						),
+						Subject: &titem.NameRange,
+					})
+				} else {
+					attrs[titem.Name] = titem
+				}
+			default:
+				// This should never happen for valid input, but may if a
+				// syntax error was detected in ParseBodyItem that prevented
+				// it from even producing a partially-broken item. In that
+				// case, it would've left at least one error in the diagnostics
+				// slice we already dealt with above.
+				//
+				// We'll assume ParseBodyItem attempted recovery to leave
+				// us in a reasonable position to try parsing the next item.
+				continue
+			}
+		default:
+			bad := p.Read()
+			if !p.recovery {
+				if bad.Type == TokenOQuote {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid argument name",
+						Detail:   "Argument names must not be quoted.",
+						Subject:  &bad.Range,
+					})
+				} else {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Argument or block definition required",
+						Detail:   "An argument or block definition is required here.",
+						Subject:  &bad.Range,
+					})
+				}
+			}
+			endRange = p.PrevRange() // arbitrary, but somewhere inside the body means better diagnostics
+
+			p.recover(end) // attempt to recover to the token after the end of this body
+			break Token
+		}
+	}
+
+	return &Body{
+		Attributes: attrs,
+		Blocks:     blocks,
+
+		SrcRange: hcl.RangeBetween(startRange, endRange),
+		EndRange: hcl.Range{
+			Filename: endRange.Filename,
+			Start:    endRange.End,
+			End:      endRange.End,
+		},
+	}, diags
+}
+
+func (p *parser) ParseBodyItem() (Node, hcl.Diagnostics) {
+	ident := p.Read()
+	if ident.Type != TokenIdent {
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument or block definition required",
+				Detail:   "An argument or block definition is required here.",
+				Subject:  &ident.Range,
+			},
+		}
+	}
+
+	next := p.Peek()
+
+	switch next.Type {
+	case TokenEqual:
+		return p.finishParsingBodyAttribute(ident, false)
+	case TokenOQuote, TokenOBrace, TokenIdent:
+		return p.finishParsingBodyBlock(ident)
+	default:
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument or block definition required",
+				Detail:   "An argument or block definition is required here. To set an argument, use the equals sign \"=\" to introduce the argument value.",
+				Subject:  &ident.Range,
+			},
+		}
+	}
+
+	return nil, nil
+}
+
+// parseSingleAttrBody is a weird variant of ParseBody that deals with the
+// body of a nested block containing only one attribute value all on a single
+// line, like foo { bar = baz } . It expects to find a single attribute item
+// immediately followed by the end token type with no intervening newlines.
+func (p *parser) parseSingleAttrBody(end TokenType) (*Body, hcl.Diagnostics) {
+	ident := p.Read()
+	if ident.Type != TokenIdent {
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument or block definition required",
+				Detail:   "An argument or block definition is required here.",
+				Subject:  &ident.Range,
+			},
+		}
+	}
+
+	var attr *Attribute
+	var diags hcl.Diagnostics
+
+	next := p.Peek()
+
+	switch next.Type {
+	case TokenEqual:
+		node, attrDiags := p.finishParsingBodyAttribute(ident, true)
+		diags = append(diags, attrDiags...)
+		attr = node.(*Attribute)
+	case TokenOQuote, TokenOBrace, TokenIdent:
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument definition required",
+				Detail:   fmt.Sprintf("A single-line block definition can contain only a single argument. If you meant to define argument %q, use an equals sign to assign it a value. To define a nested block, place it on a line of its own within its parent block.", ident.Bytes),
+				Subject:  hcl.RangeBetween(ident.Range, next.Range).Ptr(),
+			},
+		}
+	default:
+		p.recoverAfterBodyItem()
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Argument or block definition required",
+				Detail:   "An argument or block definition is required here. To set an argument, use the equals sign \"=\" to introduce the argument value.",
+				Subject:  &ident.Range,
+			},
+		}
+	}
+
+	return &Body{
+		Attributes: Attributes{
+			string(ident.Bytes): attr,
+		},
+
+		SrcRange: attr.SrcRange,
+		EndRange: hcl.Range{
+			Filename: attr.SrcRange.Filename,
+			Start:    attr.SrcRange.End,
+			End:      attr.SrcRange.End,
+		},
+	}, diags
+
+}
+
+func (p *parser) finishParsingBodyAttribute(ident Token, singleLine bool) (Node, hcl.Diagnostics) {
+	eqTok := p.Read() // eat equals token
+	if eqTok.Type != TokenEqual {
+		// should never happen if caller behaves
+		panic("finishParsingBodyAttribute called with next not equals")
+	}
+
+	var endRange hcl.Range
+
+	expr, diags := p.ParseExpression()
+	if p.recovery && diags.HasErrors() {
+		// recovery within expressions tends to be tricky, so we've probably
+		// landed somewhere weird. We'll try to reset to the start of a body
+		// item so parsing can continue.
+		endRange = p.PrevRange()
+		p.recoverAfterBodyItem()
+	} else {
+		endRange = p.PrevRange()
+		if !singleLine {
+			end := p.Peek()
+			if end.Type != TokenNewline && end.Type != TokenEOF {
+				if !p.recovery {
+					summary := "Missing newline after argument"
+					detail := "An argument definition must end with a newline."
+
+					if end.Type == TokenComma {
+						summary = "Unexpected comma after argument"
+						detail = "Argument definitions must be separated by newlines, not commas. " + detail
+					}
+
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  summary,
+						Detail:   detail,
+						Subject:  &end.Range,
+						Context:  hcl.RangeBetween(ident.Range, end.Range).Ptr(),
+					})
+				}
+				endRange = p.PrevRange()
+				p.recoverAfterBodyItem()
+			} else {
+				endRange = p.PrevRange()
+				p.Read() // eat newline
+			}
+		}
+	}
+
+	return &Attribute{
+		Name: string(ident.Bytes),
+		Expr: expr,
+
+		SrcRange:    hcl.RangeBetween(ident.Range, endRange),
+		NameRange:   ident.Range,
+		EqualsRange: eqTok.Range,
+	}, diags
+}
+
+func (p *parser) finishParsingBodyBlock(ident Token) (Node, hcl.Diagnostics) {
+	var blockType = string(ident.Bytes)
+	var diags hcl.Diagnostics
+	var labels []string
+	var labelRanges []hcl.Range
+
+	var oBrace Token
+
+Token:
+	for {
+		tok := p.Peek()
+
+		switch tok.Type {
+
+		case TokenOBrace:
+			oBrace = p.Read()
+			break Token
+
+		case TokenOQuote:
+			label, labelRange, labelDiags := p.parseQuotedStringLiteral()
+			diags = append(diags, labelDiags...)
+			labels = append(labels, label)
+			labelRanges = append(labelRanges, labelRange)
+			// parseQuoteStringLiteral recovers up to the closing quote
+			// if it encounters problems, so we can continue looking for
+			// more labels and eventually the block body even.
+
+		case TokenIdent:
+			tok = p.Read() // eat token
+			label, labelRange := string(tok.Bytes), tok.Range
+			labels = append(labels, label)
+			labelRanges = append(labelRanges, labelRange)
+
+		default:
+			switch tok.Type {
+			case TokenEqual:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid block definition",
+					Detail:   "The equals sign \"=\" indicates an argument definition, and must not be used when defining a block.",
+					Subject:  &tok.Range,
+					Context:  hcl.RangeBetween(ident.Range, tok.Range).Ptr(),
+				})
+			case TokenNewline:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid block definition",
+					Detail:   "A block definition must have block content delimited by \"{\" and \"}\", starting on the same line as the block header.",
+					Subject:  &tok.Range,
+					Context:  hcl.RangeBetween(ident.Range, tok.Range).Ptr(),
+				})
+			default:
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid block definition",
+						Detail:   "Either a quoted string block label or an opening brace (\"{\") is expected here.",
+						Subject:  &tok.Range,
+						Context:  hcl.RangeBetween(ident.Range, tok.Range).Ptr(),
+					})
+				}
+			}
+
+			p.recoverAfterBodyItem()
+
+			return &Block{
+				Type:   blockType,
+				Labels: labels,
+				Body: &Body{
+					SrcRange: ident.Range,
+					EndRange: ident.Range,
+				},
+
+				TypeRange:       ident.Range,
+				LabelRanges:     labelRanges,
+				OpenBraceRange:  ident.Range, // placeholder
+				CloseBraceRange: ident.Range, // placeholder
+			}, diags
+		}
+	}
+
+	// Once we fall out here, the peeker is pointed just after our opening
+	// brace, so we can begin our nested body parsing.
+	var body *Body
+	var bodyDiags hcl.Diagnostics
+	switch p.Peek().Type {
+	case TokenNewline, TokenEOF, TokenCBrace:
+		body, bodyDiags = p.ParseBody(TokenCBrace)
+	default:
+		// Special one-line, single-attribute block parsing mode.
+		body, bodyDiags = p.parseSingleAttrBody(TokenCBrace)
+		switch p.Peek().Type {
+		case TokenCBrace:
+			p.Read() // the happy path - just consume the closing brace
+		case TokenComma:
+			// User seems to be trying to use the object-constructor
+			// comma-separated style, which isn't permitted for blocks.
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid single-argument block definition",
+				Detail:   "Single-line block syntax can include only one argument definition. To define multiple arguments, use the multi-line block syntax with one argument definition per line.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+			p.recover(TokenCBrace)
+		case TokenNewline:
+			// We don't allow weird mixtures of single and multi-line syntax.
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid single-argument block definition",
+				Detail:   "An argument definition on the same line as its containing block creates a single-line block definition, which must also be closed on the same line. Place the block's closing brace immediately after the argument definition.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+			p.recover(TokenCBrace)
+		default:
+			// Some other weird thing is going on. Since we can't guess a likely
+			// user intent for this one, we'll skip it if we're already in
+			// recovery mode.
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid single-argument block definition",
+					Detail:   "A single-line block definition must end with a closing brace immediately after its single argument definition.",
+					Subject:  p.Peek().Range.Ptr(),
+				})
+			}
+			p.recover(TokenCBrace)
+		}
+	}
+	diags = append(diags, bodyDiags...)
+	cBraceRange := p.PrevRange()
+
+	eol := p.Peek()
+	if eol.Type == TokenNewline || eol.Type == TokenEOF {
+		p.Read() // eat newline
+	} else {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing newline after block definition",
+				Detail:   "A block definition must end with a newline.",
+				Subject:  &eol.Range,
+				Context:  hcl.RangeBetween(ident.Range, eol.Range).Ptr(),
+			})
+		}
+		p.recoverAfterBodyItem()
+	}
+
+	// We must never produce a nil body, since the caller may attempt to
+	// do analysis of a partial result when there's an error, so we'll
+	// insert a placeholder if we otherwise failed to produce a valid
+	// body due to one of the syntax error paths above.
+	if body == nil && diags.HasErrors() {
+		body = &Body{
+			SrcRange: hcl.RangeBetween(oBrace.Range, cBraceRange),
+			EndRange: cBraceRange,
+		}
+	}
+
+	return &Block{
+		Type:   blockType,
+		Labels: labels,
+		Body:   body,
+
+		TypeRange:       ident.Range,
+		LabelRanges:     labelRanges,
+		OpenBraceRange:  oBrace.Range,
+		CloseBraceRange: cBraceRange,
+	}, diags
+}
+
+func (p *parser) ParseExpression() (Expression, hcl.Diagnostics) {
+	return p.parseTernaryConditional()
+}
+
+func (p *parser) parseTernaryConditional() (Expression, hcl.Diagnostics) {
+	// The ternary conditional operator (.. ? .. : ..) behaves somewhat
+	// like a binary operator except that the "symbol" is itself
+	// an expression enclosed in two punctuation characters.
+	// The middle expression is parsed as if the ? and : symbols
+	// were parentheses. The "rhs" (the "false expression") is then
+	// treated right-associatively so it behaves similarly to the
+	// middle in terms of precedence.
+
+	startRange := p.NextRange()
+	var condExpr, trueExpr, falseExpr Expression
+	var diags hcl.Diagnostics
+
+	condExpr, condDiags := p.parseBinaryOps(binaryOps)
+	diags = append(diags, condDiags...)
+	if p.recovery && condDiags.HasErrors() {
+		return condExpr, diags
+	}
+
+	questionMark := p.Peek()
+	if questionMark.Type != TokenQuestion {
+		return condExpr, diags
+	}
+
+	p.Read() // eat question mark
+
+	trueExpr, trueDiags := p.ParseExpression()
+	diags = append(diags, trueDiags...)
+	if p.recovery && trueDiags.HasErrors() {
+		return condExpr, diags
+	}
+
+	colon := p.Peek()
+	if colon.Type != TokenColon {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Missing false expression in conditional",
+			Detail:   "The conditional operator (...?...:...) requires a false expression, delimited by a colon.",
+			Subject:  &colon.Range,
+			Context:  hcl.RangeBetween(startRange, colon.Range).Ptr(),
+		})
+		return condExpr, diags
+	}
+
+	p.Read() // eat colon
+
+	falseExpr, falseDiags := p.ParseExpression()
+	diags = append(diags, falseDiags...)
+	if p.recovery && falseDiags.HasErrors() {
+		return condExpr, diags
+	}
+
+	return &ConditionalExpr{
+		Condition:   condExpr,
+		TrueResult:  trueExpr,
+		FalseResult: falseExpr,
+
+		SrcRange: hcl.RangeBetween(startRange, falseExpr.Range()),
+	}, diags
+}
+
+// parseBinaryOps calls itself recursively to work through all of the
+// operator precedence groups, and then eventually calls parseExpressionTerm
+// for each operand.
+func (p *parser) parseBinaryOps(ops []map[TokenType]*Operation) (Expression, hcl.Diagnostics) {
+	if len(ops) == 0 {
+		// We've run out of operators, so now we'll just try to parse a term.
+		return p.parseExpressionWithTraversals()
+	}
+
+	thisLevel := ops[0]
+	remaining := ops[1:]
+
+	var lhs, rhs Expression
+	var operation *Operation
+	var diags hcl.Diagnostics
+
+	// Parse a term that might be the first operand of a binary
+	// operation or it might just be a standalone term.
+	// We won't know until we've parsed it and can look ahead
+	// to see if there's an operator token for this level.
+	lhs, lhsDiags := p.parseBinaryOps(remaining)
+	diags = append(diags, lhsDiags...)
+	if p.recovery && lhsDiags.HasErrors() {
+		return lhs, diags
+	}
+
+	// We'll keep eating up operators until we run out, so that operators
+	// with the same precedence will combine in a left-associative manner:
+	// a+b+c => (a+b)+c, not a+(b+c)
+	//
+	// Should we later want to have right-associative operators, a way
+	// to achieve that would be to call back up to ParseExpression here
+	// instead of iteratively parsing only the remaining operators.
+	for {
+		next := p.Peek()
+		var newOp *Operation
+		var ok bool
+		if newOp, ok = thisLevel[next.Type]; !ok {
+			break
+		}
+
+		// Are we extending an expression started on the previous iteration?
+		if operation != nil {
+			lhs = &BinaryOpExpr{
+				LHS: lhs,
+				Op:  operation,
+				RHS: rhs,
+
+				SrcRange: hcl.RangeBetween(lhs.Range(), rhs.Range()),
+			}
+		}
+
+		operation = newOp
+		p.Read() // eat operator token
+		var rhsDiags hcl.Diagnostics
+		rhs, rhsDiags = p.parseBinaryOps(remaining)
+		diags = append(diags, rhsDiags...)
+		if p.recovery && rhsDiags.HasErrors() {
+			return lhs, diags
+		}
+	}
+
+	if operation == nil {
+		return lhs, diags
+	}
+
+	return &BinaryOpExpr{
+		LHS: lhs,
+		Op:  operation,
+		RHS: rhs,
+
+		SrcRange: hcl.RangeBetween(lhs.Range(), rhs.Range()),
+	}, diags
+}
+
+func (p *parser) parseExpressionWithTraversals() (Expression, hcl.Diagnostics) {
+	term, diags := p.parseExpressionTerm()
+	ret, moreDiags := p.parseExpressionTraversals(term)
+	diags = append(diags, moreDiags...)
+	return ret, diags
+}
+
+func (p *parser) parseExpressionTraversals(from Expression) (Expression, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	ret := from
+
+Traversal:
+	for {
+		next := p.Peek()
+
+		switch next.Type {
+		case TokenDot:
+			// Attribute access or splat
+			dot := p.Read()
+			attrTok := p.Peek()
+
+			switch attrTok.Type {
+			case TokenIdent:
+				attrTok = p.Read() // eat token
+				name := string(attrTok.Bytes)
+				rng := hcl.RangeBetween(dot.Range, attrTok.Range)
+				step := hcl.TraverseAttr{
+					Name:     name,
+					SrcRange: rng,
+				}
+
+				ret = makeRelativeTraversal(ret, step, rng)
+
+			case TokenNumberLit:
+				// This is a weird form we inherited from HIL, allowing numbers
+				// to be used as attributes as a weird way of writing [n].
+				// This was never actually a first-class thing in HIL, but
+				// HIL tolerated sequences like .0. in its variable names and
+				// calling applications like Terraform exploited that to
+				// introduce indexing syntax where none existed.
+				numTok := p.Read() // eat token
+				attrTok = numTok
+
+				// This syntax is ambiguous if multiple indices are used in
+				// succession, like foo.0.1.baz: that actually parses as
+				// a fractional number 0.1. Since we're only supporting this
+				// syntax for compatibility with legacy Terraform
+				// configurations, and Terraform does not tend to have lists
+				// of lists, we'll choose to reject that here with a helpful
+				// error message, rather than failing later because the index
+				// isn't a whole number.
+				if dotIdx := bytes.IndexByte(numTok.Bytes, '.'); dotIdx >= 0 {
+					first := numTok.Bytes[:dotIdx]
+					second := numTok.Bytes[dotIdx+1:]
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid legacy index syntax",
+						Detail:   fmt.Sprintf("When using the legacy index syntax, chaining two indexes together is not permitted. Use the proper index syntax instead, like [%s][%s].", first, second),
+						Subject:  &attrTok.Range,
+					})
+					rng := hcl.RangeBetween(dot.Range, numTok.Range)
+					step := hcl.TraverseIndex{
+						Key:      cty.DynamicVal,
+						SrcRange: rng,
+					}
+					ret = makeRelativeTraversal(ret, step, rng)
+					break
+				}
+
+				numVal, numDiags := p.numberLitValue(numTok)
+				diags = append(diags, numDiags...)
+
+				rng := hcl.RangeBetween(dot.Range, numTok.Range)
+				step := hcl.TraverseIndex{
+					Key:      numVal,
+					SrcRange: rng,
+				}
+
+				ret = makeRelativeTraversal(ret, step, rng)
+
+			case TokenStar:
+				// "Attribute-only" splat expression.
+				// (This is a kinda weird construct inherited from HIL, which
+				// behaves a bit like a [*] splat except that it is only able
+				// to do attribute traversals into each of its elements,
+				// whereas foo[*] can support _any_ traversal.
+				marker := p.Read() // eat star
+				trav := make(hcl.Traversal, 0, 1)
+				var firstRange, lastRange hcl.Range
+				firstRange = p.NextRange()
+				for p.Peek().Type == TokenDot {
+					dot := p.Read()
+
+					if p.Peek().Type == TokenNumberLit {
+						// Continuing the "weird stuff inherited from HIL"
+						// theme, we also allow numbers as attribute names
+						// inside splats and interpret them as indexing
+						// into a list, for expressions like:
+						// foo.bar.*.baz.0.foo
+						numTok := p.Read()
+
+						// Weird special case if the user writes something
+						// like foo.bar.*.baz.0.0.foo, where 0.0 parses
+						// as a number.
+						if dotIdx := bytes.IndexByte(numTok.Bytes, '.'); dotIdx >= 0 {
+							first := numTok.Bytes[:dotIdx]
+							second := numTok.Bytes[dotIdx+1:]
+							diags = append(diags, &hcl.Diagnostic{
+								Severity: hcl.DiagError,
+								Summary:  "Invalid legacy index syntax",
+								Detail:   fmt.Sprintf("When using the legacy index syntax, chaining two indexes together is not permitted. Use the proper index syntax with a full splat expression [*] instead, like [%s][%s].", first, second),
+								Subject:  &attrTok.Range,
+							})
+							trav = append(trav, hcl.TraverseIndex{
+								Key:      cty.DynamicVal,
+								SrcRange: hcl.RangeBetween(dot.Range, numTok.Range),
+							})
+							lastRange = numTok.Range
+							continue
+						}
+
+						numVal, numDiags := p.numberLitValue(numTok)
+						diags = append(diags, numDiags...)
+						trav = append(trav, hcl.TraverseIndex{
+							Key:      numVal,
+							SrcRange: hcl.RangeBetween(dot.Range, numTok.Range),
+						})
+						lastRange = numTok.Range
+						continue
+					}
+
+					if p.Peek().Type != TokenIdent {
+						if !p.recovery {
+							if p.Peek().Type == TokenStar {
+								diags = append(diags, &hcl.Diagnostic{
+									Severity: hcl.DiagError,
+									Summary:  "Nested splat expression not allowed",
+									Detail:   "A splat expression (*) cannot be used inside another attribute-only splat expression.",
+									Subject:  p.Peek().Range.Ptr(),
+								})
+							} else {
+								diags = append(diags, &hcl.Diagnostic{
+									Severity: hcl.DiagError,
+									Summary:  "Invalid attribute name",
+									Detail:   "An attribute name is required after a dot.",
+									Subject:  &attrTok.Range,
+								})
+							}
+						}
+						p.setRecovery()
+						continue Traversal
+					}
+
+					attrTok := p.Read()
+					trav = append(trav, hcl.TraverseAttr{
+						Name:     string(attrTok.Bytes),
+						SrcRange: hcl.RangeBetween(dot.Range, attrTok.Range),
+					})
+					lastRange = attrTok.Range
+				}
+
+				itemExpr := &AnonSymbolExpr{
+					SrcRange: hcl.RangeBetween(dot.Range, marker.Range),
+				}
+				var travExpr Expression
+				if len(trav) == 0 {
+					travExpr = itemExpr
+				} else {
+					travExpr = &RelativeTraversalExpr{
+						Source:    itemExpr,
+						Traversal: trav,
+						SrcRange:  hcl.RangeBetween(firstRange, lastRange),
+					}
+				}
+
+				ret = &SplatExpr{
+					Source: ret,
+					Each:   travExpr,
+					Item:   itemExpr,
+
+					SrcRange:    hcl.RangeBetween(dot.Range, lastRange),
+					MarkerRange: hcl.RangeBetween(dot.Range, marker.Range),
+				}
+
+			default:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid attribute name",
+					Detail:   "An attribute name is required after a dot.",
+					Subject:  &attrTok.Range,
+				})
+				// This leaves the peeker in a bad place, so following items
+				// will probably be misparsed until we hit something that
+				// allows us to re-sync.
+				//
+				// We will probably need to do something better here eventually
+				// in order to support autocomplete triggered by typing a
+				// period.
+				p.setRecovery()
+			}
+
+		case TokenOBrack:
+			// Indexing of a collection.
+			// This may or may not be a hcl.Traverser, depending on whether
+			// the key value is something constant.
+
+			open := p.Read()
+			switch p.Peek().Type {
+			case TokenStar:
+				// This is a full splat expression, like foo[*], which consumes
+				// the rest of the traversal steps after it using a recursive
+				// call to this function.
+				p.Read() // consume star
+				close := p.Read()
+				if close.Type != TokenCBrack && !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing close bracket on splat index",
+						Detail:   "The star for a full splat operator must be immediately followed by a closing bracket (\"]\").",
+						Subject:  &close.Range,
+					})
+					close = p.recover(TokenCBrack)
+				}
+				// Splat expressions use a special "anonymous symbol"  as a
+				// placeholder in an expression to be evaluated once for each
+				// item in the source expression.
+				itemExpr := &AnonSymbolExpr{
+					SrcRange: hcl.RangeBetween(open.Range, close.Range),
+				}
+				// Now we'll recursively call this same function to eat any
+				// remaining traversal steps against the anonymous symbol.
+				travExpr, nestedDiags := p.parseExpressionTraversals(itemExpr)
+				diags = append(diags, nestedDiags...)
+
+				ret = &SplatExpr{
+					Source: ret,
+					Each:   travExpr,
+					Item:   itemExpr,
+
+					SrcRange:    hcl.RangeBetween(open.Range, travExpr.Range()),
+					MarkerRange: hcl.RangeBetween(open.Range, close.Range),
+				}
+
+			default:
+
+				var close Token
+				p.PushIncludeNewlines(false) // arbitrary newlines allowed in brackets
+				keyExpr, keyDiags := p.ParseExpression()
+				diags = append(diags, keyDiags...)
+				if p.recovery && keyDiags.HasErrors() {
+					close = p.recover(TokenCBrack)
+				} else {
+					close = p.Read()
+					if close.Type != TokenCBrack && !p.recovery {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity: hcl.DiagError,
+							Summary:  "Missing close bracket on index",
+							Detail:   "The index operator must end with a closing bracket (\"]\").",
+							Subject:  &close.Range,
+						})
+						close = p.recover(TokenCBrack)
+					}
+				}
+				p.PopIncludeNewlines()
+
+				if lit, isLit := keyExpr.(*LiteralValueExpr); isLit {
+					litKey, _ := lit.Value(nil)
+					rng := hcl.RangeBetween(open.Range, close.Range)
+					step := hcl.TraverseIndex{
+						Key:      litKey,
+						SrcRange: rng,
+					}
+					ret = makeRelativeTraversal(ret, step, rng)
+				} else if tmpl, isTmpl := keyExpr.(*TemplateExpr); isTmpl && tmpl.IsStringLiteral() {
+					litKey, _ := tmpl.Value(nil)
+					rng := hcl.RangeBetween(open.Range, close.Range)
+					step := hcl.TraverseIndex{
+						Key:      litKey,
+						SrcRange: rng,
+					}
+					ret = makeRelativeTraversal(ret, step, rng)
+				} else {
+					rng := hcl.RangeBetween(open.Range, close.Range)
+					ret = &IndexExpr{
+						Collection: ret,
+						Key:        keyExpr,
+
+						SrcRange:  rng,
+						OpenRange: open.Range,
+					}
+				}
+			}
+
+		default:
+			break Traversal
+		}
+	}
+
+	return ret, diags
+}
+
+// makeRelativeTraversal takes an expression and a traverser and returns
+// a traversal expression that combines the two. If the given expression
+// is already a traversal, it is extended in place (mutating it) and
+// returned. If it isn't, a new RelativeTraversalExpr is created and returned.
+func makeRelativeTraversal(expr Expression, next hcl.Traverser, rng hcl.Range) Expression {
+	switch texpr := expr.(type) {
+	case *ScopeTraversalExpr:
+		texpr.Traversal = append(texpr.Traversal, next)
+		texpr.SrcRange = hcl.RangeBetween(texpr.SrcRange, rng)
+		return texpr
+	case *RelativeTraversalExpr:
+		texpr.Traversal = append(texpr.Traversal, next)
+		texpr.SrcRange = hcl.RangeBetween(texpr.SrcRange, rng)
+		return texpr
+	default:
+		return &RelativeTraversalExpr{
+			Source:    expr,
+			Traversal: hcl.Traversal{next},
+			SrcRange:  rng,
+		}
+	}
+}
+
+func (p *parser) parseExpressionTerm() (Expression, hcl.Diagnostics) {
+	start := p.Peek()
+
+	switch start.Type {
+	case TokenOParen:
+		p.Read() // eat open paren
+
+		p.PushIncludeNewlines(false)
+
+		expr, diags := p.ParseExpression()
+		if diags.HasErrors() {
+			// attempt to place the peeker after our closing paren
+			// before we return, so that the next parser has some
+			// chance of finding a valid expression.
+			p.recover(TokenCParen)
+			p.PopIncludeNewlines()
+			return expr, diags
+		}
+
+		close := p.Peek()
+		if close.Type != TokenCParen {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unbalanced parentheses",
+				Detail:   "Expected a closing parenthesis to terminate the expression.",
+				Subject:  &close.Range,
+				Context:  hcl.RangeBetween(start.Range, close.Range).Ptr(),
+			})
+			p.setRecovery()
+		}
+
+		p.Read() // eat closing paren
+		p.PopIncludeNewlines()
+
+		return expr, diags
+
+	case TokenNumberLit:
+		tok := p.Read() // eat number token
+
+		numVal, diags := p.numberLitValue(tok)
+		return &LiteralValueExpr{
+			Val:      numVal,
+			SrcRange: tok.Range,
+		}, diags
+
+	case TokenIdent:
+		tok := p.Read() // eat identifier token
+
+		if p.Peek().Type == TokenOParen {
+			return p.finishParsingFunctionCall(tok)
+		}
+
+		name := string(tok.Bytes)
+		switch name {
+		case "true":
+			return &LiteralValueExpr{
+				Val:      cty.True,
+				SrcRange: tok.Range,
+			}, nil
+		case "false":
+			return &LiteralValueExpr{
+				Val:      cty.False,
+				SrcRange: tok.Range,
+			}, nil
+		case "null":
+			return &LiteralValueExpr{
+				Val:      cty.NullVal(cty.DynamicPseudoType),
+				SrcRange: tok.Range,
+			}, nil
+		default:
+			return &ScopeTraversalExpr{
+				Traversal: hcl.Traversal{
+					hcl.TraverseRoot{
+						Name:     name,
+						SrcRange: tok.Range,
+					},
+				},
+				SrcRange: tok.Range,
+			}, nil
+		}
+
+	case TokenOQuote, TokenOHeredoc:
+		open := p.Read() // eat opening marker
+		closer := p.oppositeBracket(open.Type)
+		exprs, passthru, _, diags := p.parseTemplateInner(closer, tokenOpensFlushHeredoc(open))
+
+		closeRange := p.PrevRange()
+
+		if passthru {
+			if len(exprs) != 1 {
+				panic("passthru set with len(exprs) != 1")
+			}
+			return &TemplateWrapExpr{
+				Wrapped:  exprs[0],
+				SrcRange: hcl.RangeBetween(open.Range, closeRange),
+			}, diags
+		}
+
+		return &TemplateExpr{
+			Parts:    exprs,
+			SrcRange: hcl.RangeBetween(open.Range, closeRange),
+		}, diags
+
+	case TokenMinus:
+		tok := p.Read() // eat minus token
+
+		// Important to use parseExpressionWithTraversals rather than parseExpression
+		// here, otherwise we can capture a following binary expression into
+		// our negation.
+		// e.g. -46+5 should parse as (-46)+5, not -(46+5)
+		operand, diags := p.parseExpressionWithTraversals()
+		return &UnaryOpExpr{
+			Op:  OpNegate,
+			Val: operand,
+
+			SrcRange:    hcl.RangeBetween(tok.Range, operand.Range()),
+			SymbolRange: tok.Range,
+		}, diags
+
+	case TokenBang:
+		tok := p.Read() // eat bang token
+
+		// Important to use parseExpressionWithTraversals rather than parseExpression
+		// here, otherwise we can capture a following binary expression into
+		// our negation.
+		operand, diags := p.parseExpressionWithTraversals()
+		return &UnaryOpExpr{
+			Op:  OpLogicalNot,
+			Val: operand,
+
+			SrcRange:    hcl.RangeBetween(tok.Range, operand.Range()),
+			SymbolRange: tok.Range,
+		}, diags
+
+	case TokenOBrack:
+		return p.parseTupleCons()
+
+	case TokenOBrace:
+		return p.parseObjectCons()
+
+	default:
+		var diags hcl.Diagnostics
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid expression",
+				Detail:   "Expected the start of an expression, but found an invalid expression token.",
+				Subject:  &start.Range,
+			})
+		}
+		p.setRecovery()
+
+		// Return a placeholder so that the AST is still structurally sound
+		// even in the presence of parse errors.
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: start.Range,
+		}, diags
+	}
+}
+
+func (p *parser) numberLitValue(tok Token) (cty.Value, hcl.Diagnostics) {
+	// The cty.ParseNumberVal is always the same behavior as converting a
+	// string to a number, ensuring we always interpret decimal numbers in
+	// the same way.
+	numVal, err := cty.ParseNumberVal(string(tok.Bytes))
+	if err != nil {
+		ret := cty.UnknownVal(cty.Number)
+		return ret, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid number literal",
+				// FIXME: not a very good error message, but convert only
+				// gives us "a number is required", so not much help either.
+				Detail:  "Failed to recognize the value of this number literal.",
+				Subject: &tok.Range,
+			},
+		}
+	}
+	return numVal, nil
+}
+
+// finishParsingFunctionCall parses a function call assuming that the function
+// name was already read, and so the peeker should be pointing at the opening
+// parenthesis after the name.
+func (p *parser) finishParsingFunctionCall(name Token) (Expression, hcl.Diagnostics) {
+	openTok := p.Read()
+	if openTok.Type != TokenOParen {
+		// should never happen if callers behave
+		panic("finishParsingFunctionCall called with non-parenthesis as next token")
+	}
+
+	var args []Expression
+	var diags hcl.Diagnostics
+	var expandFinal bool
+	var closeTok Token
+
+	// Arbitrary newlines are allowed inside the function call parentheses.
+	p.PushIncludeNewlines(false)
+
+Token:
+	for {
+		tok := p.Peek()
+
+		if tok.Type == TokenCParen {
+			closeTok = p.Read() // eat closing paren
+			break Token
+		}
+
+		arg, argDiags := p.ParseExpression()
+		args = append(args, arg)
+		diags = append(diags, argDiags...)
+		if p.recovery && argDiags.HasErrors() {
+			// if there was a parse error in the argument then we've
+			// probably been left in a weird place in the token stream,
+			// so we'll bail out with a partial argument list.
+			p.recover(TokenCParen)
+			break Token
+		}
+
+		sep := p.Read()
+		if sep.Type == TokenCParen {
+			closeTok = sep
+			break Token
+		}
+
+		if sep.Type == TokenEllipsis {
+			expandFinal = true
+
+			if p.Peek().Type != TokenCParen {
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing closing parenthesis",
+						Detail:   "An expanded function argument (with ...) must be immediately followed by closing parentheses.",
+						Subject:  &sep.Range,
+						Context:  hcl.RangeBetween(name.Range, sep.Range).Ptr(),
+					})
+				}
+				closeTok = p.recover(TokenCParen)
+			} else {
+				closeTok = p.Read() // eat closing paren
+			}
+			break Token
+		}
+
+		if sep.Type != TokenComma {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing argument separator",
+				Detail:   "A comma is required to separate each function argument from the next.",
+				Subject:  &sep.Range,
+				Context:  hcl.RangeBetween(name.Range, sep.Range).Ptr(),
+			})
+			closeTok = p.recover(TokenCParen)
+			break Token
+		}
+
+		if p.Peek().Type == TokenCParen {
+			// A trailing comma after the last argument gets us in here.
+			closeTok = p.Read() // eat closing paren
+			break Token
+		}
+
+	}
+
+	p.PopIncludeNewlines()
+
+	return &FunctionCallExpr{
+		Name: string(name.Bytes),
+		Args: args,
+
+		ExpandFinal: expandFinal,
+
+		NameRange:       name.Range,
+		OpenParenRange:  openTok.Range,
+		CloseParenRange: closeTok.Range,
+	}, diags
+}
+
+func (p *parser) parseTupleCons() (Expression, hcl.Diagnostics) {
+	open := p.Read()
+	if open.Type != TokenOBrack {
+		// Should never happen if callers are behaving
+		panic("parseTupleCons called without peeker pointing to open bracket")
+	}
+
+	p.PushIncludeNewlines(false)
+	defer p.PopIncludeNewlines()
+
+	if forKeyword.TokenMatches(p.Peek()) {
+		return p.finishParsingForExpr(open)
+	}
+
+	var close Token
+
+	var diags hcl.Diagnostics
+	var exprs []Expression
+
+	for {
+		next := p.Peek()
+		if next.Type == TokenCBrack {
+			close = p.Read() // eat closer
+			break
+		}
+
+		expr, exprDiags := p.ParseExpression()
+		exprs = append(exprs, expr)
+		diags = append(diags, exprDiags...)
+
+		if p.recovery && exprDiags.HasErrors() {
+			// If expression parsing failed then we are probably in a strange
+			// place in the token stream, so we'll bail out and try to reset
+			// to after our closing bracket to allow parsing to continue.
+			close = p.recover(TokenCBrack)
+			break
+		}
+
+		next = p.Peek()
+		if next.Type == TokenCBrack {
+			close = p.Read() // eat closer
+			break
+		}
+
+		if next.Type != TokenComma {
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing item separator",
+					Detail:   "Expected a comma to mark the beginning of the next item.",
+					Subject:  &next.Range,
+					Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+				})
+			}
+			close = p.recover(TokenCBrack)
+			break
+		}
+
+		p.Read() // eat comma
+
+	}
+
+	return &TupleConsExpr{
+		Exprs: exprs,
+
+		SrcRange:  hcl.RangeBetween(open.Range, close.Range),
+		OpenRange: open.Range,
+	}, diags
+}
+
+func (p *parser) parseObjectCons() (Expression, hcl.Diagnostics) {
+	open := p.Read()
+	if open.Type != TokenOBrace {
+		// Should never happen if callers are behaving
+		panic("parseObjectCons called without peeker pointing to open brace")
+	}
+
+	// We must temporarily stop looking at newlines here while we check for
+	// a "for" keyword, since for expressions are _not_ newline-sensitive,
+	// even though object constructors are.
+	p.PushIncludeNewlines(false)
+	isFor := forKeyword.TokenMatches(p.Peek())
+	p.PopIncludeNewlines()
+	if isFor {
+		return p.finishParsingForExpr(open)
+	}
+
+	p.PushIncludeNewlines(true)
+	defer p.PopIncludeNewlines()
+
+	var close Token
+
+	var diags hcl.Diagnostics
+	var items []ObjectConsItem
+
+	for {
+		next := p.Peek()
+		if next.Type == TokenNewline {
+			p.Read() // eat newline
+			continue
+		}
+
+		if next.Type == TokenCBrace {
+			close = p.Read() // eat closer
+			break
+		}
+
+		// Wrapping parens are not explicitly represented in the AST, but
+		// we want to use them here to disambiguate intepreting a mapping
+		// key as a full expression rather than just a name, and so
+		// we'll remember this was present and use it to force the
+		// behavior of our final ObjectConsKeyExpr.
+		forceNonLiteral := (p.Peek().Type == TokenOParen)
+
+		var key Expression
+		var keyDiags hcl.Diagnostics
+		key, keyDiags = p.ParseExpression()
+		diags = append(diags, keyDiags...)
+
+		if p.recovery && keyDiags.HasErrors() {
+			// If expression parsing failed then we are probably in a strange
+			// place in the token stream, so we'll bail out and try to reset
+			// to after our closing brace to allow parsing to continue.
+			close = p.recover(TokenCBrace)
+			break
+		}
+
+		// We wrap up the key expression in a special wrapper that deals
+		// with our special case that naked identifiers as object keys
+		// are interpreted as literal strings.
+		key = &ObjectConsKeyExpr{
+			Wrapped:         key,
+			ForceNonLiteral: forceNonLiteral,
+		}
+
+		next = p.Peek()
+		if next.Type != TokenEqual && next.Type != TokenColon {
+			if !p.recovery {
+				switch next.Type {
+				case TokenNewline, TokenComma:
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing attribute value",
+						Detail:   "Expected an attribute value, introduced by an equals sign (\"=\").",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+					})
+				case TokenIdent:
+					// Although this might just be a plain old missing equals
+					// sign before a reference, one way to get here is to try
+					// to write an attribute name containing a period followed
+					// by a digit, which was valid in HCL1, like this:
+					//     foo1.2_bar = "baz"
+					// We can't know exactly what the user intended here, but
+					// we'll augment our message with an extra hint in this case
+					// in case it is helpful.
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing key/value separator",
+						Detail:   "Expected an equals sign (\"=\") to mark the beginning of the attribute value. If you intended to given an attribute name containing periods or spaces, write the name in quotes to create a string literal.",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+					})
+				default:
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing key/value separator",
+						Detail:   "Expected an equals sign (\"=\") to mark the beginning of the attribute value.",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+					})
+				}
+			}
+			close = p.recover(TokenCBrace)
+			break
+		}
+
+		p.Read() // eat equals sign or colon
+
+		value, valueDiags := p.ParseExpression()
+		diags = append(diags, valueDiags...)
+
+		if p.recovery && valueDiags.HasErrors() {
+			// If expression parsing failed then we are probably in a strange
+			// place in the token stream, so we'll bail out and try to reset
+			// to after our closing brace to allow parsing to continue.
+			close = p.recover(TokenCBrace)
+			break
+		}
+
+		items = append(items, ObjectConsItem{
+			KeyExpr:   key,
+			ValueExpr: value,
+		})
+
+		next = p.Peek()
+		if next.Type == TokenCBrace {
+			close = p.Read() // eat closer
+			break
+		}
+
+		if next.Type != TokenComma && next.Type != TokenNewline {
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing attribute separator",
+					Detail:   "Expected a newline or comma to mark the beginning of the next attribute.",
+					Subject:  &next.Range,
+					Context:  hcl.RangeBetween(open.Range, next.Range).Ptr(),
+				})
+			}
+			close = p.recover(TokenCBrace)
+			break
+		}
+
+		p.Read() // eat comma or newline
+
+	}
+
+	return &ObjectConsExpr{
+		Items: items,
+
+		SrcRange:  hcl.RangeBetween(open.Range, close.Range),
+		OpenRange: open.Range,
+	}, diags
+}
+
+func (p *parser) finishParsingForExpr(open Token) (Expression, hcl.Diagnostics) {
+	p.PushIncludeNewlines(false)
+	defer p.PopIncludeNewlines()
+	introducer := p.Read()
+	if !forKeyword.TokenMatches(introducer) {
+		// Should never happen if callers are behaving
+		panic("finishParsingForExpr called without peeker pointing to 'for' identifier")
+	}
+
+	var makeObj bool
+	var closeType TokenType
+	switch open.Type {
+	case TokenOBrace:
+		makeObj = true
+		closeType = TokenCBrace
+	case TokenOBrack:
+		makeObj = false // making a tuple
+		closeType = TokenCBrack
+	default:
+		// Should never happen if callers are behaving
+		panic("finishParsingForExpr called with invalid open token")
+	}
+
+	var diags hcl.Diagnostics
+	var keyName, valName string
+
+	if p.Peek().Type != TokenIdent {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "For expression requires variable name after 'for'.",
+				Subject:  p.Peek().Range.Ptr(),
+				Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+			})
+		}
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+
+	valName = string(p.Read().Bytes)
+
+	if p.Peek().Type == TokenComma {
+		// What we just read was actually the key, then.
+		keyName = valName
+		p.Read() // eat comma
+
+		if p.Peek().Type != TokenIdent {
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid 'for' expression",
+					Detail:   "For expression requires value variable name after comma.",
+					Subject:  p.Peek().Range.Ptr(),
+					Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+				})
+			}
+			close := p.recover(closeType)
+			return &LiteralValueExpr{
+				Val:      cty.DynamicVal,
+				SrcRange: hcl.RangeBetween(open.Range, close.Range),
+			}, diags
+		}
+
+		valName = string(p.Read().Bytes)
+	}
+
+	if !inKeyword.TokenMatches(p.Peek()) {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "For expression requires the 'in' keyword after its name declarations.",
+				Subject:  p.Peek().Range.Ptr(),
+				Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+			})
+		}
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+	p.Read() // eat 'in' keyword
+
+	collExpr, collDiags := p.ParseExpression()
+	diags = append(diags, collDiags...)
+	if p.recovery && collDiags.HasErrors() {
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+
+	if p.Peek().Type != TokenColon {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "For expression requires a colon after the collection expression.",
+				Subject:  p.Peek().Range.Ptr(),
+				Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+			})
+		}
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+	p.Read() // eat colon
+
+	var keyExpr, valExpr Expression
+	var keyDiags, valDiags hcl.Diagnostics
+	valExpr, valDiags = p.ParseExpression()
+	if p.Peek().Type == TokenFatArrow {
+		// What we just parsed was actually keyExpr
+		p.Read() // eat the fat arrow
+		keyExpr, keyDiags = valExpr, valDiags
+
+		valExpr, valDiags = p.ParseExpression()
+	}
+	diags = append(diags, keyDiags...)
+	diags = append(diags, valDiags...)
+	if p.recovery && (keyDiags.HasErrors() || valDiags.HasErrors()) {
+		close := p.recover(closeType)
+		return &LiteralValueExpr{
+			Val:      cty.DynamicVal,
+			SrcRange: hcl.RangeBetween(open.Range, close.Range),
+		}, diags
+	}
+
+	group := false
+	var ellipsis Token
+	if p.Peek().Type == TokenEllipsis {
+		ellipsis = p.Read()
+		group = true
+	}
+
+	var condExpr Expression
+	var condDiags hcl.Diagnostics
+	if ifKeyword.TokenMatches(p.Peek()) {
+		p.Read() // eat "if"
+		condExpr, condDiags = p.ParseExpression()
+		diags = append(diags, condDiags...)
+		if p.recovery && condDiags.HasErrors() {
+			close := p.recover(p.oppositeBracket(open.Type))
+			return &LiteralValueExpr{
+				Val:      cty.DynamicVal,
+				SrcRange: hcl.RangeBetween(open.Range, close.Range),
+			}, diags
+		}
+	}
+
+	var close Token
+	if p.Peek().Type == closeType {
+		close = p.Read()
+	} else {
+		if !p.recovery {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "Extra characters after the end of the 'for' expression.",
+				Subject:  p.Peek().Range.Ptr(),
+				Context:  hcl.RangeBetween(open.Range, p.Peek().Range).Ptr(),
+			})
+		}
+		close = p.recover(closeType)
+	}
+
+	if !makeObj {
+		if keyExpr != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "Key expression is not valid when building a tuple.",
+				Subject:  keyExpr.Range().Ptr(),
+				Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+			})
+		}
+
+		if group {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "Grouping ellipsis (...) cannot be used when building a tuple.",
+				Subject:  &ellipsis.Range,
+				Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+			})
+		}
+	} else {
+		if keyExpr == nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid 'for' expression",
+				Detail:   "Key expression is required when building an object.",
+				Subject:  valExpr.Range().Ptr(),
+				Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+			})
+		}
+	}
+
+	return &ForExpr{
+		KeyVar:   keyName,
+		ValVar:   valName,
+		CollExpr: collExpr,
+		KeyExpr:  keyExpr,
+		ValExpr:  valExpr,
+		CondExpr: condExpr,
+		Group:    group,
+
+		SrcRange:   hcl.RangeBetween(open.Range, close.Range),
+		OpenRange:  open.Range,
+		CloseRange: close.Range,
+	}, diags
+}
+
+// parseQuotedStringLiteral is a helper for parsing quoted strings that
+// aren't allowed to contain any interpolations, such as block labels.
+func (p *parser) parseQuotedStringLiteral() (string, hcl.Range, hcl.Diagnostics) {
+	oQuote := p.Read()
+	if oQuote.Type != TokenOQuote {
+		return "", oQuote.Range, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid string literal",
+				Detail:   "A quoted string is required here.",
+				Subject:  &oQuote.Range,
+			},
+		}
+	}
+
+	var diags hcl.Diagnostics
+	ret := &bytes.Buffer{}
+	var cQuote Token
+
+Token:
+	for {
+		tok := p.Read()
+		switch tok.Type {
+
+		case TokenCQuote:
+			cQuote = tok
+			break Token
+
+		case TokenQuotedLit:
+			s, sDiags := ParseStringLiteralToken(tok)
+			diags = append(diags, sDiags...)
+			ret.WriteString(s)
+
+		case TokenTemplateControl, TokenTemplateInterp:
+			which := "$"
+			if tok.Type == TokenTemplateControl {
+				which = "%"
+			}
+
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid string literal",
+				Detail: fmt.Sprintf(
+					"Template sequences are not allowed in this string. To include a literal %q, double it (as \"%s%s\") to escape it.",
+					which, which, which,
+				),
+				Subject: &tok.Range,
+				Context: hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(),
+			})
+
+			// Now that we're returning an error callers won't attempt to use
+			// the result for any real operations, but they might try to use
+			// the partial AST for other analyses, so we'll leave a marker
+			// to indicate that there was something invalid in the string to
+			// help avoid misinterpretation of the partial result
+			ret.WriteString(which)
+			ret.WriteString("{ ... }")
+
+			p.recover(TokenTemplateSeqEnd) // we'll try to keep parsing after the sequence ends
+
+		case TokenEOF:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unterminated string literal",
+				Detail:   "Unable to find the closing quote mark before the end of the file.",
+				Subject:  &tok.Range,
+				Context:  hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(),
+			})
+			break Token
+
+		default:
+			// Should never happen, as long as the scanner is behaving itself
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid string literal",
+				Detail:   "This item is not valid in a string literal.",
+				Subject:  &tok.Range,
+				Context:  hcl.RangeBetween(oQuote.Range, tok.Range).Ptr(),
+			})
+			p.recover(TokenCQuote)
+			break Token
+
+		}
+
+	}
+
+	return ret.String(), hcl.RangeBetween(oQuote.Range, cQuote.Range), diags
+}
+
+// ParseStringLiteralToken processes the given token, which must be either a
+// TokenQuotedLit or a TokenStringLit, returning the string resulting from
+// resolving any escape sequences.
+//
+// If any error diagnostics are returned, the returned string may be incomplete
+// or otherwise invalid.
+func ParseStringLiteralToken(tok Token) (string, hcl.Diagnostics) {
+	var quoted bool
+	switch tok.Type {
+	case TokenQuotedLit:
+		quoted = true
+	case TokenStringLit:
+		quoted = false
+	default:
+		panic("ParseStringLiteralToken can only be used with TokenStringLit and TokenQuotedLit tokens")
+	}
+	var diags hcl.Diagnostics
+
+	ret := make([]byte, 0, len(tok.Bytes))
+	slices := scanStringLit(tok.Bytes, quoted)
+
+	// We will mutate rng constantly as we walk through our token slices below.
+	// Any diagnostics must take a copy of this rng rather than simply pointing
+	// to it, e.g. by using rng.Ptr() rather than &rng.
+	rng := tok.Range
+	rng.End = rng.Start
+
+Slices:
+	for _, slice := range slices {
+		if len(slice) == 0 {
+			continue
+		}
+
+		// Advance the start of our range to where the previous token ended
+		rng.Start = rng.End
+
+		// Advance the end of our range to after our token.
+		b := slice
+		for len(b) > 0 {
+			adv, ch, _ := textseg.ScanGraphemeClusters(b, true)
+			rng.End.Byte += adv
+			switch ch[0] {
+			case '\r', '\n':
+				rng.End.Line++
+				rng.End.Column = 1
+			default:
+				rng.End.Column++
+			}
+			b = b[adv:]
+		}
+
+	TokenType:
+		switch slice[0] {
+		case '\\':
+			if !quoted {
+				// If we're not in quoted mode then just treat this token as
+				// normal. (Slices can still start with backslash even if we're
+				// not specifically looking for backslash sequences.)
+				break TokenType
+			}
+			if len(slice) < 2 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid escape sequence",
+					Detail:   "Backslash must be followed by an escape sequence selector character.",
+					Subject:  rng.Ptr(),
+				})
+				break TokenType
+			}
+
+			switch slice[1] {
+
+			case 'n':
+				ret = append(ret, '\n')
+				continue Slices
+			case 'r':
+				ret = append(ret, '\r')
+				continue Slices
+			case 't':
+				ret = append(ret, '\t')
+				continue Slices
+			case '"':
+				ret = append(ret, '"')
+				continue Slices
+			case '\\':
+				ret = append(ret, '\\')
+				continue Slices
+			case 'u', 'U':
+				if slice[1] == 'u' && len(slice) != 6 {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid escape sequence",
+						Detail:   "The \\u escape sequence must be followed by four hexadecimal digits.",
+						Subject:  rng.Ptr(),
+					})
+					break TokenType
+				} else if slice[1] == 'U' && len(slice) != 10 {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid escape sequence",
+						Detail:   "The \\U escape sequence must be followed by eight hexadecimal digits.",
+						Subject:  rng.Ptr(),
+					})
+					break TokenType
+				}
+
+				numHex := string(slice[2:])
+				num, err := strconv.ParseUint(numHex, 16, 32)
+				if err != nil {
+					// Should never happen because the scanner won't match
+					// a sequence of digits that isn't valid.
+					panic(err)
+				}
+
+				r := rune(num)
+				l := utf8.RuneLen(r)
+				if l == -1 {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid escape sequence",
+						Detail:   fmt.Sprintf("Cannot encode character U+%04x in UTF-8.", num),
+						Subject:  rng.Ptr(),
+					})
+					break TokenType
+				}
+				for i := 0; i < l; i++ {
+					ret = append(ret, 0)
+				}
+				rb := ret[len(ret)-l:]
+				utf8.EncodeRune(rb, r)
+
+				continue Slices
+
+			default:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid escape sequence",
+					Detail:   fmt.Sprintf("The symbol %q is not a valid escape sequence selector.", slice[1:]),
+					Subject:  rng.Ptr(),
+				})
+				ret = append(ret, slice[1:]...)
+				continue Slices
+			}
+
+		case '$', '%':
+			if len(slice) != 3 {
+				// Not long enough to be our escape sequence, so it's literal.
+				break TokenType
+			}
+
+			if slice[1] == slice[0] && slice[2] == '{' {
+				ret = append(ret, slice[0])
+				ret = append(ret, '{')
+				continue Slices
+			}
+
+			break TokenType
+		}
+
+		// If we fall out here or break out of here from the switch above
+		// then this slice is just a literal.
+		ret = append(ret, slice...)
+	}
+
+	return string(ret), diags
+}
+
+// setRecovery turns on recovery mode without actually doing any recovery.
+// This can be used when a parser knowingly leaves the peeker in a useless
+// place and wants to suppress errors that might result from that decision.
+func (p *parser) setRecovery() {
+	p.recovery = true
+}
+
+// recover seeks forward in the token stream until it finds TokenType "end",
+// then returns with the peeker pointed at the following token.
+//
+// If the given token type is a bracketer, this function will additionally
+// count nested instances of the brackets to try to leave the peeker at
+// the end of the _current_ instance of that bracketer, skipping over any
+// nested instances. This is a best-effort operation and may have
+// unpredictable results on input with bad bracketer nesting.
+func (p *parser) recover(end TokenType) Token {
+	start := p.oppositeBracket(end)
+	p.recovery = true
+
+	nest := 0
+	for {
+		tok := p.Read()
+		ty := tok.Type
+		if end == TokenTemplateSeqEnd && ty == TokenTemplateControl {
+			// normalize so that our matching behavior can work, since
+			// TokenTemplateControl/TokenTemplateInterp are asymmetrical
+			// with TokenTemplateSeqEnd and thus we need to count both
+			// openers if that's the closer we're looking for.
+			ty = TokenTemplateInterp
+		}
+
+		switch ty {
+		case start:
+			nest++
+		case end:
+			if nest < 1 {
+				return tok
+			}
+
+			nest--
+		case TokenEOF:
+			return tok
+		}
+	}
+}
+
+// recoverOver seeks forward in the token stream until it finds a block
+// starting with TokenType "start", then finds the corresponding end token,
+// leaving the peeker pointed at the token after that end token.
+//
+// The given token type _must_ be a bracketer. For example, if the given
+// start token is TokenOBrace then the parser will be left at the _end_ of
+// the next brace-delimited block encountered, or at EOF if no such block
+// is found or it is unclosed.
+func (p *parser) recoverOver(start TokenType) {
+	end := p.oppositeBracket(start)
+
+	// find the opening bracket first
+Token:
+	for {
+		tok := p.Read()
+		switch tok.Type {
+		case start, TokenEOF:
+			break Token
+		}
+	}
+
+	// Now use our existing recover function to locate the _end_ of the
+	// container we've found.
+	p.recover(end)
+}
+
+func (p *parser) recoverAfterBodyItem() {
+	p.recovery = true
+	var open []TokenType
+
+Token:
+	for {
+		tok := p.Read()
+
+		switch tok.Type {
+
+		case TokenNewline:
+			if len(open) == 0 {
+				break Token
+			}
+
+		case TokenEOF:
+			break Token
+
+		case TokenOBrace, TokenOBrack, TokenOParen, TokenOQuote, TokenOHeredoc, TokenTemplateInterp, TokenTemplateControl:
+			open = append(open, tok.Type)
+
+		case TokenCBrace, TokenCBrack, TokenCParen, TokenCQuote, TokenCHeredoc:
+			opener := p.oppositeBracket(tok.Type)
+			for len(open) > 0 && open[len(open)-1] != opener {
+				open = open[:len(open)-1]
+			}
+			if len(open) > 0 {
+				open = open[:len(open)-1]
+			}
+
+		case TokenTemplateSeqEnd:
+			for len(open) > 0 && open[len(open)-1] != TokenTemplateInterp && open[len(open)-1] != TokenTemplateControl {
+				open = open[:len(open)-1]
+			}
+			if len(open) > 0 {
+				open = open[:len(open)-1]
+			}
+
+		}
+	}
+}
+
+// oppositeBracket finds the bracket that opposes the given bracketer, or
+// NilToken if the given token isn't a bracketer.
+//
+// "Bracketer", for the sake of this function, is one end of a matching
+// open/close set of tokens that establish a bracketing context.
+func (p *parser) oppositeBracket(ty TokenType) TokenType {
+	switch ty {
+
+	case TokenOBrace:
+		return TokenCBrace
+	case TokenOBrack:
+		return TokenCBrack
+	case TokenOParen:
+		return TokenCParen
+	case TokenOQuote:
+		return TokenCQuote
+	case TokenOHeredoc:
+		return TokenCHeredoc
+
+	case TokenCBrace:
+		return TokenOBrace
+	case TokenCBrack:
+		return TokenOBrack
+	case TokenCParen:
+		return TokenOParen
+	case TokenCQuote:
+		return TokenOQuote
+	case TokenCHeredoc:
+		return TokenOHeredoc
+
+	case TokenTemplateControl:
+		return TokenTemplateSeqEnd
+	case TokenTemplateInterp:
+		return TokenTemplateSeqEnd
+	case TokenTemplateSeqEnd:
+		// This is ambigous, but we return Interp here because that's
+		// what's assumed by the "recover" method.
+		return TokenTemplateInterp
+
+	default:
+		return TokenNil
+	}
+}
+
+func errPlaceholderExpr(rng hcl.Range) Expression {
+	return &LiteralValueExpr{
+		Val:      cty.DynamicVal,
+		SrcRange: rng,
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_template.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_template.go
new file mode 100644
index 000000000..eb8f7ea38
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_template.go
@@ -0,0 +1,799 @@
+package hclsyntax
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+func (p *parser) ParseTemplate() (Expression, hcl.Diagnostics) {
+	return p.parseTemplate(TokenEOF, false)
+}
+
+func (p *parser) parseTemplate(end TokenType, flushHeredoc bool) (Expression, hcl.Diagnostics) {
+	exprs, passthru, rng, diags := p.parseTemplateInner(end, flushHeredoc)
+
+	if passthru {
+		if len(exprs) != 1 {
+			panic("passthru set with len(exprs) != 1")
+		}
+		return &TemplateWrapExpr{
+			Wrapped:  exprs[0],
+			SrcRange: rng,
+		}, diags
+	}
+
+	return &TemplateExpr{
+		Parts:    exprs,
+		SrcRange: rng,
+	}, diags
+}
+
+func (p *parser) parseTemplateInner(end TokenType, flushHeredoc bool) ([]Expression, bool, hcl.Range, hcl.Diagnostics) {
+	parts, diags := p.parseTemplateParts(end)
+	if flushHeredoc {
+		flushHeredocTemplateParts(parts) // Trim off leading spaces on lines per the flush heredoc spec
+	}
+	tp := templateParser{
+		Tokens:   parts.Tokens,
+		SrcRange: parts.SrcRange,
+	}
+	exprs, exprsDiags := tp.parseRoot()
+	diags = append(diags, exprsDiags...)
+
+	passthru := false
+	if len(parts.Tokens) == 2 { // one real token and one synthetic "end" token
+		if _, isInterp := parts.Tokens[0].(*templateInterpToken); isInterp {
+			passthru = true
+		}
+	}
+
+	return exprs, passthru, parts.SrcRange, diags
+}
+
+type templateParser struct {
+	Tokens   []templateToken
+	SrcRange hcl.Range
+
+	pos int
+}
+
+func (p *templateParser) parseRoot() ([]Expression, hcl.Diagnostics) {
+	var exprs []Expression
+	var diags hcl.Diagnostics
+
+	for {
+		next := p.Peek()
+		if _, isEnd := next.(*templateEndToken); isEnd {
+			break
+		}
+
+		expr, exprDiags := p.parseExpr()
+		diags = append(diags, exprDiags...)
+		exprs = append(exprs, expr)
+	}
+
+	return exprs, diags
+}
+
+func (p *templateParser) parseExpr() (Expression, hcl.Diagnostics) {
+	next := p.Peek()
+	switch tok := next.(type) {
+
+	case *templateLiteralToken:
+		p.Read() // eat literal
+		return &LiteralValueExpr{
+			Val:      cty.StringVal(tok.Val),
+			SrcRange: tok.SrcRange,
+		}, nil
+
+	case *templateInterpToken:
+		p.Read() // eat interp
+		return tok.Expr, nil
+
+	case *templateIfToken:
+		return p.parseIf()
+
+	case *templateForToken:
+		return p.parseFor()
+
+	case *templateEndToken:
+		p.Read() // eat erroneous token
+		return errPlaceholderExpr(tok.SrcRange), hcl.Diagnostics{
+			{
+				// This is a particularly unhelpful diagnostic, so callers
+				// should attempt to pre-empt it and produce a more helpful
+				// diagnostic that is context-aware.
+				Severity: hcl.DiagError,
+				Summary:  "Unexpected end of template",
+				Detail:   "The control directives within this template are unbalanced.",
+				Subject:  &tok.SrcRange,
+			},
+		}
+
+	case *templateEndCtrlToken:
+		p.Read() // eat erroneous token
+		return errPlaceholderExpr(tok.SrcRange), hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Unexpected %s directive", tok.Name()),
+				Detail:   "The control directives within this template are unbalanced.",
+				Subject:  &tok.SrcRange,
+			},
+		}
+
+	default:
+		// should never happen, because above should be exhaustive
+		panic(fmt.Sprintf("unhandled template token type %T", next))
+	}
+}
+
+func (p *templateParser) parseIf() (Expression, hcl.Diagnostics) {
+	open := p.Read()
+	openIf, isIf := open.(*templateIfToken)
+	if !isIf {
+		// should never happen if caller is behaving
+		panic("parseIf called with peeker not pointing at if token")
+	}
+
+	var ifExprs, elseExprs []Expression
+	var diags hcl.Diagnostics
+	var endifRange hcl.Range
+
+	currentExprs := &ifExprs
+Token:
+	for {
+		next := p.Peek()
+		if end, isEnd := next.(*templateEndToken); isEnd {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unexpected end of template",
+				Detail: fmt.Sprintf(
+					"The if directive at %s is missing its corresponding endif directive.",
+					openIf.SrcRange,
+				),
+				Subject: &end.SrcRange,
+			})
+			return errPlaceholderExpr(end.SrcRange), diags
+		}
+		if end, isCtrlEnd := next.(*templateEndCtrlToken); isCtrlEnd {
+			p.Read() // eat end directive
+
+			switch end.Type {
+
+			case templateElse:
+				if currentExprs == &ifExprs {
+					currentExprs = &elseExprs
+					continue Token
+				}
+
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unexpected else directive",
+					Detail: fmt.Sprintf(
+						"Already in the else clause for the if started at %s.",
+						openIf.SrcRange,
+					),
+					Subject: &end.SrcRange,
+				})
+
+			case templateEndIf:
+				endifRange = end.SrcRange
+				break Token
+
+			default:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Unexpected %s directive", end.Name()),
+					Detail: fmt.Sprintf(
+						"Expecting an endif directive for the if started at %s.",
+						openIf.SrcRange,
+					),
+					Subject: &end.SrcRange,
+				})
+			}
+
+			return errPlaceholderExpr(end.SrcRange), diags
+		}
+
+		expr, exprDiags := p.parseExpr()
+		diags = append(diags, exprDiags...)
+		*currentExprs = append(*currentExprs, expr)
+	}
+
+	if len(ifExprs) == 0 {
+		ifExprs = append(ifExprs, &LiteralValueExpr{
+			Val: cty.StringVal(""),
+			SrcRange: hcl.Range{
+				Filename: openIf.SrcRange.Filename,
+				Start:    openIf.SrcRange.End,
+				End:      openIf.SrcRange.End,
+			},
+		})
+	}
+	if len(elseExprs) == 0 {
+		elseExprs = append(elseExprs, &LiteralValueExpr{
+			Val: cty.StringVal(""),
+			SrcRange: hcl.Range{
+				Filename: endifRange.Filename,
+				Start:    endifRange.Start,
+				End:      endifRange.Start,
+			},
+		})
+	}
+
+	trueExpr := &TemplateExpr{
+		Parts:    ifExprs,
+		SrcRange: hcl.RangeBetween(ifExprs[0].Range(), ifExprs[len(ifExprs)-1].Range()),
+	}
+	falseExpr := &TemplateExpr{
+		Parts:    elseExprs,
+		SrcRange: hcl.RangeBetween(elseExprs[0].Range(), elseExprs[len(elseExprs)-1].Range()),
+	}
+
+	return &ConditionalExpr{
+		Condition:   openIf.CondExpr,
+		TrueResult:  trueExpr,
+		FalseResult: falseExpr,
+
+		SrcRange: hcl.RangeBetween(openIf.SrcRange, endifRange),
+	}, diags
+}
+
+func (p *templateParser) parseFor() (Expression, hcl.Diagnostics) {
+	open := p.Read()
+	openFor, isFor := open.(*templateForToken)
+	if !isFor {
+		// should never happen if caller is behaving
+		panic("parseFor called with peeker not pointing at for token")
+	}
+
+	var contentExprs []Expression
+	var diags hcl.Diagnostics
+	var endforRange hcl.Range
+
+Token:
+	for {
+		next := p.Peek()
+		if end, isEnd := next.(*templateEndToken); isEnd {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unexpected end of template",
+				Detail: fmt.Sprintf(
+					"The for directive at %s is missing its corresponding endfor directive.",
+					openFor.SrcRange,
+				),
+				Subject: &end.SrcRange,
+			})
+			return errPlaceholderExpr(end.SrcRange), diags
+		}
+		if end, isCtrlEnd := next.(*templateEndCtrlToken); isCtrlEnd {
+			p.Read() // eat end directive
+
+			switch end.Type {
+
+			case templateElse:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unexpected else directive",
+					Detail:   "An else clause is not expected for a for directive.",
+					Subject:  &end.SrcRange,
+				})
+
+			case templateEndFor:
+				endforRange = end.SrcRange
+				break Token
+
+			default:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Unexpected %s directive", end.Name()),
+					Detail: fmt.Sprintf(
+						"Expecting an endfor directive corresponding to the for directive at %s.",
+						openFor.SrcRange,
+					),
+					Subject: &end.SrcRange,
+				})
+			}
+
+			return errPlaceholderExpr(end.SrcRange), diags
+		}
+
+		expr, exprDiags := p.parseExpr()
+		diags = append(diags, exprDiags...)
+		contentExprs = append(contentExprs, expr)
+	}
+
+	if len(contentExprs) == 0 {
+		contentExprs = append(contentExprs, &LiteralValueExpr{
+			Val: cty.StringVal(""),
+			SrcRange: hcl.Range{
+				Filename: openFor.SrcRange.Filename,
+				Start:    openFor.SrcRange.End,
+				End:      openFor.SrcRange.End,
+			},
+		})
+	}
+
+	contentExpr := &TemplateExpr{
+		Parts:    contentExprs,
+		SrcRange: hcl.RangeBetween(contentExprs[0].Range(), contentExprs[len(contentExprs)-1].Range()),
+	}
+
+	forExpr := &ForExpr{
+		KeyVar: openFor.KeyVar,
+		ValVar: openFor.ValVar,
+
+		CollExpr: openFor.CollExpr,
+		ValExpr:  contentExpr,
+
+		SrcRange:   hcl.RangeBetween(openFor.SrcRange, endforRange),
+		OpenRange:  openFor.SrcRange,
+		CloseRange: endforRange,
+	}
+
+	return &TemplateJoinExpr{
+		Tuple: forExpr,
+	}, diags
+}
+
+func (p *templateParser) Peek() templateToken {
+	return p.Tokens[p.pos]
+}
+
+func (p *templateParser) Read() templateToken {
+	ret := p.Peek()
+	if _, end := ret.(*templateEndToken); !end {
+		p.pos++
+	}
+	return ret
+}
+
+// parseTemplateParts produces a flat sequence of "template tokens", which are
+// either literal values (with any "trimming" already applied), interpolation
+// sequences, or control flow markers.
+//
+// A further pass is required on the result to turn it into an AST.
+func (p *parser) parseTemplateParts(end TokenType) (*templateParts, hcl.Diagnostics) {
+	var parts []templateToken
+	var diags hcl.Diagnostics
+
+	startRange := p.NextRange()
+	ltrimNext := false
+	nextCanTrimPrev := false
+	var endRange hcl.Range
+
+Token:
+	for {
+		next := p.Read()
+		if next.Type == end {
+			// all done!
+			endRange = next.Range
+			break
+		}
+
+		ltrim := ltrimNext
+		ltrimNext = false
+		canTrimPrev := nextCanTrimPrev
+		nextCanTrimPrev = false
+
+		switch next.Type {
+		case TokenStringLit, TokenQuotedLit:
+			str, strDiags := ParseStringLiteralToken(next)
+			diags = append(diags, strDiags...)
+
+			if ltrim {
+				str = strings.TrimLeftFunc(str, unicode.IsSpace)
+			}
+
+			parts = append(parts, &templateLiteralToken{
+				Val:      str,
+				SrcRange: next.Range,
+			})
+			nextCanTrimPrev = true
+
+		case TokenTemplateInterp:
+			// if the opener is ${~ then we want to eat any trailing whitespace
+			// in the preceding literal token, assuming it is indeed a literal
+			// token.
+			if canTrimPrev && len(next.Bytes) == 3 && next.Bytes[2] == '~' && len(parts) > 0 {
+				prevExpr := parts[len(parts)-1]
+				if lexpr, ok := prevExpr.(*templateLiteralToken); ok {
+					lexpr.Val = strings.TrimRightFunc(lexpr.Val, unicode.IsSpace)
+				}
+			}
+
+			p.PushIncludeNewlines(false)
+			expr, exprDiags := p.ParseExpression()
+			diags = append(diags, exprDiags...)
+			close := p.Peek()
+			if close.Type != TokenTemplateSeqEnd {
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Extra characters after interpolation expression",
+						Detail:   "Expected a closing brace to end the interpolation expression, but found extra characters.",
+						Subject:  &close.Range,
+						Context:  hcl.RangeBetween(startRange, close.Range).Ptr(),
+					})
+				}
+				p.recover(TokenTemplateSeqEnd)
+			} else {
+				p.Read() // eat closing brace
+
+				// If the closer is ~} then we want to eat any leading
+				// whitespace on the next token, if it turns out to be a
+				// literal token.
+				if len(close.Bytes) == 2 && close.Bytes[0] == '~' {
+					ltrimNext = true
+				}
+			}
+			p.PopIncludeNewlines()
+			parts = append(parts, &templateInterpToken{
+				Expr:     expr,
+				SrcRange: hcl.RangeBetween(next.Range, close.Range),
+			})
+
+		case TokenTemplateControl:
+			// if the opener is %{~ then we want to eat any trailing whitespace
+			// in the preceding literal token, assuming it is indeed a literal
+			// token.
+			if canTrimPrev && len(next.Bytes) == 3 && next.Bytes[2] == '~' && len(parts) > 0 {
+				prevExpr := parts[len(parts)-1]
+				if lexpr, ok := prevExpr.(*templateLiteralToken); ok {
+					lexpr.Val = strings.TrimRightFunc(lexpr.Val, unicode.IsSpace)
+				}
+			}
+			p.PushIncludeNewlines(false)
+
+			kw := p.Peek()
+			if kw.Type != TokenIdent {
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid template directive",
+						Detail:   "A template directive keyword (\"if\", \"for\", etc) is expected at the beginning of a %{ sequence.",
+						Subject:  &kw.Range,
+						Context:  hcl.RangeBetween(next.Range, kw.Range).Ptr(),
+					})
+				}
+				p.recover(TokenTemplateSeqEnd)
+				p.PopIncludeNewlines()
+				continue Token
+			}
+			p.Read() // eat keyword token
+
+			switch {
+
+			case ifKeyword.TokenMatches(kw):
+				condExpr, exprDiags := p.ParseExpression()
+				diags = append(diags, exprDiags...)
+				parts = append(parts, &templateIfToken{
+					CondExpr: condExpr,
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			case elseKeyword.TokenMatches(kw):
+				parts = append(parts, &templateEndCtrlToken{
+					Type:     templateElse,
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			case endifKeyword.TokenMatches(kw):
+				parts = append(parts, &templateEndCtrlToken{
+					Type:     templateEndIf,
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			case forKeyword.TokenMatches(kw):
+				var keyName, valName string
+				if p.Peek().Type != TokenIdent {
+					if !p.recovery {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity: hcl.DiagError,
+							Summary:  "Invalid 'for' directive",
+							Detail:   "For directive requires variable name after 'for'.",
+							Subject:  p.Peek().Range.Ptr(),
+						})
+					}
+					p.recover(TokenTemplateSeqEnd)
+					p.PopIncludeNewlines()
+					continue Token
+				}
+
+				valName = string(p.Read().Bytes)
+
+				if p.Peek().Type == TokenComma {
+					// What we just read was actually the key, then.
+					keyName = valName
+					p.Read() // eat comma
+
+					if p.Peek().Type != TokenIdent {
+						if !p.recovery {
+							diags = append(diags, &hcl.Diagnostic{
+								Severity: hcl.DiagError,
+								Summary:  "Invalid 'for' directive",
+								Detail:   "For directive requires value variable name after comma.",
+								Subject:  p.Peek().Range.Ptr(),
+							})
+						}
+						p.recover(TokenTemplateSeqEnd)
+						p.PopIncludeNewlines()
+						continue Token
+					}
+
+					valName = string(p.Read().Bytes)
+				}
+
+				if !inKeyword.TokenMatches(p.Peek()) {
+					if !p.recovery {
+						diags = append(diags, &hcl.Diagnostic{
+							Severity: hcl.DiagError,
+							Summary:  "Invalid 'for' directive",
+							Detail:   "For directive requires 'in' keyword after names.",
+							Subject:  p.Peek().Range.Ptr(),
+						})
+					}
+					p.recover(TokenTemplateSeqEnd)
+					p.PopIncludeNewlines()
+					continue Token
+				}
+				p.Read() // eat 'in' keyword
+
+				collExpr, collDiags := p.ParseExpression()
+				diags = append(diags, collDiags...)
+				parts = append(parts, &templateForToken{
+					KeyVar:   keyName,
+					ValVar:   valName,
+					CollExpr: collExpr,
+
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			case endforKeyword.TokenMatches(kw):
+				parts = append(parts, &templateEndCtrlToken{
+					Type:     templateEndFor,
+					SrcRange: hcl.RangeBetween(next.Range, p.NextRange()),
+				})
+
+			default:
+				if !p.recovery {
+					suggestions := []string{"if", "for", "else", "endif", "endfor"}
+					given := string(kw.Bytes)
+					suggestion := nameSuggestion(given, suggestions)
+					if suggestion != "" {
+						suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+					}
+
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid template control keyword",
+						Detail:   fmt.Sprintf("%q is not a valid template control keyword.%s", given, suggestion),
+						Subject:  &kw.Range,
+						Context:  hcl.RangeBetween(next.Range, kw.Range).Ptr(),
+					})
+				}
+				p.recover(TokenTemplateSeqEnd)
+				p.PopIncludeNewlines()
+				continue Token
+
+			}
+
+			close := p.Peek()
+			if close.Type != TokenTemplateSeqEnd {
+				if !p.recovery {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  fmt.Sprintf("Extra characters in %s marker", kw.Bytes),
+						Detail:   "Expected a closing brace to end the sequence, but found extra characters.",
+						Subject:  &close.Range,
+						Context:  hcl.RangeBetween(startRange, close.Range).Ptr(),
+					})
+				}
+				p.recover(TokenTemplateSeqEnd)
+			} else {
+				p.Read() // eat closing brace
+
+				// If the closer is ~} then we want to eat any leading
+				// whitespace on the next token, if it turns out to be a
+				// literal token.
+				if len(close.Bytes) == 2 && close.Bytes[0] == '~' {
+					ltrimNext = true
+				}
+			}
+			p.PopIncludeNewlines()
+
+		default:
+			if !p.recovery {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unterminated template string",
+					Detail:   "No closing marker was found for the string.",
+					Subject:  &next.Range,
+					Context:  hcl.RangeBetween(startRange, next.Range).Ptr(),
+				})
+			}
+			final := p.recover(end)
+			endRange = final.Range
+			break Token
+		}
+	}
+
+	if len(parts) == 0 {
+		// If a sequence has no content, we'll treat it as if it had an
+		// empty string in it because that's what the user probably means
+		// if they write "" in configuration.
+		parts = append(parts, &templateLiteralToken{
+			Val: "",
+			SrcRange: hcl.Range{
+				// Range is the zero-character span immediately after the
+				// opening quote.
+				Filename: startRange.Filename,
+				Start:    startRange.End,
+				End:      startRange.End,
+			},
+		})
+	}
+
+	// Always end with an end token, so the parser can produce diagnostics
+	// about unclosed items with proper position information.
+	parts = append(parts, &templateEndToken{
+		SrcRange: endRange,
+	})
+
+	ret := &templateParts{
+		Tokens:   parts,
+		SrcRange: hcl.RangeBetween(startRange, endRange),
+	}
+
+	return ret, diags
+}
+
+// flushHeredocTemplateParts modifies in-place the line-leading literal strings
+// to apply the flush heredoc processing rule: find the line with the smallest
+// number of whitespace characters as prefix and then trim that number of
+// characters from all of the lines.
+//
+// This rule is applied to static tokens rather than to the rendered result,
+// so interpolating a string with leading whitespace cannot affect the chosen
+// prefix length.
+func flushHeredocTemplateParts(parts *templateParts) {
+	if len(parts.Tokens) == 0 {
+		// Nothing to do
+		return
+	}
+
+	const maxInt = int((^uint(0)) >> 1)
+
+	minSpaces := maxInt
+	newline := true
+	var adjust []*templateLiteralToken
+	for _, ttok := range parts.Tokens {
+		if newline {
+			newline = false
+			var spaces int
+			if lit, ok := ttok.(*templateLiteralToken); ok {
+				orig := lit.Val
+				trimmed := strings.TrimLeftFunc(orig, unicode.IsSpace)
+				// If a token is entirely spaces and ends with a newline
+				// then it's a "blank line" and thus not considered for
+				// space-prefix-counting purposes.
+				if len(trimmed) == 0 && strings.HasSuffix(orig, "\n") {
+					spaces = maxInt
+				} else {
+					spaceBytes := len(lit.Val) - len(trimmed)
+					spaces, _ = textseg.TokenCount([]byte(orig[:spaceBytes]), textseg.ScanGraphemeClusters)
+					adjust = append(adjust, lit)
+				}
+			} else if _, ok := ttok.(*templateEndToken); ok {
+				break // don't process the end token since it never has spaces before it
+			}
+			if spaces < minSpaces {
+				minSpaces = spaces
+			}
+		}
+		if lit, ok := ttok.(*templateLiteralToken); ok {
+			if strings.HasSuffix(lit.Val, "\n") {
+				newline = true // The following token, if any, begins a new line
+			}
+		}
+	}
+
+	for _, lit := range adjust {
+		// Since we want to count space _characters_ rather than space _bytes_,
+		// we can't just do a straightforward slice operation here and instead
+		// need to hunt for the split point with a scanner.
+		valBytes := []byte(lit.Val)
+		spaceByteCount := 0
+		for i := 0; i < minSpaces; i++ {
+			adv, _, _ := textseg.ScanGraphemeClusters(valBytes, true)
+			spaceByteCount += adv
+			valBytes = valBytes[adv:]
+		}
+		lit.Val = lit.Val[spaceByteCount:]
+		lit.SrcRange.Start.Column += minSpaces
+		lit.SrcRange.Start.Byte += spaceByteCount
+	}
+}
+
+type templateParts struct {
+	Tokens   []templateToken
+	SrcRange hcl.Range
+}
+
+// templateToken is a higher-level token that represents a single atom within
+// the template language. Our template parsing first raises the raw token
+// stream to a sequence of templateToken, and then transforms the result into
+// an expression tree.
+type templateToken interface {
+	templateToken() templateToken
+}
+
+type templateLiteralToken struct {
+	Val      string
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type templateInterpToken struct {
+	Expr     Expression
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type templateIfToken struct {
+	CondExpr Expression
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type templateForToken struct {
+	KeyVar   string // empty if ignoring key
+	ValVar   string
+	CollExpr Expression
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type templateEndCtrlType int
+
+const (
+	templateEndIf templateEndCtrlType = iota
+	templateElse
+	templateEndFor
+)
+
+type templateEndCtrlToken struct {
+	Type     templateEndCtrlType
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+func (t *templateEndCtrlToken) Name() string {
+	switch t.Type {
+	case templateEndIf:
+		return "endif"
+	case templateElse:
+		return "else"
+	case templateEndFor:
+		return "endfor"
+	default:
+		// should never happen
+		panic("invalid templateEndCtrlType")
+	}
+}
+
+type templateEndToken struct {
+	SrcRange hcl.Range
+	isTemplateToken
+}
+
+type isTemplateToken [0]int
+
+func (t isTemplateToken) templateToken() templateToken {
+	return t
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_traversal.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_traversal.go
new file mode 100644
index 000000000..7dcb0fd34
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/parser_traversal.go
@@ -0,0 +1,159 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ParseTraversalAbs parses an absolute traversal that is assumed to consume
+// all of the remaining tokens in the peeker. The usual parser recovery
+// behavior is not supported here because traversals are not expected to
+// be parsed as part of a larger program.
+func (p *parser) ParseTraversalAbs() (hcl.Traversal, hcl.Diagnostics) {
+	var ret hcl.Traversal
+	var diags hcl.Diagnostics
+
+	// Absolute traversal must always begin with a variable name
+	varTok := p.Read()
+	if varTok.Type != TokenIdent {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Variable name required",
+			Detail:   "Must begin with a variable name.",
+			Subject:  &varTok.Range,
+		})
+		return ret, diags
+	}
+
+	varName := string(varTok.Bytes)
+	ret = append(ret, hcl.TraverseRoot{
+		Name:     varName,
+		SrcRange: varTok.Range,
+	})
+
+	for {
+		next := p.Peek()
+
+		if next.Type == TokenEOF {
+			return ret, diags
+		}
+
+		switch next.Type {
+		case TokenDot:
+			// Attribute access
+			dot := p.Read() // eat dot
+			nameTok := p.Read()
+			if nameTok.Type != TokenIdent {
+				if nameTok.Type == TokenStar {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Attribute name required",
+						Detail:   "Splat expressions (.*) may not be used here.",
+						Subject:  &nameTok.Range,
+						Context:  hcl.RangeBetween(varTok.Range, nameTok.Range).Ptr(),
+					})
+				} else {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Attribute name required",
+						Detail:   "Dot must be followed by attribute name.",
+						Subject:  &nameTok.Range,
+						Context:  hcl.RangeBetween(varTok.Range, nameTok.Range).Ptr(),
+					})
+				}
+				return ret, diags
+			}
+
+			attrName := string(nameTok.Bytes)
+			ret = append(ret, hcl.TraverseAttr{
+				Name:     attrName,
+				SrcRange: hcl.RangeBetween(dot.Range, nameTok.Range),
+			})
+		case TokenOBrack:
+			// Index
+			open := p.Read() // eat open bracket
+			next := p.Peek()
+
+			switch next.Type {
+			case TokenNumberLit:
+				tok := p.Read() // eat number
+				numVal, numDiags := p.numberLitValue(tok)
+				diags = append(diags, numDiags...)
+
+				close := p.Read()
+				if close.Type != TokenCBrack {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Unclosed index brackets",
+						Detail:   "Index key must be followed by a closing bracket.",
+						Subject:  &close.Range,
+						Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+					})
+				}
+
+				ret = append(ret, hcl.TraverseIndex{
+					Key:      numVal,
+					SrcRange: hcl.RangeBetween(open.Range, close.Range),
+				})
+
+				if diags.HasErrors() {
+					return ret, diags
+				}
+
+			case TokenOQuote:
+				str, _, strDiags := p.parseQuotedStringLiteral()
+				diags = append(diags, strDiags...)
+
+				close := p.Read()
+				if close.Type != TokenCBrack {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Unclosed index brackets",
+						Detail:   "Index key must be followed by a closing bracket.",
+						Subject:  &close.Range,
+						Context:  hcl.RangeBetween(open.Range, close.Range).Ptr(),
+					})
+				}
+
+				ret = append(ret, hcl.TraverseIndex{
+					Key:      cty.StringVal(str),
+					SrcRange: hcl.RangeBetween(open.Range, close.Range),
+				})
+
+				if diags.HasErrors() {
+					return ret, diags
+				}
+
+			default:
+				if next.Type == TokenStar {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Attribute name required",
+						Detail:   "Splat expressions ([*]) may not be used here.",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(varTok.Range, next.Range).Ptr(),
+					})
+				} else {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Index value required",
+						Detail:   "Index brackets must contain either a literal number or a literal string.",
+						Subject:  &next.Range,
+						Context:  hcl.RangeBetween(varTok.Range, next.Range).Ptr(),
+					})
+				}
+				return ret, diags
+			}
+
+		default:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid character",
+				Detail:   "Expected an attribute access or an index operator.",
+				Subject:  &next.Range,
+				Context:  hcl.RangeBetween(varTok.Range, next.Range).Ptr(),
+			})
+			return ret, diags
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/peeker.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/peeker.go
new file mode 100644
index 000000000..f056f906e
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/peeker.go
@@ -0,0 +1,212 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// This is set to true at init() time in tests, to enable more useful output
+// if a stack discipline error is detected. It should not be enabled in
+// normal mode since there is a performance penalty from accessing the
+// runtime stack to produce the traces, but could be temporarily set to
+// true for debugging if desired.
+var tracePeekerNewlinesStack = false
+
+type peeker struct {
+	Tokens    Tokens
+	NextIndex int
+
+	IncludeComments      bool
+	IncludeNewlinesStack []bool
+
+	// used only when tracePeekerNewlinesStack is set
+	newlineStackChanges []peekerNewlineStackChange
+}
+
+// for use in debugging the stack usage only
+type peekerNewlineStackChange struct {
+	Pushing bool // if false, then popping
+	Frame   runtime.Frame
+	Include bool
+}
+
+func newPeeker(tokens Tokens, includeComments bool) *peeker {
+	return &peeker{
+		Tokens:          tokens,
+		IncludeComments: includeComments,
+
+		IncludeNewlinesStack: []bool{true},
+	}
+}
+
+func (p *peeker) Peek() Token {
+	ret, _ := p.nextToken()
+	return ret
+}
+
+func (p *peeker) Read() Token {
+	ret, nextIdx := p.nextToken()
+	p.NextIndex = nextIdx
+	return ret
+}
+
+func (p *peeker) NextRange() hcl.Range {
+	return p.Peek().Range
+}
+
+func (p *peeker) PrevRange() hcl.Range {
+	if p.NextIndex == 0 {
+		return p.NextRange()
+	}
+
+	return p.Tokens[p.NextIndex-1].Range
+}
+
+func (p *peeker) nextToken() (Token, int) {
+	for i := p.NextIndex; i < len(p.Tokens); i++ {
+		tok := p.Tokens[i]
+		switch tok.Type {
+		case TokenComment:
+			if !p.IncludeComments {
+				// Single-line comment tokens, starting with # or //, absorb
+				// the trailing newline that terminates them as part of their
+				// bytes. When we're filtering out comments, we must as a
+				// special case transform these to newline tokens in order
+				// to properly parse newline-terminated block items.
+
+				if p.includingNewlines() {
+					if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' {
+						fakeNewline := Token{
+							Type:  TokenNewline,
+							Bytes: tok.Bytes[len(tok.Bytes)-1 : len(tok.Bytes)],
+
+							// We use the whole token range as the newline
+							// range, even though that's a little... weird,
+							// because otherwise we'd need to go count
+							// characters again in order to figure out the
+							// column of the newline, and that complexity
+							// isn't justified when ranges of newlines are
+							// so rarely printed anyway.
+							Range: tok.Range,
+						}
+						return fakeNewline, i + 1
+					}
+				}
+
+				continue
+			}
+		case TokenNewline:
+			if !p.includingNewlines() {
+				continue
+			}
+		}
+
+		return tok, i + 1
+	}
+
+	// if we fall out here then we'll return the EOF token, and leave
+	// our index pointed off the end of the array so we'll keep
+	// returning EOF in future too.
+	return p.Tokens[len(p.Tokens)-1], len(p.Tokens)
+}
+
+func (p *peeker) includingNewlines() bool {
+	return p.IncludeNewlinesStack[len(p.IncludeNewlinesStack)-1]
+}
+
+func (p *peeker) PushIncludeNewlines(include bool) {
+	if tracePeekerNewlinesStack {
+		// Record who called us so that we can more easily track down any
+		// mismanagement of the stack in the parser.
+		callers := []uintptr{0}
+		runtime.Callers(2, callers)
+		frames := runtime.CallersFrames(callers)
+		frame, _ := frames.Next()
+		p.newlineStackChanges = append(p.newlineStackChanges, peekerNewlineStackChange{
+			true, frame, include,
+		})
+	}
+
+	p.IncludeNewlinesStack = append(p.IncludeNewlinesStack, include)
+}
+
+func (p *peeker) PopIncludeNewlines() bool {
+	stack := p.IncludeNewlinesStack
+	remain, ret := stack[:len(stack)-1], stack[len(stack)-1]
+	p.IncludeNewlinesStack = remain
+
+	if tracePeekerNewlinesStack {
+		// Record who called us so that we can more easily track down any
+		// mismanagement of the stack in the parser.
+		callers := []uintptr{0}
+		runtime.Callers(2, callers)
+		frames := runtime.CallersFrames(callers)
+		frame, _ := frames.Next()
+		p.newlineStackChanges = append(p.newlineStackChanges, peekerNewlineStackChange{
+			false, frame, ret,
+		})
+	}
+
+	return ret
+}
+
+// AssertEmptyNewlinesStack checks if the IncludeNewlinesStack is empty, doing
+// panicking if it is not. This can be used to catch stack mismanagement that
+// might otherwise just cause confusing downstream errors.
+//
+// This function is a no-op if the stack is empty when called.
+//
+// If newlines stack tracing is enabled by setting the global variable
+// tracePeekerNewlinesStack at init time, a full log of all of the push/pop
+// calls will be produced to help identify which caller in the parser is
+// misbehaving.
+func (p *peeker) AssertEmptyIncludeNewlinesStack() {
+	if len(p.IncludeNewlinesStack) != 1 {
+		// Should never happen; indicates mismanagement of the stack inside
+		// the parser.
+		if p.newlineStackChanges != nil { // only if traceNewlinesStack is enabled above
+			panic(fmt.Errorf(
+				"non-empty IncludeNewlinesStack after parse with %d calls unaccounted for:\n%s",
+				len(p.IncludeNewlinesStack)-1,
+				formatPeekerNewlineStackChanges(p.newlineStackChanges),
+			))
+		} else {
+			panic(fmt.Errorf("non-empty IncludeNewlinesStack after parse: %#v", p.IncludeNewlinesStack))
+		}
+	}
+}
+
+func formatPeekerNewlineStackChanges(changes []peekerNewlineStackChange) string {
+	indent := 0
+	var buf bytes.Buffer
+	for _, change := range changes {
+		funcName := change.Frame.Function
+		if idx := strings.LastIndexByte(funcName, '.'); idx != -1 {
+			funcName = funcName[idx+1:]
+		}
+		filename := change.Frame.File
+		if idx := strings.LastIndexByte(filename, filepath.Separator); idx != -1 {
+			filename = filename[idx+1:]
+		}
+
+		switch change.Pushing {
+
+		case true:
+			buf.WriteString(strings.Repeat("    ", indent))
+			fmt.Fprintf(&buf, "PUSH %#v (%s at %s:%d)\n", change.Include, funcName, filename, change.Frame.Line)
+			indent++
+
+		case false:
+			indent--
+			buf.WriteString(strings.Repeat("    ", indent))
+			fmt.Fprintf(&buf, "POP %#v (%s at %s:%d)\n", change.Include, funcName, filename, change.Frame.Line)
+
+		}
+	}
+	return buf.String()
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/public.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/public.go
new file mode 100644
index 000000000..0b68efd60
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/public.go
@@ -0,0 +1,171 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// ParseConfig parses the given buffer as a whole HCL config file, returning
+// a *hcl.File representing its contents. If HasErrors called on the returned
+// diagnostics returns true, the returned body is likely to be incomplete
+// and should therefore be used with care.
+//
+// The body in the returned file has dynamic type *hclsyntax.Body, so callers
+// may freely type-assert this to get access to the full hclsyntax API in
+// situations where detailed access is required. However, most common use-cases
+// should be served using the hcl.Body interface to ensure compatibility with
+// other configurationg syntaxes, such as JSON.
+func ParseConfig(src []byte, filename string, start hcl.Pos) (*hcl.File, hcl.Diagnostics) {
+	tokens, diags := LexConfig(src, filename, start)
+	peeker := newPeeker(tokens, false)
+	parser := &parser{peeker: peeker}
+	body, parseDiags := parser.ParseBody(TokenEOF)
+	diags = append(diags, parseDiags...)
+
+	// Panic if the parser uses incorrect stack discipline with the peeker's
+	// newlines stack, since otherwise it will produce confusing downstream
+	// errors.
+	peeker.AssertEmptyIncludeNewlinesStack()
+
+	return &hcl.File{
+		Body:  body,
+		Bytes: src,
+
+		Nav: navigation{
+			root: body,
+		},
+	}, diags
+}
+
+// ParseExpression parses the given buffer as a standalone HCL expression,
+// returning it as an instance of Expression.
+func ParseExpression(src []byte, filename string, start hcl.Pos) (Expression, hcl.Diagnostics) {
+	tokens, diags := LexExpression(src, filename, start)
+	peeker := newPeeker(tokens, false)
+	parser := &parser{peeker: peeker}
+
+	// Bare expressions are always parsed in  "ignore newlines" mode, as if
+	// they were wrapped in parentheses.
+	parser.PushIncludeNewlines(false)
+
+	expr, parseDiags := parser.ParseExpression()
+	diags = append(diags, parseDiags...)
+
+	next := parser.Peek()
+	if next.Type != TokenEOF && !parser.recovery {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Extra characters after expression",
+			Detail:   "An expression was successfully parsed, but extra characters were found after it.",
+			Subject:  &next.Range,
+		})
+	}
+
+	parser.PopIncludeNewlines()
+
+	// Panic if the parser uses incorrect stack discipline with the peeker's
+	// newlines stack, since otherwise it will produce confusing downstream
+	// errors.
+	peeker.AssertEmptyIncludeNewlinesStack()
+
+	return expr, diags
+}
+
+// ParseTemplate parses the given buffer as a standalone HCL template,
+// returning it as an instance of Expression.
+func ParseTemplate(src []byte, filename string, start hcl.Pos) (Expression, hcl.Diagnostics) {
+	tokens, diags := LexTemplate(src, filename, start)
+	peeker := newPeeker(tokens, false)
+	parser := &parser{peeker: peeker}
+	expr, parseDiags := parser.ParseTemplate()
+	diags = append(diags, parseDiags...)
+
+	// Panic if the parser uses incorrect stack discipline with the peeker's
+	// newlines stack, since otherwise it will produce confusing downstream
+	// errors.
+	peeker.AssertEmptyIncludeNewlinesStack()
+
+	return expr, diags
+}
+
+// ParseTraversalAbs parses the given buffer as a standalone absolute traversal.
+//
+// Parsing as a traversal is more limited than parsing as an expession since
+// it allows only attribute and indexing operations on variables. Traverals
+// are useful as a syntax for referring to objects without necessarily
+// evaluating them.
+func ParseTraversalAbs(src []byte, filename string, start hcl.Pos) (hcl.Traversal, hcl.Diagnostics) {
+	tokens, diags := LexExpression(src, filename, start)
+	peeker := newPeeker(tokens, false)
+	parser := &parser{peeker: peeker}
+
+	// Bare traverals are always parsed in  "ignore newlines" mode, as if
+	// they were wrapped in parentheses.
+	parser.PushIncludeNewlines(false)
+
+	expr, parseDiags := parser.ParseTraversalAbs()
+	diags = append(diags, parseDiags...)
+
+	parser.PopIncludeNewlines()
+
+	// Panic if the parser uses incorrect stack discipline with the peeker's
+	// newlines stack, since otherwise it will produce confusing downstream
+	// errors.
+	peeker.AssertEmptyIncludeNewlinesStack()
+
+	return expr, diags
+}
+
+// LexConfig performs lexical analysis on the given buffer, treating it as a
+// whole HCL config file, and returns the resulting tokens.
+//
+// Only minimal validation is done during lexical analysis, so the returned
+// diagnostics may include errors about lexical issues such as bad character
+// encodings or unrecognized characters, but full parsing is required to
+// detect _all_ syntax errors.
+func LexConfig(src []byte, filename string, start hcl.Pos) (Tokens, hcl.Diagnostics) {
+	tokens := scanTokens(src, filename, start, scanNormal)
+	diags := checkInvalidTokens(tokens)
+	return tokens, diags
+}
+
+// LexExpression performs lexical analysis on the given buffer, treating it as
+// a standalone HCL expression, and returns the resulting tokens.
+//
+// Only minimal validation is done during lexical analysis, so the returned
+// diagnostics may include errors about lexical issues such as bad character
+// encodings or unrecognized characters, but full parsing is required to
+// detect _all_ syntax errors.
+func LexExpression(src []byte, filename string, start hcl.Pos) (Tokens, hcl.Diagnostics) {
+	// This is actually just the same thing as LexConfig, since configs
+	// and expressions lex in the same way.
+	tokens := scanTokens(src, filename, start, scanNormal)
+	diags := checkInvalidTokens(tokens)
+	return tokens, diags
+}
+
+// LexTemplate performs lexical analysis on the given buffer, treating it as a
+// standalone HCL template, and returns the resulting tokens.
+//
+// Only minimal validation is done during lexical analysis, so the returned
+// diagnostics may include errors about lexical issues such as bad character
+// encodings or unrecognized characters, but full parsing is required to
+// detect _all_ syntax errors.
+func LexTemplate(src []byte, filename string, start hcl.Pos) (Tokens, hcl.Diagnostics) {
+	tokens := scanTokens(src, filename, start, scanTemplate)
+	diags := checkInvalidTokens(tokens)
+	return tokens, diags
+}
+
+// ValidIdentifier tests if the given string could be a valid identifier in
+// a native syntax expression.
+//
+// This is useful when accepting names from the user that will be used as
+// variable or attribute names in the scope, to ensure that any name chosen
+// will be traversable using the variable or attribute traversal syntax.
+func ValidIdentifier(s string) bool {
+	// This is a kinda-expensive way to do something pretty simple, but it
+	// is easiest to do with our existing scanner-related infrastructure here
+	// and nobody should be validating identifiers in a tight loop.
+	tokens := scanTokens([]byte(s), "", hcl.Pos{}, scanIdentOnly)
+	return len(tokens) == 2 && tokens[0].Type == TokenIdent && tokens[1].Type == TokenEOF
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.go
new file mode 100644
index 000000000..2895ade75
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.go
@@ -0,0 +1,301 @@
+//line scan_string_lit.rl:1
+
+package hclsyntax
+
+// This file is generated from scan_string_lit.rl. DO NOT EDIT.
+
+//line scan_string_lit.go:9
+var _hclstrtok_actions []byte = []byte{
+	0, 1, 0, 1, 1, 2, 1, 0,
+}
+
+var _hclstrtok_key_offsets []byte = []byte{
+	0, 0, 2, 4, 6, 10, 14, 18,
+	22, 27, 31, 36, 41, 46, 51, 57,
+	62, 74, 85, 96, 107, 118, 129, 140,
+	151,
+}
+
+var _hclstrtok_trans_keys []byte = []byte{
+	128, 191, 128, 191, 128, 191, 10, 13,
+	36, 37, 10, 13, 36, 37, 10, 13,
+	36, 37, 10, 13, 36, 37, 10, 13,
+	36, 37, 123, 10, 13, 36, 37, 10,
+	13, 36, 37, 92, 10, 13, 36, 37,
+	92, 10, 13, 36, 37, 92, 10, 13,
+	36, 37, 92, 10, 13, 36, 37, 92,
+	123, 10, 13, 36, 37, 92, 85, 117,
+	128, 191, 192, 223, 224, 239, 240, 247,
+	248, 255, 10, 13, 36, 37, 92, 48,
+	57, 65, 70, 97, 102, 10, 13, 36,
+	37, 92, 48, 57, 65, 70, 97, 102,
+	10, 13, 36, 37, 92, 48, 57, 65,
+	70, 97, 102, 10, 13, 36, 37, 92,
+	48, 57, 65, 70, 97, 102, 10, 13,
+	36, 37, 92, 48, 57, 65, 70, 97,
+	102, 10, 13, 36, 37, 92, 48, 57,
+	65, 70, 97, 102, 10, 13, 36, 37,
+	92, 48, 57, 65, 70, 97, 102, 10,
+	13, 36, 37, 92, 48, 57, 65, 70,
+	97, 102,
+}
+
+var _hclstrtok_single_lengths []byte = []byte{
+	0, 0, 0, 0, 4, 4, 4, 4,
+	5, 4, 5, 5, 5, 5, 6, 5,
+	2, 5, 5, 5, 5, 5, 5, 5,
+	5,
+}
+
+var _hclstrtok_range_lengths []byte = []byte{
+	0, 1, 1, 1, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	5, 3, 3, 3, 3, 3, 3, 3,
+	3,
+}
+
+var _hclstrtok_index_offsets []byte = []byte{
+	0, 0, 2, 4, 6, 11, 16, 21,
+	26, 32, 37, 43, 49, 55, 61, 68,
+	74, 82, 91, 100, 109, 118, 127, 136,
+	145,
+}
+
+var _hclstrtok_indicies []byte = []byte{
+	0, 1, 2, 1, 3, 1, 5, 6,
+	7, 8, 4, 10, 11, 12, 13, 9,
+	14, 11, 12, 13, 9, 10, 11, 15,
+	13, 9, 10, 11, 12, 13, 14, 9,
+	10, 11, 12, 15, 9, 17, 18, 19,
+	20, 21, 16, 23, 24, 25, 26, 27,
+	22, 0, 24, 25, 26, 27, 22, 23,
+	24, 28, 26, 27, 22, 23, 24, 25,
+	26, 27, 0, 22, 23, 24, 25, 28,
+	27, 22, 29, 30, 22, 2, 3, 31,
+	22, 0, 23, 24, 25, 26, 27, 32,
+	32, 32, 22, 23, 24, 25, 26, 27,
+	33, 33, 33, 22, 23, 24, 25, 26,
+	27, 34, 34, 34, 22, 23, 24, 25,
+	26, 27, 30, 30, 30, 22, 23, 24,
+	25, 26, 27, 35, 35, 35, 22, 23,
+	24, 25, 26, 27, 36, 36, 36, 22,
+	23, 24, 25, 26, 27, 37, 37, 37,
+	22, 23, 24, 25, 26, 27, 0, 0,
+	0, 22,
+}
+
+var _hclstrtok_trans_targs []byte = []byte{
+	11, 0, 1, 2, 4, 5, 6, 7,
+	9, 4, 5, 6, 7, 9, 5, 8,
+	10, 11, 12, 13, 15, 16, 10, 11,
+	12, 13, 15, 16, 14, 17, 21, 3,
+	18, 19, 20, 22, 23, 24,
+}
+
+var _hclstrtok_trans_actions []byte = []byte{
+	0, 0, 0, 0, 0, 1, 1, 1,
+	1, 3, 5, 5, 5, 5, 0, 0,
+	0, 1, 1, 1, 1, 1, 3, 5,
+	5, 5, 5, 5, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0,
+}
+
+var _hclstrtok_eof_actions []byte = []byte{
+	0, 0, 0, 0, 0, 3, 3, 3,
+	3, 3, 0, 3, 3, 3, 3, 3,
+	3, 3, 3, 3, 3, 3, 3, 3,
+	3,
+}
+
+const hclstrtok_start int = 4
+const hclstrtok_first_final int = 4
+const hclstrtok_error int = 0
+
+const hclstrtok_en_quoted int = 10
+const hclstrtok_en_unquoted int = 4
+
+//line scan_string_lit.rl:10
+
+func scanStringLit(data []byte, quoted bool) [][]byte {
+	var ret [][]byte
+
+//line scan_string_lit.rl:61
+
+	// Ragel state
+	p := 0          // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+	ts := 0
+	te := 0
+	eof := pe
+
+	var cs int // current state
+	switch {
+	case quoted:
+		cs = hclstrtok_en_quoted
+	default:
+		cs = hclstrtok_en_unquoted
+	}
+
+	// Make Go compiler happy
+	_ = ts
+	_ = eof
+
+	/*token := func () {
+	    ret = append(ret, data[ts:te])
+	}*/
+
+//line scan_string_lit.go:154
+	{
+	}
+
+//line scan_string_lit.go:158
+	{
+		var _klen int
+		var _trans int
+		var _acts int
+		var _nacts uint
+		var _keys int
+		if p == pe {
+			goto _test_eof
+		}
+		if cs == 0 {
+			goto _out
+		}
+	_resume:
+		_keys = int(_hclstrtok_key_offsets[cs])
+		_trans = int(_hclstrtok_index_offsets[cs])
+
+		_klen = int(_hclstrtok_single_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + _klen - 1)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + ((_upper - _lower) >> 1)
+				switch {
+				case data[p] < _hclstrtok_trans_keys[_mid]:
+					_upper = _mid - 1
+				case data[p] > _hclstrtok_trans_keys[_mid]:
+					_lower = _mid + 1
+				default:
+					_trans += int(_mid - int(_keys))
+					goto _match
+				}
+			}
+			_keys += _klen
+			_trans += _klen
+		}
+
+		_klen = int(_hclstrtok_range_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + (_klen << 1) - 2)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + (((_upper - _lower) >> 1) & ^1)
+				switch {
+				case data[p] < _hclstrtok_trans_keys[_mid]:
+					_upper = _mid - 2
+				case data[p] > _hclstrtok_trans_keys[_mid+1]:
+					_lower = _mid + 2
+				default:
+					_trans += int((_mid - int(_keys)) >> 1)
+					goto _match
+				}
+			}
+			_trans += _klen
+		}
+
+	_match:
+		_trans = int(_hclstrtok_indicies[_trans])
+		cs = int(_hclstrtok_trans_targs[_trans])
+
+		if _hclstrtok_trans_actions[_trans] == 0 {
+			goto _again
+		}
+
+		_acts = int(_hclstrtok_trans_actions[_trans])
+		_nacts = uint(_hclstrtok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _hclstrtok_actions[_acts-1] {
+			case 0:
+//line scan_string_lit.rl:40
+
+				// If te is behind p then we've skipped over some literal
+				// characters which we must now return.
+				if te < p {
+					ret = append(ret, data[te:p])
+				}
+				ts = p
+
+			case 1:
+//line scan_string_lit.rl:48
+
+				te = p
+				ret = append(ret, data[ts:te])
+
+//line scan_string_lit.go:253
+			}
+		}
+
+	_again:
+		if cs == 0 {
+			goto _out
+		}
+		p++
+		if p != pe {
+			goto _resume
+		}
+	_test_eof:
+		{
+		}
+		if p == eof {
+			__acts := _hclstrtok_eof_actions[cs]
+			__nacts := uint(_hclstrtok_actions[__acts])
+			__acts++
+			for ; __nacts > 0; __nacts-- {
+				__acts++
+				switch _hclstrtok_actions[__acts-1] {
+				case 1:
+//line scan_string_lit.rl:48
+
+					te = p
+					ret = append(ret, data[ts:te])
+
+//line scan_string_lit.go:278
+				}
+			}
+		}
+
+	_out:
+		{
+		}
+	}
+
+//line scan_string_lit.rl:89
+
+	if te < p {
+		// Collect any leftover literal characters at the end of the input
+		ret = append(ret, data[te:p])
+	}
+
+	// If we fall out here without being in a final state then we've
+	// encountered something that the scanner can't match, which should
+	// be impossible (the scanner matches all bytes _somehow_) but we'll
+	// tolerate it and let the caller deal with it.
+	if cs < hclstrtok_first_final {
+		ret = append(ret, data[p:len(data)])
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.rl b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.rl
new file mode 100644
index 000000000..f8ac11751
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_string_lit.rl
@@ -0,0 +1,105 @@
+
+package hclsyntax
+
+// This file is generated from scan_string_lit.rl. DO NOT EDIT.
+%%{
+  # (except you are actually in scan_string_lit.rl here, so edit away!)
+
+  machine hclstrtok;
+  write data;
+}%%
+
+func scanStringLit(data []byte, quoted bool) [][]byte {
+    var ret [][]byte
+
+    %%{
+        include UnicodeDerived "unicode_derived.rl";
+
+        UTF8Cont = 0x80 .. 0xBF;
+        AnyUTF8 = (
+            0x00..0x7F |
+            0xC0..0xDF . UTF8Cont |
+            0xE0..0xEF . UTF8Cont . UTF8Cont |
+            0xF0..0xF7 . UTF8Cont . UTF8Cont . UTF8Cont
+        );
+        BadUTF8 = any - AnyUTF8;
+
+        Hex = ('0'..'9' | 'a'..'f' | 'A'..'F');
+
+        # Our goal with this patterns is to capture user intent as best as
+        # possible, even if the input is invalid. The caller will then verify
+        # whether each token is valid and generate suitable error messages
+        # if not.
+        UnicodeEscapeShort = "\\u" . Hex{0,4};
+        UnicodeEscapeLong = "\\U" . Hex{0,8};
+        UnicodeEscape = (UnicodeEscapeShort | UnicodeEscapeLong);
+        SimpleEscape = "\\" . (AnyUTF8 - ('U'|'u'))?;
+        TemplateEscape = ("$" . ("$" . ("{"?))?) | ("%" . ("%" . ("{"?))?);
+        Newline = ("\r\n" | "\r" | "\n");
+
+        action Begin {
+            // If te is behind p then we've skipped over some literal
+            // characters which we must now return.
+            if te < p {
+                ret = append(ret, data[te:p])
+            }
+            ts = p;
+        }
+        action End {
+            te = p;
+            ret = append(ret, data[ts:te]);
+        }
+
+        QuotedToken = (UnicodeEscape | SimpleEscape | TemplateEscape | Newline) >Begin %End;
+        UnquotedToken = (TemplateEscape | Newline) >Begin %End;
+        QuotedLiteral = (any - ("\\" | "$" | "%" | "\r" | "\n"));
+        UnquotedLiteral = (any - ("$" | "%" | "\r" | "\n"));
+
+        quoted := (QuotedToken | QuotedLiteral)**;
+        unquoted := (UnquotedToken | UnquotedLiteral)**;
+
+    }%%
+
+    // Ragel state
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    eof := pe
+
+    var cs int // current state
+    switch {
+    case quoted:
+        cs = hclstrtok_en_quoted
+    default:
+        cs = hclstrtok_en_unquoted
+    }
+
+    // Make Go compiler happy
+    _ = ts
+    _ = eof
+
+    /*token := func () {
+        ret = append(ret, data[ts:te])
+    }*/
+
+    %%{
+        write init nocs;
+        write exec;
+    }%%
+
+    if te < p {
+        // Collect any leftover literal characters at the end of the input
+        ret = append(ret, data[te:p])
+    }
+
+    // If we fall out here without being in a final state then we've
+    // encountered something that the scanner can't match, which should
+    // be impossible (the scanner matches all bytes _somehow_) but we'll
+    // tolerate it and let the caller deal with it.
+    if cs < hclstrtok_first_final {
+        ret = append(ret, data[p:len(data)])
+    }
+
+    return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.go
new file mode 100644
index 000000000..794123a85
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.go
@@ -0,0 +1,5265 @@
+//line scan_tokens.rl:1
+
+package hclsyntax
+
+import (
+	"bytes"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// This file is generated from scan_tokens.rl. DO NOT EDIT.
+
+//line scan_tokens.go:15
+var _hcltok_actions []byte = []byte{
+	0, 1, 0, 1, 1, 1, 3, 1, 4,
+	1, 7, 1, 8, 1, 9, 1, 10,
+	1, 11, 1, 12, 1, 13, 1, 14,
+	1, 15, 1, 16, 1, 17, 1, 18,
+	1, 19, 1, 20, 1, 23, 1, 24,
+	1, 25, 1, 26, 1, 27, 1, 28,
+	1, 29, 1, 30, 1, 31, 1, 32,
+	1, 35, 1, 36, 1, 37, 1, 38,
+	1, 39, 1, 40, 1, 41, 1, 42,
+	1, 43, 1, 44, 1, 47, 1, 48,
+	1, 49, 1, 50, 1, 51, 1, 52,
+	1, 53, 1, 56, 1, 57, 1, 58,
+	1, 59, 1, 60, 1, 61, 1, 62,
+	1, 63, 1, 64, 1, 65, 1, 66,
+	1, 67, 1, 68, 1, 69, 1, 70,
+	1, 71, 1, 72, 1, 73, 1, 74,
+	1, 75, 1, 76, 1, 77, 1, 78,
+	1, 79, 1, 80, 1, 81, 1, 82,
+	1, 83, 1, 84, 1, 85, 2, 0,
+	14, 2, 0, 25, 2, 0, 29, 2,
+	0, 37, 2, 0, 41, 2, 1, 2,
+	2, 4, 5, 2, 4, 6, 2, 4,
+	21, 2, 4, 22, 2, 4, 33, 2,
+	4, 34, 2, 4, 45, 2, 4, 46,
+	2, 4, 54, 2, 4, 55,
+}
+
+var _hcltok_key_offsets []int16 = []int16{
+	0, 0, 1, 2, 4, 9, 13, 15,
+	57, 98, 144, 145, 149, 155, 155, 157,
+	159, 168, 174, 181, 182, 185, 186, 190,
+	195, 204, 208, 212, 220, 222, 224, 226,
+	229, 261, 263, 265, 269, 273, 276, 287,
+	300, 319, 332, 348, 360, 376, 391, 412,
+	422, 434, 445, 459, 474, 484, 496, 505,
+	517, 519, 523, 544, 553, 563, 569, 575,
+	576, 625, 627, 631, 633, 639, 646, 654,
+	661, 664, 670, 674, 678, 680, 684, 688,
+	692, 698, 706, 714, 720, 722, 726, 728,
+	734, 738, 742, 746, 750, 755, 762, 768,
+	770, 772, 776, 778, 784, 788, 792, 802,
+	807, 821, 836, 838, 846, 848, 853, 867,
+	872, 874, 878, 879, 883, 889, 895, 905,
+	915, 926, 934, 937, 940, 944, 948, 950,
+	953, 953, 956, 958, 988, 990, 992, 996,
+	1001, 1005, 1010, 1012, 1014, 1016, 1025, 1029,
+	1033, 1039, 1041, 1049, 1057, 1069, 1072, 1078,
+	1082, 1084, 1088, 1108, 1110, 1112, 1123, 1129,
+	1131, 1133, 1135, 1139, 1145, 1151, 1153, 1158,
+	1162, 1164, 1172, 1190, 1230, 1240, 1244, 1246,
+	1248, 1249, 1253, 1257, 1261, 1265, 1269, 1274,
+	1278, 1282, 1286, 1288, 1290, 1294, 1304, 1308,
+	1310, 1314, 1318, 1322, 1335, 1337, 1339, 1343,
+	1345, 1349, 1351, 1353, 1383, 1387, 1391, 1395,
+	1398, 1405, 1410, 1421, 1425, 1441, 1455, 1459,
+	1464, 1468, 1472, 1478, 1480, 1486, 1488, 1492,
+	1494, 1500, 1505, 1510, 1520, 1522, 1524, 1528,
+	1532, 1534, 1547, 1549, 1553, 1557, 1565, 1567,
+	1571, 1573, 1574, 1577, 1582, 1584, 1586, 1590,
+	1592, 1596, 1602, 1622, 1628, 1634, 1636, 1637,
+	1647, 1648, 1656, 1663, 1665, 1668, 1670, 1672,
+	1674, 1679, 1683, 1687, 1692, 1702, 1712, 1716,
+	1720, 1734, 1760, 1770, 1772, 1774, 1777, 1779,
+	1782, 1784, 1788, 1790, 1791, 1795, 1797, 1800,
+	1807, 1815, 1817, 1819, 1823, 1825, 1831, 1842,
+	1845, 1847, 1851, 1856, 1886, 1891, 1893, 1896,
+	1901, 1915, 1922, 1936, 1941, 1954, 1958, 1971,
+	1976, 1994, 1995, 2004, 2008, 2020, 2025, 2032,
+	2039, 2046, 2048, 2052, 2074, 2079, 2080, 2084,
+	2086, 2136, 2139, 2150, 2154, 2156, 2162, 2168,
+	2170, 2175, 2177, 2181, 2183, 2184, 2186, 2188,
+	2194, 2196, 2198, 2202, 2208, 2221, 2223, 2229,
+	2233, 2241, 2252, 2260, 2263, 2293, 2299, 2302,
+	2307, 2309, 2313, 2317, 2321, 2323, 2330, 2332,
+	2341, 2348, 2356, 2358, 2378, 2390, 2394, 2396,
+	2414, 2453, 2455, 2459, 2461, 2468, 2472, 2500,
+	2502, 2504, 2506, 2508, 2511, 2513, 2517, 2521,
+	2523, 2526, 2528, 2530, 2533, 2535, 2537, 2538,
+	2540, 2542, 2546, 2550, 2553, 2566, 2568, 2574,
+	2578, 2580, 2584, 2588, 2602, 2605, 2614, 2616,
+	2620, 2626, 2626, 2628, 2630, 2639, 2645, 2652,
+	2653, 2656, 2657, 2661, 2666, 2675, 2679, 2683,
+	2691, 2693, 2695, 2697, 2700, 2732, 2734, 2736,
+	2740, 2744, 2747, 2758, 2771, 2790, 2803, 2819,
+	2831, 2847, 2862, 2883, 2893, 2905, 2916, 2930,
+	2945, 2955, 2967, 2976, 2988, 2990, 2994, 3015,
+	3024, 3034, 3040, 3046, 3047, 3096, 3098, 3102,
+	3104, 3110, 3117, 3125, 3132, 3135, 3141, 3145,
+	3149, 3151, 3155, 3159, 3163, 3169, 3177, 3185,
+	3191, 3193, 3197, 3199, 3205, 3209, 3213, 3217,
+	3221, 3226, 3233, 3239, 3241, 3243, 3247, 3249,
+	3255, 3259, 3263, 3273, 3278, 3292, 3307, 3309,
+	3317, 3319, 3324, 3338, 3343, 3345, 3349, 3350,
+	3354, 3360, 3366, 3376, 3386, 3397, 3405, 3408,
+	3411, 3415, 3419, 3421, 3424, 3424, 3427, 3429,
+	3459, 3461, 3463, 3467, 3472, 3476, 3481, 3483,
+	3485, 3487, 3496, 3500, 3504, 3510, 3512, 3520,
+	3528, 3540, 3543, 3549, 3553, 3555, 3559, 3579,
+	3581, 3583, 3594, 3600, 3602, 3604, 3606, 3610,
+	3616, 3622, 3624, 3629, 3633, 3635, 3643, 3661,
+	3701, 3711, 3715, 3717, 3719, 3720, 3724, 3728,
+	3732, 3736, 3740, 3745, 3749, 3753, 3757, 3759,
+	3761, 3765, 3775, 3779, 3781, 3785, 3789, 3793,
+	3806, 3808, 3810, 3814, 3816, 3820, 3822, 3824,
+	3854, 3858, 3862, 3866, 3869, 3876, 3881, 3892,
+	3896, 3912, 3926, 3930, 3935, 3939, 3943, 3949,
+	3951, 3957, 3959, 3963, 3965, 3971, 3976, 3981,
+	3991, 3993, 3995, 3999, 4003, 4005, 4018, 4020,
+	4024, 4028, 4036, 4038, 4042, 4044, 4045, 4048,
+	4053, 4055, 4057, 4061, 4063, 4067, 4073, 4093,
+	4099, 4105, 4107, 4108, 4118, 4119, 4127, 4134,
+	4136, 4139, 4141, 4143, 4145, 4150, 4154, 4158,
+	4163, 4173, 4183, 4187, 4191, 4205, 4231, 4241,
+	4243, 4245, 4248, 4250, 4253, 4255, 4259, 4261,
+	4262, 4266, 4268, 4270, 4277, 4281, 4288, 4295,
+	4304, 4320, 4332, 4350, 4361, 4373, 4381, 4399,
+	4407, 4437, 4440, 4450, 4460, 4472, 4483, 4492,
+	4505, 4517, 4521, 4527, 4554, 4563, 4566, 4571,
+	4577, 4582, 4603, 4607, 4613, 4613, 4620, 4629,
+	4637, 4640, 4644, 4650, 4656, 4659, 4663, 4670,
+	4676, 4685, 4694, 4698, 4702, 4706, 4710, 4717,
+	4721, 4725, 4735, 4741, 4745, 4751, 4755, 4758,
+	4764, 4770, 4782, 4786, 4790, 4800, 4804, 4815,
+	4817, 4819, 4823, 4835, 4840, 4864, 4868, 4874,
+	4896, 4905, 4909, 4912, 4913, 4921, 4929, 4935,
+	4945, 4952, 4970, 4973, 4976, 4984, 4990, 4994,
+	4998, 5002, 5008, 5016, 5021, 5027, 5031, 5039,
+	5046, 5050, 5057, 5063, 5071, 5079, 5085, 5091,
+	5102, 5106, 5118, 5127, 5144, 5161, 5164, 5168,
+	5170, 5176, 5178, 5182, 5197, 5201, 5205, 5209,
+	5213, 5217, 5219, 5225, 5230, 5234, 5240, 5247,
+	5250, 5268, 5270, 5315, 5321, 5327, 5331, 5335,
+	5341, 5345, 5351, 5357, 5364, 5366, 5372, 5378,
+	5382, 5386, 5394, 5407, 5413, 5420, 5428, 5434,
+	5443, 5449, 5453, 5458, 5462, 5470, 5474, 5478,
+	5508, 5514, 5520, 5526, 5532, 5539, 5545, 5552,
+	5557, 5567, 5571, 5578, 5584, 5588, 5595, 5599,
+	5605, 5608, 5612, 5616, 5620, 5624, 5629, 5634,
+	5638, 5649, 5653, 5657, 5663, 5671, 5675, 5692,
+	5696, 5702, 5712, 5718, 5724, 5727, 5732, 5741,
+	5745, 5749, 5755, 5759, 5765, 5773, 5791, 5792,
+	5802, 5803, 5812, 5820, 5822, 5825, 5827, 5829,
+	5831, 5836, 5849, 5853, 5868, 5897, 5908, 5910,
+	5914, 5918, 5923, 5927, 5929, 5936, 5940, 5948,
+	5952, 5964, 5966, 5968, 5970, 5972, 5974, 5975,
+	5977, 5979, 5981, 5983, 5985, 5986, 5988, 5990,
+	5992, 5994, 5996, 6000, 6006, 6006, 6008, 6010,
+	6019, 6025, 6032, 6033, 6036, 6037, 6041, 6046,
+	6055, 6059, 6063, 6071, 6073, 6075, 6077, 6080,
+	6112, 6114, 6116, 6120, 6124, 6127, 6138, 6151,
+	6170, 6183, 6199, 6211, 6227, 6242, 6263, 6273,
+	6285, 6296, 6310, 6325, 6335, 6347, 6356, 6368,
+	6370, 6374, 6395, 6404, 6414, 6420, 6426, 6427,
+	6476, 6478, 6482, 6484, 6490, 6497, 6505, 6512,
+	6515, 6521, 6525, 6529, 6531, 6535, 6539, 6543,
+	6549, 6557, 6565, 6571, 6573, 6577, 6579, 6585,
+	6589, 6593, 6597, 6601, 6606, 6613, 6619, 6621,
+	6623, 6627, 6629, 6635, 6639, 6643, 6653, 6658,
+	6672, 6687, 6689, 6697, 6699, 6704, 6718, 6723,
+	6725, 6729, 6730, 6734, 6740, 6746, 6756, 6766,
+	6777, 6785, 6788, 6791, 6795, 6799, 6801, 6804,
+	6804, 6807, 6809, 6839, 6841, 6843, 6847, 6852,
+	6856, 6861, 6863, 6865, 6867, 6876, 6880, 6884,
+	6890, 6892, 6900, 6908, 6920, 6923, 6929, 6933,
+	6935, 6939, 6959, 6961, 6963, 6974, 6980, 6982,
+	6984, 6986, 6990, 6996, 7002, 7004, 7009, 7013,
+	7015, 7023, 7041, 7081, 7091, 7095, 7097, 7099,
+	7100, 7104, 7108, 7112, 7116, 7120, 7125, 7129,
+	7133, 7137, 7139, 7141, 7145, 7155, 7159, 7161,
+	7165, 7169, 7173, 7186, 7188, 7190, 7194, 7196,
+	7200, 7202, 7204, 7234, 7238, 7242, 7246, 7249,
+	7256, 7261, 7272, 7276, 7292, 7306, 7310, 7315,
+	7319, 7323, 7329, 7331, 7337, 7339, 7343, 7345,
+	7351, 7356, 7361, 7371, 7373, 7375, 7379, 7383,
+	7385, 7398, 7400, 7404, 7408, 7416, 7418, 7422,
+	7424, 7425, 7428, 7433, 7435, 7437, 7441, 7443,
+	7447, 7453, 7473, 7479, 7485, 7487, 7488, 7498,
+	7499, 7507, 7514, 7516, 7519, 7521, 7523, 7525,
+	7530, 7534, 7538, 7543, 7553, 7563, 7567, 7571,
+	7585, 7611, 7621, 7623, 7625, 7628, 7630, 7633,
+	7635, 7639, 7641, 7642, 7646, 7648, 7650, 7657,
+	7661, 7668, 7675, 7684, 7700, 7712, 7730, 7741,
+	7753, 7761, 7779, 7787, 7817, 7820, 7830, 7840,
+	7852, 7863, 7872, 7885, 7897, 7901, 7907, 7934,
+	7943, 7946, 7951, 7957, 7962, 7983, 7987, 7993,
+	7993, 8000, 8009, 8017, 8020, 8024, 8030, 8036,
+	8039, 8043, 8050, 8056, 8065, 8074, 8078, 8082,
+	8086, 8090, 8097, 8101, 8105, 8115, 8121, 8125,
+	8131, 8135, 8138, 8144, 8150, 8162, 8166, 8170,
+	8180, 8184, 8195, 8197, 8199, 8203, 8215, 8220,
+	8244, 8248, 8254, 8276, 8285, 8289, 8292, 8293,
+	8301, 8309, 8315, 8325, 8332, 8350, 8353, 8356,
+	8364, 8370, 8374, 8378, 8382, 8388, 8396, 8401,
+	8407, 8411, 8419, 8426, 8430, 8437, 8443, 8451,
+	8459, 8465, 8471, 8482, 8486, 8498, 8507, 8524,
+	8541, 8544, 8548, 8550, 8556, 8558, 8562, 8577,
+	8581, 8585, 8589, 8593, 8597, 8599, 8605, 8610,
+	8614, 8620, 8627, 8630, 8648, 8650, 8695, 8701,
+	8707, 8711, 8715, 8721, 8725, 8731, 8737, 8744,
+	8746, 8752, 8758, 8762, 8766, 8774, 8787, 8793,
+	8800, 8808, 8814, 8823, 8829, 8833, 8838, 8842,
+	8850, 8854, 8858, 8888, 8894, 8900, 8906, 8912,
+	8919, 8925, 8932, 8937, 8947, 8951, 8958, 8964,
+	8968, 8975, 8979, 8985, 8988, 8992, 8996, 9000,
+	9004, 9009, 9014, 9018, 9029, 9033, 9037, 9043,
+	9051, 9055, 9072, 9076, 9082, 9092, 9098, 9104,
+	9107, 9112, 9121, 9125, 9129, 9135, 9139, 9145,
+	9153, 9171, 9172, 9182, 9183, 9192, 9200, 9202,
+	9205, 9207, 9209, 9211, 9216, 9229, 9233, 9248,
+	9277, 9288, 9290, 9294, 9298, 9303, 9307, 9309,
+	9316, 9320, 9328, 9332, 9407, 9409, 9410, 9411,
+	9412, 9413, 9414, 9416, 9421, 9423, 9425, 9426,
+	9470, 9471, 9472, 9474, 9479, 9483, 9483, 9485,
+	9487, 9498, 9508, 9516, 9517, 9519, 9520, 9524,
+	9528, 9538, 9542, 9549, 9560, 9567, 9571, 9577,
+	9588, 9620, 9669, 9684, 9699, 9704, 9706, 9711,
+	9743, 9751, 9753, 9775, 9797, 9799, 9815, 9831,
+	9833, 9835, 9835, 9836, 9837, 9838, 9840, 9841,
+	9853, 9855, 9857, 9859, 9873, 9887, 9889, 9892,
+	9895, 9897, 9898, 9899, 9901, 9903, 9905, 9919,
+	9933, 9935, 9938, 9941, 9943, 9944, 9945, 9947,
+	9949, 9951, 10000, 10044, 10046, 10051, 10055, 10055,
+	10057, 10059, 10070, 10080, 10088, 10089, 10091, 10092,
+	10096, 10100, 10110, 10114, 10121, 10132, 10139, 10143,
+	10149, 10160, 10192, 10241, 10256, 10271, 10276, 10278,
+	10283, 10315, 10323, 10325, 10347, 10369,
+}
+
+var _hcltok_trans_keys []byte = []byte{
+	46, 42, 42, 47, 46, 69, 101, 48,
+	57, 43, 45, 48, 57, 48, 57, 45,
+	95, 194, 195, 198, 199, 203, 205, 206,
+	207, 210, 212, 213, 214, 215, 216, 217,
+	219, 220, 221, 222, 223, 224, 225, 226,
+	227, 228, 233, 234, 237, 239, 240, 65,
+	90, 97, 122, 196, 202, 208, 218, 229,
+	236, 95, 194, 195, 198, 199, 203, 205,
+	206, 207, 210, 212, 213, 214, 215, 216,
+	217, 219, 220, 221, 222, 223, 224, 225,
+	226, 227, 228, 233, 234, 237, 239, 240,
+	65, 90, 97, 122, 196, 202, 208, 218,
+	229, 236, 10, 13, 45, 95, 194, 195,
+	198, 199, 203, 204, 205, 206, 207, 210,
+	212, 213, 214, 215, 216, 217, 219, 220,
+	221, 222, 223, 224, 225, 226, 227, 228,
+	233, 234, 237, 239, 240, 243, 48, 57,
+	65, 90, 97, 122, 196, 218, 229, 236,
+	10, 170, 181, 183, 186, 128, 150, 152,
+	182, 184, 255, 192, 255, 128, 255, 173,
+	130, 133, 146, 159, 165, 171, 175, 255,
+	181, 190, 184, 185, 192, 255, 140, 134,
+	138, 142, 161, 163, 255, 182, 130, 136,
+	137, 176, 151, 152, 154, 160, 190, 136,
+	144, 192, 255, 135, 129, 130, 132, 133,
+	144, 170, 176, 178, 144, 154, 160, 191,
+	128, 169, 174, 255, 148, 169, 157, 158,
+	189, 190, 192, 255, 144, 255, 139, 140,
+	178, 255, 186, 128, 181, 160, 161, 162,
+	163, 164, 165, 166, 167, 168, 169, 170,
+	171, 172, 173, 174, 175, 176, 177, 178,
+	179, 180, 181, 182, 183, 184, 185, 186,
+	187, 188, 189, 190, 191, 128, 173, 128,
+	155, 160, 180, 182, 189, 148, 161, 163,
+	255, 176, 164, 165, 132, 169, 177, 141,
+	142, 145, 146, 179, 181, 186, 187, 158,
+	133, 134, 137, 138, 143, 150, 152, 155,
+	164, 165, 178, 255, 188, 129, 131, 133,
+	138, 143, 144, 147, 168, 170, 176, 178,
+	179, 181, 182, 184, 185, 190, 255, 157,
+	131, 134, 137, 138, 142, 144, 146, 152,
+	159, 165, 182, 255, 129, 131, 133, 141,
+	143, 145, 147, 168, 170, 176, 178, 179,
+	181, 185, 188, 255, 134, 138, 142, 143,
+	145, 159, 164, 165, 176, 184, 186, 255,
+	129, 131, 133, 140, 143, 144, 147, 168,
+	170, 176, 178, 179, 181, 185, 188, 191,
+	177, 128, 132, 135, 136, 139, 141, 150,
+	151, 156, 157, 159, 163, 166, 175, 156,
+	130, 131, 133, 138, 142, 144, 146, 149,
+	153, 154, 158, 159, 163, 164, 168, 170,
+	174, 185, 190, 191, 144, 151, 128, 130,
+	134, 136, 138, 141, 166, 175, 128, 131,
+	133, 140, 142, 144, 146, 168, 170, 185,
+	189, 255, 133, 137, 151, 142, 148, 155,
+	159, 164, 165, 176, 255, 128, 131, 133,
+	140, 142, 144, 146, 168, 170, 179, 181,
+	185, 188, 191, 158, 128, 132, 134, 136,
+	138, 141, 149, 150, 160, 163, 166, 175,
+	177, 178, 129, 131, 133, 140, 142, 144,
+	146, 186, 189, 255, 133, 137, 143, 147,
+	152, 158, 164, 165, 176, 185, 192, 255,
+	189, 130, 131, 133, 150, 154, 177, 179,
+	187, 138, 150, 128, 134, 143, 148, 152,
+	159, 166, 175, 178, 179, 129, 186, 128,
+	142, 144, 153, 132, 138, 141, 165, 167,
+	129, 130, 135, 136, 148, 151, 153, 159,
+	161, 163, 170, 171, 173, 185, 187, 189,
+	134, 128, 132, 136, 141, 144, 153, 156,
+	159, 128, 181, 183, 185, 152, 153, 160,
+	169, 190, 191, 128, 135, 137, 172, 177,
+	191, 128, 132, 134, 151, 153, 188, 134,
+	128, 129, 130, 131, 137, 138, 139, 140,
+	141, 142, 143, 144, 153, 154, 155, 156,
+	157, 158, 159, 160, 161, 162, 163, 164,
+	165, 166, 167, 168, 169, 170, 173, 175,
+	176, 177, 178, 179, 181, 182, 183, 188,
+	189, 190, 191, 132, 152, 172, 184, 185,
+	187, 128, 191, 128, 137, 144, 255, 158,
+	159, 134, 187, 136, 140, 142, 143, 137,
+	151, 153, 142, 143, 158, 159, 137, 177,
+	142, 143, 182, 183, 191, 255, 128, 130,
+	133, 136, 150, 152, 255, 145, 150, 151,
+	155, 156, 160, 168, 178, 255, 128, 143,
+	160, 255, 182, 183, 190, 255, 129, 255,
+	173, 174, 192, 255, 129, 154, 160, 255,
+	171, 173, 185, 255, 128, 140, 142, 148,
+	160, 180, 128, 147, 160, 172, 174, 176,
+	178, 179, 148, 150, 152, 155, 158, 159,
+	170, 255, 139, 141, 144, 153, 160, 255,
+	184, 255, 128, 170, 176, 255, 182, 255,
+	128, 158, 160, 171, 176, 187, 134, 173,
+	176, 180, 128, 171, 176, 255, 138, 143,
+	155, 255, 128, 155, 160, 255, 159, 189,
+	190, 192, 255, 167, 128, 137, 144, 153,
+	176, 189, 140, 143, 154, 170, 180, 255,
+	180, 255, 128, 183, 128, 137, 141, 189,
+	128, 136, 144, 146, 148, 182, 184, 185,
+	128, 181, 187, 191, 150, 151, 158, 159,
+	152, 154, 156, 158, 134, 135, 142, 143,
+	190, 255, 190, 128, 180, 182, 188, 130,
+	132, 134, 140, 144, 147, 150, 155, 160,
+	172, 178, 180, 182, 188, 128, 129, 130,
+	131, 132, 133, 134, 176, 177, 178, 179,
+	180, 181, 182, 183, 191, 255, 129, 147,
+	149, 176, 178, 190, 192, 255, 144, 156,
+	161, 144, 156, 165, 176, 130, 135, 149,
+	164, 166, 168, 138, 147, 152, 157, 170,
+	185, 188, 191, 142, 133, 137, 160, 255,
+	137, 255, 128, 174, 176, 255, 159, 165,
+	170, 180, 255, 167, 173, 128, 165, 176,
+	255, 168, 174, 176, 190, 192, 255, 128,
+	150, 160, 166, 168, 174, 176, 182, 184,
+	190, 128, 134, 136, 142, 144, 150, 152,
+	158, 160, 191, 128, 129, 130, 131, 132,
+	133, 134, 135, 144, 145, 255, 133, 135,
+	161, 175, 177, 181, 184, 188, 160, 151,
+	152, 187, 192, 255, 133, 173, 177, 255,
+	143, 159, 187, 255, 176, 191, 182, 183,
+	184, 191, 192, 255, 150, 255, 128, 146,
+	147, 148, 152, 153, 154, 155, 156, 158,
+	159, 160, 161, 162, 163, 164, 165, 166,
+	167, 168, 169, 170, 171, 172, 173, 174,
+	175, 176, 129, 255, 141, 255, 144, 189,
+	141, 143, 172, 255, 191, 128, 175, 180,
+	189, 151, 159, 162, 255, 175, 137, 138,
+	184, 255, 183, 255, 168, 255, 128, 179,
+	188, 134, 143, 154, 159, 184, 186, 190,
+	255, 128, 173, 176, 255, 148, 159, 189,
+	255, 129, 142, 154, 159, 191, 255, 128,
+	182, 128, 141, 144, 153, 160, 182, 186,
+	255, 128, 130, 155, 157, 160, 175, 178,
+	182, 129, 134, 137, 142, 145, 150, 160,
+	166, 168, 174, 176, 255, 155, 166, 175,
+	128, 170, 172, 173, 176, 185, 158, 159,
+	160, 255, 164, 175, 135, 138, 188, 255,
+	164, 169, 171, 172, 173, 174, 175, 180,
+	181, 182, 183, 184, 185, 187, 188, 189,
+	190, 191, 165, 186, 174, 175, 154, 255,
+	190, 128, 134, 147, 151, 157, 168, 170,
+	182, 184, 188, 128, 129, 131, 132, 134,
+	255, 147, 255, 190, 255, 144, 145, 136,
+	175, 188, 255, 128, 143, 160, 175, 179,
+	180, 141, 143, 176, 180, 182, 255, 189,
+	255, 191, 144, 153, 161, 186, 129, 154,
+	166, 255, 191, 255, 130, 135, 138, 143,
+	146, 151, 154, 156, 144, 145, 146, 147,
+	148, 150, 151, 152, 155, 157, 158, 160,
+	170, 171, 172, 175, 161, 169, 128, 129,
+	130, 131, 133, 135, 138, 139, 140, 141,
+	142, 143, 144, 145, 146, 147, 148, 149,
+	152, 156, 157, 160, 161, 162, 163, 164,
+	166, 168, 169, 170, 171, 172, 173, 174,
+	176, 177, 153, 155, 178, 179, 128, 139,
+	141, 166, 168, 186, 188, 189, 191, 255,
+	142, 143, 158, 255, 187, 255, 128, 180,
+	189, 128, 156, 160, 255, 145, 159, 161,
+	255, 128, 159, 176, 255, 139, 143, 187,
+	255, 128, 157, 160, 255, 144, 132, 135,
+	150, 255, 158, 159, 170, 175, 148, 151,
+	188, 255, 128, 167, 176, 255, 164, 255,
+	183, 255, 128, 149, 160, 167, 136, 188,
+	128, 133, 138, 181, 183, 184, 191, 255,
+	150, 159, 183, 255, 128, 158, 160, 178,
+	180, 181, 128, 149, 160, 185, 128, 183,
+	190, 191, 191, 128, 131, 133, 134, 140,
+	147, 149, 151, 153, 179, 184, 186, 160,
+	188, 128, 156, 128, 135, 137, 166, 128,
+	181, 128, 149, 160, 178, 128, 145, 128,
+	178, 129, 130, 131, 132, 133, 135, 136,
+	138, 139, 140, 141, 144, 145, 146, 147,
+	150, 151, 152, 153, 154, 155, 156, 162,
+	163, 171, 176, 177, 178, 128, 134, 135,
+	165, 176, 190, 144, 168, 176, 185, 128,
+	180, 182, 191, 182, 144, 179, 155, 133,
+	137, 141, 143, 157, 255, 190, 128, 145,
+	147, 183, 136, 128, 134, 138, 141, 143,
+	157, 159, 168, 176, 255, 171, 175, 186,
+	255, 128, 131, 133, 140, 143, 144, 147,
+	168, 170, 176, 178, 179, 181, 185, 188,
+	191, 144, 151, 128, 132, 135, 136, 139,
+	141, 157, 163, 166, 172, 176, 180, 128,
+	138, 144, 153, 134, 136, 143, 154, 255,
+	128, 181, 184, 255, 129, 151, 158, 255,
+	129, 131, 133, 143, 154, 255, 128, 137,
+	128, 153, 157, 171, 176, 185, 160, 255,
+	170, 190, 192, 255, 128, 184, 128, 136,
+	138, 182, 184, 191, 128, 144, 153, 178,
+	255, 168, 144, 145, 183, 255, 128, 142,
+	145, 149, 129, 141, 144, 146, 147, 148,
+	175, 255, 132, 255, 128, 144, 129, 143,
+	144, 153, 145, 152, 135, 255, 160, 168,
+	169, 171, 172, 173, 174, 188, 189, 190,
+	191, 161, 167, 185, 255, 128, 158, 160,
+	169, 144, 173, 176, 180, 128, 131, 144,
+	153, 163, 183, 189, 255, 144, 255, 133,
+	143, 191, 255, 143, 159, 160, 128, 129,
+	255, 159, 160, 171, 172, 255, 173, 255,
+	179, 255, 128, 176, 177, 178, 128, 129,
+	171, 175, 189, 255, 128, 136, 144, 153,
+	157, 158, 133, 134, 137, 144, 145, 146,
+	147, 148, 149, 154, 155, 156, 157, 158,
+	159, 168, 169, 170, 150, 153, 165, 169,
+	173, 178, 187, 255, 131, 132, 140, 169,
+	174, 255, 130, 132, 149, 157, 173, 186,
+	188, 160, 161, 163, 164, 167, 168, 132,
+	134, 149, 157, 186, 139, 140, 191, 255,
+	134, 128, 132, 138, 144, 146, 255, 166,
+	167, 129, 155, 187, 149, 181, 143, 175,
+	137, 169, 131, 140, 141, 192, 255, 128,
+	182, 187, 255, 173, 180, 182, 255, 132,
+	155, 159, 161, 175, 128, 160, 163, 164,
+	165, 184, 185, 186, 161, 162, 128, 134,
+	136, 152, 155, 161, 163, 164, 166, 170,
+	133, 143, 151, 255, 139, 143, 154, 255,
+	164, 167, 185, 187, 128, 131, 133, 159,
+	161, 162, 169, 178, 180, 183, 130, 135,
+	137, 139, 148, 151, 153, 155, 157, 159,
+	164, 190, 141, 143, 145, 146, 161, 162,
+	167, 170, 172, 178, 180, 183, 185, 188,
+	128, 137, 139, 155, 161, 163, 165, 169,
+	171, 187, 155, 156, 151, 255, 156, 157,
+	160, 181, 255, 186, 187, 255, 162, 255,
+	160, 168, 161, 167, 158, 255, 160, 132,
+	135, 133, 134, 176, 255, 170, 181, 186,
+	191, 176, 180, 182, 183, 186, 189, 134,
+	140, 136, 138, 142, 161, 163, 255, 130,
+	137, 136, 255, 144, 170, 176, 178, 160,
+	191, 128, 138, 174, 175, 177, 255, 148,
+	150, 164, 167, 173, 176, 185, 189, 190,
+	192, 255, 144, 146, 175, 141, 255, 166,
+	176, 178, 255, 186, 138, 170, 180, 181,
+	160, 161, 162, 164, 165, 166, 167, 168,
+	169, 170, 171, 172, 173, 174, 175, 176,
+	177, 178, 179, 180, 181, 182, 184, 186,
+	187, 188, 189, 190, 183, 185, 154, 164,
+	168, 128, 149, 128, 152, 189, 132, 185,
+	144, 152, 161, 177, 255, 169, 177, 129,
+	132, 141, 142, 145, 146, 179, 181, 186,
+	188, 190, 255, 142, 156, 157, 159, 161,
+	176, 177, 133, 138, 143, 144, 147, 168,
+	170, 176, 178, 179, 181, 182, 184, 185,
+	158, 153, 156, 178, 180, 189, 133, 141,
+	143, 145, 147, 168, 170, 176, 178, 179,
+	181, 185, 144, 185, 160, 161, 189, 133,
+	140, 143, 144, 147, 168, 170, 176, 178,
+	179, 181, 185, 177, 156, 157, 159, 161,
+	131, 156, 133, 138, 142, 144, 146, 149,
+	153, 154, 158, 159, 163, 164, 168, 170,
+	174, 185, 144, 189, 133, 140, 142, 144,
+	146, 168, 170, 185, 152, 154, 160, 161,
+	128, 189, 133, 140, 142, 144, 146, 168,
+	170, 179, 181, 185, 158, 160, 161, 177,
+	178, 189, 133, 140, 142, 144, 146, 186,
+	142, 148, 150, 159, 161, 186, 191, 189,
+	133, 150, 154, 177, 179, 187, 128, 134,
+	129, 176, 178, 179, 132, 138, 141, 165,
+	167, 189, 129, 130, 135, 136, 148, 151,
+	153, 159, 161, 163, 170, 171, 173, 176,
+	178, 179, 134, 128, 132, 156, 159, 128,
+	128, 135, 137, 172, 136, 140, 128, 129,
+	130, 131, 137, 138, 139, 140, 141, 142,
+	143, 144, 153, 154, 155, 156, 157, 158,
+	159, 160, 161, 162, 163, 164, 165, 166,
+	167, 168, 169, 170, 172, 173, 174, 175,
+	176, 177, 178, 179, 180, 181, 182, 184,
+	188, 189, 190, 191, 132, 152, 185, 187,
+	191, 128, 170, 161, 144, 149, 154, 157,
+	165, 166, 174, 176, 181, 255, 130, 141,
+	143, 159, 155, 255, 128, 140, 142, 145,
+	160, 177, 128, 145, 160, 172, 174, 176,
+	151, 156, 170, 128, 168, 176, 255, 138,
+	255, 128, 150, 160, 255, 149, 255, 167,
+	133, 179, 133, 139, 131, 160, 174, 175,
+	186, 255, 166, 255, 128, 163, 141, 143,
+	154, 189, 169, 172, 174, 177, 181, 182,
+	129, 130, 132, 133, 134, 176, 177, 178,
+	179, 180, 181, 182, 183, 177, 191, 165,
+	170, 175, 177, 180, 255, 168, 174, 176,
+	255, 128, 134, 136, 142, 144, 150, 152,
+	158, 128, 129, 130, 131, 132, 133, 134,
+	135, 144, 145, 255, 133, 135, 161, 169,
+	177, 181, 184, 188, 160, 151, 154, 128,
+	146, 147, 148, 152, 153, 154, 155, 156,
+	158, 159, 160, 161, 162, 163, 164, 165,
+	166, 167, 168, 169, 170, 171, 172, 173,
+	174, 175, 176, 129, 255, 141, 143, 160,
+	169, 172, 255, 191, 128, 174, 130, 134,
+	139, 163, 255, 130, 179, 187, 189, 178,
+	183, 138, 165, 176, 255, 135, 159, 189,
+	255, 132, 178, 143, 160, 164, 166, 175,
+	186, 190, 128, 168, 186, 128, 130, 132,
+	139, 160, 182, 190, 255, 176, 178, 180,
+	183, 184, 190, 255, 128, 130, 155, 157,
+	160, 170, 178, 180, 128, 162, 164, 169,
+	171, 172, 173, 174, 175, 180, 181, 182,
+	183, 185, 186, 187, 188, 189, 190, 191,
+	165, 179, 157, 190, 128, 134, 147, 151,
+	159, 168, 170, 182, 184, 188, 176, 180,
+	182, 255, 161, 186, 144, 145, 146, 147,
+	148, 150, 151, 152, 155, 157, 158, 160,
+	170, 171, 172, 175, 161, 169, 128, 129,
+	130, 131, 133, 138, 139, 140, 141, 142,
+	143, 144, 145, 146, 147, 148, 149, 152,
+	156, 157, 160, 161, 162, 163, 164, 166,
+	168, 169, 170, 171, 172, 173, 174, 176,
+	177, 153, 155, 178, 179, 145, 255, 139,
+	143, 182, 255, 158, 175, 128, 144, 147,
+	149, 151, 153, 179, 128, 135, 137, 164,
+	128, 130, 131, 132, 133, 134, 135, 136,
+	138, 139, 140, 141, 144, 145, 146, 147,
+	150, 151, 152, 153, 154, 156, 162, 163,
+	171, 176, 177, 178, 131, 183, 131, 175,
+	144, 168, 131, 166, 182, 144, 178, 131,
+	178, 154, 156, 129, 132, 128, 145, 147,
+	171, 159, 255, 144, 157, 161, 135, 138,
+	128, 175, 135, 132, 133, 128, 174, 152,
+	155, 132, 128, 170, 128, 153, 160, 190,
+	192, 255, 128, 136, 138, 174, 128, 178,
+	255, 160, 168, 169, 171, 172, 173, 174,
+	188, 189, 190, 191, 161, 167, 144, 173,
+	128, 131, 163, 183, 189, 255, 133, 143,
+	145, 255, 147, 159, 128, 176, 177, 178,
+	128, 136, 144, 153, 144, 145, 146, 147,
+	148, 149, 154, 155, 156, 157, 158, 159,
+	150, 153, 131, 140, 255, 160, 163, 164,
+	165, 184, 185, 186, 161, 162, 133, 255,
+	170, 181, 183, 186, 128, 150, 152, 182,
+	184, 255, 192, 255, 128, 255, 173, 130,
+	133, 146, 159, 165, 171, 175, 255, 181,
+	190, 184, 185, 192, 255, 140, 134, 138,
+	142, 161, 163, 255, 182, 130, 136, 137,
+	176, 151, 152, 154, 160, 190, 136, 144,
+	192, 255, 135, 129, 130, 132, 133, 144,
+	170, 176, 178, 144, 154, 160, 191, 128,
+	169, 174, 255, 148, 169, 157, 158, 189,
+	190, 192, 255, 144, 255, 139, 140, 178,
+	255, 186, 128, 181, 160, 161, 162, 163,
+	164, 165, 166, 167, 168, 169, 170, 171,
+	172, 173, 174, 175, 176, 177, 178, 179,
+	180, 181, 182, 183, 184, 185, 186, 187,
+	188, 189, 190, 191, 128, 173, 128, 155,
+	160, 180, 182, 189, 148, 161, 163, 255,
+	176, 164, 165, 132, 169, 177, 141, 142,
+	145, 146, 179, 181, 186, 187, 158, 133,
+	134, 137, 138, 143, 150, 152, 155, 164,
+	165, 178, 255, 188, 129, 131, 133, 138,
+	143, 144, 147, 168, 170, 176, 178, 179,
+	181, 182, 184, 185, 190, 255, 157, 131,
+	134, 137, 138, 142, 144, 146, 152, 159,
+	165, 182, 255, 129, 131, 133, 141, 143,
+	145, 147, 168, 170, 176, 178, 179, 181,
+	185, 188, 255, 134, 138, 142, 143, 145,
+	159, 164, 165, 176, 184, 186, 255, 129,
+	131, 133, 140, 143, 144, 147, 168, 170,
+	176, 178, 179, 181, 185, 188, 191, 177,
+	128, 132, 135, 136, 139, 141, 150, 151,
+	156, 157, 159, 163, 166, 175, 156, 130,
+	131, 133, 138, 142, 144, 146, 149, 153,
+	154, 158, 159, 163, 164, 168, 170, 174,
+	185, 190, 191, 144, 151, 128, 130, 134,
+	136, 138, 141, 166, 175, 128, 131, 133,
+	140, 142, 144, 146, 168, 170, 185, 189,
+	255, 133, 137, 151, 142, 148, 155, 159,
+	164, 165, 176, 255, 128, 131, 133, 140,
+	142, 144, 146, 168, 170, 179, 181, 185,
+	188, 191, 158, 128, 132, 134, 136, 138,
+	141, 149, 150, 160, 163, 166, 175, 177,
+	178, 129, 131, 133, 140, 142, 144, 146,
+	186, 189, 255, 133, 137, 143, 147, 152,
+	158, 164, 165, 176, 185, 192, 255, 189,
+	130, 131, 133, 150, 154, 177, 179, 187,
+	138, 150, 128, 134, 143, 148, 152, 159,
+	166, 175, 178, 179, 129, 186, 128, 142,
+	144, 153, 132, 138, 141, 165, 167, 129,
+	130, 135, 136, 148, 151, 153, 159, 161,
+	163, 170, 171, 173, 185, 187, 189, 134,
+	128, 132, 136, 141, 144, 153, 156, 159,
+	128, 181, 183, 185, 152, 153, 160, 169,
+	190, 191, 128, 135, 137, 172, 177, 191,
+	128, 132, 134, 151, 153, 188, 134, 128,
+	129, 130, 131, 137, 138, 139, 140, 141,
+	142, 143, 144, 153, 154, 155, 156, 157,
+	158, 159, 160, 161, 162, 163, 164, 165,
+	166, 167, 168, 169, 170, 173, 175, 176,
+	177, 178, 179, 181, 182, 183, 188, 189,
+	190, 191, 132, 152, 172, 184, 185, 187,
+	128, 191, 128, 137, 144, 255, 158, 159,
+	134, 187, 136, 140, 142, 143, 137, 151,
+	153, 142, 143, 158, 159, 137, 177, 142,
+	143, 182, 183, 191, 255, 128, 130, 133,
+	136, 150, 152, 255, 145, 150, 151, 155,
+	156, 160, 168, 178, 255, 128, 143, 160,
+	255, 182, 183, 190, 255, 129, 255, 173,
+	174, 192, 255, 129, 154, 160, 255, 171,
+	173, 185, 255, 128, 140, 142, 148, 160,
+	180, 128, 147, 160, 172, 174, 176, 178,
+	179, 148, 150, 152, 155, 158, 159, 170,
+	255, 139, 141, 144, 153, 160, 255, 184,
+	255, 128, 170, 176, 255, 182, 255, 128,
+	158, 160, 171, 176, 187, 134, 173, 176,
+	180, 128, 171, 176, 255, 138, 143, 155,
+	255, 128, 155, 160, 255, 159, 189, 190,
+	192, 255, 167, 128, 137, 144, 153, 176,
+	189, 140, 143, 154, 170, 180, 255, 180,
+	255, 128, 183, 128, 137, 141, 189, 128,
+	136, 144, 146, 148, 182, 184, 185, 128,
+	181, 187, 191, 150, 151, 158, 159, 152,
+	154, 156, 158, 134, 135, 142, 143, 190,
+	255, 190, 128, 180, 182, 188, 130, 132,
+	134, 140, 144, 147, 150, 155, 160, 172,
+	178, 180, 182, 188, 128, 129, 130, 131,
+	132, 133, 134, 176, 177, 178, 179, 180,
+	181, 182, 183, 191, 255, 129, 147, 149,
+	176, 178, 190, 192, 255, 144, 156, 161,
+	144, 156, 165, 176, 130, 135, 149, 164,
+	166, 168, 138, 147, 152, 157, 170, 185,
+	188, 191, 142, 133, 137, 160, 255, 137,
+	255, 128, 174, 176, 255, 159, 165, 170,
+	180, 255, 167, 173, 128, 165, 176, 255,
+	168, 174, 176, 190, 192, 255, 128, 150,
+	160, 166, 168, 174, 176, 182, 184, 190,
+	128, 134, 136, 142, 144, 150, 152, 158,
+	160, 191, 128, 129, 130, 131, 132, 133,
+	134, 135, 144, 145, 255, 133, 135, 161,
+	175, 177, 181, 184, 188, 160, 151, 152,
+	187, 192, 255, 133, 173, 177, 255, 143,
+	159, 187, 255, 176, 191, 182, 183, 184,
+	191, 192, 255, 150, 255, 128, 146, 147,
+	148, 152, 153, 154, 155, 156, 158, 159,
+	160, 161, 162, 163, 164, 165, 166, 167,
+	168, 169, 170, 171, 172, 173, 174, 175,
+	176, 129, 255, 141, 255, 144, 189, 141,
+	143, 172, 255, 191, 128, 175, 180, 189,
+	151, 159, 162, 255, 175, 137, 138, 184,
+	255, 183, 255, 168, 255, 128, 179, 188,
+	134, 143, 154, 159, 184, 186, 190, 255,
+	128, 173, 176, 255, 148, 159, 189, 255,
+	129, 142, 154, 159, 191, 255, 128, 182,
+	128, 141, 144, 153, 160, 182, 186, 255,
+	128, 130, 155, 157, 160, 175, 178, 182,
+	129, 134, 137, 142, 145, 150, 160, 166,
+	168, 174, 176, 255, 155, 166, 175, 128,
+	170, 172, 173, 176, 185, 158, 159, 160,
+	255, 164, 175, 135, 138, 188, 255, 164,
+	169, 171, 172, 173, 174, 175, 180, 181,
+	182, 183, 184, 185, 187, 188, 189, 190,
+	191, 165, 186, 174, 175, 154, 255, 190,
+	128, 134, 147, 151, 157, 168, 170, 182,
+	184, 188, 128, 129, 131, 132, 134, 255,
+	147, 255, 190, 255, 144, 145, 136, 175,
+	188, 255, 128, 143, 160, 175, 179, 180,
+	141, 143, 176, 180, 182, 255, 189, 255,
+	191, 144, 153, 161, 186, 129, 154, 166,
+	255, 191, 255, 130, 135, 138, 143, 146,
+	151, 154, 156, 144, 145, 146, 147, 148,
+	150, 151, 152, 155, 157, 158, 160, 170,
+	171, 172, 175, 161, 169, 128, 129, 130,
+	131, 133, 135, 138, 139, 140, 141, 142,
+	143, 144, 145, 146, 147, 148, 149, 152,
+	156, 157, 160, 161, 162, 163, 164, 166,
+	168, 169, 170, 171, 172, 173, 174, 176,
+	177, 153, 155, 178, 179, 128, 139, 141,
+	166, 168, 186, 188, 189, 191, 255, 142,
+	143, 158, 255, 187, 255, 128, 180, 189,
+	128, 156, 160, 255, 145, 159, 161, 255,
+	128, 159, 176, 255, 139, 143, 187, 255,
+	128, 157, 160, 255, 144, 132, 135, 150,
+	255, 158, 159, 170, 175, 148, 151, 188,
+	255, 128, 167, 176, 255, 164, 255, 183,
+	255, 128, 149, 160, 167, 136, 188, 128,
+	133, 138, 181, 183, 184, 191, 255, 150,
+	159, 183, 255, 128, 158, 160, 178, 180,
+	181, 128, 149, 160, 185, 128, 183, 190,
+	191, 191, 128, 131, 133, 134, 140, 147,
+	149, 151, 153, 179, 184, 186, 160, 188,
+	128, 156, 128, 135, 137, 166, 128, 181,
+	128, 149, 160, 178, 128, 145, 128, 178,
+	129, 130, 131, 132, 133, 135, 136, 138,
+	139, 140, 141, 144, 145, 146, 147, 150,
+	151, 152, 153, 154, 155, 156, 162, 163,
+	171, 176, 177, 178, 128, 134, 135, 165,
+	176, 190, 144, 168, 176, 185, 128, 180,
+	182, 191, 182, 144, 179, 155, 133, 137,
+	141, 143, 157, 255, 190, 128, 145, 147,
+	183, 136, 128, 134, 138, 141, 143, 157,
+	159, 168, 176, 255, 171, 175, 186, 255,
+	128, 131, 133, 140, 143, 144, 147, 168,
+	170, 176, 178, 179, 181, 185, 188, 191,
+	144, 151, 128, 132, 135, 136, 139, 141,
+	157, 163, 166, 172, 176, 180, 128, 138,
+	144, 153, 134, 136, 143, 154, 255, 128,
+	181, 184, 255, 129, 151, 158, 255, 129,
+	131, 133, 143, 154, 255, 128, 137, 128,
+	153, 157, 171, 176, 185, 160, 255, 170,
+	190, 192, 255, 128, 184, 128, 136, 138,
+	182, 184, 191, 128, 144, 153, 178, 255,
+	168, 144, 145, 183, 255, 128, 142, 145,
+	149, 129, 141, 144, 146, 147, 148, 175,
+	255, 132, 255, 128, 144, 129, 143, 144,
+	153, 145, 152, 135, 255, 160, 168, 169,
+	171, 172, 173, 174, 188, 189, 190, 191,
+	161, 167, 185, 255, 128, 158, 160, 169,
+	144, 173, 176, 180, 128, 131, 144, 153,
+	163, 183, 189, 255, 144, 255, 133, 143,
+	191, 255, 143, 159, 160, 128, 129, 255,
+	159, 160, 171, 172, 255, 173, 255, 179,
+	255, 128, 176, 177, 178, 128, 129, 171,
+	175, 189, 255, 128, 136, 144, 153, 157,
+	158, 133, 134, 137, 144, 145, 146, 147,
+	148, 149, 154, 155, 156, 157, 158, 159,
+	168, 169, 170, 150, 153, 165, 169, 173,
+	178, 187, 255, 131, 132, 140, 169, 174,
+	255, 130, 132, 149, 157, 173, 186, 188,
+	160, 161, 163, 164, 167, 168, 132, 134,
+	149, 157, 186, 139, 140, 191, 255, 134,
+	128, 132, 138, 144, 146, 255, 166, 167,
+	129, 155, 187, 149, 181, 143, 175, 137,
+	169, 131, 140, 141, 192, 255, 128, 182,
+	187, 255, 173, 180, 182, 255, 132, 155,
+	159, 161, 175, 128, 160, 163, 164, 165,
+	184, 185, 186, 161, 162, 128, 134, 136,
+	152, 155, 161, 163, 164, 166, 170, 133,
+	143, 151, 255, 139, 143, 154, 255, 164,
+	167, 185, 187, 128, 131, 133, 159, 161,
+	162, 169, 178, 180, 183, 130, 135, 137,
+	139, 148, 151, 153, 155, 157, 159, 164,
+	190, 141, 143, 145, 146, 161, 162, 167,
+	170, 172, 178, 180, 183, 185, 188, 128,
+	137, 139, 155, 161, 163, 165, 169, 171,
+	187, 155, 156, 151, 255, 156, 157, 160,
+	181, 255, 186, 187, 255, 162, 255, 160,
+	168, 161, 167, 158, 255, 160, 132, 135,
+	133, 134, 176, 255, 128, 191, 154, 164,
+	168, 128, 149, 150, 191, 128, 152, 153,
+	191, 181, 128, 159, 160, 189, 190, 191,
+	189, 128, 131, 132, 185, 186, 191, 144,
+	128, 151, 152, 161, 162, 176, 177, 255,
+	169, 177, 129, 132, 141, 142, 145, 146,
+	179, 181, 186, 188, 190, 191, 192, 255,
+	142, 158, 128, 155, 156, 161, 162, 175,
+	176, 177, 178, 191, 169, 177, 180, 183,
+	128, 132, 133, 138, 139, 142, 143, 144,
+	145, 146, 147, 185, 186, 191, 157, 128,
+	152, 153, 158, 159, 177, 178, 180, 181,
+	191, 142, 146, 169, 177, 180, 189, 128,
+	132, 133, 185, 186, 191, 144, 185, 128,
+	159, 160, 161, 162, 191, 169, 177, 180,
+	189, 128, 132, 133, 140, 141, 142, 143,
+	144, 145, 146, 147, 185, 186, 191, 158,
+	177, 128, 155, 156, 161, 162, 191, 131,
+	145, 155, 157, 128, 132, 133, 138, 139,
+	141, 142, 149, 150, 152, 153, 159, 160,
+	162, 163, 164, 165, 167, 168, 170, 171,
+	173, 174, 185, 186, 191, 144, 128, 191,
+	141, 145, 169, 189, 128, 132, 133, 185,
+	186, 191, 128, 151, 152, 154, 155, 159,
+	160, 161, 162, 191, 128, 141, 145, 169,
+	180, 189, 129, 132, 133, 185, 186, 191,
+	158, 128, 159, 160, 161, 162, 176, 177,
+	178, 179, 191, 141, 145, 189, 128, 132,
+	133, 186, 187, 191, 142, 128, 147, 148,
+	150, 151, 158, 159, 161, 162, 185, 186,
+	191, 178, 188, 128, 132, 133, 150, 151,
+	153, 154, 189, 190, 191, 128, 134, 135,
+	191, 128, 177, 129, 179, 180, 191, 128,
+	131, 137, 141, 152, 160, 164, 166, 172,
+	177, 189, 129, 132, 133, 134, 135, 138,
+	139, 147, 148, 167, 168, 169, 170, 179,
+	180, 191, 133, 128, 134, 135, 155, 156,
+	159, 160, 191, 128, 129, 191, 136, 128,
+	172, 173, 191, 128, 135, 136, 140, 141,
+	191, 191, 128, 170, 171, 190, 161, 128,
+	143, 144, 149, 150, 153, 154, 157, 158,
+	164, 165, 166, 167, 173, 174, 176, 177,
+	180, 181, 255, 130, 141, 143, 159, 134,
+	187, 136, 140, 142, 143, 137, 151, 153,
+	142, 143, 158, 159, 137, 177, 191, 142,
+	143, 182, 183, 192, 255, 129, 151, 128,
+	133, 134, 135, 136, 255, 145, 150, 151,
+	155, 191, 192, 255, 128, 143, 144, 159,
+	160, 255, 182, 183, 190, 191, 192, 255,
+	128, 129, 255, 173, 174, 192, 255, 128,
+	129, 154, 155, 159, 160, 255, 171, 173,
+	185, 191, 192, 255, 141, 128, 145, 146,
+	159, 160, 177, 178, 191, 173, 128, 145,
+	146, 159, 160, 176, 177, 191, 128, 179,
+	180, 191, 151, 156, 128, 191, 128, 159,
+	160, 255, 184, 191, 192, 255, 169, 128,
+	170, 171, 175, 176, 255, 182, 191, 192,
+	255, 128, 158, 159, 191, 128, 143, 144,
+	173, 174, 175, 176, 180, 181, 191, 128,
+	171, 172, 175, 176, 255, 138, 191, 192,
+	255, 128, 150, 151, 159, 160, 255, 149,
+	191, 192, 255, 167, 128, 191, 128, 132,
+	133, 179, 180, 191, 128, 132, 133, 139,
+	140, 191, 128, 130, 131, 160, 161, 173,
+	174, 175, 176, 185, 186, 255, 166, 191,
+	192, 255, 128, 163, 164, 191, 128, 140,
+	141, 143, 144, 153, 154, 189, 190, 191,
+	128, 136, 137, 191, 173, 128, 168, 169,
+	177, 178, 180, 181, 182, 183, 191, 0,
+	127, 192, 255, 150, 151, 158, 159, 152,
+	154, 156, 158, 134, 135, 142, 143, 190,
+	191, 192, 255, 181, 189, 191, 128, 190,
+	133, 181, 128, 129, 130, 140, 141, 143,
+	144, 147, 148, 149, 150, 155, 156, 159,
+	160, 172, 173, 177, 178, 188, 189, 191,
+	177, 191, 128, 190, 128, 143, 144, 156,
+	157, 191, 130, 135, 148, 164, 166, 168,
+	128, 137, 138, 149, 150, 151, 152, 157,
+	158, 169, 170, 185, 186, 187, 188, 191,
+	142, 128, 132, 133, 137, 138, 159, 160,
+	255, 137, 191, 192, 255, 175, 128, 255,
+	159, 165, 170, 175, 177, 180, 191, 192,
+	255, 166, 173, 128, 167, 168, 175, 176,
+	255, 168, 174, 176, 191, 192, 255, 167,
+	175, 183, 191, 128, 150, 151, 159, 160,
+	190, 135, 143, 151, 128, 158, 159, 191,
+	128, 132, 133, 135, 136, 160, 161, 169,
+	170, 176, 177, 181, 182, 183, 184, 188,
+	189, 191, 160, 151, 154, 187, 192, 255,
+	128, 132, 133, 173, 174, 176, 177, 255,
+	143, 159, 187, 191, 192, 255, 128, 175,
+	176, 191, 150, 191, 192, 255, 141, 191,
+	192, 255, 128, 143, 144, 189, 190, 191,
+	141, 143, 160, 169, 172, 191, 192, 255,
+	191, 128, 174, 175, 190, 128, 157, 158,
+	159, 160, 255, 176, 191, 192, 255, 128,
+	150, 151, 159, 160, 161, 162, 255, 175,
+	137, 138, 184, 191, 192, 255, 128, 182,
+	183, 255, 130, 134, 139, 163, 191, 192,
+	255, 128, 129, 130, 179, 180, 191, 187,
+	189, 128, 177, 178, 183, 184, 191, 128,
+	137, 138, 165, 166, 175, 176, 255, 135,
+	159, 189, 191, 192, 255, 128, 131, 132,
+	178, 179, 191, 143, 165, 191, 128, 159,
+	160, 175, 176, 185, 186, 190, 128, 168,
+	169, 191, 131, 186, 128, 139, 140, 159,
+	160, 182, 183, 189, 190, 255, 176, 178,
+	180, 183, 184, 190, 191, 192, 255, 129,
+	128, 130, 131, 154, 155, 157, 158, 159,
+	160, 170, 171, 177, 178, 180, 181, 191,
+	128, 167, 175, 129, 134, 135, 136, 137,
+	142, 143, 144, 145, 150, 151, 159, 160,
+	255, 155, 166, 175, 128, 162, 163, 191,
+	164, 175, 135, 138, 188, 191, 192, 255,
+	174, 175, 154, 191, 192, 255, 157, 169,
+	183, 189, 191, 128, 134, 135, 146, 147,
+	151, 152, 158, 159, 190, 130, 133, 128,
+	255, 178, 191, 192, 255, 128, 146, 147,
+	255, 190, 191, 192, 255, 128, 143, 144,
+	255, 144, 145, 136, 175, 188, 191, 192,
+	255, 181, 128, 175, 176, 255, 189, 191,
+	192, 255, 128, 160, 161, 186, 187, 191,
+	128, 129, 154, 155, 165, 166, 255, 191,
+	192, 255, 128, 129, 130, 135, 136, 137,
+	138, 143, 144, 145, 146, 151, 152, 153,
+	154, 156, 157, 191, 128, 191, 128, 129,
+	130, 131, 133, 138, 139, 140, 141, 142,
+	143, 144, 145, 146, 147, 148, 149, 152,
+	156, 157, 160, 161, 162, 163, 164, 166,
+	168, 169, 170, 171, 172, 173, 174, 176,
+	177, 132, 151, 153, 155, 158, 175, 178,
+	179, 180, 191, 140, 167, 187, 190, 128,
+	255, 142, 143, 158, 191, 192, 255, 187,
+	191, 192, 255, 128, 180, 181, 191, 128,
+	156, 157, 159, 160, 255, 145, 191, 192,
+	255, 128, 159, 160, 175, 176, 255, 139,
+	143, 182, 191, 192, 255, 144, 132, 135,
+	150, 191, 192, 255, 158, 175, 148, 151,
+	188, 191, 192, 255, 128, 167, 168, 175,
+	176, 255, 164, 191, 192, 255, 183, 191,
+	192, 255, 128, 149, 150, 159, 160, 167,
+	168, 191, 136, 182, 188, 128, 133, 134,
+	137, 138, 184, 185, 190, 191, 255, 150,
+	159, 183, 191, 192, 255, 179, 128, 159,
+	160, 181, 182, 191, 128, 149, 150, 159,
+	160, 185, 186, 191, 128, 183, 184, 189,
+	190, 191, 128, 148, 152, 129, 143, 144,
+	179, 180, 191, 128, 159, 160, 188, 189,
+	191, 128, 156, 157, 191, 136, 128, 164,
+	165, 191, 128, 181, 182, 191, 128, 149,
+	150, 159, 160, 178, 179, 191, 128, 145,
+	146, 191, 128, 178, 179, 191, 128, 130,
+	131, 132, 133, 134, 135, 136, 138, 139,
+	140, 141, 144, 145, 146, 147, 150, 151,
+	152, 153, 154, 156, 162, 163, 171, 176,
+	177, 178, 129, 191, 128, 130, 131, 183,
+	184, 191, 128, 130, 131, 175, 176, 191,
+	128, 143, 144, 168, 169, 191, 128, 130,
+	131, 166, 167, 191, 182, 128, 143, 144,
+	178, 179, 191, 128, 130, 131, 178, 179,
+	191, 128, 154, 156, 129, 132, 133, 191,
+	146, 128, 171, 172, 191, 135, 137, 142,
+	158, 128, 168, 169, 175, 176, 255, 159,
+	191, 192, 255, 144, 128, 156, 157, 161,
+	162, 191, 128, 134, 135, 138, 139, 191,
+	128, 175, 176, 191, 134, 128, 131, 132,
+	135, 136, 191, 128, 174, 175, 191, 128,
+	151, 152, 155, 156, 191, 132, 128, 191,
+	128, 170, 171, 191, 128, 153, 154, 191,
+	160, 190, 192, 255, 128, 184, 185, 191,
+	137, 128, 174, 175, 191, 128, 129, 177,
+	178, 255, 144, 191, 192, 255, 128, 142,
+	143, 144, 145, 146, 149, 129, 148, 150,
+	191, 175, 191, 192, 255, 132, 191, 192,
+	255, 128, 144, 129, 143, 145, 191, 144,
+	153, 128, 143, 145, 152, 154, 191, 135,
+	191, 192, 255, 160, 168, 169, 171, 172,
+	173, 174, 188, 189, 190, 191, 128, 159,
+	161, 167, 170, 187, 185, 191, 192, 255,
+	128, 143, 144, 173, 174, 191, 128, 131,
+	132, 162, 163, 183, 184, 188, 189, 255,
+	133, 143, 145, 191, 192, 255, 128, 146,
+	147, 159, 160, 191, 160, 128, 191, 128,
+	129, 191, 192, 255, 159, 160, 171, 128,
+	170, 172, 191, 192, 255, 173, 191, 192,
+	255, 179, 191, 192, 255, 128, 176, 177,
+	178, 129, 191, 128, 129, 130, 191, 171,
+	175, 189, 191, 192, 255, 128, 136, 137,
+	143, 144, 153, 154, 191, 144, 145, 146,
+	147, 148, 149, 154, 155, 156, 157, 158,
+	159, 128, 143, 150, 153, 160, 191, 149,
+	157, 173, 186, 188, 160, 161, 163, 164,
+	167, 168, 132, 134, 149, 157, 186, 191,
+	139, 140, 192, 255, 133, 145, 128, 134,
+	135, 137, 138, 255, 166, 167, 129, 155,
+	187, 149, 181, 143, 175, 137, 169, 131,
+	140, 191, 192, 255, 160, 163, 164, 165,
+	184, 185, 186, 128, 159, 161, 162, 166,
+	191, 133, 191, 192, 255, 132, 160, 163,
+	167, 179, 184, 186, 128, 164, 165, 168,
+	169, 187, 188, 191, 130, 135, 137, 139,
+	144, 147, 151, 153, 155, 157, 159, 163,
+	171, 179, 184, 189, 191, 128, 140, 141,
+	148, 149, 160, 161, 164, 165, 166, 167,
+	190, 138, 164, 170, 128, 155, 156, 160,
+	161, 187, 188, 191, 128, 191, 155, 156,
+	128, 191, 151, 191, 192, 255, 156, 157,
+	160, 128, 191, 181, 191, 192, 255, 158,
+	159, 186, 128, 185, 187, 191, 192, 255,
+	162, 191, 192, 255, 160, 168, 128, 159,
+	161, 167, 169, 191, 158, 191, 192, 255,
+	10, 13, 128, 191, 192, 223, 224, 239,
+	240, 247, 248, 255, 128, 191, 128, 191,
+	128, 191, 128, 191, 128, 191, 10, 128,
+	191, 128, 191, 128, 191, 36, 123, 37,
+	123, 10, 128, 191, 128, 191, 128, 191,
+	36, 123, 37, 123, 170, 181, 183, 186,
+	128, 150, 152, 182, 184, 255, 192, 255,
+	128, 255, 173, 130, 133, 146, 159, 165,
+	171, 175, 255, 181, 190, 184, 185, 192,
+	255, 140, 134, 138, 142, 161, 163, 255,
+	182, 130, 136, 137, 176, 151, 152, 154,
+	160, 190, 136, 144, 192, 255, 135, 129,
+	130, 132, 133, 144, 170, 176, 178, 144,
+	154, 160, 191, 128, 169, 174, 255, 148,
+	169, 157, 158, 189, 190, 192, 255, 144,
+	255, 139, 140, 178, 255, 186, 128, 181,
+	160, 161, 162, 163, 164, 165, 166, 167,
+	168, 169, 170, 171, 172, 173, 174, 175,
+	176, 177, 178, 179, 180, 181, 182, 183,
+	184, 185, 186, 187, 188, 189, 190, 191,
+	128, 173, 128, 155, 160, 180, 182, 189,
+	148, 161, 163, 255, 176, 164, 165, 132,
+	169, 177, 141, 142, 145, 146, 179, 181,
+	186, 187, 158, 133, 134, 137, 138, 143,
+	150, 152, 155, 164, 165, 178, 255, 188,
+	129, 131, 133, 138, 143, 144, 147, 168,
+	170, 176, 178, 179, 181, 182, 184, 185,
+	190, 255, 157, 131, 134, 137, 138, 142,
+	144, 146, 152, 159, 165, 182, 255, 129,
+	131, 133, 141, 143, 145, 147, 168, 170,
+	176, 178, 179, 181, 185, 188, 255, 134,
+	138, 142, 143, 145, 159, 164, 165, 176,
+	184, 186, 255, 129, 131, 133, 140, 143,
+	144, 147, 168, 170, 176, 178, 179, 181,
+	185, 188, 191, 177, 128, 132, 135, 136,
+	139, 141, 150, 151, 156, 157, 159, 163,
+	166, 175, 156, 130, 131, 133, 138, 142,
+	144, 146, 149, 153, 154, 158, 159, 163,
+	164, 168, 170, 174, 185, 190, 191, 144,
+	151, 128, 130, 134, 136, 138, 141, 166,
+	175, 128, 131, 133, 140, 142, 144, 146,
+	168, 170, 185, 189, 255, 133, 137, 151,
+	142, 148, 155, 159, 164, 165, 176, 255,
+	128, 131, 133, 140, 142, 144, 146, 168,
+	170, 179, 181, 185, 188, 191, 158, 128,
+	132, 134, 136, 138, 141, 149, 150, 160,
+	163, 166, 175, 177, 178, 129, 131, 133,
+	140, 142, 144, 146, 186, 189, 255, 133,
+	137, 143, 147, 152, 158, 164, 165, 176,
+	185, 192, 255, 189, 130, 131, 133, 150,
+	154, 177, 179, 187, 138, 150, 128, 134,
+	143, 148, 152, 159, 166, 175, 178, 179,
+	129, 186, 128, 142, 144, 153, 132, 138,
+	141, 165, 167, 129, 130, 135, 136, 148,
+	151, 153, 159, 161, 163, 170, 171, 173,
+	185, 187, 189, 134, 128, 132, 136, 141,
+	144, 153, 156, 159, 128, 181, 183, 185,
+	152, 153, 160, 169, 190, 191, 128, 135,
+	137, 172, 177, 191, 128, 132, 134, 151,
+	153, 188, 134, 128, 129, 130, 131, 137,
+	138, 139, 140, 141, 142, 143, 144, 153,
+	154, 155, 156, 157, 158, 159, 160, 161,
+	162, 163, 164, 165, 166, 167, 168, 169,
+	170, 173, 175, 176, 177, 178, 179, 181,
+	182, 183, 188, 189, 190, 191, 132, 152,
+	172, 184, 185, 187, 128, 191, 128, 137,
+	144, 255, 158, 159, 134, 187, 136, 140,
+	142, 143, 137, 151, 153, 142, 143, 158,
+	159, 137, 177, 142, 143, 182, 183, 191,
+	255, 128, 130, 133, 136, 150, 152, 255,
+	145, 150, 151, 155, 156, 160, 168, 178,
+	255, 128, 143, 160, 255, 182, 183, 190,
+	255, 129, 255, 173, 174, 192, 255, 129,
+	154, 160, 255, 171, 173, 185, 255, 128,
+	140, 142, 148, 160, 180, 128, 147, 160,
+	172, 174, 176, 178, 179, 148, 150, 152,
+	155, 158, 159, 170, 255, 139, 141, 144,
+	153, 160, 255, 184, 255, 128, 170, 176,
+	255, 182, 255, 128, 158, 160, 171, 176,
+	187, 134, 173, 176, 180, 128, 171, 176,
+	255, 138, 143, 155, 255, 128, 155, 160,
+	255, 159, 189, 190, 192, 255, 167, 128,
+	137, 144, 153, 176, 189, 140, 143, 154,
+	170, 180, 255, 180, 255, 128, 183, 128,
+	137, 141, 189, 128, 136, 144, 146, 148,
+	182, 184, 185, 128, 181, 187, 191, 150,
+	151, 158, 159, 152, 154, 156, 158, 134,
+	135, 142, 143, 190, 255, 190, 128, 180,
+	182, 188, 130, 132, 134, 140, 144, 147,
+	150, 155, 160, 172, 178, 180, 182, 188,
+	128, 129, 130, 131, 132, 133, 134, 176,
+	177, 178, 179, 180, 181, 182, 183, 191,
+	255, 129, 147, 149, 176, 178, 190, 192,
+	255, 144, 156, 161, 144, 156, 165, 176,
+	130, 135, 149, 164, 166, 168, 138, 147,
+	152, 157, 170, 185, 188, 191, 142, 133,
+	137, 160, 255, 137, 255, 128, 174, 176,
+	255, 159, 165, 170, 180, 255, 167, 173,
+	128, 165, 176, 255, 168, 174, 176, 190,
+	192, 255, 128, 150, 160, 166, 168, 174,
+	176, 182, 184, 190, 128, 134, 136, 142,
+	144, 150, 152, 158, 160, 191, 128, 129,
+	130, 131, 132, 133, 134, 135, 144, 145,
+	255, 133, 135, 161, 175, 177, 181, 184,
+	188, 160, 151, 152, 187, 192, 255, 133,
+	173, 177, 255, 143, 159, 187, 255, 176,
+	191, 182, 183, 184, 191, 192, 255, 150,
+	255, 128, 146, 147, 148, 152, 153, 154,
+	155, 156, 158, 159, 160, 161, 162, 163,
+	164, 165, 166, 167, 168, 169, 170, 171,
+	172, 173, 174, 175, 176, 129, 255, 141,
+	255, 144, 189, 141, 143, 172, 255, 191,
+	128, 175, 180, 189, 151, 159, 162, 255,
+	175, 137, 138, 184, 255, 183, 255, 168,
+	255, 128, 179, 188, 134, 143, 154, 159,
+	184, 186, 190, 255, 128, 173, 176, 255,
+	148, 159, 189, 255, 129, 142, 154, 159,
+	191, 255, 128, 182, 128, 141, 144, 153,
+	160, 182, 186, 255, 128, 130, 155, 157,
+	160, 175, 178, 182, 129, 134, 137, 142,
+	145, 150, 160, 166, 168, 174, 176, 255,
+	155, 166, 175, 128, 170, 172, 173, 176,
+	185, 158, 159, 160, 255, 164, 175, 135,
+	138, 188, 255, 164, 169, 171, 172, 173,
+	174, 175, 180, 181, 182, 183, 184, 185,
+	187, 188, 189, 190, 191, 165, 186, 174,
+	175, 154, 255, 190, 128, 134, 147, 151,
+	157, 168, 170, 182, 184, 188, 128, 129,
+	131, 132, 134, 255, 147, 255, 190, 255,
+	144, 145, 136, 175, 188, 255, 128, 143,
+	160, 175, 179, 180, 141, 143, 176, 180,
+	182, 255, 189, 255, 191, 144, 153, 161,
+	186, 129, 154, 166, 255, 191, 255, 130,
+	135, 138, 143, 146, 151, 154, 156, 144,
+	145, 146, 147, 148, 150, 151, 152, 155,
+	157, 158, 160, 170, 171, 172, 175, 161,
+	169, 128, 129, 130, 131, 133, 135, 138,
+	139, 140, 141, 142, 143, 144, 145, 146,
+	147, 148, 149, 152, 156, 157, 160, 161,
+	162, 163, 164, 166, 168, 169, 170, 171,
+	172, 173, 174, 176, 177, 153, 155, 178,
+	179, 128, 139, 141, 166, 168, 186, 188,
+	189, 191, 255, 142, 143, 158, 255, 187,
+	255, 128, 180, 189, 128, 156, 160, 255,
+	145, 159, 161, 255, 128, 159, 176, 255,
+	139, 143, 187, 255, 128, 157, 160, 255,
+	144, 132, 135, 150, 255, 158, 159, 170,
+	175, 148, 151, 188, 255, 128, 167, 176,
+	255, 164, 255, 183, 255, 128, 149, 160,
+	167, 136, 188, 128, 133, 138, 181, 183,
+	184, 191, 255, 150, 159, 183, 255, 128,
+	158, 160, 178, 180, 181, 128, 149, 160,
+	185, 128, 183, 190, 191, 191, 128, 131,
+	133, 134, 140, 147, 149, 151, 153, 179,
+	184, 186, 160, 188, 128, 156, 128, 135,
+	137, 166, 128, 181, 128, 149, 160, 178,
+	128, 145, 128, 178, 129, 130, 131, 132,
+	133, 135, 136, 138, 139, 140, 141, 144,
+	145, 146, 147, 150, 151, 152, 153, 154,
+	155, 156, 162, 163, 171, 176, 177, 178,
+	128, 134, 135, 165, 176, 190, 144, 168,
+	176, 185, 128, 180, 182, 191, 182, 144,
+	179, 155, 133, 137, 141, 143, 157, 255,
+	190, 128, 145, 147, 183, 136, 128, 134,
+	138, 141, 143, 157, 159, 168, 176, 255,
+	171, 175, 186, 255, 128, 131, 133, 140,
+	143, 144, 147, 168, 170, 176, 178, 179,
+	181, 185, 188, 191, 144, 151, 128, 132,
+	135, 136, 139, 141, 157, 163, 166, 172,
+	176, 180, 128, 138, 144, 153, 134, 136,
+	143, 154, 255, 128, 181, 184, 255, 129,
+	151, 158, 255, 129, 131, 133, 143, 154,
+	255, 128, 137, 128, 153, 157, 171, 176,
+	185, 160, 255, 170, 190, 192, 255, 128,
+	184, 128, 136, 138, 182, 184, 191, 128,
+	144, 153, 178, 255, 168, 144, 145, 183,
+	255, 128, 142, 145, 149, 129, 141, 144,
+	146, 147, 148, 175, 255, 132, 255, 128,
+	144, 129, 143, 144, 153, 145, 152, 135,
+	255, 160, 168, 169, 171, 172, 173, 174,
+	188, 189, 190, 191, 161, 167, 185, 255,
+	128, 158, 160, 169, 144, 173, 176, 180,
+	128, 131, 144, 153, 163, 183, 189, 255,
+	144, 255, 133, 143, 191, 255, 143, 159,
+	160, 128, 129, 255, 159, 160, 171, 172,
+	255, 173, 255, 179, 255, 128, 176, 177,
+	178, 128, 129, 171, 175, 189, 255, 128,
+	136, 144, 153, 157, 158, 133, 134, 137,
+	144, 145, 146, 147, 148, 149, 154, 155,
+	156, 157, 158, 159, 168, 169, 170, 150,
+	153, 165, 169, 173, 178, 187, 255, 131,
+	132, 140, 169, 174, 255, 130, 132, 149,
+	157, 173, 186, 188, 160, 161, 163, 164,
+	167, 168, 132, 134, 149, 157, 186, 139,
+	140, 191, 255, 134, 128, 132, 138, 144,
+	146, 255, 166, 167, 129, 155, 187, 149,
+	181, 143, 175, 137, 169, 131, 140, 141,
+	192, 255, 128, 182, 187, 255, 173, 180,
+	182, 255, 132, 155, 159, 161, 175, 128,
+	160, 163, 164, 165, 184, 185, 186, 161,
+	162, 128, 134, 136, 152, 155, 161, 163,
+	164, 166, 170, 133, 143, 151, 255, 139,
+	143, 154, 255, 164, 167, 185, 187, 128,
+	131, 133, 159, 161, 162, 169, 178, 180,
+	183, 130, 135, 137, 139, 148, 151, 153,
+	155, 157, 159, 164, 190, 141, 143, 145,
+	146, 161, 162, 167, 170, 172, 178, 180,
+	183, 185, 188, 128, 137, 139, 155, 161,
+	163, 165, 169, 171, 187, 155, 156, 151,
+	255, 156, 157, 160, 181, 255, 186, 187,
+	255, 162, 255, 160, 168, 161, 167, 158,
+	255, 160, 132, 135, 133, 134, 176, 255,
+	128, 191, 154, 164, 168, 128, 149, 150,
+	191, 128, 152, 153, 191, 181, 128, 159,
+	160, 189, 190, 191, 189, 128, 131, 132,
+	185, 186, 191, 144, 128, 151, 152, 161,
+	162, 176, 177, 255, 169, 177, 129, 132,
+	141, 142, 145, 146, 179, 181, 186, 188,
+	190, 191, 192, 255, 142, 158, 128, 155,
+	156, 161, 162, 175, 176, 177, 178, 191,
+	169, 177, 180, 183, 128, 132, 133, 138,
+	139, 142, 143, 144, 145, 146, 147, 185,
+	186, 191, 157, 128, 152, 153, 158, 159,
+	177, 178, 180, 181, 191, 142, 146, 169,
+	177, 180, 189, 128, 132, 133, 185, 186,
+	191, 144, 185, 128, 159, 160, 161, 162,
+	191, 169, 177, 180, 189, 128, 132, 133,
+	140, 141, 142, 143, 144, 145, 146, 147,
+	185, 186, 191, 158, 177, 128, 155, 156,
+	161, 162, 191, 131, 145, 155, 157, 128,
+	132, 133, 138, 139, 141, 142, 149, 150,
+	152, 153, 159, 160, 162, 163, 164, 165,
+	167, 168, 170, 171, 173, 174, 185, 186,
+	191, 144, 128, 191, 141, 145, 169, 189,
+	128, 132, 133, 185, 186, 191, 128, 151,
+	152, 154, 155, 159, 160, 161, 162, 191,
+	128, 141, 145, 169, 180, 189, 129, 132,
+	133, 185, 186, 191, 158, 128, 159, 160,
+	161, 162, 176, 177, 178, 179, 191, 141,
+	145, 189, 128, 132, 133, 186, 187, 191,
+	142, 128, 147, 148, 150, 151, 158, 159,
+	161, 162, 185, 186, 191, 178, 188, 128,
+	132, 133, 150, 151, 153, 154, 189, 190,
+	191, 128, 134, 135, 191, 128, 177, 129,
+	179, 180, 191, 128, 131, 137, 141, 152,
+	160, 164, 166, 172, 177, 189, 129, 132,
+	133, 134, 135, 138, 139, 147, 148, 167,
+	168, 169, 170, 179, 180, 191, 133, 128,
+	134, 135, 155, 156, 159, 160, 191, 128,
+	129, 191, 136, 128, 172, 173, 191, 128,
+	135, 136, 140, 141, 191, 191, 128, 170,
+	171, 190, 161, 128, 143, 144, 149, 150,
+	153, 154, 157, 158, 164, 165, 166, 167,
+	173, 174, 176, 177, 180, 181, 255, 130,
+	141, 143, 159, 134, 187, 136, 140, 142,
+	143, 137, 151, 153, 142, 143, 158, 159,
+	137, 177, 191, 142, 143, 182, 183, 192,
+	255, 129, 151, 128, 133, 134, 135, 136,
+	255, 145, 150, 151, 155, 191, 192, 255,
+	128, 143, 144, 159, 160, 255, 182, 183,
+	190, 191, 192, 255, 128, 129, 255, 173,
+	174, 192, 255, 128, 129, 154, 155, 159,
+	160, 255, 171, 173, 185, 191, 192, 255,
+	141, 128, 145, 146, 159, 160, 177, 178,
+	191, 173, 128, 145, 146, 159, 160, 176,
+	177, 191, 128, 179, 180, 191, 151, 156,
+	128, 191, 128, 159, 160, 255, 184, 191,
+	192, 255, 169, 128, 170, 171, 175, 176,
+	255, 182, 191, 192, 255, 128, 158, 159,
+	191, 128, 143, 144, 173, 174, 175, 176,
+	180, 181, 191, 128, 171, 172, 175, 176,
+	255, 138, 191, 192, 255, 128, 150, 151,
+	159, 160, 255, 149, 191, 192, 255, 167,
+	128, 191, 128, 132, 133, 179, 180, 191,
+	128, 132, 133, 139, 140, 191, 128, 130,
+	131, 160, 161, 173, 174, 175, 176, 185,
+	186, 255, 166, 191, 192, 255, 128, 163,
+	164, 191, 128, 140, 141, 143, 144, 153,
+	154, 189, 190, 191, 128, 136, 137, 191,
+	173, 128, 168, 169, 177, 178, 180, 181,
+	182, 183, 191, 0, 127, 192, 255, 150,
+	151, 158, 159, 152, 154, 156, 158, 134,
+	135, 142, 143, 190, 191, 192, 255, 181,
+	189, 191, 128, 190, 133, 181, 128, 129,
+	130, 140, 141, 143, 144, 147, 148, 149,
+	150, 155, 156, 159, 160, 172, 173, 177,
+	178, 188, 189, 191, 177, 191, 128, 190,
+	128, 143, 144, 156, 157, 191, 130, 135,
+	148, 164, 166, 168, 128, 137, 138, 149,
+	150, 151, 152, 157, 158, 169, 170, 185,
+	186, 187, 188, 191, 142, 128, 132, 133,
+	137, 138, 159, 160, 255, 137, 191, 192,
+	255, 175, 128, 255, 159, 165, 170, 175,
+	177, 180, 191, 192, 255, 166, 173, 128,
+	167, 168, 175, 176, 255, 168, 174, 176,
+	191, 192, 255, 167, 175, 183, 191, 128,
+	150, 151, 159, 160, 190, 135, 143, 151,
+	128, 158, 159, 191, 128, 132, 133, 135,
+	136, 160, 161, 169, 170, 176, 177, 181,
+	182, 183, 184, 188, 189, 191, 160, 151,
+	154, 187, 192, 255, 128, 132, 133, 173,
+	174, 176, 177, 255, 143, 159, 187, 191,
+	192, 255, 128, 175, 176, 191, 150, 191,
+	192, 255, 141, 191, 192, 255, 128, 143,
+	144, 189, 190, 191, 141, 143, 160, 169,
+	172, 191, 192, 255, 191, 128, 174, 175,
+	190, 128, 157, 158, 159, 160, 255, 176,
+	191, 192, 255, 128, 150, 151, 159, 160,
+	161, 162, 255, 175, 137, 138, 184, 191,
+	192, 255, 128, 182, 183, 255, 130, 134,
+	139, 163, 191, 192, 255, 128, 129, 130,
+	179, 180, 191, 187, 189, 128, 177, 178,
+	183, 184, 191, 128, 137, 138, 165, 166,
+	175, 176, 255, 135, 159, 189, 191, 192,
+	255, 128, 131, 132, 178, 179, 191, 143,
+	165, 191, 128, 159, 160, 175, 176, 185,
+	186, 190, 128, 168, 169, 191, 131, 186,
+	128, 139, 140, 159, 160, 182, 183, 189,
+	190, 255, 176, 178, 180, 183, 184, 190,
+	191, 192, 255, 129, 128, 130, 131, 154,
+	155, 157, 158, 159, 160, 170, 171, 177,
+	178, 180, 181, 191, 128, 167, 175, 129,
+	134, 135, 136, 137, 142, 143, 144, 145,
+	150, 151, 159, 160, 255, 155, 166, 175,
+	128, 162, 163, 191, 164, 175, 135, 138,
+	188, 191, 192, 255, 174, 175, 154, 191,
+	192, 255, 157, 169, 183, 189, 191, 128,
+	134, 135, 146, 147, 151, 152, 158, 159,
+	190, 130, 133, 128, 255, 178, 191, 192,
+	255, 128, 146, 147, 255, 190, 191, 192,
+	255, 128, 143, 144, 255, 144, 145, 136,
+	175, 188, 191, 192, 255, 181, 128, 175,
+	176, 255, 189, 191, 192, 255, 128, 160,
+	161, 186, 187, 191, 128, 129, 154, 155,
+	165, 166, 255, 191, 192, 255, 128, 129,
+	130, 135, 136, 137, 138, 143, 144, 145,
+	146, 151, 152, 153, 154, 156, 157, 191,
+	128, 191, 128, 129, 130, 131, 133, 138,
+	139, 140, 141, 142, 143, 144, 145, 146,
+	147, 148, 149, 152, 156, 157, 160, 161,
+	162, 163, 164, 166, 168, 169, 170, 171,
+	172, 173, 174, 176, 177, 132, 151, 153,
+	155, 158, 175, 178, 179, 180, 191, 140,
+	167, 187, 190, 128, 255, 142, 143, 158,
+	191, 192, 255, 187, 191, 192, 255, 128,
+	180, 181, 191, 128, 156, 157, 159, 160,
+	255, 145, 191, 192, 255, 128, 159, 160,
+	175, 176, 255, 139, 143, 182, 191, 192,
+	255, 144, 132, 135, 150, 191, 192, 255,
+	158, 175, 148, 151, 188, 191, 192, 255,
+	128, 167, 168, 175, 176, 255, 164, 191,
+	192, 255, 183, 191, 192, 255, 128, 149,
+	150, 159, 160, 167, 168, 191, 136, 182,
+	188, 128, 133, 134, 137, 138, 184, 185,
+	190, 191, 255, 150, 159, 183, 191, 192,
+	255, 179, 128, 159, 160, 181, 182, 191,
+	128, 149, 150, 159, 160, 185, 186, 191,
+	128, 183, 184, 189, 190, 191, 128, 148,
+	152, 129, 143, 144, 179, 180, 191, 128,
+	159, 160, 188, 189, 191, 128, 156, 157,
+	191, 136, 128, 164, 165, 191, 128, 181,
+	182, 191, 128, 149, 150, 159, 160, 178,
+	179, 191, 128, 145, 146, 191, 128, 178,
+	179, 191, 128, 130, 131, 132, 133, 134,
+	135, 136, 138, 139, 140, 141, 144, 145,
+	146, 147, 150, 151, 152, 153, 154, 156,
+	162, 163, 171, 176, 177, 178, 129, 191,
+	128, 130, 131, 183, 184, 191, 128, 130,
+	131, 175, 176, 191, 128, 143, 144, 168,
+	169, 191, 128, 130, 131, 166, 167, 191,
+	182, 128, 143, 144, 178, 179, 191, 128,
+	130, 131, 178, 179, 191, 128, 154, 156,
+	129, 132, 133, 191, 146, 128, 171, 172,
+	191, 135, 137, 142, 158, 128, 168, 169,
+	175, 176, 255, 159, 191, 192, 255, 144,
+	128, 156, 157, 161, 162, 191, 128, 134,
+	135, 138, 139, 191, 128, 175, 176, 191,
+	134, 128, 131, 132, 135, 136, 191, 128,
+	174, 175, 191, 128, 151, 152, 155, 156,
+	191, 132, 128, 191, 128, 170, 171, 191,
+	128, 153, 154, 191, 160, 190, 192, 255,
+	128, 184, 185, 191, 137, 128, 174, 175,
+	191, 128, 129, 177, 178, 255, 144, 191,
+	192, 255, 128, 142, 143, 144, 145, 146,
+	149, 129, 148, 150, 191, 175, 191, 192,
+	255, 132, 191, 192, 255, 128, 144, 129,
+	143, 145, 191, 144, 153, 128, 143, 145,
+	152, 154, 191, 135, 191, 192, 255, 160,
+	168, 169, 171, 172, 173, 174, 188, 189,
+	190, 191, 128, 159, 161, 167, 170, 187,
+	185, 191, 192, 255, 128, 143, 144, 173,
+	174, 191, 128, 131, 132, 162, 163, 183,
+	184, 188, 189, 255, 133, 143, 145, 191,
+	192, 255, 128, 146, 147, 159, 160, 191,
+	160, 128, 191, 128, 129, 191, 192, 255,
+	159, 160, 171, 128, 170, 172, 191, 192,
+	255, 173, 191, 192, 255, 179, 191, 192,
+	255, 128, 176, 177, 178, 129, 191, 128,
+	129, 130, 191, 171, 175, 189, 191, 192,
+	255, 128, 136, 137, 143, 144, 153, 154,
+	191, 144, 145, 146, 147, 148, 149, 154,
+	155, 156, 157, 158, 159, 128, 143, 150,
+	153, 160, 191, 149, 157, 173, 186, 188,
+	160, 161, 163, 164, 167, 168, 132, 134,
+	149, 157, 186, 191, 139, 140, 192, 255,
+	133, 145, 128, 134, 135, 137, 138, 255,
+	166, 167, 129, 155, 187, 149, 181, 143,
+	175, 137, 169, 131, 140, 191, 192, 255,
+	160, 163, 164, 165, 184, 185, 186, 128,
+	159, 161, 162, 166, 191, 133, 191, 192,
+	255, 132, 160, 163, 167, 179, 184, 186,
+	128, 164, 165, 168, 169, 187, 188, 191,
+	130, 135, 137, 139, 144, 147, 151, 153,
+	155, 157, 159, 163, 171, 179, 184, 189,
+	191, 128, 140, 141, 148, 149, 160, 161,
+	164, 165, 166, 167, 190, 138, 164, 170,
+	128, 155, 156, 160, 161, 187, 188, 191,
+	128, 191, 155, 156, 128, 191, 151, 191,
+	192, 255, 156, 157, 160, 128, 191, 181,
+	191, 192, 255, 158, 159, 186, 128, 185,
+	187, 191, 192, 255, 162, 191, 192, 255,
+	160, 168, 128, 159, 161, 167, 169, 191,
+	158, 191, 192, 255, 9, 10, 13, 32,
+	33, 34, 35, 38, 46, 47, 60, 61,
+	62, 64, 92, 95, 123, 124, 125, 126,
+	127, 194, 195, 198, 199, 203, 204, 205,
+	206, 207, 210, 212, 213, 214, 215, 216,
+	217, 219, 220, 221, 222, 223, 224, 225,
+	226, 227, 228, 233, 234, 237, 238, 239,
+	240, 0, 36, 37, 45, 48, 57, 58,
+	63, 65, 90, 91, 96, 97, 122, 192,
+	193, 196, 218, 229, 236, 241, 247, 9,
+	32, 10, 61, 10, 38, 46, 42, 47,
+	46, 69, 101, 48, 57, 60, 61, 61,
+	62, 61, 45, 95, 194, 195, 198, 199,
+	203, 204, 205, 206, 207, 210, 212, 213,
+	214, 215, 216, 217, 219, 220, 221, 222,
+	223, 224, 225, 226, 227, 228, 233, 234,
+	237, 239, 240, 243, 48, 57, 65, 90,
+	97, 122, 196, 218, 229, 236, 124, 125,
+	128, 191, 170, 181, 186, 128, 191, 151,
+	183, 128, 255, 192, 255, 0, 127, 173,
+	130, 133, 146, 159, 165, 171, 175, 191,
+	192, 255, 181, 190, 128, 175, 176, 183,
+	184, 185, 186, 191, 134, 139, 141, 162,
+	128, 135, 136, 255, 182, 130, 137, 176,
+	151, 152, 154, 160, 136, 191, 192, 255,
+	128, 143, 144, 170, 171, 175, 176, 178,
+	179, 191, 128, 159, 160, 191, 176, 128,
+	138, 139, 173, 174, 255, 148, 150, 164,
+	167, 173, 176, 185, 189, 190, 192, 255,
+	144, 128, 145, 146, 175, 176, 191, 128,
+	140, 141, 255, 166, 176, 178, 191, 192,
+	255, 186, 128, 137, 138, 170, 171, 179,
+	180, 181, 182, 191, 160, 161, 162, 164,
+	165, 166, 167, 168, 169, 170, 171, 172,
+	173, 174, 175, 176, 177, 178, 179, 180,
+	181, 182, 183, 184, 185, 186, 187, 188,
+	189, 190, 128, 191, 128, 129, 130, 131,
+	137, 138, 139, 140, 141, 142, 143, 144,
+	153, 154, 155, 156, 157, 158, 159, 160,
+	161, 162, 163, 164, 165, 166, 167, 168,
+	169, 170, 171, 172, 173, 174, 175, 176,
+	177, 178, 179, 180, 182, 183, 184, 188,
+	189, 190, 191, 132, 187, 129, 130, 132,
+	133, 134, 176, 177, 178, 179, 180, 181,
+	182, 183, 128, 191, 128, 129, 130, 131,
+	132, 133, 134, 135, 144, 136, 143, 145,
+	191, 192, 255, 182, 183, 184, 128, 191,
+	128, 191, 191, 128, 190, 192, 255, 128,
+	146, 147, 148, 152, 153, 154, 155, 156,
+	158, 159, 160, 161, 162, 163, 164, 165,
+	166, 167, 168, 169, 170, 171, 172, 173,
+	174, 175, 176, 129, 191, 192, 255, 158,
+	159, 128, 157, 160, 191, 192, 255, 128,
+	191, 164, 169, 171, 172, 173, 174, 175,
+	180, 181, 182, 183, 184, 185, 187, 188,
+	189, 190, 191, 128, 163, 165, 186, 144,
+	145, 146, 147, 148, 150, 151, 152, 155,
+	157, 158, 160, 170, 171, 172, 175, 128,
+	159, 161, 169, 173, 191, 128, 191, 10,
+	13, 34, 36, 37, 92, 128, 191, 192,
+	223, 224, 239, 240, 247, 248, 255, 10,
+	13, 34, 92, 36, 37, 128, 191, 192,
+	223, 224, 239, 240, 247, 248, 255, 10,
+	13, 36, 123, 123, 126, 126, 37, 123,
+	126, 10, 13, 128, 191, 192, 223, 224,
+	239, 240, 247, 248, 255, 128, 191, 128,
+	191, 128, 191, 10, 13, 36, 37, 128,
+	191, 192, 223, 224, 239, 240, 247, 248,
+	255, 10, 13, 36, 37, 128, 191, 192,
+	223, 224, 239, 240, 247, 248, 255, 10,
+	13, 10, 13, 123, 10, 13, 126, 10,
+	13, 126, 126, 128, 191, 128, 191, 128,
+	191, 10, 13, 36, 37, 128, 191, 192,
+	223, 224, 239, 240, 247, 248, 255, 10,
+	13, 36, 37, 128, 191, 192, 223, 224,
+	239, 240, 247, 248, 255, 10, 13, 10,
+	13, 123, 10, 13, 126, 10, 13, 126,
+	126, 128, 191, 128, 191, 128, 191, 95,
+	194, 195, 198, 199, 203, 204, 205, 206,
+	207, 210, 212, 213, 214, 215, 216, 217,
+	219, 220, 221, 222, 223, 224, 225, 226,
+	227, 228, 233, 234, 237, 238, 239, 240,
+	65, 90, 97, 122, 128, 191, 192, 193,
+	196, 218, 229, 236, 241, 247, 248, 255,
+	45, 95, 194, 195, 198, 199, 203, 204,
+	205, 206, 207, 210, 212, 213, 214, 215,
+	216, 217, 219, 220, 221, 222, 223, 224,
+	225, 226, 227, 228, 233, 234, 237, 239,
+	240, 243, 48, 57, 65, 90, 97, 122,
+	196, 218, 229, 236, 128, 191, 170, 181,
+	186, 128, 191, 151, 183, 128, 255, 192,
+	255, 0, 127, 173, 130, 133, 146, 159,
+	165, 171, 175, 191, 192, 255, 181, 190,
+	128, 175, 176, 183, 184, 185, 186, 191,
+	134, 139, 141, 162, 128, 135, 136, 255,
+	182, 130, 137, 176, 151, 152, 154, 160,
+	136, 191, 192, 255, 128, 143, 144, 170,
+	171, 175, 176, 178, 179, 191, 128, 159,
+	160, 191, 176, 128, 138, 139, 173, 174,
+	255, 148, 150, 164, 167, 173, 176, 185,
+	189, 190, 192, 255, 144, 128, 145, 146,
+	175, 176, 191, 128, 140, 141, 255, 166,
+	176, 178, 191, 192, 255, 186, 128, 137,
+	138, 170, 171, 179, 180, 181, 182, 191,
+	160, 161, 162, 164, 165, 166, 167, 168,
+	169, 170, 171, 172, 173, 174, 175, 176,
+	177, 178, 179, 180, 181, 182, 183, 184,
+	185, 186, 187, 188, 189, 190, 128, 191,
+	128, 129, 130, 131, 137, 138, 139, 140,
+	141, 142, 143, 144, 153, 154, 155, 156,
+	157, 158, 159, 160, 161, 162, 163, 164,
+	165, 166, 167, 168, 169, 170, 171, 172,
+	173, 174, 175, 176, 177, 178, 179, 180,
+	182, 183, 184, 188, 189, 190, 191, 132,
+	187, 129, 130, 132, 133, 134, 176, 177,
+	178, 179, 180, 181, 182, 183, 128, 191,
+	128, 129, 130, 131, 132, 133, 134, 135,
+	144, 136, 143, 145, 191, 192, 255, 182,
+	183, 184, 128, 191, 128, 191, 191, 128,
+	190, 192, 255, 128, 146, 147, 148, 152,
+	153, 154, 155, 156, 158, 159, 160, 161,
+	162, 163, 164, 165, 166, 167, 168, 169,
+	170, 171, 172, 173, 174, 175, 176, 129,
+	191, 192, 255, 158, 159, 128, 157, 160,
+	191, 192, 255, 128, 191, 164, 169, 171,
+	172, 173, 174, 175, 180, 181, 182, 183,
+	184, 185, 187, 188, 189, 190, 191, 128,
+	163, 165, 186, 144, 145, 146, 147, 148,
+	150, 151, 152, 155, 157, 158, 160, 170,
+	171, 172, 175, 128, 159, 161, 169, 173,
+	191, 128, 191,
+}
+
+var _hcltok_single_lengths []byte = []byte{
+	0, 1, 1, 2, 3, 2, 0, 32,
+	31, 36, 1, 4, 0, 0, 0, 0,
+	1, 2, 1, 1, 1, 1, 0, 1,
+	1, 0, 0, 2, 0, 0, 0, 1,
+	32, 0, 0, 0, 0, 1, 3, 1,
+	1, 1, 0, 2, 0, 1, 1, 2,
+	0, 3, 0, 1, 0, 2, 1, 2,
+	0, 0, 5, 1, 4, 0, 0, 1,
+	43, 0, 0, 0, 2, 3, 2, 1,
+	1, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 1, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 4, 1,
+	0, 15, 0, 0, 0, 1, 6, 1,
+	0, 0, 1, 0, 2, 0, 0, 0,
+	9, 0, 1, 1, 0, 0, 0, 3,
+	0, 1, 0, 28, 0, 0, 0, 1,
+	0, 1, 0, 0, 0, 1, 0, 0,
+	0, 0, 0, 0, 0, 1, 0, 2,
+	0, 0, 18, 0, 0, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 16, 36, 0, 0, 0, 0,
+	1, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 0, 0, 0, 2, 0, 0,
+	0, 0, 0, 1, 0, 0, 0, 0,
+	0, 0, 0, 28, 0, 0, 0, 1,
+	1, 1, 1, 0, 0, 2, 0, 1,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 1, 1, 4, 0, 0, 2, 2,
+	0, 11, 0, 0, 0, 0, 0, 0,
+	0, 1, 1, 3, 0, 0, 4, 0,
+	0, 0, 18, 0, 0, 0, 1, 4,
+	1, 4, 1, 0, 3, 2, 2, 2,
+	1, 0, 0, 1, 8, 0, 0, 0,
+	4, 12, 0, 2, 0, 3, 0, 1,
+	0, 2, 0, 1, 2, 0, 3, 1,
+	2, 0, 0, 0, 0, 0, 1, 1,
+	0, 0, 1, 28, 3, 0, 1, 1,
+	2, 1, 0, 1, 1, 2, 1, 1,
+	2, 1, 1, 0, 2, 1, 1, 1,
+	1, 0, 0, 6, 1, 1, 0, 0,
+	46, 1, 1, 0, 0, 0, 0, 2,
+	1, 0, 0, 0, 1, 0, 0, 0,
+	0, 0, 0, 0, 13, 2, 0, 0,
+	0, 9, 0, 1, 28, 0, 1, 3,
+	0, 2, 0, 0, 0, 1, 0, 1,
+	1, 2, 0, 18, 2, 0, 0, 16,
+	35, 0, 0, 0, 1, 0, 28, 0,
+	0, 0, 0, 1, 0, 2, 0, 0,
+	1, 0, 0, 1, 0, 0, 1, 0,
+	0, 0, 0, 1, 11, 0, 0, 0,
+	0, 4, 0, 12, 1, 7, 0, 4,
+	0, 0, 0, 0, 1, 2, 1, 1,
+	1, 1, 0, 1, 1, 0, 0, 2,
+	0, 0, 0, 1, 32, 0, 0, 0,
+	0, 1, 3, 1, 1, 1, 0, 2,
+	0, 1, 1, 2, 0, 3, 0, 1,
+	0, 2, 1, 2, 0, 0, 5, 1,
+	4, 0, 0, 1, 43, 0, 0, 0,
+	2, 3, 2, 1, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	1, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 4, 1, 0, 15, 0, 0,
+	0, 1, 6, 1, 0, 0, 1, 0,
+	2, 0, 0, 0, 9, 0, 1, 1,
+	0, 0, 0, 3, 0, 1, 0, 28,
+	0, 0, 0, 1, 0, 1, 0, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 2, 0, 0, 18, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 1, 0, 0, 0, 16, 36,
+	0, 0, 0, 0, 1, 0, 0, 0,
+	0, 0, 1, 0, 0, 0, 0, 0,
+	0, 2, 0, 0, 0, 0, 0, 1,
+	0, 0, 0, 0, 0, 0, 0, 28,
+	0, 0, 0, 1, 1, 1, 1, 0,
+	0, 2, 0, 1, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 1, 4,
+	0, 0, 2, 2, 0, 11, 0, 0,
+	0, 0, 0, 0, 0, 1, 1, 3,
+	0, 0, 4, 0, 0, 0, 18, 0,
+	0, 0, 1, 4, 1, 4, 1, 0,
+	3, 2, 2, 2, 1, 0, 0, 1,
+	8, 0, 0, 0, 4, 12, 0, 2,
+	0, 3, 0, 1, 0, 2, 0, 1,
+	2, 0, 0, 3, 0, 1, 1, 1,
+	2, 2, 4, 1, 6, 2, 4, 2,
+	4, 1, 4, 0, 6, 1, 3, 1,
+	2, 0, 2, 11, 1, 1, 1, 0,
+	1, 1, 0, 2, 0, 3, 3, 2,
+	1, 0, 0, 0, 1, 0, 1, 0,
+	1, 1, 0, 2, 0, 0, 1, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 4, 3, 2, 2, 0, 6,
+	1, 0, 1, 1, 0, 2, 0, 4,
+	3, 0, 1, 1, 0, 0, 0, 0,
+	0, 0, 0, 1, 0, 0, 0, 1,
+	0, 3, 0, 2, 0, 0, 0, 3,
+	0, 2, 1, 1, 3, 1, 0, 0,
+	0, 0, 0, 5, 2, 0, 0, 0,
+	0, 0, 0, 1, 0, 0, 1, 1,
+	0, 0, 35, 4, 0, 0, 0, 0,
+	0, 0, 0, 1, 0, 0, 0, 0,
+	0, 0, 3, 0, 1, 0, 0, 3,
+	0, 0, 1, 0, 0, 0, 0, 28,
+	0, 0, 0, 0, 1, 0, 3, 1,
+	4, 0, 1, 0, 0, 1, 0, 0,
+	1, 0, 0, 0, 0, 1, 1, 0,
+	7, 0, 0, 2, 2, 0, 11, 0,
+	0, 0, 0, 0, 1, 1, 3, 0,
+	0, 4, 0, 0, 0, 12, 1, 4,
+	1, 5, 2, 0, 3, 2, 2, 2,
+	1, 7, 0, 7, 17, 3, 0, 2,
+	0, 3, 0, 0, 1, 0, 2, 0,
+	2, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 2, 2, 1, 0, 0, 0,
+	2, 2, 4, 0, 0, 0, 0, 1,
+	2, 1, 1, 1, 1, 0, 1, 1,
+	0, 0, 2, 0, 0, 0, 1, 32,
+	0, 0, 0, 0, 1, 3, 1, 1,
+	1, 0, 2, 0, 1, 1, 2, 0,
+	3, 0, 1, 0, 2, 1, 2, 0,
+	0, 5, 1, 4, 0, 0, 1, 43,
+	0, 0, 0, 2, 3, 2, 1, 1,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 1, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 4, 1, 0,
+	15, 0, 0, 0, 1, 6, 1, 0,
+	0, 1, 0, 2, 0, 0, 0, 9,
+	0, 1, 1, 0, 0, 0, 3, 0,
+	1, 0, 28, 0, 0, 0, 1, 0,
+	1, 0, 0, 0, 1, 0, 0, 0,
+	0, 0, 0, 0, 1, 0, 2, 0,
+	0, 18, 0, 0, 1, 0, 0, 0,
+	0, 0, 0, 0, 0, 1, 0, 0,
+	0, 16, 36, 0, 0, 0, 0, 1,
+	0, 0, 0, 0, 0, 1, 0, 0,
+	0, 0, 0, 0, 2, 0, 0, 0,
+	0, 0, 1, 0, 0, 0, 0, 0,
+	0, 0, 28, 0, 0, 0, 1, 1,
+	1, 1, 0, 0, 2, 0, 1, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	1, 1, 4, 0, 0, 2, 2, 0,
+	11, 0, 0, 0, 0, 0, 0, 0,
+	1, 1, 3, 0, 0, 4, 0, 0,
+	0, 18, 0, 0, 0, 1, 4, 1,
+	4, 1, 0, 3, 2, 2, 2, 1,
+	0, 0, 1, 8, 0, 0, 0, 4,
+	12, 0, 2, 0, 3, 0, 1, 0,
+	2, 0, 1, 2, 0, 0, 3, 0,
+	1, 1, 1, 2, 2, 4, 1, 6,
+	2, 4, 2, 4, 1, 4, 0, 6,
+	1, 3, 1, 2, 0, 2, 11, 1,
+	1, 1, 0, 1, 1, 0, 2, 0,
+	3, 3, 2, 1, 0, 0, 0, 1,
+	0, 1, 0, 1, 1, 0, 2, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 0, 0, 4, 3, 2,
+	2, 0, 6, 1, 0, 1, 1, 0,
+	2, 0, 4, 3, 0, 1, 1, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 1, 0, 3, 0, 2, 0,
+	0, 0, 3, 0, 2, 1, 1, 3,
+	1, 0, 0, 0, 0, 0, 5, 2,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 1, 1, 0, 0, 35, 4, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
+	0, 0, 0, 0, 0, 3, 0, 1,
+	0, 0, 3, 0, 0, 1, 0, 0,
+	0, 0, 28, 0, 0, 0, 0, 1,
+	0, 3, 1, 4, 0, 1, 0, 0,
+	1, 0, 0, 1, 0, 0, 0, 0,
+	1, 1, 0, 7, 0, 0, 2, 2,
+	0, 11, 0, 0, 0, 0, 0, 1,
+	1, 3, 0, 0, 4, 0, 0, 0,
+	12, 1, 4, 1, 5, 2, 0, 3,
+	2, 2, 2, 1, 7, 0, 7, 17,
+	3, 0, 2, 0, 3, 0, 0, 1,
+	0, 2, 0, 53, 2, 1, 1, 1,
+	1, 1, 2, 3, 2, 2, 1, 34,
+	1, 1, 0, 3, 2, 0, 0, 0,
+	1, 2, 4, 1, 0, 1, 0, 0,
+	0, 0, 1, 1, 1, 0, 0, 1,
+	30, 47, 13, 9, 3, 0, 1, 28,
+	2, 0, 18, 16, 0, 6, 4, 2,
+	2, 0, 1, 1, 1, 2, 1, 2,
+	0, 0, 0, 4, 2, 2, 3, 3,
+	2, 1, 1, 0, 0, 0, 4, 2,
+	2, 3, 3, 2, 1, 1, 0, 0,
+	0, 33, 34, 0, 3, 2, 0, 0,
+	0, 1, 2, 4, 1, 0, 1, 0,
+	0, 0, 0, 1, 1, 1, 0, 0,
+	1, 30, 47, 13, 9, 3, 0, 1,
+	28, 2, 0, 18, 16, 0,
+}
+
+var _hcltok_range_lengths []byte = []byte{
+	0, 0, 0, 0, 1, 1, 1, 5,
+	5, 5, 0, 0, 3, 0, 1, 1,
+	4, 2, 3, 0, 1, 0, 2, 2,
+	4, 2, 2, 3, 1, 1, 1, 1,
+	0, 1, 1, 2, 2, 1, 4, 6,
+	9, 6, 8, 5, 8, 7, 10, 4,
+	6, 4, 7, 7, 5, 5, 4, 5,
+	1, 2, 8, 4, 3, 3, 3, 0,
+	3, 1, 2, 1, 2, 2, 3, 3,
+	1, 3, 2, 2, 1, 2, 2, 2,
+	3, 4, 4, 3, 1, 2, 1, 3,
+	2, 2, 2, 2, 2, 3, 3, 1,
+	1, 2, 1, 3, 2, 2, 3, 2,
+	7, 0, 1, 4, 1, 2, 4, 2,
+	1, 2, 0, 2, 2, 3, 5, 5,
+	1, 4, 1, 1, 2, 2, 1, 0,
+	0, 1, 1, 1, 1, 1, 2, 2,
+	2, 2, 1, 1, 1, 4, 2, 2,
+	3, 1, 4, 4, 6, 1, 3, 1,
+	1, 2, 1, 1, 1, 5, 3, 1,
+	1, 1, 2, 3, 3, 1, 2, 2,
+	1, 4, 1, 2, 5, 2, 1, 1,
+	0, 2, 2, 2, 2, 2, 2, 2,
+	2, 2, 1, 1, 2, 4, 2, 1,
+	2, 2, 2, 6, 1, 1, 2, 1,
+	2, 1, 1, 1, 2, 2, 2, 1,
+	3, 2, 5, 2, 8, 6, 2, 2,
+	2, 2, 3, 1, 3, 1, 2, 1,
+	3, 2, 2, 3, 1, 1, 1, 1,
+	1, 1, 1, 2, 2, 4, 1, 2,
+	1, 0, 1, 1, 1, 1, 0, 1,
+	2, 3, 1, 3, 3, 1, 0, 3,
+	0, 2, 3, 1, 0, 0, 0, 0,
+	2, 2, 2, 2, 1, 5, 2, 2,
+	5, 7, 5, 0, 1, 0, 1, 1,
+	1, 1, 1, 0, 1, 1, 0, 3,
+	3, 1, 1, 2, 1, 3, 5, 1,
+	1, 2, 2, 1, 1, 1, 1, 2,
+	6, 3, 7, 2, 6, 1, 6, 2,
+	8, 0, 4, 2, 5, 2, 3, 3,
+	3, 1, 2, 8, 2, 0, 2, 1,
+	2, 1, 5, 2, 1, 3, 3, 0,
+	2, 1, 2, 1, 0, 1, 1, 3,
+	1, 1, 2, 3, 0, 0, 3, 2,
+	4, 1, 4, 1, 1, 3, 1, 1,
+	1, 1, 2, 2, 1, 3, 1, 4,
+	3, 3, 1, 1, 5, 2, 1, 1,
+	2, 1, 2, 1, 3, 2, 0, 1,
+	1, 1, 1, 1, 1, 1, 2, 1,
+	1, 1, 1, 1, 1, 1, 0, 1,
+	1, 2, 2, 1, 1, 1, 3, 2,
+	1, 0, 2, 1, 1, 1, 1, 0,
+	3, 0, 1, 1, 4, 2, 3, 0,
+	1, 0, 2, 2, 4, 2, 2, 3,
+	1, 1, 1, 1, 0, 1, 1, 2,
+	2, 1, 4, 6, 9, 6, 8, 5,
+	8, 7, 10, 4, 6, 4, 7, 7,
+	5, 5, 4, 5, 1, 2, 8, 4,
+	3, 3, 3, 0, 3, 1, 2, 1,
+	2, 2, 3, 3, 1, 3, 2, 2,
+	1, 2, 2, 2, 3, 4, 4, 3,
+	1, 2, 1, 3, 2, 2, 2, 2,
+	2, 3, 3, 1, 1, 2, 1, 3,
+	2, 2, 3, 2, 7, 0, 1, 4,
+	1, 2, 4, 2, 1, 2, 0, 2,
+	2, 3, 5, 5, 1, 4, 1, 1,
+	2, 2, 1, 0, 0, 1, 1, 1,
+	1, 1, 2, 2, 2, 2, 1, 1,
+	1, 4, 2, 2, 3, 1, 4, 4,
+	6, 1, 3, 1, 1, 2, 1, 1,
+	1, 5, 3, 1, 1, 1, 2, 3,
+	3, 1, 2, 2, 1, 4, 1, 2,
+	5, 2, 1, 1, 0, 2, 2, 2,
+	2, 2, 2, 2, 2, 2, 1, 1,
+	2, 4, 2, 1, 2, 2, 2, 6,
+	1, 1, 2, 1, 2, 1, 1, 1,
+	2, 2, 2, 1, 3, 2, 5, 2,
+	8, 6, 2, 2, 2, 2, 3, 1,
+	3, 1, 2, 1, 3, 2, 2, 3,
+	1, 1, 1, 1, 1, 1, 1, 2,
+	2, 4, 1, 2, 1, 0, 1, 1,
+	1, 1, 0, 1, 2, 3, 1, 3,
+	3, 1, 0, 3, 0, 2, 3, 1,
+	0, 0, 0, 0, 2, 2, 2, 2,
+	1, 5, 2, 2, 5, 7, 5, 0,
+	1, 0, 1, 1, 1, 1, 1, 0,
+	1, 1, 1, 2, 2, 3, 3, 4,
+	7, 5, 7, 5, 3, 3, 7, 3,
+	13, 1, 3, 5, 3, 5, 3, 6,
+	5, 2, 2, 8, 4, 1, 2, 3,
+	2, 10, 2, 2, 0, 2, 3, 3,
+	1, 2, 3, 3, 1, 2, 3, 3,
+	4, 4, 2, 1, 2, 2, 3, 2,
+	2, 5, 3, 2, 3, 2, 1, 3,
+	3, 6, 2, 2, 5, 2, 5, 1,
+	1, 2, 4, 1, 11, 1, 3, 8,
+	4, 2, 1, 0, 4, 3, 3, 3,
+	2, 9, 1, 1, 4, 3, 2, 2,
+	2, 3, 4, 2, 3, 2, 4, 3,
+	2, 2, 3, 3, 4, 3, 3, 4,
+	2, 5, 4, 8, 7, 1, 2, 1,
+	3, 1, 2, 5, 1, 2, 2, 2,
+	2, 1, 3, 2, 2, 3, 3, 1,
+	9, 1, 5, 1, 3, 2, 2, 3,
+	2, 3, 3, 3, 1, 3, 3, 2,
+	2, 4, 5, 3, 3, 4, 3, 3,
+	3, 2, 2, 2, 4, 2, 2, 1,
+	3, 3, 3, 3, 3, 3, 2, 2,
+	3, 2, 3, 3, 2, 3, 2, 3,
+	1, 2, 2, 2, 2, 2, 2, 2,
+	2, 2, 2, 2, 3, 2, 3, 2,
+	3, 5, 3, 3, 1, 2, 3, 2,
+	2, 1, 2, 3, 4, 3, 0, 3,
+	0, 2, 3, 1, 0, 0, 0, 0,
+	2, 3, 2, 4, 6, 4, 1, 1,
+	2, 1, 2, 1, 3, 2, 3, 2,
+	5, 1, 1, 1, 1, 1, 0, 1,
+	1, 1, 0, 0, 0, 1, 1, 1,
+	0, 0, 0, 3, 0, 1, 1, 4,
+	2, 3, 0, 1, 0, 2, 2, 4,
+	2, 2, 3, 1, 1, 1, 1, 0,
+	1, 1, 2, 2, 1, 4, 6, 9,
+	6, 8, 5, 8, 7, 10, 4, 6,
+	4, 7, 7, 5, 5, 4, 5, 1,
+	2, 8, 4, 3, 3, 3, 0, 3,
+	1, 2, 1, 2, 2, 3, 3, 1,
+	3, 2, 2, 1, 2, 2, 2, 3,
+	4, 4, 3, 1, 2, 1, 3, 2,
+	2, 2, 2, 2, 3, 3, 1, 1,
+	2, 1, 3, 2, 2, 3, 2, 7,
+	0, 1, 4, 1, 2, 4, 2, 1,
+	2, 0, 2, 2, 3, 5, 5, 1,
+	4, 1, 1, 2, 2, 1, 0, 0,
+	1, 1, 1, 1, 1, 2, 2, 2,
+	2, 1, 1, 1, 4, 2, 2, 3,
+	1, 4, 4, 6, 1, 3, 1, 1,
+	2, 1, 1, 1, 5, 3, 1, 1,
+	1, 2, 3, 3, 1, 2, 2, 1,
+	4, 1, 2, 5, 2, 1, 1, 0,
+	2, 2, 2, 2, 2, 2, 2, 2,
+	2, 1, 1, 2, 4, 2, 1, 2,
+	2, 2, 6, 1, 1, 2, 1, 2,
+	1, 1, 1, 2, 2, 2, 1, 3,
+	2, 5, 2, 8, 6, 2, 2, 2,
+	2, 3, 1, 3, 1, 2, 1, 3,
+	2, 2, 3, 1, 1, 1, 1, 1,
+	1, 1, 2, 2, 4, 1, 2, 1,
+	0, 1, 1, 1, 1, 0, 1, 2,
+	3, 1, 3, 3, 1, 0, 3, 0,
+	2, 3, 1, 0, 0, 0, 0, 2,
+	2, 2, 2, 1, 5, 2, 2, 5,
+	7, 5, 0, 1, 0, 1, 1, 1,
+	1, 1, 0, 1, 1, 1, 2, 2,
+	3, 3, 4, 7, 5, 7, 5, 3,
+	3, 7, 3, 13, 1, 3, 5, 3,
+	5, 3, 6, 5, 2, 2, 8, 4,
+	1, 2, 3, 2, 10, 2, 2, 0,
+	2, 3, 3, 1, 2, 3, 3, 1,
+	2, 3, 3, 4, 4, 2, 1, 2,
+	2, 3, 2, 2, 5, 3, 2, 3,
+	2, 1, 3, 3, 6, 2, 2, 5,
+	2, 5, 1, 1, 2, 4, 1, 11,
+	1, 3, 8, 4, 2, 1, 0, 4,
+	3, 3, 3, 2, 9, 1, 1, 4,
+	3, 2, 2, 2, 3, 4, 2, 3,
+	2, 4, 3, 2, 2, 3, 3, 4,
+	3, 3, 4, 2, 5, 4, 8, 7,
+	1, 2, 1, 3, 1, 2, 5, 1,
+	2, 2, 2, 2, 1, 3, 2, 2,
+	3, 3, 1, 9, 1, 5, 1, 3,
+	2, 2, 3, 2, 3, 3, 3, 1,
+	3, 3, 2, 2, 4, 5, 3, 3,
+	4, 3, 3, 3, 2, 2, 2, 4,
+	2, 2, 1, 3, 3, 3, 3, 3,
+	3, 2, 2, 3, 2, 3, 3, 2,
+	3, 2, 3, 1, 2, 2, 2, 2,
+	2, 2, 2, 2, 2, 2, 2, 3,
+	2, 3, 2, 3, 5, 3, 3, 1,
+	2, 3, 2, 2, 1, 2, 3, 4,
+	3, 0, 3, 0, 2, 3, 1, 0,
+	0, 0, 0, 2, 3, 2, 4, 6,
+	4, 1, 1, 2, 1, 2, 1, 3,
+	2, 3, 2, 11, 0, 0, 0, 0,
+	0, 0, 0, 1, 0, 0, 0, 5,
+	0, 0, 1, 1, 1, 0, 1, 1,
+	5, 4, 2, 0, 1, 0, 2, 2,
+	5, 2, 3, 5, 3, 2, 3, 5,
+	1, 1, 1, 3, 1, 1, 2, 2,
+	3, 1, 2, 3, 1, 5, 6, 0,
+	0, 0, 0, 0, 0, 0, 0, 5,
+	1, 1, 1, 5, 6, 0, 0, 0,
+	0, 0, 0, 1, 1, 1, 5, 6,
+	0, 0, 0, 0, 0, 0, 1, 1,
+	1, 8, 5, 1, 1, 1, 0, 1,
+	1, 5, 4, 2, 0, 1, 0, 2,
+	2, 5, 2, 3, 5, 3, 2, 3,
+	5, 1, 1, 1, 3, 1, 1, 2,
+	2, 3, 1, 2, 3, 1,
+}
+
+var _hcltok_index_offsets []int16 = []int16{
+	0, 0, 2, 4, 7, 12, 16, 18,
+	56, 93, 135, 137, 142, 146, 147, 149,
+	151, 157, 162, 167, 169, 172, 174, 177,
+	181, 187, 190, 193, 199, 201, 203, 205,
+	208, 241, 243, 245, 248, 251, 254, 262,
+	270, 281, 289, 298, 306, 315, 324, 336,
+	343, 350, 358, 366, 375, 381, 389, 395,
+	403, 405, 408, 422, 428, 436, 440, 444,
+	446, 493, 495, 498, 500, 505, 511, 517,
+	522, 525, 529, 532, 535, 537, 540, 543,
+	546, 550, 555, 560, 564, 566, 569, 571,
+	575, 578, 581, 584, 587, 591, 596, 600,
+	602, 604, 607, 609, 613, 616, 619, 627,
+	631, 639, 655, 657, 662, 664, 668, 679,
+	683, 685, 688, 690, 693, 698, 702, 708,
+	714, 725, 730, 733, 736, 739, 742, 744,
+	748, 749, 752, 754, 784, 786, 788, 791,
+	795, 798, 802, 804, 806, 808, 814, 817,
+	820, 824, 826, 831, 836, 843, 846, 850,
+	854, 856, 859, 879, 881, 883, 890, 894,
+	896, 898, 900, 903, 907, 911, 913, 917,
+	920, 922, 927, 945, 984, 990, 993, 995,
+	997, 999, 1002, 1005, 1008, 1011, 1014, 1018,
+	1021, 1024, 1027, 1029, 1031, 1034, 1041, 1044,
+	1046, 1049, 1052, 1055, 1063, 1065, 1067, 1070,
+	1072, 1075, 1077, 1079, 1109, 1112, 1115, 1118,
+	1121, 1126, 1130, 1137, 1140, 1149, 1158, 1161,
+	1165, 1168, 1171, 1175, 1177, 1181, 1183, 1186,
+	1188, 1192, 1196, 1200, 1208, 1210, 1212, 1216,
+	1220, 1222, 1235, 1237, 1240, 1243, 1248, 1250,
+	1253, 1255, 1257, 1260, 1265, 1267, 1269, 1274,
+	1276, 1279, 1283, 1303, 1307, 1311, 1313, 1315,
+	1323, 1325, 1332, 1337, 1339, 1343, 1346, 1349,
+	1352, 1356, 1359, 1362, 1366, 1376, 1382, 1385,
+	1388, 1398, 1418, 1424, 1427, 1429, 1433, 1435,
+	1438, 1440, 1444, 1446, 1448, 1452, 1454, 1458,
+	1463, 1469, 1471, 1473, 1476, 1478, 1482, 1489,
+	1492, 1494, 1497, 1501, 1531, 1536, 1538, 1541,
+	1545, 1554, 1559, 1567, 1571, 1579, 1583, 1591,
+	1595, 1606, 1608, 1614, 1617, 1625, 1629, 1634,
+	1639, 1644, 1646, 1649, 1664, 1668, 1670, 1673,
+	1675, 1724, 1727, 1734, 1737, 1739, 1743, 1747,
+	1750, 1754, 1756, 1759, 1761, 1763, 1765, 1767,
+	1771, 1773, 1775, 1778, 1782, 1796, 1799, 1803,
+	1806, 1811, 1822, 1827, 1830, 1860, 1864, 1867,
+	1872, 1874, 1878, 1881, 1884, 1886, 1891, 1893,
+	1899, 1904, 1910, 1912, 1932, 1940, 1943, 1945,
+	1963, 2001, 2003, 2006, 2008, 2013, 2016, 2045,
+	2047, 2049, 2051, 2053, 2056, 2058, 2062, 2065,
+	2067, 2070, 2072, 2074, 2077, 2079, 2081, 2083,
+	2085, 2087, 2090, 2093, 2096, 2109, 2111, 2115,
+	2118, 2120, 2125, 2128, 2142, 2145, 2154, 2156,
+	2161, 2165, 2166, 2168, 2170, 2176, 2181, 2186,
+	2188, 2191, 2193, 2196, 2200, 2206, 2209, 2212,
+	2218, 2220, 2222, 2224, 2227, 2260, 2262, 2264,
+	2267, 2270, 2273, 2281, 2289, 2300, 2308, 2317,
+	2325, 2334, 2343, 2355, 2362, 2369, 2377, 2385,
+	2394, 2400, 2408, 2414, 2422, 2424, 2427, 2441,
+	2447, 2455, 2459, 2463, 2465, 2512, 2514, 2517,
+	2519, 2524, 2530, 2536, 2541, 2544, 2548, 2551,
+	2554, 2556, 2559, 2562, 2565, 2569, 2574, 2579,
+	2583, 2585, 2588, 2590, 2594, 2597, 2600, 2603,
+	2606, 2610, 2615, 2619, 2621, 2623, 2626, 2628,
+	2632, 2635, 2638, 2646, 2650, 2658, 2674, 2676,
+	2681, 2683, 2687, 2698, 2702, 2704, 2707, 2709,
+	2712, 2717, 2721, 2727, 2733, 2744, 2749, 2752,
+	2755, 2758, 2761, 2763, 2767, 2768, 2771, 2773,
+	2803, 2805, 2807, 2810, 2814, 2817, 2821, 2823,
+	2825, 2827, 2833, 2836, 2839, 2843, 2845, 2850,
+	2855, 2862, 2865, 2869, 2873, 2875, 2878, 2898,
+	2900, 2902, 2909, 2913, 2915, 2917, 2919, 2922,
+	2926, 2930, 2932, 2936, 2939, 2941, 2946, 2964,
+	3003, 3009, 3012, 3014, 3016, 3018, 3021, 3024,
+	3027, 3030, 3033, 3037, 3040, 3043, 3046, 3048,
+	3050, 3053, 3060, 3063, 3065, 3068, 3071, 3074,
+	3082, 3084, 3086, 3089, 3091, 3094, 3096, 3098,
+	3128, 3131, 3134, 3137, 3140, 3145, 3149, 3156,
+	3159, 3168, 3177, 3180, 3184, 3187, 3190, 3194,
+	3196, 3200, 3202, 3205, 3207, 3211, 3215, 3219,
+	3227, 3229, 3231, 3235, 3239, 3241, 3254, 3256,
+	3259, 3262, 3267, 3269, 3272, 3274, 3276, 3279,
+	3284, 3286, 3288, 3293, 3295, 3298, 3302, 3322,
+	3326, 3330, 3332, 3334, 3342, 3344, 3351, 3356,
+	3358, 3362, 3365, 3368, 3371, 3375, 3378, 3381,
+	3385, 3395, 3401, 3404, 3407, 3417, 3437, 3443,
+	3446, 3448, 3452, 3454, 3457, 3459, 3463, 3465,
+	3467, 3471, 3473, 3475, 3481, 3484, 3489, 3494,
+	3500, 3510, 3518, 3530, 3537, 3547, 3553, 3565,
+	3571, 3589, 3592, 3600, 3606, 3616, 3623, 3630,
+	3638, 3646, 3649, 3654, 3674, 3680, 3683, 3687,
+	3691, 3695, 3707, 3710, 3715, 3716, 3722, 3729,
+	3735, 3738, 3741, 3745, 3749, 3752, 3755, 3760,
+	3764, 3770, 3776, 3779, 3783, 3786, 3789, 3794,
+	3797, 3800, 3806, 3810, 3813, 3817, 3820, 3823,
+	3827, 3831, 3838, 3841, 3844, 3850, 3853, 3860,
+	3862, 3864, 3867, 3876, 3881, 3895, 3899, 3903,
+	3918, 3924, 3927, 3930, 3932, 3937, 3943, 3947,
+	3955, 3961, 3971, 3974, 3977, 3982, 3986, 3989,
+	3992, 3995, 3999, 4004, 4008, 4012, 4015, 4020,
+	4025, 4028, 4034, 4038, 4044, 4049, 4053, 4057,
+	4065, 4068, 4076, 4082, 4092, 4103, 4106, 4109,
+	4111, 4115, 4117, 4120, 4131, 4135, 4138, 4141,
+	4144, 4147, 4149, 4153, 4157, 4160, 4164, 4169,
+	4172, 4182, 4184, 4225, 4231, 4235, 4238, 4241,
+	4245, 4248, 4252, 4256, 4261, 4263, 4267, 4271,
+	4274, 4277, 4282, 4291, 4295, 4300, 4305, 4309,
+	4316, 4320, 4323, 4327, 4330, 4335, 4338, 4341,
+	4371, 4375, 4379, 4383, 4387, 4392, 4396, 4402,
+	4406, 4414, 4417, 4422, 4426, 4429, 4434, 4437,
+	4441, 4444, 4447, 4450, 4453, 4456, 4460, 4464,
+	4467, 4477, 4480, 4483, 4488, 4494, 4497, 4512,
+	4515, 4519, 4525, 4529, 4533, 4536, 4540, 4547,
+	4550, 4553, 4559, 4562, 4566, 4571, 4587, 4589,
+	4597, 4599, 4607, 4613, 4615, 4619, 4622, 4625,
+	4628, 4632, 4643, 4646, 4658, 4682, 4690, 4692,
+	4696, 4699, 4704, 4707, 4709, 4714, 4717, 4723,
+	4726, 4734, 4736, 4738, 4740, 4742, 4744, 4746,
+	4748, 4750, 4752, 4755, 4758, 4760, 4762, 4764,
+	4766, 4769, 4772, 4777, 4781, 4782, 4784, 4786,
+	4792, 4797, 4802, 4804, 4807, 4809, 4812, 4816,
+	4822, 4825, 4828, 4834, 4836, 4838, 4840, 4843,
+	4876, 4878, 4880, 4883, 4886, 4889, 4897, 4905,
+	4916, 4924, 4933, 4941, 4950, 4959, 4971, 4978,
+	4985, 4993, 5001, 5010, 5016, 5024, 5030, 5038,
+	5040, 5043, 5057, 5063, 5071, 5075, 5079, 5081,
+	5128, 5130, 5133, 5135, 5140, 5146, 5152, 5157,
+	5160, 5164, 5167, 5170, 5172, 5175, 5178, 5181,
+	5185, 5190, 5195, 5199, 5201, 5204, 5206, 5210,
+	5213, 5216, 5219, 5222, 5226, 5231, 5235, 5237,
+	5239, 5242, 5244, 5248, 5251, 5254, 5262, 5266,
+	5274, 5290, 5292, 5297, 5299, 5303, 5314, 5318,
+	5320, 5323, 5325, 5328, 5333, 5337, 5343, 5349,
+	5360, 5365, 5368, 5371, 5374, 5377, 5379, 5383,
+	5384, 5387, 5389, 5419, 5421, 5423, 5426, 5430,
+	5433, 5437, 5439, 5441, 5443, 5449, 5452, 5455,
+	5459, 5461, 5466, 5471, 5478, 5481, 5485, 5489,
+	5491, 5494, 5514, 5516, 5518, 5525, 5529, 5531,
+	5533, 5535, 5538, 5542, 5546, 5548, 5552, 5555,
+	5557, 5562, 5580, 5619, 5625, 5628, 5630, 5632,
+	5634, 5637, 5640, 5643, 5646, 5649, 5653, 5656,
+	5659, 5662, 5664, 5666, 5669, 5676, 5679, 5681,
+	5684, 5687, 5690, 5698, 5700, 5702, 5705, 5707,
+	5710, 5712, 5714, 5744, 5747, 5750, 5753, 5756,
+	5761, 5765, 5772, 5775, 5784, 5793, 5796, 5800,
+	5803, 5806, 5810, 5812, 5816, 5818, 5821, 5823,
+	5827, 5831, 5835, 5843, 5845, 5847, 5851, 5855,
+	5857, 5870, 5872, 5875, 5878, 5883, 5885, 5888,
+	5890, 5892, 5895, 5900, 5902, 5904, 5909, 5911,
+	5914, 5918, 5938, 5942, 5946, 5948, 5950, 5958,
+	5960, 5967, 5972, 5974, 5978, 5981, 5984, 5987,
+	5991, 5994, 5997, 6001, 6011, 6017, 6020, 6023,
+	6033, 6053, 6059, 6062, 6064, 6068, 6070, 6073,
+	6075, 6079, 6081, 6083, 6087, 6089, 6091, 6097,
+	6100, 6105, 6110, 6116, 6126, 6134, 6146, 6153,
+	6163, 6169, 6181, 6187, 6205, 6208, 6216, 6222,
+	6232, 6239, 6246, 6254, 6262, 6265, 6270, 6290,
+	6296, 6299, 6303, 6307, 6311, 6323, 6326, 6331,
+	6332, 6338, 6345, 6351, 6354, 6357, 6361, 6365,
+	6368, 6371, 6376, 6380, 6386, 6392, 6395, 6399,
+	6402, 6405, 6410, 6413, 6416, 6422, 6426, 6429,
+	6433, 6436, 6439, 6443, 6447, 6454, 6457, 6460,
+	6466, 6469, 6476, 6478, 6480, 6483, 6492, 6497,
+	6511, 6515, 6519, 6534, 6540, 6543, 6546, 6548,
+	6553, 6559, 6563, 6571, 6577, 6587, 6590, 6593,
+	6598, 6602, 6605, 6608, 6611, 6615, 6620, 6624,
+	6628, 6631, 6636, 6641, 6644, 6650, 6654, 6660,
+	6665, 6669, 6673, 6681, 6684, 6692, 6698, 6708,
+	6719, 6722, 6725, 6727, 6731, 6733, 6736, 6747,
+	6751, 6754, 6757, 6760, 6763, 6765, 6769, 6773,
+	6776, 6780, 6785, 6788, 6798, 6800, 6841, 6847,
+	6851, 6854, 6857, 6861, 6864, 6868, 6872, 6877,
+	6879, 6883, 6887, 6890, 6893, 6898, 6907, 6911,
+	6916, 6921, 6925, 6932, 6936, 6939, 6943, 6946,
+	6951, 6954, 6957, 6987, 6991, 6995, 6999, 7003,
+	7008, 7012, 7018, 7022, 7030, 7033, 7038, 7042,
+	7045, 7050, 7053, 7057, 7060, 7063, 7066, 7069,
+	7072, 7076, 7080, 7083, 7093, 7096, 7099, 7104,
+	7110, 7113, 7128, 7131, 7135, 7141, 7145, 7149,
+	7152, 7156, 7163, 7166, 7169, 7175, 7178, 7182,
+	7187, 7203, 7205, 7213, 7215, 7223, 7229, 7231,
+	7235, 7238, 7241, 7244, 7248, 7259, 7262, 7274,
+	7298, 7306, 7308, 7312, 7315, 7320, 7323, 7325,
+	7330, 7333, 7339, 7342, 7407, 7410, 7412, 7414,
+	7416, 7418, 7420, 7423, 7428, 7431, 7434, 7436,
+	7476, 7478, 7480, 7482, 7487, 7491, 7492, 7494,
+	7496, 7503, 7510, 7517, 7519, 7521, 7523, 7526,
+	7529, 7535, 7538, 7543, 7550, 7555, 7558, 7562,
+	7569, 7601, 7650, 7665, 7678, 7683, 7685, 7689,
+	7720, 7726, 7728, 7749, 7769, 7771, 7783, 7794,
+	7797, 7800, 7801, 7803, 7805, 7807, 7810, 7812,
+	7820, 7822, 7824, 7826, 7836, 7845, 7848, 7852,
+	7856, 7859, 7861, 7863, 7865, 7867, 7869, 7879,
+	7888, 7891, 7895, 7899, 7902, 7904, 7906, 7908,
+	7910, 7912, 7954, 7994, 7996, 8001, 8005, 8006,
+	8008, 8010, 8017, 8024, 8031, 8033, 8035, 8037,
+	8040, 8043, 8049, 8052, 8057, 8064, 8069, 8072,
+	8076, 8083, 8115, 8164, 8179, 8192, 8197, 8199,
+	8203, 8234, 8240, 8242, 8263, 8283,
+}
+
+var _hcltok_indicies []int16 = []int16{
+	1, 0, 3, 2, 3, 4, 2, 6,
+	8, 8, 7, 5, 9, 9, 7, 5,
+	7, 5, 10, 11, 12, 13, 15, 16,
+	17, 18, 19, 20, 21, 22, 23, 24,
+	25, 26, 27, 28, 29, 30, 31, 32,
+	33, 34, 35, 36, 37, 39, 40, 41,
+	42, 43, 11, 11, 14, 14, 38, 0,
+	11, 12, 13, 15, 16, 17, 18, 19,
+	20, 21, 22, 23, 24, 25, 26, 27,
+	28, 29, 30, 31, 32, 33, 34, 35,
+	36, 37, 39, 40, 41, 42, 43, 11,
+	11, 14, 14, 38, 0, 44, 45, 11,
+	11, 46, 13, 15, 16, 17, 16, 47,
+	48, 20, 49, 22, 23, 50, 51, 52,
+	53, 54, 55, 56, 57, 58, 59, 60,
+	61, 62, 37, 39, 63, 41, 64, 65,
+	66, 11, 11, 11, 14, 38, 0, 44,
+	0, 11, 11, 11, 11, 0, 11, 11,
+	11, 0, 11, 0, 11, 11, 0, 0,
+	0, 0, 0, 0, 11, 0, 0, 0,
+	0, 11, 11, 11, 11, 11, 0, 0,
+	11, 0, 0, 11, 0, 11, 0, 0,
+	11, 0, 0, 0, 11, 11, 11, 11,
+	11, 11, 0, 11, 11, 0, 11, 11,
+	0, 0, 0, 0, 0, 0, 11, 11,
+	0, 0, 11, 0, 11, 11, 11, 0,
+	67, 68, 69, 70, 14, 71, 72, 73,
+	74, 75, 76, 77, 78, 79, 80, 81,
+	82, 83, 84, 85, 86, 87, 88, 89,
+	90, 91, 92, 93, 94, 95, 96, 97,
+	0, 11, 0, 11, 0, 11, 11, 0,
+	11, 11, 0, 0, 0, 11, 0, 0,
+	0, 0, 0, 0, 0, 11, 0, 0,
+	0, 0, 0, 0, 0, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	11, 0, 0, 0, 0, 0, 0, 0,
+	0, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 0, 11, 11, 11, 11, 11,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 0,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 0, 0, 0,
+	0, 0, 0, 0, 0, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 0, 0, 0, 0,
+	0, 0, 0, 0, 11, 11, 11, 11,
+	11, 11, 0, 11, 11, 11, 11, 11,
+	11, 11, 0, 11, 0, 11, 11, 0,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 11, 11, 0, 11, 11, 11, 0,
+	11, 11, 11, 0, 11, 0, 98, 99,
+	100, 101, 102, 103, 104, 105, 106, 107,
+	108, 109, 110, 111, 112, 113, 114, 16,
+	115, 116, 117, 118, 119, 120, 121, 122,
+	123, 124, 125, 126, 127, 128, 129, 130,
+	131, 132, 14, 15, 133, 134, 135, 136,
+	137, 14, 16, 14, 0, 11, 0, 11,
+	11, 0, 0, 11, 0, 0, 0, 0,
+	11, 0, 0, 0, 0, 0, 11, 0,
+	0, 0, 0, 0, 11, 11, 11, 11,
+	11, 0, 0, 0, 11, 0, 0, 0,
+	11, 11, 11, 0, 0, 0, 11, 11,
+	0, 0, 0, 11, 11, 11, 0, 0,
+	0, 11, 11, 11, 11, 0, 11, 11,
+	11, 11, 0, 0, 0, 0, 0, 11,
+	11, 11, 11, 0, 0, 11, 11, 11,
+	0, 0, 11, 11, 11, 11, 0, 11,
+	11, 0, 11, 11, 0, 0, 0, 11,
+	11, 11, 0, 0, 0, 0, 11, 11,
+	11, 11, 11, 0, 0, 0, 0, 11,
+	0, 11, 11, 0, 11, 11, 0, 11,
+	0, 11, 11, 11, 0, 11, 11, 0,
+	0, 0, 11, 0, 0, 0, 0, 0,
+	0, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 11, 0, 138,
+	139, 140, 141, 142, 143, 144, 145, 146,
+	14, 147, 148, 149, 150, 151, 0, 11,
+	0, 0, 0, 0, 0, 11, 11, 0,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 0, 0, 11, 11, 11, 0,
+	0, 11, 0, 0, 11, 11, 11, 11,
+	11, 0, 0, 0, 0, 11, 11, 11,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 0, 152, 109, 153, 154, 155, 14,
+	156, 157, 16, 14, 0, 11, 11, 11,
+	11, 0, 0, 0, 11, 0, 0, 11,
+	11, 11, 0, 0, 0, 11, 11, 0,
+	119, 0, 16, 14, 14, 158, 0, 14,
+	0, 11, 16, 159, 160, 16, 161, 162,
+	16, 57, 163, 164, 165, 166, 167, 16,
+	168, 169, 170, 16, 171, 172, 173, 15,
+	174, 175, 176, 15, 177, 16, 14, 0,
+	0, 11, 11, 0, 0, 0, 11, 11,
+	11, 11, 0, 11, 11, 0, 0, 0,
+	0, 11, 11, 0, 0, 11, 11, 0,
+	0, 0, 0, 0, 0, 11, 11, 11,
+	0, 0, 0, 11, 0, 0, 0, 11,
+	11, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 0, 11, 11, 11, 11,
+	11, 11, 0, 0, 0, 11, 11, 11,
+	11, 0, 178, 179, 0, 14, 0, 11,
+	0, 0, 11, 16, 180, 181, 182, 183,
+	57, 184, 185, 55, 186, 187, 188, 189,
+	190, 191, 192, 193, 194, 14, 0, 0,
+	11, 0, 11, 11, 11, 11, 11, 11,
+	11, 0, 11, 11, 11, 0, 11, 0,
+	0, 11, 0, 11, 0, 0, 11, 11,
+	11, 11, 0, 11, 11, 11, 0, 0,
+	11, 11, 11, 11, 0, 11, 11, 0,
+	0, 11, 11, 11, 11, 11, 0, 195,
+	196, 197, 198, 199, 200, 201, 202, 203,
+	204, 205, 201, 206, 207, 208, 209, 38,
+	0, 210, 211, 16, 212, 213, 214, 215,
+	216, 217, 218, 219, 220, 16, 14, 221,
+	222, 223, 224, 16, 225, 226, 227, 228,
+	229, 230, 231, 232, 233, 234, 235, 236,
+	237, 238, 239, 16, 144, 14, 240, 0,
+	11, 11, 11, 11, 11, 0, 0, 0,
+	11, 0, 11, 11, 0, 11, 0, 11,
+	11, 0, 0, 0, 11, 11, 11, 0,
+	0, 0, 11, 11, 11, 0, 0, 0,
+	0, 11, 0, 0, 11, 0, 0, 11,
+	11, 11, 0, 0, 11, 0, 11, 11,
+	11, 0, 11, 11, 11, 11, 11, 11,
+	0, 0, 0, 11, 11, 0, 11, 11,
+	0, 11, 11, 0, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	0, 11, 0, 11, 11, 0, 11, 0,
+	11, 11, 0, 11, 0, 11, 0, 241,
+	212, 242, 243, 244, 245, 246, 247, 248,
+	249, 250, 98, 251, 16, 252, 253, 254,
+	16, 255, 129, 256, 257, 258, 259, 260,
+	261, 262, 263, 16, 0, 0, 0, 11,
+	11, 11, 0, 11, 11, 0, 11, 11,
+	0, 0, 0, 0, 0, 11, 11, 11,
+	11, 0, 11, 11, 11, 11, 11, 11,
+	0, 0, 0, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 0, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	0, 0, 0, 0, 11, 11, 11, 0,
+	0, 0, 11, 0, 0, 0, 11, 11,
+	0, 11, 11, 11, 0, 11, 0, 0,
+	0, 11, 11, 0, 11, 11, 11, 0,
+	11, 11, 11, 0, 0, 0, 0, 11,
+	16, 181, 264, 265, 14, 16, 14, 0,
+	0, 11, 0, 11, 16, 264, 14, 0,
+	16, 266, 14, 0, 0, 11, 16, 267,
+	268, 269, 172, 270, 271, 16, 272, 273,
+	274, 14, 0, 0, 11, 11, 11, 0,
+	11, 11, 0, 11, 11, 11, 11, 0,
+	0, 11, 0, 0, 11, 11, 0, 11,
+	0, 16, 14, 0, 275, 16, 276, 0,
+	14, 0, 11, 0, 11, 277, 16, 278,
+	279, 0, 11, 0, 0, 0, 11, 11,
+	11, 11, 0, 280, 281, 282, 16, 283,
+	284, 285, 286, 287, 288, 289, 290, 291,
+	292, 293, 294, 295, 296, 14, 0, 11,
+	11, 11, 0, 0, 0, 0, 11, 11,
+	0, 0, 11, 0, 0, 0, 0, 0,
+	0, 0, 11, 0, 11, 0, 0, 0,
+	0, 0, 0, 11, 11, 11, 11, 11,
+	0, 0, 11, 0, 0, 0, 11, 0,
+	0, 11, 0, 0, 11, 0, 0, 11,
+	0, 0, 0, 11, 11, 11, 0, 0,
+	0, 11, 11, 11, 11, 0, 297, 16,
+	298, 16, 299, 300, 301, 302, 14, 0,
+	11, 11, 11, 11, 11, 0, 0, 0,
+	11, 0, 0, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 11,
+	11, 0, 11, 11, 11, 11, 11, 0,
+	303, 16, 14, 0, 11, 304, 16, 100,
+	14, 0, 11, 305, 0, 14, 0, 11,
+	16, 306, 14, 0, 0, 11, 307, 0,
+	16, 308, 14, 0, 0, 11, 11, 11,
+	11, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 0, 0, 11, 0,
+	11, 11, 11, 0, 11, 0, 11, 11,
+	11, 0, 0, 0, 0, 0, 0, 0,
+	11, 11, 11, 0, 11, 0, 0, 0,
+	11, 11, 11, 11, 0, 309, 310, 69,
+	311, 312, 313, 314, 315, 316, 317, 318,
+	319, 320, 321, 322, 323, 324, 325, 326,
+	327, 328, 329, 331, 332, 333, 334, 335,
+	336, 330, 0, 11, 11, 11, 11, 0,
+	11, 0, 11, 11, 0, 11, 11, 11,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 0, 11, 11, 11, 11, 11,
+	11, 11, 0, 11, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 11, 0, 11,
+	11, 11, 0, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 0, 11, 0,
+	11, 11, 11, 11, 11, 0, 11, 11,
+	0, 11, 11, 11, 11, 11, 11, 11,
+	0, 11, 11, 11, 0, 11, 11, 11,
+	11, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 11, 0, 11, 0, 11, 11,
+	0, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 11, 11, 11, 0,
+	11, 11, 11, 0, 11, 0, 11, 11,
+	0, 11, 0, 337, 338, 339, 101, 102,
+	103, 104, 105, 340, 107, 108, 109, 110,
+	111, 112, 341, 342, 167, 343, 258, 117,
+	344, 119, 229, 269, 122, 345, 346, 347,
+	348, 349, 350, 351, 352, 353, 354, 131,
+	355, 16, 14, 15, 16, 134, 135, 136,
+	137, 14, 14, 0, 11, 11, 0, 11,
+	11, 11, 11, 11, 11, 0, 0, 0,
+	11, 0, 11, 11, 11, 11, 0, 11,
+	11, 11, 0, 11, 11, 0, 11, 11,
+	11, 0, 0, 11, 11, 11, 0, 0,
+	11, 11, 0, 11, 0, 11, 0, 11,
+	11, 11, 0, 0, 11, 11, 0, 11,
+	11, 0, 11, 11, 11, 0, 356, 140,
+	142, 143, 144, 145, 146, 14, 357, 148,
+	358, 150, 359, 0, 11, 11, 0, 0,
+	0, 0, 11, 0, 0, 11, 11, 11,
+	11, 11, 0, 360, 109, 361, 154, 155,
+	14, 156, 157, 16, 14, 0, 11, 11,
+	11, 11, 0, 0, 0, 11, 16, 159,
+	160, 16, 362, 363, 219, 308, 163, 164,
+	165, 364, 167, 365, 366, 367, 368, 369,
+	370, 371, 372, 373, 374, 175, 176, 15,
+	375, 16, 14, 0, 0, 0, 0, 11,
+	11, 11, 0, 0, 0, 0, 0, 11,
+	11, 0, 11, 11, 11, 0, 11, 11,
+	0, 0, 0, 11, 11, 0, 11, 11,
+	11, 11, 0, 11, 0, 11, 11, 11,
+	11, 11, 0, 0, 0, 0, 0, 11,
+	11, 11, 11, 11, 11, 0, 11, 0,
+	16, 180, 181, 376, 183, 57, 184, 185,
+	55, 186, 187, 377, 14, 190, 378, 192,
+	193, 194, 14, 0, 11, 11, 11, 11,
+	11, 11, 11, 0, 11, 11, 0, 11,
+	0, 379, 380, 197, 198, 199, 381, 201,
+	202, 382, 383, 384, 201, 206, 207, 208,
+	209, 38, 0, 210, 211, 16, 212, 213,
+	215, 385, 217, 386, 219, 220, 16, 14,
+	387, 222, 223, 224, 16, 225, 226, 227,
+	228, 229, 230, 231, 232, 388, 234, 235,
+	389, 237, 238, 239, 16, 144, 14, 240,
+	0, 0, 11, 0, 0, 11, 0, 11,
+	11, 11, 11, 11, 0, 11, 11, 0,
+	390, 391, 392, 393, 394, 395, 396, 397,
+	247, 398, 319, 399, 213, 400, 401, 402,
+	403, 404, 401, 405, 406, 407, 258, 408,
+	260, 409, 410, 271, 0, 11, 0, 11,
+	0, 11, 0, 11, 0, 11, 11, 0,
+	11, 0, 11, 11, 11, 0, 11, 11,
+	0, 0, 11, 11, 11, 0, 11, 0,
+	11, 0, 11, 11, 0, 11, 0, 11,
+	0, 11, 0, 11, 0, 11, 0, 0,
+	0, 11, 11, 11, 0, 11, 11, 0,
+	16, 267, 229, 411, 401, 412, 271, 16,
+	413, 414, 274, 14, 0, 11, 0, 11,
+	11, 11, 0, 0, 0, 11, 11, 0,
+	277, 16, 278, 415, 0, 11, 11, 0,
+	16, 283, 284, 285, 286, 287, 288, 289,
+	290, 291, 292, 416, 14, 0, 0, 0,
+	11, 16, 417, 16, 265, 300, 301, 302,
+	14, 0, 0, 11, 419, 419, 419, 419,
+	418, 419, 419, 419, 418, 419, 418, 419,
+	419, 418, 418, 418, 418, 418, 418, 419,
+	418, 418, 418, 418, 419, 419, 419, 419,
+	419, 418, 418, 419, 418, 418, 419, 418,
+	419, 418, 418, 419, 418, 418, 418, 419,
+	419, 419, 419, 419, 419, 418, 419, 419,
+	418, 419, 419, 418, 418, 418, 418, 418,
+	418, 419, 419, 418, 418, 419, 418, 419,
+	419, 419, 418, 421, 422, 423, 424, 425,
+	426, 427, 428, 429, 430, 431, 432, 433,
+	434, 435, 436, 437, 438, 439, 440, 441,
+	442, 443, 444, 445, 446, 447, 448, 449,
+	450, 451, 452, 418, 419, 418, 419, 418,
+	419, 419, 418, 419, 419, 418, 418, 418,
+	419, 418, 418, 418, 418, 418, 418, 418,
+	419, 418, 418, 418, 418, 418, 418, 418,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 418, 418, 418, 418, 418,
+	418, 418, 418, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 418, 418, 418, 418,
+	418, 418, 418, 418, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 418, 419, 419,
+	419, 419, 419, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 418, 419, 419, 419, 419, 419,
+	419, 418, 419, 419, 419, 419, 419, 419,
+	418, 418, 418, 418, 418, 418, 418, 418,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	418, 419, 419, 419, 419, 419, 419, 419,
+	419, 418, 419, 419, 419, 419, 419, 418,
+	418, 418, 418, 418, 418, 418, 418, 419,
+	419, 419, 419, 419, 419, 418, 419, 419,
+	419, 419, 419, 419, 419, 418, 419, 418,
+	419, 419, 418, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	418, 419, 419, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 419, 419, 418, 419,
+	419, 419, 418, 419, 419, 419, 418, 419,
+	418, 453, 454, 455, 456, 457, 458, 459,
+	460, 461, 462, 463, 464, 465, 466, 467,
+	468, 469, 470, 471, 472, 473, 474, 475,
+	476, 477, 478, 479, 480, 481, 482, 483,
+	484, 485, 486, 487, 488, 425, 489, 490,
+	491, 492, 493, 494, 425, 470, 425, 418,
+	419, 418, 419, 419, 418, 418, 419, 418,
+	418, 418, 418, 419, 418, 418, 418, 418,
+	418, 419, 418, 418, 418, 418, 418, 419,
+	419, 419, 419, 419, 418, 418, 418, 419,
+	418, 418, 418, 419, 419, 419, 418, 418,
+	418, 419, 419, 418, 418, 418, 419, 419,
+	419, 418, 418, 418, 419, 419, 419, 419,
+	418, 419, 419, 419, 419, 418, 418, 418,
+	418, 418, 419, 419, 419, 419, 418, 418,
+	419, 419, 419, 418, 418, 419, 419, 419,
+	419, 418, 419, 419, 418, 419, 419, 418,
+	418, 418, 419, 419, 419, 418, 418, 418,
+	418, 419, 419, 419, 419, 419, 418, 418,
+	418, 418, 419, 418, 419, 419, 418, 419,
+	419, 418, 419, 418, 419, 419, 419, 418,
+	419, 419, 418, 418, 418, 419, 418, 418,
+	418, 418, 418, 418, 418, 419, 419, 419,
+	419, 418, 419, 419, 419, 419, 419, 419,
+	419, 418, 495, 496, 497, 498, 499, 500,
+	501, 502, 503, 425, 504, 505, 506, 507,
+	508, 418, 419, 418, 418, 418, 418, 418,
+	419, 419, 418, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 418, 419, 419, 419, 418, 418, 419,
+	419, 419, 418, 418, 419, 418, 418, 419,
+	419, 419, 419, 419, 418, 418, 418, 418,
+	419, 419, 419, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 418, 509, 464, 510,
+	511, 512, 425, 513, 514, 470, 425, 418,
+	419, 419, 419, 419, 418, 418, 418, 419,
+	418, 418, 419, 419, 419, 418, 418, 418,
+	419, 419, 418, 475, 418, 470, 425, 425,
+	515, 418, 425, 418, 419, 470, 516, 517,
+	470, 518, 519, 470, 520, 521, 522, 523,
+	524, 525, 470, 526, 527, 528, 470, 529,
+	530, 531, 489, 532, 533, 534, 489, 535,
+	470, 425, 418, 418, 419, 419, 418, 418,
+	418, 419, 419, 419, 419, 418, 419, 419,
+	418, 418, 418, 418, 419, 419, 418, 418,
+	419, 419, 418, 418, 418, 418, 418, 418,
+	419, 419, 419, 418, 418, 418, 419, 418,
+	418, 418, 419, 419, 418, 419, 419, 419,
+	419, 418, 419, 419, 419, 419, 418, 419,
+	419, 419, 419, 419, 419, 418, 418, 418,
+	419, 419, 419, 419, 418, 536, 537, 418,
+	425, 418, 419, 418, 418, 419, 470, 538,
+	539, 540, 541, 520, 542, 543, 544, 545,
+	546, 547, 548, 549, 550, 551, 552, 553,
+	425, 418, 418, 419, 418, 419, 419, 419,
+	419, 419, 419, 419, 418, 419, 419, 419,
+	418, 419, 418, 418, 419, 418, 419, 418,
+	418, 419, 419, 419, 419, 418, 419, 419,
+	419, 418, 418, 419, 419, 419, 419, 418,
+	419, 419, 418, 418, 419, 419, 419, 419,
+	419, 418, 554, 555, 556, 557, 558, 559,
+	560, 561, 562, 563, 564, 560, 566, 567,
+	568, 569, 565, 418, 570, 571, 470, 572,
+	573, 574, 575, 576, 577, 578, 579, 580,
+	470, 425, 581, 582, 583, 584, 470, 585,
+	586, 587, 588, 589, 590, 591, 592, 593,
+	594, 595, 596, 597, 598, 599, 470, 501,
+	425, 600, 418, 419, 419, 419, 419, 419,
+	418, 418, 418, 419, 418, 419, 419, 418,
+	419, 418, 419, 419, 418, 418, 418, 419,
+	419, 419, 418, 418, 418, 419, 419, 419,
+	418, 418, 418, 418, 419, 418, 418, 419,
+	418, 418, 419, 419, 419, 418, 418, 419,
+	418, 419, 419, 419, 418, 419, 419, 419,
+	419, 419, 419, 418, 418, 418, 419, 419,
+	418, 419, 419, 418, 419, 419, 418, 419,
+	419, 418, 419, 419, 419, 419, 419, 419,
+	419, 418, 419, 418, 419, 418, 419, 419,
+	418, 419, 418, 419, 419, 418, 419, 418,
+	419, 418, 601, 572, 602, 603, 604, 605,
+	606, 607, 608, 609, 610, 453, 611, 470,
+	612, 613, 614, 470, 615, 485, 616, 617,
+	618, 619, 620, 621, 622, 623, 470, 418,
+	418, 418, 419, 419, 419, 418, 419, 419,
+	418, 419, 419, 418, 418, 418, 418, 418,
+	419, 419, 419, 419, 418, 419, 419, 419,
+	419, 419, 419, 418, 418, 418, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 418,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	418, 419, 419, 418, 418, 418, 418, 419,
+	419, 419, 418, 418, 418, 419, 418, 418,
+	418, 419, 419, 418, 419, 419, 419, 418,
+	419, 418, 418, 418, 419, 419, 418, 419,
+	419, 419, 418, 419, 419, 419, 418, 418,
+	418, 418, 419, 470, 539, 624, 625, 425,
+	470, 425, 418, 418, 419, 418, 419, 470,
+	624, 425, 418, 470, 626, 425, 418, 418,
+	419, 470, 627, 628, 629, 530, 630, 631,
+	470, 632, 633, 634, 425, 418, 418, 419,
+	419, 419, 418, 419, 419, 418, 419, 419,
+	419, 419, 418, 418, 419, 418, 418, 419,
+	419, 418, 419, 418, 470, 425, 418, 635,
+	470, 636, 418, 425, 418, 419, 418, 419,
+	637, 470, 638, 639, 418, 419, 418, 418,
+	418, 419, 419, 419, 419, 418, 640, 641,
+	642, 470, 643, 644, 645, 646, 647, 648,
+	649, 650, 651, 652, 653, 654, 655, 656,
+	425, 418, 419, 419, 419, 418, 418, 418,
+	418, 419, 419, 418, 418, 419, 418, 418,
+	418, 418, 418, 418, 418, 419, 418, 419,
+	418, 418, 418, 418, 418, 418, 419, 419,
+	419, 419, 419, 418, 418, 419, 418, 418,
+	418, 419, 418, 418, 419, 418, 418, 419,
+	418, 418, 419, 418, 418, 418, 419, 419,
+	419, 418, 418, 418, 419, 419, 419, 419,
+	418, 657, 470, 658, 470, 659, 660, 661,
+	662, 425, 418, 419, 419, 419, 419, 419,
+	418, 418, 418, 419, 418, 418, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	418, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 418, 419, 419, 419,
+	419, 419, 418, 663, 470, 425, 418, 419,
+	664, 470, 455, 425, 418, 419, 665, 418,
+	425, 418, 419, 470, 666, 425, 418, 418,
+	419, 667, 418, 470, 668, 425, 418, 418,
+	419, 670, 669, 419, 419, 419, 419, 670,
+	669, 419, 670, 669, 670, 670, 419, 670,
+	669, 419, 670, 419, 670, 669, 419, 670,
+	419, 670, 419, 669, 670, 670, 670, 670,
+	670, 670, 670, 670, 669, 419, 419, 670,
+	670, 419, 670, 419, 670, 669, 670, 670,
+	670, 670, 670, 419, 670, 419, 670, 419,
+	670, 669, 670, 670, 419, 670, 419, 670,
+	669, 670, 670, 670, 670, 670, 419, 670,
+	419, 670, 669, 419, 419, 670, 419, 670,
+	669, 670, 670, 670, 419, 670, 419, 670,
+	419, 670, 419, 670, 669, 670, 419, 670,
+	419, 670, 669, 419, 670, 670, 670, 670,
+	419, 670, 419, 670, 419, 670, 419, 670,
+	419, 670, 419, 670, 669, 419, 670, 669,
+	670, 670, 670, 419, 670, 419, 670, 669,
+	670, 419, 670, 419, 670, 669, 419, 670,
+	670, 670, 670, 419, 670, 419, 670, 669,
+	419, 670, 419, 670, 419, 670, 669, 670,
+	670, 419, 670, 419, 670, 669, 419, 670,
+	419, 670, 419, 670, 419, 669, 670, 670,
+	670, 419, 670, 419, 670, 669, 419, 670,
+	669, 670, 670, 419, 670, 669, 670, 670,
+	670, 419, 670, 670, 670, 670, 670, 670,
+	419, 419, 670, 419, 670, 419, 670, 419,
+	670, 669, 670, 419, 670, 419, 670, 669,
+	419, 670, 669, 670, 419, 670, 669, 670,
+	419, 670, 669, 419, 419, 670, 669, 419,
+	670, 419, 670, 419, 670, 419, 670, 419,
+	670, 419, 669, 670, 670, 419, 670, 670,
+	670, 670, 419, 419, 670, 670, 670, 670,
+	670, 419, 670, 670, 670, 670, 670, 669,
+	419, 670, 670, 419, 670, 419, 669, 670,
+	670, 419, 670, 669, 419, 419, 670, 419,
+	669, 670, 670, 669, 419, 670, 419, 669,
+	670, 669, 419, 670, 419, 670, 419, 669,
+	670, 670, 669, 419, 670, 419, 670, 419,
+	670, 669, 670, 419, 670, 419, 670, 669,
+	419, 670, 669, 419, 419, 670, 669, 670,
+	419, 669, 670, 669, 419, 670, 419, 670,
+	419, 669, 670, 669, 419, 419, 670, 669,
+	670, 419, 670, 419, 670, 669, 419, 670,
+	419, 669, 670, 669, 419, 419, 670, 419,
+	669, 670, 669, 419, 419, 670, 669, 670,
+	419, 670, 669, 670, 419, 670, 669, 670,
+	419, 670, 419, 670, 419, 669, 670, 669,
+	419, 419, 670, 669, 670, 419, 670, 419,
+	670, 669, 419, 670, 669, 670, 670, 419,
+	670, 419, 670, 669, 669, 419, 669, 419,
+	670, 670, 419, 670, 670, 670, 670, 670,
+	670, 670, 669, 419, 670, 670, 670, 419,
+	669, 670, 670, 670, 419, 670, 419, 670,
+	419, 670, 419, 670, 419, 670, 669, 419,
+	419, 670, 669, 670, 419, 670, 669, 419,
+	419, 670, 419, 419, 419, 670, 419, 670,
+	419, 670, 419, 670, 419, 669, 419, 670,
+	419, 670, 419, 669, 670, 669, 419, 670,
+	419, 669, 670, 419, 670, 670, 670, 669,
+	419, 670, 419, 419, 670, 419, 669, 670,
+	670, 669, 419, 670, 670, 670, 670, 419,
+	670, 419, 669, 670, 670, 670, 419, 670,
+	669, 670, 419, 670, 419, 670, 419, 670,
+	419, 670, 669, 670, 670, 419, 670, 669,
+	419, 670, 419, 670, 419, 669, 670, 670,
+	669, 419, 670, 419, 669, 670, 669, 419,
+	670, 669, 419, 670, 419, 670, 669, 670,
+	670, 670, 669, 419, 419, 419, 670, 669,
+	419, 670, 419, 669, 670, 669, 419, 670,
+	419, 670, 419, 669, 670, 670, 670, 669,
+	419, 670, 419, 669, 670, 670, 670, 670,
+	669, 419, 670, 419, 670, 669, 419, 419,
+	670, 419, 670, 669, 670, 419, 670, 419,
+	669, 670, 670, 669, 419, 670, 419, 670,
+	669, 419, 670, 670, 670, 419, 670, 419,
+	669, 419, 670, 669, 670, 419, 419, 670,
+	419, 670, 419, 669, 670, 670, 670, 670,
+	669, 419, 670, 419, 670, 419, 670, 419,
+	670, 419, 670, 669, 670, 670, 670, 419,
+	670, 419, 670, 419, 670, 419, 669, 670,
+	670, 419, 419, 670, 669, 670, 419, 670,
+	670, 669, 419, 670, 419, 670, 669, 419,
+	419, 670, 670, 670, 670, 419, 670, 419,
+	670, 419, 669, 670, 670, 419, 669, 670,
+	669, 419, 670, 419, 669, 670, 669, 419,
+	670, 419, 669, 670, 419, 670, 670, 669,
+	419, 670, 670, 419, 669, 670, 669, 419,
+	670, 419, 670, 669, 670, 419, 670, 419,
+	669, 670, 669, 419, 670, 419, 670, 419,
+	670, 419, 670, 419, 670, 669, 671, 669,
+	672, 673, 674, 675, 676, 677, 678, 679,
+	680, 681, 682, 674, 683, 684, 685, 686,
+	687, 674, 688, 689, 690, 691, 692, 693,
+	694, 695, 696, 697, 698, 699, 700, 701,
+	702, 674, 703, 671, 683, 671, 704, 671,
+	669, 670, 670, 670, 670, 419, 669, 670,
+	670, 669, 419, 670, 669, 419, 419, 670,
+	669, 419, 670, 419, 669, 670, 669, 419,
+	419, 670, 419, 669, 670, 670, 669, 419,
+	670, 670, 670, 669, 419, 670, 419, 670,
+	670, 669, 419, 419, 670, 419, 669, 670,
+	669, 419, 670, 669, 419, 419, 670, 419,
+	670, 669, 419, 670, 419, 419, 670, 419,
+	670, 419, 669, 670, 670, 669, 419, 670,
+	670, 419, 670, 669, 419, 670, 419, 670,
+	669, 419, 670, 419, 669, 419, 670, 670,
+	670, 419, 670, 669, 670, 419, 670, 669,
+	419, 670, 669, 670, 419, 670, 669, 419,
+	670, 669, 419, 670, 419, 670, 669, 419,
+	670, 669, 419, 670, 669, 705, 706, 707,
+	708, 709, 710, 711, 712, 713, 714, 715,
+	716, 676, 717, 718, 719, 720, 721, 718,
+	722, 723, 724, 725, 726, 727, 728, 729,
+	730, 671, 669, 670, 419, 670, 669, 670,
+	419, 670, 669, 670, 419, 670, 669, 670,
+	419, 670, 669, 419, 670, 419, 670, 669,
+	670, 419, 670, 669, 670, 419, 419, 419,
+	670, 669, 670, 419, 670, 669, 670, 670,
+	670, 670, 419, 670, 419, 669, 670, 669,
+	419, 419, 670, 419, 670, 669, 670, 419,
+	670, 669, 419, 670, 669, 670, 670, 419,
+	670, 669, 419, 670, 669, 670, 419, 670,
+	669, 419, 670, 669, 419, 670, 669, 419,
+	670, 669, 670, 669, 419, 419, 670, 669,
+	670, 419, 670, 669, 419, 670, 419, 669,
+	670, 669, 419, 674, 731, 671, 674, 732,
+	674, 733, 683, 671, 669, 670, 669, 419,
+	670, 669, 419, 674, 732, 683, 671, 669,
+	674, 734, 671, 683, 671, 669, 670, 669,
+	419, 674, 735, 692, 736, 718, 737, 730,
+	674, 738, 739, 740, 671, 683, 671, 669,
+	670, 669, 419, 670, 419, 670, 669, 419,
+	670, 419, 670, 419, 669, 670, 670, 669,
+	419, 670, 419, 670, 669, 419, 670, 669,
+	674, 683, 425, 669, 741, 674, 742, 683,
+	671, 669, 425, 670, 669, 419, 670, 669,
+	419, 743, 674, 744, 745, 671, 669, 419,
+	670, 669, 670, 670, 669, 419, 419, 670,
+	419, 670, 669, 674, 746, 747, 748, 749,
+	750, 751, 752, 753, 754, 755, 756, 671,
+	683, 671, 669, 670, 419, 670, 670, 670,
+	670, 670, 670, 670, 419, 670, 419, 670,
+	670, 670, 670, 670, 670, 669, 419, 670,
+	670, 419, 670, 419, 669, 670, 419, 670,
+	670, 670, 419, 670, 670, 419, 670, 670,
+	419, 670, 670, 419, 670, 670, 669, 419,
+	674, 757, 674, 733, 758, 759, 760, 671,
+	683, 671, 669, 670, 669, 419, 670, 670,
+	670, 419, 670, 670, 670, 419, 670, 419,
+	670, 669, 419, 419, 419, 419, 670, 670,
+	419, 419, 419, 419, 419, 670, 670, 670,
+	670, 670, 670, 670, 419, 670, 419, 670,
+	419, 669, 670, 670, 670, 419, 670, 419,
+	670, 669, 683, 425, 761, 674, 683, 425,
+	670, 669, 419, 762, 674, 763, 683, 425,
+	670, 669, 419, 670, 419, 764, 683, 671,
+	669, 425, 670, 669, 419, 674, 765, 671,
+	683, 671, 669, 670, 669, 419, 766, 766,
+	766, 768, 769, 770, 766, 767, 767, 771,
+	768, 771, 769, 771, 767, 772, 773, 772,
+	775, 774, 776, 774, 777, 774, 779, 778,
+	781, 782, 780, 781, 783, 780, 785, 784,
+	786, 784, 787, 784, 789, 788, 791, 792,
+	790, 791, 793, 790, 795, 795, 795, 795,
+	794, 795, 795, 795, 794, 795, 794, 795,
+	795, 794, 794, 794, 794, 794, 794, 795,
+	794, 794, 794, 794, 795, 795, 795, 795,
+	795, 794, 794, 795, 794, 794, 795, 794,
+	795, 794, 794, 795, 794, 794, 794, 795,
+	795, 795, 795, 795, 795, 794, 795, 795,
+	794, 795, 795, 794, 794, 794, 794, 794,
+	794, 795, 795, 794, 794, 795, 794, 795,
+	795, 795, 794, 797, 798, 799, 800, 801,
+	802, 803, 804, 805, 806, 807, 808, 809,
+	810, 811, 812, 813, 814, 815, 816, 817,
+	818, 819, 820, 821, 822, 823, 824, 825,
+	826, 827, 828, 794, 795, 794, 795, 794,
+	795, 795, 794, 795, 795, 794, 794, 794,
+	795, 794, 794, 794, 794, 794, 794, 794,
+	795, 794, 794, 794, 794, 794, 794, 794,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 794, 794, 794, 794, 794,
+	794, 794, 794, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 794, 794, 794, 794,
+	794, 794, 794, 794, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 794, 795, 795,
+	795, 795, 795, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 794, 795, 795, 795, 795, 795,
+	795, 794, 795, 795, 795, 795, 795, 795,
+	794, 794, 794, 794, 794, 794, 794, 794,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	794, 795, 795, 795, 795, 795, 795, 795,
+	795, 794, 795, 795, 795, 795, 795, 794,
+	794, 794, 794, 794, 794, 794, 794, 795,
+	795, 795, 795, 795, 795, 794, 795, 795,
+	795, 795, 795, 795, 795, 794, 795, 794,
+	795, 795, 794, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	794, 795, 795, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 795, 795, 794, 795,
+	795, 795, 794, 795, 795, 795, 794, 795,
+	794, 829, 830, 831, 832, 833, 834, 835,
+	836, 837, 838, 839, 840, 841, 842, 843,
+	844, 845, 846, 847, 848, 849, 850, 851,
+	852, 853, 854, 855, 856, 857, 858, 859,
+	860, 861, 862, 863, 864, 801, 865, 866,
+	867, 868, 869, 870, 801, 846, 801, 794,
+	795, 794, 795, 795, 794, 794, 795, 794,
+	794, 794, 794, 795, 794, 794, 794, 794,
+	794, 795, 794, 794, 794, 794, 794, 795,
+	795, 795, 795, 795, 794, 794, 794, 795,
+	794, 794, 794, 795, 795, 795, 794, 794,
+	794, 795, 795, 794, 794, 794, 795, 795,
+	795, 794, 794, 794, 795, 795, 795, 795,
+	794, 795, 795, 795, 795, 794, 794, 794,
+	794, 794, 795, 795, 795, 795, 794, 794,
+	795, 795, 795, 794, 794, 795, 795, 795,
+	795, 794, 795, 795, 794, 795, 795, 794,
+	794, 794, 795, 795, 795, 794, 794, 794,
+	794, 795, 795, 795, 795, 795, 794, 794,
+	794, 794, 795, 794, 795, 795, 794, 795,
+	795, 794, 795, 794, 795, 795, 795, 794,
+	795, 795, 794, 794, 794, 795, 794, 794,
+	794, 794, 794, 794, 794, 795, 795, 795,
+	795, 794, 795, 795, 795, 795, 795, 795,
+	795, 794, 871, 872, 873, 874, 875, 876,
+	877, 878, 879, 801, 880, 881, 882, 883,
+	884, 794, 795, 794, 794, 794, 794, 794,
+	795, 795, 794, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 794, 795, 795, 795, 794, 794, 795,
+	795, 795, 794, 794, 795, 794, 794, 795,
+	795, 795, 795, 795, 794, 794, 794, 794,
+	795, 795, 795, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 794, 885, 840, 886,
+	887, 888, 801, 889, 890, 846, 801, 794,
+	795, 795, 795, 795, 794, 794, 794, 795,
+	794, 794, 795, 795, 795, 794, 794, 794,
+	795, 795, 794, 851, 794, 846, 801, 801,
+	891, 794, 801, 794, 795, 846, 892, 893,
+	846, 894, 895, 846, 896, 897, 898, 899,
+	900, 901, 846, 902, 903, 904, 846, 905,
+	906, 907, 865, 908, 909, 910, 865, 911,
+	846, 801, 794, 794, 795, 795, 794, 794,
+	794, 795, 795, 795, 795, 794, 795, 795,
+	794, 794, 794, 794, 795, 795, 794, 794,
+	795, 795, 794, 794, 794, 794, 794, 794,
+	795, 795, 795, 794, 794, 794, 795, 794,
+	794, 794, 795, 795, 794, 795, 795, 795,
+	795, 794, 795, 795, 795, 795, 794, 795,
+	795, 795, 795, 795, 795, 794, 794, 794,
+	795, 795, 795, 795, 794, 912, 913, 794,
+	801, 794, 795, 794, 794, 795, 846, 914,
+	915, 916, 917, 896, 918, 919, 920, 921,
+	922, 923, 924, 925, 926, 927, 928, 929,
+	801, 794, 794, 795, 794, 795, 795, 795,
+	795, 795, 795, 795, 794, 795, 795, 795,
+	794, 795, 794, 794, 795, 794, 795, 794,
+	794, 795, 795, 795, 795, 794, 795, 795,
+	795, 794, 794, 795, 795, 795, 795, 794,
+	795, 795, 794, 794, 795, 795, 795, 795,
+	795, 794, 930, 931, 932, 933, 934, 935,
+	936, 937, 938, 939, 940, 936, 942, 943,
+	944, 945, 941, 794, 946, 947, 846, 948,
+	949, 950, 951, 952, 953, 954, 955, 956,
+	846, 801, 957, 958, 959, 960, 846, 961,
+	962, 963, 964, 965, 966, 967, 968, 969,
+	970, 971, 972, 973, 974, 975, 846, 877,
+	801, 976, 794, 795, 795, 795, 795, 795,
+	794, 794, 794, 795, 794, 795, 795, 794,
+	795, 794, 795, 795, 794, 794, 794, 795,
+	795, 795, 794, 794, 794, 795, 795, 795,
+	794, 794, 794, 794, 795, 794, 794, 795,
+	794, 794, 795, 795, 795, 794, 794, 795,
+	794, 795, 795, 795, 794, 795, 795, 795,
+	795, 795, 795, 794, 794, 794, 795, 795,
+	794, 795, 795, 794, 795, 795, 794, 795,
+	795, 794, 795, 795, 795, 795, 795, 795,
+	795, 794, 795, 794, 795, 794, 795, 795,
+	794, 795, 794, 795, 795, 794, 795, 794,
+	795, 794, 977, 948, 978, 979, 980, 981,
+	982, 983, 984, 985, 986, 829, 987, 846,
+	988, 989, 990, 846, 991, 861, 992, 993,
+	994, 995, 996, 997, 998, 999, 846, 794,
+	794, 794, 795, 795, 795, 794, 795, 795,
+	794, 795, 795, 794, 794, 794, 794, 794,
+	795, 795, 795, 795, 794, 795, 795, 795,
+	795, 795, 795, 794, 794, 794, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 794,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	794, 795, 795, 794, 794, 794, 794, 795,
+	795, 795, 794, 794, 794, 795, 794, 794,
+	794, 795, 795, 794, 795, 795, 795, 794,
+	795, 794, 794, 794, 795, 795, 794, 795,
+	795, 795, 794, 795, 795, 795, 794, 794,
+	794, 794, 795, 846, 915, 1000, 1001, 801,
+	846, 801, 794, 794, 795, 794, 795, 846,
+	1000, 801, 794, 846, 1002, 801, 794, 794,
+	795, 846, 1003, 1004, 1005, 906, 1006, 1007,
+	846, 1008, 1009, 1010, 801, 794, 794, 795,
+	795, 795, 794, 795, 795, 794, 795, 795,
+	795, 795, 794, 794, 795, 794, 794, 795,
+	795, 794, 795, 794, 846, 801, 794, 1011,
+	846, 1012, 794, 801, 794, 795, 794, 795,
+	1013, 846, 1014, 1015, 794, 795, 794, 794,
+	794, 795, 795, 795, 795, 794, 1016, 1017,
+	1018, 846, 1019, 1020, 1021, 1022, 1023, 1024,
+	1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032,
+	801, 794, 795, 795, 795, 794, 794, 794,
+	794, 795, 795, 794, 794, 795, 794, 794,
+	794, 794, 794, 794, 794, 795, 794, 795,
+	794, 794, 794, 794, 794, 794, 795, 795,
+	795, 795, 795, 794, 794, 795, 794, 794,
+	794, 795, 794, 794, 795, 794, 794, 795,
+	794, 794, 795, 794, 794, 794, 795, 795,
+	795, 794, 794, 794, 795, 795, 795, 795,
+	794, 1033, 846, 1034, 846, 1035, 1036, 1037,
+	1038, 801, 794, 795, 795, 795, 795, 795,
+	794, 794, 794, 795, 794, 794, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	794, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 794, 795, 795, 795,
+	795, 795, 794, 1039, 846, 801, 794, 795,
+	1040, 846, 831, 801, 794, 795, 1041, 794,
+	801, 794, 795, 846, 1042, 801, 794, 794,
+	795, 1043, 794, 846, 1044, 801, 794, 794,
+	795, 1046, 1045, 795, 795, 795, 795, 1046,
+	1045, 795, 1046, 1045, 1046, 1046, 795, 1046,
+	1045, 795, 1046, 795, 1046, 1045, 795, 1046,
+	795, 1046, 795, 1045, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1045, 795, 795, 1046,
+	1046, 795, 1046, 795, 1046, 1045, 1046, 1046,
+	1046, 1046, 1046, 795, 1046, 795, 1046, 795,
+	1046, 1045, 1046, 1046, 795, 1046, 795, 1046,
+	1045, 1046, 1046, 1046, 1046, 1046, 795, 1046,
+	795, 1046, 1045, 795, 795, 1046, 795, 1046,
+	1045, 1046, 1046, 1046, 795, 1046, 795, 1046,
+	795, 1046, 795, 1046, 1045, 1046, 795, 1046,
+	795, 1046, 1045, 795, 1046, 1046, 1046, 1046,
+	795, 1046, 795, 1046, 795, 1046, 795, 1046,
+	795, 1046, 795, 1046, 1045, 795, 1046, 1045,
+	1046, 1046, 1046, 795, 1046, 795, 1046, 1045,
+	1046, 795, 1046, 795, 1046, 1045, 795, 1046,
+	1046, 1046, 1046, 795, 1046, 795, 1046, 1045,
+	795, 1046, 795, 1046, 795, 1046, 1045, 1046,
+	1046, 795, 1046, 795, 1046, 1045, 795, 1046,
+	795, 1046, 795, 1046, 795, 1045, 1046, 1046,
+	1046, 795, 1046, 795, 1046, 1045, 795, 1046,
+	1045, 1046, 1046, 795, 1046, 1045, 1046, 1046,
+	1046, 795, 1046, 1046, 1046, 1046, 1046, 1046,
+	795, 795, 1046, 795, 1046, 795, 1046, 795,
+	1046, 1045, 1046, 795, 1046, 795, 1046, 1045,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 1046,
+	795, 1046, 1045, 795, 795, 1046, 1045, 795,
+	1046, 795, 1046, 795, 1046, 795, 1046, 795,
+	1046, 795, 1045, 1046, 1046, 795, 1046, 1046,
+	1046, 1046, 795, 795, 1046, 1046, 1046, 1046,
+	1046, 795, 1046, 1046, 1046, 1046, 1046, 1045,
+	795, 1046, 1046, 795, 1046, 795, 1045, 1046,
+	1046, 795, 1046, 1045, 795, 795, 1046, 795,
+	1045, 1046, 1046, 1045, 795, 1046, 795, 1045,
+	1046, 1045, 795, 1046, 795, 1046, 795, 1045,
+	1046, 1046, 1045, 795, 1046, 795, 1046, 795,
+	1046, 1045, 1046, 795, 1046, 795, 1046, 1045,
+	795, 1046, 1045, 795, 795, 1046, 1045, 1046,
+	795, 1045, 1046, 1045, 795, 1046, 795, 1046,
+	795, 1045, 1046, 1045, 795, 795, 1046, 1045,
+	1046, 795, 1046, 795, 1046, 1045, 795, 1046,
+	795, 1045, 1046, 1045, 795, 795, 1046, 795,
+	1045, 1046, 1045, 795, 795, 1046, 1045, 1046,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 1046,
+	795, 1046, 795, 1046, 795, 1045, 1046, 1045,
+	795, 795, 1046, 1045, 1046, 795, 1046, 795,
+	1046, 1045, 795, 1046, 1045, 1046, 1046, 795,
+	1046, 795, 1046, 1045, 1045, 795, 1045, 795,
+	1046, 1046, 795, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1045, 795, 1046, 1046, 1046, 795,
+	1045, 1046, 1046, 1046, 795, 1046, 795, 1046,
+	795, 1046, 795, 1046, 795, 1046, 1045, 795,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 795,
+	795, 1046, 795, 795, 795, 1046, 795, 1046,
+	795, 1046, 795, 1046, 795, 1045, 795, 1046,
+	795, 1046, 795, 1045, 1046, 1045, 795, 1046,
+	795, 1045, 1046, 795, 1046, 1046, 1046, 1045,
+	795, 1046, 795, 795, 1046, 795, 1045, 1046,
+	1046, 1045, 795, 1046, 1046, 1046, 1046, 795,
+	1046, 795, 1045, 1046, 1046, 1046, 795, 1046,
+	1045, 1046, 795, 1046, 795, 1046, 795, 1046,
+	795, 1046, 1045, 1046, 1046, 795, 1046, 1045,
+	795, 1046, 795, 1046, 795, 1045, 1046, 1046,
+	1045, 795, 1046, 795, 1045, 1046, 1045, 795,
+	1046, 1045, 795, 1046, 795, 1046, 1045, 1046,
+	1046, 1046, 1045, 795, 795, 795, 1046, 1045,
+	795, 1046, 795, 1045, 1046, 1045, 795, 1046,
+	795, 1046, 795, 1045, 1046, 1046, 1046, 1045,
+	795, 1046, 795, 1045, 1046, 1046, 1046, 1046,
+	1045, 795, 1046, 795, 1046, 1045, 795, 795,
+	1046, 795, 1046, 1045, 1046, 795, 1046, 795,
+	1045, 1046, 1046, 1045, 795, 1046, 795, 1046,
+	1045, 795, 1046, 1046, 1046, 795, 1046, 795,
+	1045, 795, 1046, 1045, 1046, 795, 795, 1046,
+	795, 1046, 795, 1045, 1046, 1046, 1046, 1046,
+	1045, 795, 1046, 795, 1046, 795, 1046, 795,
+	1046, 795, 1046, 1045, 1046, 1046, 1046, 795,
+	1046, 795, 1046, 795, 1046, 795, 1045, 1046,
+	1046, 795, 795, 1046, 1045, 1046, 795, 1046,
+	1046, 1045, 795, 1046, 795, 1046, 1045, 795,
+	795, 1046, 1046, 1046, 1046, 795, 1046, 795,
+	1046, 795, 1045, 1046, 1046, 795, 1045, 1046,
+	1045, 795, 1046, 795, 1045, 1046, 1045, 795,
+	1046, 795, 1045, 1046, 795, 1046, 1046, 1045,
+	795, 1046, 1046, 795, 1045, 1046, 1045, 795,
+	1046, 795, 1046, 1045, 1046, 795, 1046, 795,
+	1045, 1046, 1045, 795, 1046, 795, 1046, 795,
+	1046, 795, 1046, 795, 1046, 1045, 1047, 1045,
+	1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055,
+	1056, 1057, 1058, 1050, 1059, 1060, 1061, 1062,
+	1063, 1050, 1064, 1065, 1066, 1067, 1068, 1069,
+	1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077,
+	1078, 1050, 1079, 1047, 1059, 1047, 1080, 1047,
+	1045, 1046, 1046, 1046, 1046, 795, 1045, 1046,
+	1046, 1045, 795, 1046, 1045, 795, 795, 1046,
+	1045, 795, 1046, 795, 1045, 1046, 1045, 795,
+	795, 1046, 795, 1045, 1046, 1046, 1045, 795,
+	1046, 1046, 1046, 1045, 795, 1046, 795, 1046,
+	1046, 1045, 795, 795, 1046, 795, 1045, 1046,
+	1045, 795, 1046, 1045, 795, 795, 1046, 795,
+	1046, 1045, 795, 1046, 795, 795, 1046, 795,
+	1046, 795, 1045, 1046, 1046, 1045, 795, 1046,
+	1046, 795, 1046, 1045, 795, 1046, 795, 1046,
+	1045, 795, 1046, 795, 1045, 795, 1046, 1046,
+	1046, 795, 1046, 1045, 1046, 795, 1046, 1045,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 795,
+	1046, 1045, 795, 1046, 795, 1046, 1045, 795,
+	1046, 1045, 795, 1046, 1045, 1081, 1082, 1083,
+	1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091,
+	1092, 1052, 1093, 1094, 1095, 1096, 1097, 1094,
+	1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105,
+	1106, 1047, 1045, 1046, 795, 1046, 1045, 1046,
+	795, 1046, 1045, 1046, 795, 1046, 1045, 1046,
+	795, 1046, 1045, 795, 1046, 795, 1046, 1045,
+	1046, 795, 1046, 1045, 1046, 795, 795, 795,
+	1046, 1045, 1046, 795, 1046, 1045, 1046, 1046,
+	1046, 1046, 795, 1046, 795, 1045, 1046, 1045,
+	795, 795, 1046, 795, 1046, 1045, 1046, 795,
+	1046, 1045, 795, 1046, 1045, 1046, 1046, 795,
+	1046, 1045, 795, 1046, 1045, 1046, 795, 1046,
+	1045, 795, 1046, 1045, 795, 1046, 1045, 795,
+	1046, 1045, 1046, 1045, 795, 795, 1046, 1045,
+	1046, 795, 1046, 1045, 795, 1046, 795, 1045,
+	1046, 1045, 795, 1050, 1107, 1047, 1050, 1108,
+	1050, 1109, 1059, 1047, 1045, 1046, 1045, 795,
+	1046, 1045, 795, 1050, 1108, 1059, 1047, 1045,
+	1050, 1110, 1047, 1059, 1047, 1045, 1046, 1045,
+	795, 1050, 1111, 1068, 1112, 1094, 1113, 1106,
+	1050, 1114, 1115, 1116, 1047, 1059, 1047, 1045,
+	1046, 1045, 795, 1046, 795, 1046, 1045, 795,
+	1046, 795, 1046, 795, 1045, 1046, 1046, 1045,
+	795, 1046, 795, 1046, 1045, 795, 1046, 1045,
+	1050, 1059, 801, 1045, 1117, 1050, 1118, 1059,
+	1047, 1045, 801, 1046, 1045, 795, 1046, 1045,
+	795, 1119, 1050, 1120, 1121, 1047, 1045, 795,
+	1046, 1045, 1046, 1046, 1045, 795, 795, 1046,
+	795, 1046, 1045, 1050, 1122, 1123, 1124, 1125,
+	1126, 1127, 1128, 1129, 1130, 1131, 1132, 1047,
+	1059, 1047, 1045, 1046, 795, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 795, 1046, 795, 1046,
+	1046, 1046, 1046, 1046, 1046, 1045, 795, 1046,
+	1046, 795, 1046, 795, 1045, 1046, 795, 1046,
+	1046, 1046, 795, 1046, 1046, 795, 1046, 1046,
+	795, 1046, 1046, 795, 1046, 1046, 1045, 795,
+	1050, 1133, 1050, 1109, 1134, 1135, 1136, 1047,
+	1059, 1047, 1045, 1046, 1045, 795, 1046, 1046,
+	1046, 795, 1046, 1046, 1046, 795, 1046, 795,
+	1046, 1045, 795, 795, 795, 795, 1046, 1046,
+	795, 795, 795, 795, 795, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 795, 1046, 795, 1046,
+	795, 1045, 1046, 1046, 1046, 795, 1046, 795,
+	1046, 1045, 1059, 801, 1137, 1050, 1059, 801,
+	1046, 1045, 795, 1138, 1050, 1139, 1059, 801,
+	1046, 1045, 795, 1046, 795, 1140, 1059, 1047,
+	1045, 801, 1046, 1045, 795, 1050, 1141, 1047,
+	1059, 1047, 1045, 1046, 1045, 795, 1142, 1143,
+	1144, 1142, 1145, 1146, 1147, 1149, 1150, 1151,
+	1152, 1153, 1154, 670, 670, 419, 1155, 1156,
+	1157, 1158, 670, 1161, 1162, 1164, 1165, 1166,
+	1160, 1167, 1168, 1169, 1170, 1171, 1172, 1173,
+	1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181,
+	1182, 1183, 1184, 1185, 1186, 1188, 1189, 1190,
+	1191, 1192, 1193, 670, 1148, 7, 1148, 419,
+	1148, 419, 1160, 1163, 1187, 1194, 1159, 1142,
+	1142, 1195, 1143, 1196, 1198, 1197, 4, 1147,
+	1200, 1197, 1201, 1197, 2, 1147, 1197, 6,
+	8, 8, 7, 1202, 1203, 1204, 1197, 1205,
+	1206, 1197, 1207, 1197, 419, 419, 1209, 1210,
+	489, 470, 1211, 470, 1212, 1213, 1214, 1215,
+	1216, 1217, 1218, 1219, 1220, 1221, 1222, 544,
+	1223, 520, 1224, 1225, 1226, 1227, 1228, 1229,
+	1230, 1231, 1232, 1233, 1234, 1235, 419, 419,
+	419, 425, 565, 1208, 1236, 1197, 1237, 1197,
+	670, 1238, 419, 419, 419, 670, 1238, 670,
+	670, 419, 1238, 419, 1238, 419, 1238, 419,
+	670, 670, 670, 670, 670, 1238, 419, 670,
+	670, 670, 419, 670, 419, 1238, 419, 670,
+	670, 670, 670, 419, 1238, 670, 419, 670,
+	419, 670, 419, 670, 670, 419, 670, 1238,
+	419, 670, 419, 670, 419, 670, 1238, 670,
+	419, 1238, 670, 419, 670, 419, 1238, 670,
+	670, 670, 670, 670, 1238, 419, 419, 670,
+	419, 670, 1238, 670, 419, 1238, 670, 670,
+	1238, 419, 419, 670, 419, 670, 419, 670,
+	1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245,
+	1246, 1247, 1248, 1249, 715, 1250, 1251, 1252,
+	1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260,
+	1261, 1260, 1262, 1263, 1264, 1265, 1266, 671,
+	1238, 1267, 1268, 1269, 1270, 1271, 1272, 1273,
+	1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281,
+	1282, 1283, 1284, 1285, 725, 1286, 1287, 1288,
+	692, 1289, 1290, 1291, 1292, 1293, 1294, 671,
+	1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302,
+	674, 1303, 671, 674, 1304, 1305, 1306, 1307,
+	683, 1238, 1308, 1309, 1310, 1311, 703, 1312,
+	1313, 683, 1314, 1315, 1316, 1317, 1318, 671,
+	1238, 1319, 1278, 1320, 1321, 1322, 683, 1323,
+	1324, 674, 671, 683, 425, 1238, 1288, 671,
+	674, 683, 425, 683, 425, 1325, 683, 1238,
+	425, 674, 1326, 1327, 674, 1328, 1329, 681,
+	1330, 1331, 1332, 1333, 1334, 1284, 1335, 1336,
+	1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344,
+	1345, 1346, 1303, 1347, 674, 683, 425, 1238,
+	1348, 1349, 683, 671, 1238, 425, 671, 1238,
+	674, 1350, 731, 1351, 1352, 1353, 1354, 1355,
+	1356, 1357, 1358, 671, 1359, 1360, 1361, 1362,
+	1363, 1364, 671, 683, 1238, 1366, 1367, 1368,
+	1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376,
+	1372, 1378, 1379, 1380, 1381, 1365, 1377, 1365,
+	1238, 1365, 1238, 1382, 1382, 1383, 1384, 1385,
+	1386, 1387, 1388, 1389, 1390, 1387, 767, 1391,
+	1391, 1391, 1392, 1391, 1391, 768, 769, 770,
+	1391, 767, 1382, 1382, 1393, 1396, 1397, 1395,
+	1398, 1399, 1398, 1400, 1391, 1402, 1401, 1396,
+	1403, 1395, 1405, 1404, 1394, 1394, 1394, 768,
+	769, 770, 1394, 767, 767, 1406, 773, 1406,
+	1407, 1406, 775, 1408, 1409, 1410, 1411, 1412,
+	1413, 1414, 1411, 776, 775, 1408, 1415, 1415,
+	777, 779, 1416, 1415, 776, 1418, 1419, 1417,
+	1418, 1419, 1420, 1417, 775, 1408, 1421, 1415,
+	775, 1408, 1415, 1423, 1422, 1425, 1424, 776,
+	1426, 777, 1426, 779, 1426, 785, 1427, 1428,
+	1429, 1430, 1431, 1432, 1433, 1430, 786, 785,
+	1427, 1434, 1434, 787, 789, 1435, 1434, 786,
+	1437, 1438, 1436, 1437, 1438, 1439, 1436, 785,
+	1427, 1440, 1434, 785, 1427, 1434, 1442, 1441,
+	1444, 1443, 786, 1445, 787, 1445, 789, 1445,
+	795, 1448, 1449, 1451, 1452, 1453, 1447, 1454,
+	1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462,
+	1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470,
+	1471, 1472, 1473, 1475, 1476, 1477, 1478, 1479,
+	1480, 795, 795, 1446, 1447, 1450, 1474, 1481,
+	1446, 1046, 795, 795, 1483, 1484, 865, 846,
+	1485, 846, 1486, 1487, 1488, 1489, 1490, 1491,
+	1492, 1493, 1494, 1495, 1496, 920, 1497, 896,
+	1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505,
+	1506, 1507, 1508, 1509, 795, 795, 795, 801,
+	941, 1482, 1046, 1510, 795, 795, 795, 1046,
+	1510, 1046, 1046, 795, 1510, 795, 1510, 795,
+	1510, 795, 1046, 1046, 1046, 1046, 1046, 1510,
+	795, 1046, 1046, 1046, 795, 1046, 795, 1510,
+	795, 1046, 1046, 1046, 1046, 795, 1510, 1046,
+	795, 1046, 795, 1046, 795, 1046, 1046, 795,
+	1046, 1510, 795, 1046, 795, 1046, 795, 1046,
+	1510, 1046, 795, 1510, 1046, 795, 1046, 795,
+	1510, 1046, 1046, 1046, 1046, 1046, 1510, 795,
+	795, 1046, 795, 1046, 1510, 1046, 795, 1510,
+	1046, 1046, 1510, 795, 795, 1046, 795, 1046,
+	795, 1046, 1510, 1511, 1512, 1513, 1514, 1515,
+	1516, 1517, 1518, 1519, 1520, 1521, 1091, 1522,
+	1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530,
+	1531, 1532, 1533, 1532, 1534, 1535, 1536, 1537,
+	1538, 1047, 1510, 1539, 1540, 1541, 1542, 1543,
+	1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551,
+	1552, 1553, 1554, 1555, 1556, 1557, 1101, 1558,
+	1559, 1560, 1068, 1561, 1562, 1563, 1564, 1565,
+	1566, 1047, 1567, 1568, 1569, 1570, 1571, 1572,
+	1573, 1574, 1050, 1575, 1047, 1050, 1576, 1577,
+	1578, 1579, 1059, 1510, 1580, 1581, 1582, 1583,
+	1079, 1584, 1585, 1059, 1586, 1587, 1588, 1589,
+	1590, 1047, 1510, 1591, 1550, 1592, 1593, 1594,
+	1059, 1595, 1596, 1050, 1047, 1059, 801, 1510,
+	1560, 1047, 1050, 1059, 801, 1059, 801, 1597,
+	1059, 1510, 801, 1050, 1598, 1599, 1050, 1600,
+	1601, 1057, 1602, 1603, 1604, 1605, 1606, 1556,
+	1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614,
+	1615, 1616, 1617, 1618, 1575, 1619, 1050, 1059,
+	801, 1510, 1620, 1621, 1059, 1047, 1510, 801,
+	1047, 1510, 1050, 1622, 1107, 1623, 1624, 1625,
+	1626, 1627, 1628, 1629, 1630, 1047, 1631, 1632,
+	1633, 1634, 1635, 1636, 1047, 1059, 1510, 1638,
+	1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646,
+	1647, 1648, 1644, 1650, 1651, 1652, 1653, 1637,
+	1649, 1637, 1510, 1637, 1510,
+}
+
+var _hcltok_trans_targs []int16 = []int16{
+	1459, 1459, 2, 3, 1459, 1459, 4, 1467,
+	5, 6, 8, 9, 286, 12, 13, 14,
+	15, 16, 287, 288, 19, 289, 21, 22,
+	290, 291, 292, 293, 294, 295, 296, 297,
+	298, 299, 328, 348, 353, 127, 128, 129,
+	356, 151, 371, 375, 1459, 10, 11, 17,
+	18, 20, 23, 24, 25, 26, 27, 28,
+	29, 30, 31, 32, 64, 105, 120, 131,
+	154, 170, 283, 33, 34, 35, 36, 37,
+	38, 39, 40, 41, 42, 43, 44, 45,
+	46, 47, 48, 49, 50, 51, 52, 53,
+	54, 55, 56, 57, 58, 59, 60, 61,
+	62, 63, 65, 66, 67, 68, 69, 70,
+	71, 72, 73, 74, 75, 76, 77, 78,
+	79, 80, 81, 82, 83, 84, 85, 86,
+	87, 88, 89, 90, 91, 92, 93, 94,
+	95, 96, 97, 98, 99, 100, 101, 102,
+	103, 104, 106, 107, 108, 109, 110, 111,
+	112, 113, 114, 115, 116, 117, 118, 119,
+	121, 122, 123, 124, 125, 126, 130, 132,
+	133, 134, 135, 136, 137, 138, 139, 140,
+	141, 142, 143, 144, 145, 146, 147, 148,
+	149, 150, 152, 153, 155, 156, 157, 158,
+	159, 160, 161, 162, 163, 164, 165, 166,
+	167, 168, 169, 171, 203, 227, 230, 231,
+	233, 242, 243, 246, 250, 268, 275, 277,
+	279, 281, 172, 173, 174, 175, 176, 177,
+	178, 179, 180, 181, 182, 183, 184, 185,
+	186, 187, 188, 189, 190, 191, 192, 193,
+	194, 195, 196, 197, 198, 199, 200, 201,
+	202, 204, 205, 206, 207, 208, 209, 210,
+	211, 212, 213, 214, 215, 216, 217, 218,
+	219, 220, 221, 222, 223, 224, 225, 226,
+	228, 229, 232, 234, 235, 236, 237, 238,
+	239, 240, 241, 244, 245, 247, 248, 249,
+	251, 252, 253, 254, 255, 256, 257, 258,
+	259, 260, 261, 262, 263, 264, 265, 266,
+	267, 269, 270, 271, 272, 273, 274, 276,
+	278, 280, 282, 284, 285, 300, 301, 302,
+	303, 304, 305, 306, 307, 308, 309, 310,
+	311, 312, 313, 314, 315, 316, 317, 318,
+	319, 320, 321, 322, 323, 324, 325, 326,
+	327, 329, 330, 331, 332, 333, 334, 335,
+	336, 337, 338, 339, 340, 341, 342, 343,
+	344, 345, 346, 347, 349, 350, 351, 352,
+	354, 355, 357, 358, 359, 360, 361, 362,
+	363, 364, 365, 366, 367, 368, 369, 370,
+	372, 373, 374, 376, 382, 404, 409, 411,
+	413, 377, 378, 379, 380, 381, 383, 384,
+	385, 386, 387, 388, 389, 390, 391, 392,
+	393, 394, 395, 396, 397, 398, 399, 400,
+	401, 402, 403, 405, 406, 407, 408, 410,
+	412, 414, 1459, 1471, 1459, 437, 438, 439,
+	440, 417, 441, 442, 443, 444, 445, 446,
+	447, 448, 449, 450, 451, 452, 453, 454,
+	455, 456, 457, 458, 459, 460, 461, 462,
+	463, 464, 465, 466, 467, 469, 470, 471,
+	472, 473, 474, 475, 476, 477, 478, 479,
+	480, 481, 482, 483, 484, 485, 419, 486,
+	487, 488, 489, 490, 491, 492, 493, 494,
+	495, 496, 497, 498, 499, 500, 501, 502,
+	503, 418, 504, 505, 506, 507, 508, 510,
+	511, 512, 513, 514, 515, 516, 517, 518,
+	519, 520, 521, 522, 523, 525, 526, 527,
+	528, 529, 530, 534, 536, 537, 538, 539,
+	434, 540, 541, 542, 543, 544, 545, 546,
+	547, 548, 549, 550, 551, 552, 553, 554,
+	556, 557, 559, 560, 561, 562, 563, 564,
+	432, 565, 566, 567, 568, 569, 570, 571,
+	572, 573, 575, 607, 631, 634, 635, 637,
+	646, 647, 650, 654, 672, 532, 679, 681,
+	683, 685, 576, 577, 578, 579, 580, 581,
+	582, 583, 584, 585, 586, 587, 588, 589,
+	590, 591, 592, 593, 594, 595, 596, 597,
+	598, 599, 600, 601, 602, 603, 604, 605,
+	606, 608, 609, 610, 611, 612, 613, 614,
+	615, 616, 617, 618, 619, 620, 621, 622,
+	623, 624, 625, 626, 627, 628, 629, 630,
+	632, 633, 636, 638, 639, 640, 641, 642,
+	643, 644, 645, 648, 649, 651, 652, 653,
+	655, 656, 657, 658, 659, 660, 661, 662,
+	663, 664, 665, 666, 667, 668, 669, 670,
+	671, 673, 674, 675, 676, 677, 678, 680,
+	682, 684, 686, 688, 689, 1459, 1459, 690,
+	827, 828, 759, 829, 830, 831, 832, 833,
+	834, 788, 835, 724, 836, 837, 838, 839,
+	840, 841, 842, 843, 744, 844, 845, 846,
+	847, 848, 849, 850, 851, 852, 853, 769,
+	854, 856, 857, 858, 859, 860, 861, 862,
+	863, 864, 865, 702, 866, 867, 868, 869,
+	870, 871, 872, 873, 874, 740, 875, 876,
+	877, 878, 879, 810, 881, 882, 885, 887,
+	888, 889, 890, 891, 892, 895, 896, 898,
+	899, 900, 902, 903, 904, 905, 906, 907,
+	908, 909, 910, 911, 912, 914, 915, 916,
+	917, 920, 922, 923, 925, 927, 1509, 1510,
+	929, 930, 931, 1509, 1509, 932, 1523, 1523,
+	1524, 935, 1523, 936, 1525, 1526, 1529, 1530,
+	1534, 1534, 1535, 941, 1534, 942, 1536, 1537,
+	1540, 1541, 1545, 1546, 1545, 968, 969, 970,
+	971, 948, 972, 973, 974, 975, 976, 977,
+	978, 979, 980, 981, 982, 983, 984, 985,
+	986, 987, 988, 989, 990, 991, 992, 993,
+	994, 995, 996, 997, 998, 1000, 1001, 1002,
+	1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010,
+	1011, 1012, 1013, 1014, 1015, 1016, 950, 1017,
+	1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025,
+	1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033,
+	1034, 949, 1035, 1036, 1037, 1038, 1039, 1041,
+	1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049,
+	1050, 1051, 1052, 1053, 1054, 1056, 1057, 1058,
+	1059, 1060, 1061, 1065, 1067, 1068, 1069, 1070,
+	965, 1071, 1072, 1073, 1074, 1075, 1076, 1077,
+	1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085,
+	1087, 1088, 1090, 1091, 1092, 1093, 1094, 1095,
+	963, 1096, 1097, 1098, 1099, 1100, 1101, 1102,
+	1103, 1104, 1106, 1138, 1162, 1165, 1166, 1168,
+	1177, 1178, 1181, 1185, 1203, 1063, 1210, 1212,
+	1214, 1216, 1107, 1108, 1109, 1110, 1111, 1112,
+	1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120,
+	1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128,
+	1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136,
+	1137, 1139, 1140, 1141, 1142, 1143, 1144, 1145,
+	1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153,
+	1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
+	1163, 1164, 1167, 1169, 1170, 1171, 1172, 1173,
+	1174, 1175, 1176, 1179, 1180, 1182, 1183, 1184,
+	1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193,
+	1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201,
+	1202, 1204, 1205, 1206, 1207, 1208, 1209, 1211,
+	1213, 1215, 1217, 1219, 1220, 1545, 1545, 1221,
+	1358, 1359, 1290, 1360, 1361, 1362, 1363, 1364,
+	1365, 1319, 1366, 1255, 1367, 1368, 1369, 1370,
+	1371, 1372, 1373, 1374, 1275, 1375, 1376, 1377,
+	1378, 1379, 1380, 1381, 1382, 1383, 1384, 1300,
+	1385, 1387, 1388, 1389, 1390, 1391, 1392, 1393,
+	1394, 1395, 1396, 1233, 1397, 1398, 1399, 1400,
+	1401, 1402, 1403, 1404, 1405, 1271, 1406, 1407,
+	1408, 1409, 1410, 1341, 1412, 1413, 1416, 1418,
+	1419, 1420, 1421, 1422, 1423, 1426, 1427, 1429,
+	1430, 1431, 1433, 1434, 1435, 1436, 1437, 1438,
+	1439, 1440, 1441, 1442, 1443, 1445, 1446, 1447,
+	1448, 1451, 1453, 1454, 1456, 1458, 1460, 1459,
+	1461, 1462, 1459, 1463, 1459, 1464, 1465, 1466,
+	1468, 1469, 1470, 1459, 1472, 1459, 1473, 1459,
+	1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
+	1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489,
+	1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497,
+	1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505,
+	1506, 1507, 1508, 1459, 1459, 1459, 1459, 1459,
+	1459, 1, 1459, 7, 1459, 1459, 1459, 1459,
+	1459, 415, 416, 420, 421, 422, 423, 424,
+	425, 426, 427, 428, 429, 430, 431, 433,
+	435, 436, 468, 509, 524, 531, 533, 535,
+	555, 558, 574, 687, 1459, 1459, 1459, 691,
+	692, 693, 694, 695, 696, 697, 698, 699,
+	700, 701, 703, 704, 705, 706, 707, 708,
+	709, 710, 711, 712, 713, 714, 715, 716,
+	717, 718, 719, 720, 721, 722, 723, 725,
+	726, 727, 728, 729, 730, 731, 732, 733,
+	734, 735, 736, 737, 738, 739, 741, 742,
+	743, 745, 746, 747, 748, 749, 750, 751,
+	752, 753, 754, 755, 756, 757, 758, 760,
+	761, 762, 763, 764, 765, 766, 767, 768,
+	770, 771, 772, 773, 774, 775, 776, 777,
+	778, 779, 780, 781, 782, 783, 784, 785,
+	786, 787, 789, 790, 791, 792, 793, 794,
+	795, 796, 797, 798, 799, 800, 801, 802,
+	803, 804, 805, 806, 807, 808, 809, 811,
+	812, 813, 814, 815, 816, 817, 818, 819,
+	820, 821, 822, 823, 824, 825, 826, 855,
+	880, 883, 884, 886, 893, 894, 897, 901,
+	913, 918, 919, 921, 924, 926, 1511, 1509,
+	1512, 1517, 1519, 1509, 1520, 1521, 1522, 1509,
+	928, 1509, 1509, 1513, 1514, 1516, 1509, 1515,
+	1509, 1509, 1509, 1518, 1509, 1509, 1509, 933,
+	934, 938, 939, 1523, 1531, 1532, 1533, 1523,
+	937, 1523, 1523, 934, 1527, 1528, 1523, 1523,
+	1523, 1523, 1523, 940, 944, 945, 1534, 1542,
+	1543, 1544, 1534, 943, 1534, 1534, 940, 1538,
+	1539, 1534, 1534, 1534, 1534, 1534, 1545, 1547,
+	1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555,
+	1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563,
+	1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571,
+	1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579,
+	1580, 1581, 1545, 946, 947, 951, 952, 953,
+	954, 955, 956, 957, 958, 959, 960, 961,
+	962, 964, 966, 967, 999, 1040, 1055, 1062,
+	1064, 1066, 1086, 1089, 1105, 1218, 1545, 1222,
+	1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230,
+	1231, 1232, 1234, 1235, 1236, 1237, 1238, 1239,
+	1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247,
+	1248, 1249, 1250, 1251, 1252, 1253, 1254, 1256,
+	1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264,
+	1265, 1266, 1267, 1268, 1269, 1270, 1272, 1273,
+	1274, 1276, 1277, 1278, 1279, 1280, 1281, 1282,
+	1283, 1284, 1285, 1286, 1287, 1288, 1289, 1291,
+	1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299,
+	1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308,
+	1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316,
+	1317, 1318, 1320, 1321, 1322, 1323, 1324, 1325,
+	1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333,
+	1334, 1335, 1336, 1337, 1338, 1339, 1340, 1342,
+	1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350,
+	1351, 1352, 1353, 1354, 1355, 1356, 1357, 1386,
+	1411, 1414, 1415, 1417, 1424, 1425, 1428, 1432,
+	1444, 1449, 1450, 1452, 1455, 1457,
+}
+
+var _hcltok_trans_actions []byte = []byte{
+	145, 107, 0, 0, 91, 141, 0, 7,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 121, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 143, 193, 149, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 147, 125, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 31, 169,
+	0, 0, 0, 35, 33, 0, 55, 41,
+	175, 0, 53, 0, 175, 175, 0, 0,
+	75, 61, 181, 0, 73, 0, 181, 181,
+	0, 0, 85, 187, 89, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 87, 79, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 93,
+	0, 0, 119, 0, 111, 0, 7, 7,
+	7, 0, 0, 113, 0, 115, 0, 123,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 7, 7,
+	7, 196, 196, 196, 196, 196, 196, 7,
+	7, 196, 7, 127, 139, 135, 97, 133,
+	103, 0, 129, 0, 101, 95, 109, 99,
+	131, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 105, 117, 137, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 13,
+	0, 0, 172, 17, 0, 7, 7, 23,
+	0, 25, 27, 0, 0, 0, 151, 0,
+	15, 19, 9, 0, 21, 11, 29, 0,
+	0, 0, 0, 43, 0, 178, 178, 49,
+	0, 157, 154, 1, 175, 175, 45, 37,
+	47, 39, 51, 0, 0, 0, 63, 0,
+	184, 184, 69, 0, 163, 160, 1, 181,
+	181, 65, 57, 67, 59, 71, 77, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 7, 7, 7,
+	190, 190, 190, 190, 190, 190, 7, 7,
+	190, 7, 81, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 83, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0,
+}
+
+var _hcltok_to_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 3, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 3, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 166, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 166, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 3, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0,
+}
+
+var _hcltok_from_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 5, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 5, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 5, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 5, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 5, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0,
+}
+
+var _hcltok_eof_trans []int16 = []int16{
+	0, 1, 1, 1, 6, 6, 6, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 419,
+	419, 421, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 419, 419, 419, 419, 419, 419,
+	419, 419, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	670, 670, 670, 670, 670, 670, 670, 670,
+	767, 772, 772, 772, 773, 773, 775, 775,
+	775, 779, 0, 0, 785, 785, 785, 789,
+	0, 0, 795, 795, 797, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 795, 795, 795,
+	795, 795, 795, 795, 795, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046,
+	1046, 1046, 1046, 0, 1196, 1197, 1198, 1200,
+	1198, 1198, 1198, 1203, 1198, 1198, 1198, 1209,
+	1198, 1198, 1239, 1239, 1239, 1239, 1239, 1239,
+	1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239,
+	1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239,
+	1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239,
+	1239, 1239, 1239, 1239, 1239, 0, 1392, 1394,
+	1395, 1399, 1399, 1392, 1402, 1395, 1405, 1395,
+	1407, 1407, 1407, 0, 1416, 1418, 1418, 1416,
+	1416, 1423, 1425, 1427, 1427, 1427, 0, 1435,
+	1437, 1437, 1435, 1435, 1442, 1444, 1446, 1446,
+	1446, 0, 1483, 1511, 1511, 1511, 1511, 1511,
+	1511, 1511, 1511, 1511, 1511, 1511, 1511, 1511,
+	1511, 1511, 1511, 1511, 1511, 1511, 1511, 1511,
+	1511, 1511, 1511, 1511, 1511, 1511, 1511, 1511,
+	1511, 1511, 1511, 1511, 1511, 1511,
+}
+
+const hcltok_start int = 1459
+const hcltok_first_final int = 1459
+const hcltok_error int = 0
+
+const hcltok_en_stringTemplate int = 1509
+const hcltok_en_heredocTemplate int = 1523
+const hcltok_en_bareTemplate int = 1534
+const hcltok_en_identOnly int = 1545
+const hcltok_en_main int = 1459
+
+//line scan_tokens.rl:16
+
+func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token {
+	stripData := stripUTF8BOM(data)
+	start.Byte += len(data) - len(stripData)
+	data = stripData
+
+	f := &tokenAccum{
+		Filename:  filename,
+		Bytes:     data,
+		Pos:       start,
+		StartByte: start.Byte,
+	}
+
+//line scan_tokens.rl:305
+
+	// Ragel state
+	p := 0          // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+	ts := 0
+	te := 0
+	act := 0
+	eof := pe
+	var stack []int
+	var top int
+
+	var cs int // current state
+	switch mode {
+	case scanNormal:
+		cs = hcltok_en_main
+	case scanTemplate:
+		cs = hcltok_en_bareTemplate
+	case scanIdentOnly:
+		cs = hcltok_en_identOnly
+	default:
+		panic("invalid scanMode")
+	}
+
+	braces := 0
+	var retBraces []int              // stack of brace levels that cause us to use fret
+	var heredocs []heredocInProgress // stack of heredocs we're currently processing
+
+//line scan_tokens.rl:340
+
+	// Make Go compiler happy
+	_ = ts
+	_ = te
+	_ = act
+	_ = eof
+
+	token := func(ty TokenType) {
+		f.emitToken(ty, ts, te)
+	}
+	selfToken := func() {
+		b := data[ts:te]
+		if len(b) != 1 {
+			// should never happen
+			panic("selfToken only works for single-character tokens")
+		}
+		f.emitToken(TokenType(b[0]), ts, te)
+	}
+
+//line scan_tokens.go:4289
+	{
+		top = 0
+		ts = 0
+		te = 0
+		act = 0
+	}
+
+//line scan_tokens.go:4297
+	{
+		var _klen int
+		var _trans int
+		var _acts int
+		var _nacts uint
+		var _keys int
+		if p == pe {
+			goto _test_eof
+		}
+		if cs == 0 {
+			goto _out
+		}
+	_resume:
+		_acts = int(_hcltok_from_state_actions[cs])
+		_nacts = uint(_hcltok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _hcltok_actions[_acts-1] {
+			case 3:
+//line NONE:1
+				ts = p
+
+//line scan_tokens.go:4320
+			}
+		}
+
+		_keys = int(_hcltok_key_offsets[cs])
+		_trans = int(_hcltok_index_offsets[cs])
+
+		_klen = int(_hcltok_single_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + _klen - 1)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + ((_upper - _lower) >> 1)
+				switch {
+				case data[p] < _hcltok_trans_keys[_mid]:
+					_upper = _mid - 1
+				case data[p] > _hcltok_trans_keys[_mid]:
+					_lower = _mid + 1
+				default:
+					_trans += int(_mid - int(_keys))
+					goto _match
+				}
+			}
+			_keys += _klen
+			_trans += _klen
+		}
+
+		_klen = int(_hcltok_range_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + (_klen << 1) - 2)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + (((_upper - _lower) >> 1) & ^1)
+				switch {
+				case data[p] < _hcltok_trans_keys[_mid]:
+					_upper = _mid - 2
+				case data[p] > _hcltok_trans_keys[_mid+1]:
+					_lower = _mid + 2
+				default:
+					_trans += int((_mid - int(_keys)) >> 1)
+					goto _match
+				}
+			}
+			_trans += _klen
+		}
+
+	_match:
+		_trans = int(_hcltok_indicies[_trans])
+	_eof_trans:
+		cs = int(_hcltok_trans_targs[_trans])
+
+		if _hcltok_trans_actions[_trans] == 0 {
+			goto _again
+		}
+
+		_acts = int(_hcltok_trans_actions[_trans])
+		_nacts = uint(_hcltok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _hcltok_actions[_acts-1] {
+			case 0:
+//line scan_tokens.rl:224
+				p--
+
+			case 4:
+//line NONE:1
+				te = p + 1
+
+			case 5:
+//line scan_tokens.rl:248
+				act = 4
+			case 6:
+//line scan_tokens.rl:250
+				act = 6
+			case 7:
+//line scan_tokens.rl:160
+				te = p + 1
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 8:
+//line scan_tokens.rl:170
+				te = p + 1
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 9:
+//line scan_tokens.rl:84
+				te = p + 1
+				{
+					token(TokenCQuote)
+					top--
+					cs = stack[top]
+					{
+						stack = stack[:len(stack)-1]
+					}
+					goto _again
+
+				}
+			case 10:
+//line scan_tokens.rl:248
+				te = p + 1
+				{
+					token(TokenQuotedLit)
+				}
+			case 11:
+//line scan_tokens.rl:251
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 12:
+//line scan_tokens.rl:160
+				te = p
+				p--
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 13:
+//line scan_tokens.rl:170
+				te = p
+				p--
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 14:
+//line scan_tokens.rl:248
+				te = p
+				p--
+				{
+					token(TokenQuotedLit)
+				}
+			case 15:
+//line scan_tokens.rl:249
+				te = p
+				p--
+				{
+					token(TokenQuotedNewline)
+				}
+			case 16:
+//line scan_tokens.rl:250
+				te = p
+				p--
+				{
+					token(TokenInvalid)
+				}
+			case 17:
+//line scan_tokens.rl:251
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 18:
+//line scan_tokens.rl:248
+				p = (te) - 1
+				{
+					token(TokenQuotedLit)
+				}
+			case 19:
+//line scan_tokens.rl:251
+				p = (te) - 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 20:
+//line NONE:1
+				switch act {
+				case 4:
+					{
+						p = (te) - 1
+						token(TokenQuotedLit)
+					}
+				case 6:
+					{
+						p = (te) - 1
+						token(TokenInvalid)
+					}
+				}
+
+			case 21:
+//line scan_tokens.rl:148
+				act = 11
+			case 22:
+//line scan_tokens.rl:259
+				act = 12
+			case 23:
+//line scan_tokens.rl:160
+				te = p + 1
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 24:
+//line scan_tokens.rl:170
+				te = p + 1
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 25:
+//line scan_tokens.rl:111
+				te = p + 1
+				{
+					// This action is called specificially when a heredoc literal
+					// ends with a newline character.
+
+					// This might actually be our end marker.
+					topdoc := &heredocs[len(heredocs)-1]
+					if topdoc.StartOfLine {
+						maybeMarker := bytes.TrimSpace(data[ts:te])
+						if bytes.Equal(maybeMarker, topdoc.Marker) {
+							// We actually emit two tokens here: the end-of-heredoc
+							// marker first, and then separately the newline that
+							// follows it. This then avoids issues with the closing
+							// marker consuming a newline that would normally be used
+							// to mark the end of an attribute definition.
+							// We might have either a \n sequence or an \r\n sequence
+							// here, so we must handle both.
+							nls := te - 1
+							nle := te
+							te--
+							if data[te-1] == '\r' {
+								// back up one more byte
+								nls--
+								te--
+							}
+							token(TokenCHeredoc)
+							ts = nls
+							te = nle
+							token(TokenNewline)
+							heredocs = heredocs[:len(heredocs)-1]
+							top--
+							cs = stack[top]
+							{
+								stack = stack[:len(stack)-1]
+							}
+							goto _again
+
+						}
+					}
+
+					topdoc.StartOfLine = true
+					token(TokenStringLit)
+				}
+			case 26:
+//line scan_tokens.rl:259
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 27:
+//line scan_tokens.rl:160
+				te = p
+				p--
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 28:
+//line scan_tokens.rl:170
+				te = p
+				p--
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 29:
+//line scan_tokens.rl:148
+				te = p
+				p--
+				{
+					// This action is called when a heredoc literal _doesn't_ end
+					// with a newline character, e.g. because we're about to enter
+					// an interpolation sequence.
+					heredocs[len(heredocs)-1].StartOfLine = false
+					token(TokenStringLit)
+				}
+			case 30:
+//line scan_tokens.rl:259
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 31:
+//line scan_tokens.rl:148
+				p = (te) - 1
+				{
+					// This action is called when a heredoc literal _doesn't_ end
+					// with a newline character, e.g. because we're about to enter
+					// an interpolation sequence.
+					heredocs[len(heredocs)-1].StartOfLine = false
+					token(TokenStringLit)
+				}
+			case 32:
+//line NONE:1
+				switch act {
+				case 0:
+					{
+						cs = 0
+						goto _again
+					}
+				case 11:
+					{
+						p = (te) - 1
+
+						// This action is called when a heredoc literal _doesn't_ end
+						// with a newline character, e.g. because we're about to enter
+						// an interpolation sequence.
+						heredocs[len(heredocs)-1].StartOfLine = false
+						token(TokenStringLit)
+					}
+				case 12:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				}
+
+			case 33:
+//line scan_tokens.rl:156
+				act = 15
+			case 34:
+//line scan_tokens.rl:266
+				act = 16
+			case 35:
+//line scan_tokens.rl:160
+				te = p + 1
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 36:
+//line scan_tokens.rl:170
+				te = p + 1
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 37:
+//line scan_tokens.rl:156
+				te = p + 1
+				{
+					token(TokenStringLit)
+				}
+			case 38:
+//line scan_tokens.rl:266
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 39:
+//line scan_tokens.rl:160
+				te = p
+				p--
+				{
+					token(TokenTemplateInterp)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 40:
+//line scan_tokens.rl:170
+				te = p
+				p--
+				{
+					token(TokenTemplateControl)
+					braces++
+					retBraces = append(retBraces, braces)
+					if len(heredocs) > 0 {
+						heredocs[len(heredocs)-1].StartOfLine = false
+					}
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1459
+						goto _again
+					}
+				}
+			case 41:
+//line scan_tokens.rl:156
+				te = p
+				p--
+				{
+					token(TokenStringLit)
+				}
+			case 42:
+//line scan_tokens.rl:266
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 43:
+//line scan_tokens.rl:156
+				p = (te) - 1
+				{
+					token(TokenStringLit)
+				}
+			case 44:
+//line NONE:1
+				switch act {
+				case 0:
+					{
+						cs = 0
+						goto _again
+					}
+				case 15:
+					{
+						p = (te) - 1
+
+						token(TokenStringLit)
+					}
+				case 16:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				}
+
+			case 45:
+//line scan_tokens.rl:270
+				act = 17
+			case 46:
+//line scan_tokens.rl:271
+				act = 18
+			case 47:
+//line scan_tokens.rl:271
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 48:
+//line scan_tokens.rl:272
+				te = p + 1
+				{
+					token(TokenInvalid)
+				}
+			case 49:
+//line scan_tokens.rl:270
+				te = p
+				p--
+				{
+					token(TokenIdent)
+				}
+			case 50:
+//line scan_tokens.rl:271
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 51:
+//line scan_tokens.rl:270
+				p = (te) - 1
+				{
+					token(TokenIdent)
+				}
+			case 52:
+//line scan_tokens.rl:271
+				p = (te) - 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 53:
+//line NONE:1
+				switch act {
+				case 17:
+					{
+						p = (te) - 1
+						token(TokenIdent)
+					}
+				case 18:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				}
+
+			case 54:
+//line scan_tokens.rl:278
+				act = 22
+			case 55:
+//line scan_tokens.rl:301
+				act = 39
+			case 56:
+//line scan_tokens.rl:280
+				te = p + 1
+				{
+					token(TokenComment)
+				}
+			case 57:
+//line scan_tokens.rl:281
+				te = p + 1
+				{
+					token(TokenNewline)
+				}
+			case 58:
+//line scan_tokens.rl:283
+				te = p + 1
+				{
+					token(TokenEqualOp)
+				}
+			case 59:
+//line scan_tokens.rl:284
+				te = p + 1
+				{
+					token(TokenNotEqual)
+				}
+			case 60:
+//line scan_tokens.rl:285
+				te = p + 1
+				{
+					token(TokenGreaterThanEq)
+				}
+			case 61:
+//line scan_tokens.rl:286
+				te = p + 1
+				{
+					token(TokenLessThanEq)
+				}
+			case 62:
+//line scan_tokens.rl:287
+				te = p + 1
+				{
+					token(TokenAnd)
+				}
+			case 63:
+//line scan_tokens.rl:288
+				te = p + 1
+				{
+					token(TokenOr)
+				}
+			case 64:
+//line scan_tokens.rl:289
+				te = p + 1
+				{
+					token(TokenEllipsis)
+				}
+			case 65:
+//line scan_tokens.rl:290
+				te = p + 1
+				{
+					token(TokenFatArrow)
+				}
+			case 66:
+//line scan_tokens.rl:291
+				te = p + 1
+				{
+					selfToken()
+				}
+			case 67:
+//line scan_tokens.rl:180
+				te = p + 1
+				{
+					token(TokenOBrace)
+					braces++
+				}
+			case 68:
+//line scan_tokens.rl:185
+				te = p + 1
+				{
+					if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
+						token(TokenTemplateSeqEnd)
+						braces--
+						retBraces = retBraces[0 : len(retBraces)-1]
+						top--
+						cs = stack[top]
+						{
+							stack = stack[:len(stack)-1]
+						}
+						goto _again
+
+					} else {
+						token(TokenCBrace)
+						braces--
+					}
+				}
+			case 69:
+//line scan_tokens.rl:197
+				te = p + 1
+				{
+					// Only consume from the retBraces stack and return if we are at
+					// a suitable brace nesting level, otherwise things will get
+					// confused. (Not entering this branch indicates a syntax error,
+					// which we will catch in the parser.)
+					if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
+						token(TokenTemplateSeqEnd)
+						braces--
+						retBraces = retBraces[0 : len(retBraces)-1]
+						top--
+						cs = stack[top]
+						{
+							stack = stack[:len(stack)-1]
+						}
+						goto _again
+
+					} else {
+						// We intentionally generate a TokenTemplateSeqEnd here,
+						// even though the user apparently wanted a brace, because
+						// we want to allow the parser to catch the incorrect use
+						// of a ~} to balance a generic opening brace, rather than
+						// a template sequence.
+						token(TokenTemplateSeqEnd)
+						braces--
+					}
+				}
+			case 70:
+//line scan_tokens.rl:79
+				te = p + 1
+				{
+					token(TokenOQuote)
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1509
+						goto _again
+					}
+				}
+			case 71:
+//line scan_tokens.rl:89
+				te = p + 1
+				{
+					token(TokenOHeredoc)
+					// the token is currently the whole heredoc introducer, like
+					// <<EOT or <<-EOT, followed by a newline. We want to extract
+					// just the "EOT" portion that we'll use as the closing marker.
+
+					marker := data[ts+2 : te-1]
+					if marker[0] == '-' {
+						marker = marker[1:]
+					}
+					if marker[len(marker)-1] == '\r' {
+						marker = marker[:len(marker)-1]
+					}
+
+					heredocs = append(heredocs, heredocInProgress{
+						Marker:      marker,
+						StartOfLine: true,
+					})
+
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1523
+						goto _again
+					}
+				}
+			case 72:
+//line scan_tokens.rl:301
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 73:
+//line scan_tokens.rl:302
+				te = p + 1
+				{
+					token(TokenInvalid)
+				}
+			case 74:
+//line scan_tokens.rl:276
+				te = p
+				p--
+
+			case 75:
+//line scan_tokens.rl:277
+				te = p
+				p--
+				{
+					token(TokenNumberLit)
+				}
+			case 76:
+//line scan_tokens.rl:278
+				te = p
+				p--
+				{
+					token(TokenIdent)
+				}
+			case 77:
+//line scan_tokens.rl:280
+				te = p
+				p--
+				{
+					token(TokenComment)
+				}
+			case 78:
+//line scan_tokens.rl:291
+				te = p
+				p--
+				{
+					selfToken()
+				}
+			case 79:
+//line scan_tokens.rl:301
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 80:
+//line scan_tokens.rl:302
+				te = p
+				p--
+				{
+					token(TokenInvalid)
+				}
+			case 81:
+//line scan_tokens.rl:277
+				p = (te) - 1
+				{
+					token(TokenNumberLit)
+				}
+			case 82:
+//line scan_tokens.rl:278
+				p = (te) - 1
+				{
+					token(TokenIdent)
+				}
+			case 83:
+//line scan_tokens.rl:291
+				p = (te) - 1
+				{
+					selfToken()
+				}
+			case 84:
+//line scan_tokens.rl:301
+				p = (te) - 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 85:
+//line NONE:1
+				switch act {
+				case 22:
+					{
+						p = (te) - 1
+						token(TokenIdent)
+					}
+				case 39:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				}
+
+//line scan_tokens.go:5055
+			}
+		}
+
+	_again:
+		_acts = int(_hcltok_to_state_actions[cs])
+		_nacts = uint(_hcltok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _hcltok_actions[_acts-1] {
+			case 1:
+//line NONE:1
+				ts = 0
+
+			case 2:
+//line NONE:1
+				act = 0
+
+//line scan_tokens.go:5073
+			}
+		}
+
+		if cs == 0 {
+			goto _out
+		}
+		p++
+		if p != pe {
+			goto _resume
+		}
+	_test_eof:
+		{
+		}
+		if p == eof {
+			if _hcltok_eof_trans[cs] > 0 {
+				_trans = int(_hcltok_eof_trans[cs] - 1)
+				goto _eof_trans
+			}
+		}
+
+	_out:
+		{
+		}
+	}
+
+//line scan_tokens.rl:363
+
+	// If we fall out here without being in a final state then we've
+	// encountered something that the scanner can't match, which we'll
+	// deal with as an invalid.
+	if cs < hcltok_first_final {
+		if mode == scanTemplate && len(stack) == 0 {
+			// If we're scanning a bare template then any straggling
+			// top-level stuff is actually literal string, rather than
+			// invalid. This handles the case where the template ends
+			// with a single "$" or "%", which trips us up because we
+			// want to see another character to decide if it's a sequence
+			// or an escape.
+			f.emitToken(TokenStringLit, ts, len(data))
+		} else {
+			f.emitToken(TokenInvalid, ts, len(data))
+		}
+	}
+
+	// We always emit a synthetic EOF token at the end, since it gives the
+	// parser position information for an "unexpected EOF" diagnostic.
+	f.emitToken(TokenEOF, len(data), len(data))
+
+	return f.Tokens
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.rl b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.rl
new file mode 100644
index 000000000..942ad92ba
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/scan_tokens.rl
@@ -0,0 +1,395 @@
+
+package hclsyntax
+
+import (
+    "bytes"
+
+    "github.com/hashicorp/hcl/v2"
+)
+
+// This file is generated from scan_tokens.rl. DO NOT EDIT.
+%%{
+  # (except when you are actually in scan_tokens.rl here, so edit away!)
+
+  machine hcltok;
+  write data;
+}%%
+
+func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token {
+    stripData := stripUTF8BOM(data)
+    start.Byte += len(data) - len(stripData)
+    data = stripData
+
+    f := &tokenAccum{
+        Filename:  filename,
+        Bytes:     data,
+        Pos:       start,
+        StartByte: start.Byte,
+    }
+
+    %%{
+        include UnicodeDerived "unicode_derived.rl";
+
+        UTF8Cont = 0x80 .. 0xBF;
+        AnyUTF8 = (
+            0x00..0x7F |
+            0xC0..0xDF . UTF8Cont |
+            0xE0..0xEF . UTF8Cont . UTF8Cont |
+            0xF0..0xF7 . UTF8Cont . UTF8Cont . UTF8Cont
+        );
+        BrokenUTF8 = any - AnyUTF8;
+
+        NumberLitContinue = (digit|'.'|('e'|'E') ('+'|'-')? digit);
+        NumberLit = digit ("" | (NumberLitContinue - '.') | (NumberLitContinue* (NumberLitContinue - '.')));
+        Ident = (ID_Start | '_') (ID_Continue | '-')*;
+
+        # Symbols that just represent themselves are handled as a single rule.
+        SelfToken = "[" | "]" | "(" | ")" | "." | "," | "*" | "/" | "%" | "+" | "-" | "=" | "<" | ">" | "!" | "?" | ":" | "\n" | "&" | "|" | "~" | "^" | ";" | "`" | "'";
+
+        EqualOp = "==";
+        NotEqual = "!=";
+        GreaterThanEqual = ">=";
+        LessThanEqual = "<=";
+        LogicalAnd = "&&";
+        LogicalOr = "||";
+
+        Ellipsis = "...";
+        FatArrow = "=>";
+
+        Newline = '\r' ? '\n';
+        EndOfLine = Newline;
+
+        BeginStringTmpl = '"';
+        BeginHeredocTmpl = '<<' ('-')? Ident Newline;
+
+        Comment = (
+            # The :>> operator in these is a "finish-guarded concatenation",
+            # which terminates the sequence on its left when it completes
+            # the sequence on its right.
+            # In the single-line comment cases this is allowing us to make
+            # the trailing EndOfLine optional while still having the overall
+            # pattern terminate. In the multi-line case it ensures that
+            # the first comment in the file ends at the first */, rather than
+            # gobbling up all of the "any*" until the _final_ */ in the file.
+            ("#" (any - EndOfLine)* :>> EndOfLine?) |
+            ("//" (any - EndOfLine)* :>> EndOfLine?) |
+            ("/*" any* :>> "*/")
+        );
+
+        # Note: hclwrite assumes that only ASCII spaces appear between tokens,
+        # and uses this assumption to recreate the spaces between tokens by
+        # looking at byte offset differences. This means it will produce
+        # incorrect results in the presence of tabs, but that's acceptable
+        # because the canonical style (which hclwrite itself can impose
+        # automatically is to never use tabs).
+        Spaces = (' ' | 0x09)+;
+
+        action beginStringTemplate {
+            token(TokenOQuote);
+            fcall stringTemplate;
+        }
+
+        action endStringTemplate {
+            token(TokenCQuote);
+            fret;
+        }
+
+        action beginHeredocTemplate {
+            token(TokenOHeredoc);
+            // the token is currently the whole heredoc introducer, like
+            // <<EOT or <<-EOT, followed by a newline. We want to extract
+            // just the "EOT" portion that we'll use as the closing marker.
+
+            marker := data[ts+2:te-1]
+            if marker[0] == '-' {
+                marker = marker[1:]
+            }
+            if marker[len(marker)-1] == '\r' {
+                marker = marker[:len(marker)-1]
+            }
+
+            heredocs = append(heredocs, heredocInProgress{
+                Marker:      marker,
+                StartOfLine: true,
+            })
+
+            fcall heredocTemplate;
+        }
+
+        action heredocLiteralEOL {
+            // This action is called specificially when a heredoc literal
+            // ends with a newline character.
+
+            // This might actually be our end marker.
+            topdoc := &heredocs[len(heredocs)-1]
+            if topdoc.StartOfLine {
+                maybeMarker := bytes.TrimSpace(data[ts:te])
+                if bytes.Equal(maybeMarker, topdoc.Marker) {
+                    // We actually emit two tokens here: the end-of-heredoc
+                    // marker first, and then separately the newline that
+                    // follows it. This then avoids issues with the closing
+                    // marker consuming a newline that would normally be used
+                    // to mark the end of an attribute definition.
+                    // We might have either a \n sequence or an \r\n sequence
+                    // here, so we must handle both.
+                    nls := te-1
+                    nle := te
+                    te--
+                    if data[te-1] == '\r' {
+                        // back up one more byte
+                        nls--
+                        te--
+                    }
+                    token(TokenCHeredoc);
+                    ts = nls
+                    te = nle
+                    token(TokenNewline);
+                    heredocs = heredocs[:len(heredocs)-1]
+                    fret;
+                }
+            }
+
+            topdoc.StartOfLine = true;
+            token(TokenStringLit);
+        }
+
+        action heredocLiteralMidline {
+            // This action is called when a heredoc literal _doesn't_ end
+            // with a newline character, e.g. because we're about to enter
+            // an interpolation sequence.
+            heredocs[len(heredocs)-1].StartOfLine = false;
+            token(TokenStringLit);
+        }
+
+        action bareTemplateLiteral {
+            token(TokenStringLit);
+        }
+
+        action beginTemplateInterp {
+            token(TokenTemplateInterp);
+            braces++;
+            retBraces = append(retBraces, braces);
+            if len(heredocs) > 0 {
+                heredocs[len(heredocs)-1].StartOfLine = false;
+            }
+            fcall main;
+        }
+
+        action beginTemplateControl {
+            token(TokenTemplateControl);
+            braces++;
+            retBraces = append(retBraces, braces);
+            if len(heredocs) > 0 {
+                heredocs[len(heredocs)-1].StartOfLine = false;
+            }
+            fcall main;
+        }
+
+        action openBrace {
+            token(TokenOBrace);
+            braces++;
+        }
+
+        action closeBrace {
+            if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
+                token(TokenTemplateSeqEnd);
+                braces--;
+                retBraces = retBraces[0:len(retBraces)-1]
+                fret;
+            } else {
+                token(TokenCBrace);
+                braces--;
+            }
+        }
+
+        action closeTemplateSeqEatWhitespace {
+            // Only consume from the retBraces stack and return if we are at
+            // a suitable brace nesting level, otherwise things will get
+            // confused. (Not entering this branch indicates a syntax error,
+            // which we will catch in the parser.)
+            if len(retBraces) > 0 && retBraces[len(retBraces)-1] == braces {
+                token(TokenTemplateSeqEnd);
+                braces--;
+                retBraces = retBraces[0:len(retBraces)-1]
+                fret;
+            } else {
+                // We intentionally generate a TokenTemplateSeqEnd here,
+                // even though the user apparently wanted a brace, because
+                // we want to allow the parser to catch the incorrect use
+                // of a ~} to balance a generic opening brace, rather than
+                // a template sequence.
+                token(TokenTemplateSeqEnd);
+                braces--;
+            }
+        }
+
+        TemplateInterp = "${" ("~")?;
+        TemplateControl = "%{" ("~")?;
+        EndStringTmpl = '"';
+        NewlineChars = ("\r"|"\n");
+        NewlineCharsSeq = NewlineChars+;
+        StringLiteralChars = (AnyUTF8 - NewlineChars);
+        TemplateIgnoredNonBrace = (^'{' %{ fhold; });
+        TemplateNotInterp = '$' (TemplateIgnoredNonBrace | TemplateInterp);
+        TemplateNotControl = '%' (TemplateIgnoredNonBrace | TemplateControl);
+        QuotedStringLiteralWithEsc = ('\\' StringLiteralChars) | (StringLiteralChars - ("$" | '%' | '"' | "\\"));
+        TemplateStringLiteral = (
+            (TemplateNotInterp) |
+            (TemplateNotControl) |
+            (QuotedStringLiteralWithEsc)+
+        );
+        HeredocStringLiteral = (
+            (TemplateNotInterp) |
+            (TemplateNotControl) |
+            (StringLiteralChars - ("$" | '%'))*
+        );
+        BareStringLiteral = (
+            (TemplateNotInterp) |
+            (TemplateNotControl) |
+            (StringLiteralChars - ("$" | '%'))*
+        ) Newline?;
+
+        stringTemplate := |*
+            TemplateInterp        => beginTemplateInterp;
+            TemplateControl       => beginTemplateControl;
+            EndStringTmpl         => endStringTemplate;
+            TemplateStringLiteral => { token(TokenQuotedLit); };
+            NewlineCharsSeq       => { token(TokenQuotedNewline); };
+            AnyUTF8               => { token(TokenInvalid); };
+            BrokenUTF8            => { token(TokenBadUTF8); };
+        *|;
+
+        heredocTemplate := |*
+            TemplateInterp        => beginTemplateInterp;
+            TemplateControl       => beginTemplateControl;
+            HeredocStringLiteral EndOfLine => heredocLiteralEOL;
+            HeredocStringLiteral  => heredocLiteralMidline;
+            BrokenUTF8            => { token(TokenBadUTF8); };
+        *|;
+
+        bareTemplate := |*
+            TemplateInterp        => beginTemplateInterp;
+            TemplateControl       => beginTemplateControl;
+            BareStringLiteral     => bareTemplateLiteral;
+            BrokenUTF8            => { token(TokenBadUTF8); };
+        *|;
+
+        identOnly := |*
+            Ident            => { token(TokenIdent) };
+            BrokenUTF8       => { token(TokenBadUTF8) };
+            AnyUTF8          => { token(TokenInvalid) };
+        *|;
+
+        main := |*
+            Spaces           => {};
+            NumberLit        => { token(TokenNumberLit) };
+            Ident            => { token(TokenIdent) };
+
+            Comment          => { token(TokenComment) };
+            Newline          => { token(TokenNewline) };
+
+            EqualOp          => { token(TokenEqualOp); };
+            NotEqual         => { token(TokenNotEqual); };
+            GreaterThanEqual => { token(TokenGreaterThanEq); };
+            LessThanEqual    => { token(TokenLessThanEq); };
+            LogicalAnd       => { token(TokenAnd); };
+            LogicalOr        => { token(TokenOr); };
+            Ellipsis         => { token(TokenEllipsis); };
+            FatArrow         => { token(TokenFatArrow); };
+            SelfToken        => { selfToken() };
+
+            "{"              => openBrace;
+            "}"              => closeBrace;
+
+            "~}"             => closeTemplateSeqEatWhitespace;
+
+            BeginStringTmpl  => beginStringTemplate;
+            BeginHeredocTmpl => beginHeredocTemplate;
+
+            BrokenUTF8       => { token(TokenBadUTF8) };
+            AnyUTF8          => { token(TokenInvalid) };
+        *|;
+
+    }%%
+
+    // Ragel state
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    act := 0
+    eof := pe
+    var stack []int
+    var top int
+
+    var cs int // current state
+    switch mode {
+    case scanNormal:
+        cs = hcltok_en_main
+    case scanTemplate:
+        cs = hcltok_en_bareTemplate
+    case scanIdentOnly:
+        cs = hcltok_en_identOnly
+    default:
+        panic("invalid scanMode")
+    }
+
+    braces := 0
+    var retBraces []int // stack of brace levels that cause us to use fret
+    var heredocs []heredocInProgress // stack of heredocs we're currently processing
+
+    %%{
+        prepush {
+            stack = append(stack, 0);
+        }
+        postpop {
+            stack = stack[:len(stack)-1];
+        }
+    }%%
+
+    // Make Go compiler happy
+    _ = ts
+    _ = te
+    _ = act
+    _ = eof
+
+    token := func (ty TokenType) {
+        f.emitToken(ty, ts, te)
+    }
+    selfToken := func () {
+        b := data[ts:te]
+        if len(b) != 1 {
+            // should never happen
+            panic("selfToken only works for single-character tokens")
+        }
+        f.emitToken(TokenType(b[0]), ts, te)
+    }
+
+    %%{
+        write init nocs;
+        write exec;
+    }%%
+
+    // If we fall out here without being in a final state then we've
+    // encountered something that the scanner can't match, which we'll
+    // deal with as an invalid.
+    if cs < hcltok_first_final {
+        if mode == scanTemplate && len(stack) == 0 {
+            // If we're scanning a bare template then any straggling
+            // top-level stuff is actually literal string, rather than
+            // invalid. This handles the case where the template ends
+            // with a single "$" or "%", which trips us up because we
+            // want to see another character to decide if it's a sequence
+            // or an escape.
+            f.emitToken(TokenStringLit, ts, len(data))
+        } else {
+            f.emitToken(TokenInvalid, ts, len(data))
+        }
+    }
+
+    // We always emit a synthetic EOF token at the end, since it gives the
+    // parser position information for an "unexpected EOF" diagnostic.
+    f.emitToken(TokenEOF, len(data), len(data))
+
+    return f.Tokens
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/spec.md b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/spec.md
new file mode 100644
index 000000000..3fc5f5f1b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/spec.md
@@ -0,0 +1,941 @@
+# HCL Native Syntax Specification
+
+This is the specification of the syntax and semantics of the native syntax
+for HCL. HCL is a system for defining configuration languages for applications.
+The HCL information model is designed to support multiple concrete syntaxes
+for configuration, but this native syntax is considered the primary format
+and is optimized for human authoring and maintenance, as opposed to machine
+generation of configuration.
+
+The language consists of three integrated sub-languages:
+
+- The _structural_ language defines the overall hierarchical configuration
+  structure, and is a serialization of HCL bodies, blocks and attributes.
+
+- The _expression_ language is used to express attribute values, either as
+  literals or as derivations of other values.
+
+- The _template_ language is used to compose values together into strings,
+  as one of several types of expression in the expression language.
+
+In normal use these three sub-languages are used together within configuration
+files to describe an overall configuration, with the structural language
+being used at the top level. The expression and template languages can also
+be used in isolation, to implement features such as REPLs, debuggers, and
+integration into more limited HCL syntaxes such as the JSON profile.
+
+## Syntax Notation
+
+Within this specification a semi-formal notation is used to illustrate the
+details of syntax. This notation is intended for human consumption rather
+than machine consumption, with the following conventions:
+
+- A naked name starting with an uppercase letter is a global production,
+  common to all of the syntax specifications in this document.
+- A naked name starting with a lowercase letter is a local production,
+  meaningful only within the specification where it is defined.
+- Double and single quotes (`"` and `'`) are used to mark literal character
+  sequences, which may be either punctuation markers or keywords.
+- The default operator for combining items, which has no punctuation,
+  is concatenation.
+- The symbol `|` indicates that any one of its left and right operands may
+  be present.
+- The `*` symbol indicates zero or more repetitions of the item to its left.
+- The `?` symbol indicates zero or one of the item to its left.
+- Parentheses (`(` and `)`) are used to group items together to apply
+  the `|`, `*` and `?` operators to them collectively.
+
+The grammar notation does not fully describe the language. The prose may
+augment or conflict with the illustrated grammar. In case of conflict, prose
+has priority.
+
+## Source Code Representation
+
+Source code is unicode text expressed in the UTF-8 encoding. The language
+itself does not perform unicode normalization, so syntax features such as
+identifiers are sequences of unicode code points and so e.g. a precombined
+accented character is distinct from a letter associated with a combining
+accent. (String literals have some special handling with regard to Unicode
+normalization which will be covered later in the relevant section.)
+
+UTF-8 encoded Unicode byte order marks are not permitted. Invalid or
+non-normalized UTF-8 encoding is always a parse error.
+
+## Lexical Elements
+
+### Comments and Whitespace
+
+Comments and Whitespace are recognized as lexical elements but are ignored
+except as described below.
+
+Whitespace is defined as a sequence of zero or more space characters
+(U+0020). Newline sequences (either U+000A or U+000D followed by U+000A)
+are _not_ considered whitespace but are ignored as such in certain contexts.
+Horizontal tab characters (U+0009) are also treated as whitespace, but are
+counted only as one "column" for the purpose of reporting source positions.
+
+Comments serve as program documentation and come in two forms:
+
+- _Line comments_ start with either the `//` or `#` sequences and end with
+  the next newline sequence. A line comment is considered equivalent to a
+  newline sequence.
+
+- _Inline comments_ start with the `/*` sequence and end with the `*/`
+  sequence, and may have any characters within except the ending sequence.
+  An inline comments is considered equivalent to a whitespace sequence.
+
+Comments and whitespace cannot begin within within other comments, or within
+template literals except inside an interpolation sequence or template directive.
+
+### Identifiers
+
+Identifiers name entities such as blocks, attributes and expression variables.
+Identifiers are interpreted as per [UAX #31][uax31] Section 2. Specifically,
+their syntax is defined in terms of the `ID_Start` and `ID_Continue`
+character properties as follows:
+
+```ebnf
+Identifier = ID_Start (ID_Continue | '-')*;
+```
+
+The Unicode specification provides the normative requirements for identifier
+parsing. Non-normatively, the spirit of this specification is that `ID_Start`
+consists of Unicode letter and certain unambiguous punctuation tokens, while
+`ID_Continue` augments that set with Unicode digits, combining marks, etc.
+
+The dash character `-` is additionally allowed in identifiers, even though
+that is not part of the unicode `ID_Continue` definition. This is to allow
+attribute names and block type names to contain dashes, although underscores
+as word separators are considered the idiomatic usage.
+
+[uax31]: http://unicode.org/reports/tr31/ "Unicode Identifier and Pattern Syntax"
+
+### Keywords
+
+There are no globally-reserved words, but in some contexts certain identifiers
+are reserved to function as keywords. These are discussed further in the
+relevant documentation sections that follow. In such situations, the
+identifier's role as a keyword supersedes any other valid interpretation that
+may be possible. Outside of these specific situations, the keywords have no
+special meaning and are interpreted as regular identifiers.
+
+### Operators and Delimiters
+
+The following character sequences represent operators, delimiters, and other
+special tokens:
+
+```
++    &&   ==   <    :    {    [    (    ${
+-    ||   !=   >    ?    }    ]    )    %{
+*    !         <=        =         .
+/              >=        =>        ,
+%                                  ...
+```
+
+### Numeric Literals
+
+A numeric literal is a decimal representation of a
+real number. It has an integer part, a fractional part,
+and an exponent part.
+
+```ebnf
+NumericLit = decimal+ ("." decimal+)? (expmark decimal+)?;
+decimal    = '0' .. '9';
+expmark    = ('e' | 'E') ("+" | "-")?;
+```
+
+## Structural Elements
+
+The structural language consists of syntax representing the following
+constructs:
+
+- _Attributes_, which assign a value to a specified name.
+- _Blocks_, which create a child body annotated by a type and optional labels.
+- _Body Content_, which consists of a collection of attributes and blocks.
+
+These constructs correspond to the similarly-named concepts in the
+language-agnostic HCL information model.
+
+```ebnf
+ConfigFile   = Body;
+Body         = (Attribute | Block | OneLineBlock)*;
+Attribute    = Identifier "=" Expression Newline;
+Block        = Identifier (StringLit|Identifier)* "{" Newline Body "}" Newline;
+OneLineBlock = Identifier (StringLit|Identifier)* "{" (Identifier "=" Expression)? "}" Newline;
+```
+
+### Configuration Files
+
+A _configuration file_ is a sequence of characters whose top-level is
+interpreted as a Body.
+
+### Bodies
+
+A _body_ is a collection of associated attributes and blocks. The meaning of
+this association is defined by the calling application.
+
+### Attribute Definitions
+
+An _attribute definition_ assigns a value to a particular attribute name within
+a body. Each distinct attribute name may be defined no more than once within a
+single body.
+
+The attribute value is given as an expression, which is retained literally
+for later evaluation by the calling application.
+
+### Blocks
+
+A _block_ creates a child body that is annotated with a block _type_ and
+zero or more block _labels_. Blocks create a structural hierarchy which can be
+interpreted by the calling application.
+
+Block labels can either be quoted literal strings or naked identifiers.
+
+## Expressions
+
+The expression sub-language is used within attribute definitions to specify
+values.
+
+```ebnf
+Expression = (
+    ExprTerm |
+    Operation |
+    Conditional
+);
+```
+
+### Types
+
+The value types used within the expression language are those defined by the
+syntax-agnostic HCL information model. An expression may return any valid
+type, but only a subset of the available types have first-class syntax.
+A calling application may make other types available via _variables_ and
+_functions_.
+
+### Expression Terms
+
+Expression _terms_ are the operands for unary and binary expressions, as well
+as acting as expressions in their own right.
+
+```ebnf
+ExprTerm = (
+    LiteralValue |
+    CollectionValue |
+    TemplateExpr |
+    VariableExpr |
+    FunctionCall |
+    ForExpr |
+    ExprTerm Index |
+    ExprTerm GetAttr |
+    ExprTerm Splat |
+    "(" Expression ")"
+);
+```
+
+The productions for these different term types are given in their corresponding
+sections.
+
+Between the `(` and `)` characters denoting a sub-expression, newline
+characters are ignored as whitespace.
+
+### Literal Values
+
+A _literal value_ immediately represents a particular value of a primitive
+type.
+
+```ebnf
+LiteralValue = (
+  NumericLit |
+  "true" |
+  "false" |
+  "null"
+);
+```
+
+- Numeric literals represent values of type _number_.
+- The `true` and `false` keywords represent values of type _bool_.
+- The `null` keyword represents a null value of the dynamic pseudo-type.
+
+String literals are not directly available in the expression sub-language, but
+are available via the template sub-language, which can in turn be incorporated
+via _template expressions_.
+
+### Collection Values
+
+A _collection value_ combines zero or more other expressions to produce a
+collection value.
+
+```ebnf
+CollectionValue = tuple | object;
+tuple = "[" (
+    (Expression ("," Expression)* ","?)?
+) "]";
+object = "{" (
+    (objectelem ("," objectelem)* ","?)?
+) "}";
+objectelem = (Identifier | Expression) "=" Expression;
+```
+
+Only tuple and object values can be directly constructed via native syntax.
+Tuple and object values can in turn be converted to list, set and map values
+with other operations, which behaves as defined by the syntax-agnostic HCL
+information model.
+
+When specifying an object element, an identifier is interpreted as a literal
+attribute name as opposed to a variable reference. To populate an item key
+from a variable, use parentheses to disambiguate:
+
+- `{foo = "baz"}` is interpreted as an attribute literally named `foo`.
+- `{(foo) = "baz"}` is interpreted as an attribute whose name is taken
+  from the variable named `foo`.
+
+Between the open and closing delimiters of these sequences, newline sequences
+are ignored as whitespace.
+
+There is a syntax ambiguity between _for expressions_ and collection values
+whose first element is a reference to a variable named `for`. The
+_for expression_ interpretation has priority, so to produce a tuple whose
+first element is the value of a variable named `for`, or an object with a
+key named `for`, use parentheses to disambiguate:
+
+- `[for, foo, baz]` is a syntax error.
+- `[(for), foo, baz]` is a tuple whose first element is the value of variable
+  `for`.
+- `{for: 1, baz: 2}` is a syntax error.
+- `{(for): 1, baz: 2}` is an object with an attribute literally named `for`.
+- `{baz: 2, for: 1}` is equivalent to the previous example, and resolves the
+  ambiguity by reordering.
+
+### Template Expressions
+
+A _template expression_ embeds a program written in the template sub-language
+as an expression. Template expressions come in two forms:
+
+- A _quoted_ template expression is delimited by quote characters (`"`) and
+  defines a template as a single-line expression with escape characters.
+- A _heredoc_ template expression is introduced by a `<<` sequence and
+  defines a template via a multi-line sequence terminated by a user-chosen
+  delimiter.
+
+In both cases the template interpolation and directive syntax is available for
+use within the delimiters, and any text outside of these special sequences is
+interpreted as a literal string.
+
+In _quoted_ template expressions any literal string sequences within the
+template behave in a special way: literal newline sequences are not permitted
+and instead _escape sequences_ can be included, starting with the
+backslash `\`:
+
+```
+    \n         Unicode newline control character
+    \r         Unicode carriage return control character
+    \t         Unicode tab control character
+    \"         Literal quote mark, used to prevent interpretation as end of string
+    \\         Literal backslash, used to prevent interpretation as escape sequence
+    \uNNNN     Unicode character from Basic Multilingual Plane (NNNN is four hexadecimal digits)
+    \UNNNNNNNN Unicode character from supplementary planes (NNNNNNNN is eight hexadecimal digits)
+```
+
+The _heredoc_ template expression type is introduced by either `<<` or `<<-`,
+followed by an identifier. The template expression ends when the given
+identifier subsequently appears again on a line of its own.
+
+If a heredoc template is introduced with the `<<-` symbol, any literal string
+at the start of each line is analyzed to find the minimum number of leading
+spaces, and then that number of prefix spaces is removed from all line-leading
+literal strings. The final closing marker may also have an arbitrary number
+of spaces preceding it on its line.
+
+```ebnf
+TemplateExpr = quotedTemplate | heredocTemplate;
+quotedTemplate = (as defined in prose above);
+heredocTemplate = (
+    ("<<" | "<<-") Identifier Newline
+    (content as defined in prose above)
+    Identifier Newline
+);
+```
+
+A quoted template expression containing only a single literal string serves
+as a syntax for defining literal string _expressions_. In certain contexts
+the template syntax is restricted in this manner:
+
+```ebnf
+StringLit = '"' (quoted literals as defined in prose above) '"';
+```
+
+The `StringLit` production permits the escape sequences discussed for quoted
+template expressions as above, but does _not_ permit template interpolation
+or directive sequences.
+
+### Variables and Variable Expressions
+
+A _variable_ is a value that has been assigned a symbolic name. Variables are
+made available for use in expressions by the calling application, by populating
+the _global scope_ used for expression evaluation.
+
+Variables can also be created by expressions themselves, which always creates
+a _child scope_ that incorporates the variables from its parent scope but
+(re-)defines zero or more names with new values.
+
+The value of a variable is accessed using a _variable expression_, which is
+a standalone `Identifier` whose name corresponds to a defined variable:
+
+```ebnf
+VariableExpr = Identifier;
+```
+
+Variables in a particular scope are immutable, but child scopes may _hide_
+a variable from an ancestor scope by defining a new variable of the same name.
+When looking up variables, the most locally-defined variable of the given name
+is used, and ancestor-scoped variables of the same name cannot be accessed.
+
+No direct syntax is provided for declaring or assigning variables, but other
+expression constructs implicitly create child scopes and define variables as
+part of their evaluation.
+
+### Functions and Function Calls
+
+A _function_ is an operation that has been assigned a symbolic name. Functions
+are made available for use in expressions by the calling application, by
+populating the _function table_ used for expression evaluation.
+
+The namespace of functions is distinct from the namespace of variables. A
+function and a variable may share the same name with no implication that they
+are in any way related.
+
+A function can be executed via a _function call_ expression:
+
+```ebnf
+FunctionCall = Identifier "(" arguments ")";
+Arguments = (
+    () ||
+    (Expression ("," Expression)* ("," | "...")?)
+);
+```
+
+The definition of functions and the semantics of calling them are defined by
+the language-agnostic HCL information model. The given arguments are mapped
+onto the function's _parameters_ and the result of a function call expression
+is the return value of the named function when given those arguments.
+
+If the final argument expression is followed by the ellipsis symbol (`...`),
+the final argument expression must evaluate to either a list or tuple value.
+The elements of the value are each mapped to a single parameter of the
+named function, beginning at the first parameter remaining after all other
+argument expressions have been mapped.
+
+Within the parentheses that delimit the function arguments, newline sequences
+are ignored as whitespace.
+
+### For Expressions
+
+A _for expression_ is a construct for constructing a collection by projecting
+the items from another collection.
+
+```ebnf
+ForExpr = forTupleExpr | forObjectExpr;
+forTupleExpr = "[" forIntro Expression forCond? "]";
+forObjectExpr = "{" forIntro Expression "=>" Expression "..."? forCond? "}";
+forIntro = "for" Identifier ("," Identifier)? "in" Expression ":";
+forCond = "if" Expression;
+```
+
+The punctuation used to delimit a for expression decide whether it will produce
+a tuple value (`[` and `]`) or an object value (`{` and `}`).
+
+The "introduction" is equivalent in both cases: the keyword `for` followed by
+either one or two identifiers separated by a comma which define the temporary
+variable names used for iteration, followed by the keyword `in` and then
+an expression that must evaluate to a value that can be iterated. The
+introduction is then terminated by the colon (`:`) symbol.
+
+If only one identifier is provided, it is the name of a variable that will
+be temporarily assigned the value of each element during iteration. If both
+are provided, the first is the key and the second is the value.
+
+Tuple, object, list, map, and set types are iterable. The type of collection
+used defines how the key and value variables are populated:
+
+- For tuple and list types, the _key_ is the zero-based index into the
+  sequence for each element, and the _value_ is the element value. The
+  elements are visited in index order.
+- For object and map types, the _key_ is the string attribute name or element
+  key, and the _value_ is the attribute or element value. The elements are
+  visited in the order defined by a lexicographic sort of the attribute names
+  or keys.
+- For set types, the _key_ and _value_ are both the element value. The elements
+  are visited in an undefined but consistent order.
+
+The expression after the colon and (in the case of object `for`) the expression
+after the `=>` are both evaluated once for each element of the source
+collection, in a local scope that defines the key and value variable names
+specified.
+
+The results of evaluating these expressions for each input element are used
+to populate an element in the new collection. In the case of tuple `for`, the
+single expression becomes an element, appending values to the tuple in visit
+order. In the case of object `for`, the pair of expressions is used as an
+attribute name and value respectively, creating an element in the resulting
+object.
+
+In the case of object `for`, it is an error if two input elements produce
+the same result from the attribute name expression, since duplicate
+attributes are not possible. If the ellipsis symbol (`...`) appears
+immediately after the value expression, this activates the grouping mode in
+which each value in the resulting object is a _tuple_ of all of the values
+that were produced against each distinct key.
+
+- `[for v in ["a", "b"]: v]` returns `["a", "b"]`.
+- `[for i, v in ["a", "b"]: i]` returns `[0, 1]`.
+- `{for i, v in ["a", "b"]: v => i}` returns `{a = 0, b = 1}`.
+- `{for i, v in ["a", "a", "b"]: k => v}` produces an error, because attribute
+  `a` is defined twice.
+- `{for i, v in ["a", "a", "b"]: v => i...}` returns `{a = [0, 1], b = [2]}`.
+
+If the `if` keyword is used after the element expression(s), it applies an
+additional predicate that can be used to conditionally filter elements from
+the source collection from consideration. The expression following `if` is
+evaluated once for each source element, in the same scope used for the
+element expression(s). It must evaluate to a boolean value; if `true`, the
+element will be evaluated as normal, while if `false` the element will be
+skipped.
+
+- `[for i, v in ["a", "b", "c"]: v if i < 2]` returns `["a", "b"]`.
+
+If the collection value, element expression(s) or condition expression return
+unknown values that are otherwise type-valid, the result is a value of the
+dynamic pseudo-type.
+
+### Index Operator
+
+The _index_ operator returns the value of a single element of a collection
+value. It is a postfix operator and can be applied to any value that has
+a tuple, object, map, or list type.
+
+```ebnf
+Index = "[" Expression "]";
+```
+
+The expression delimited by the brackets is the _key_ by which an element
+will be looked up.
+
+If the index operator is applied to a value of tuple or list type, the
+key expression must be an non-negative integer number representing the
+zero-based element index to access. If applied to a value of object or map
+type, the key expression must be a string representing the attribute name
+or element key. If the given key value is not of the appropriate type, a
+conversion is attempted using the conversion rules from the HCL
+syntax-agnostic information model.
+
+An error is produced if the given key expression does not correspond to
+an element in the collection, either because it is of an unconvertable type,
+because it is outside the range of elements for a tuple or list, or because
+the given attribute or key does not exist.
+
+If either the collection or the key are an unknown value of an
+otherwise-suitable type, the return value is an unknown value whose type
+matches what type would be returned given known values, or a value of the
+dynamic pseudo-type if type information alone cannot determine a suitable
+return type.
+
+Within the brackets that delimit the index key, newline sequences are ignored
+as whitespace.
+
+The HCL native syntax also includes a _legacy_ index operator that exists
+only for compatibility with the precursor language HIL:
+
+```ebnf
+LegacyIndex = '.' digit+
+```
+
+This legacy index operator must be supported by parser for compatibility but
+should not be used in new configurations. This allows an attribute-access-like
+syntax for indexing, must still be interpreted as an index operation rather
+than attribute access.
+
+The legacy syntax does not support chaining of index operations, like
+`foo.0.0.bar`, because the interpretation of `0.0` as a number literal token
+takes priority and thus renders the resulting sequence invalid.
+
+### Attribute Access Operator
+
+The _attribute access_ operator returns the value of a single attribute in
+an object value. It is a postfix operator and can be applied to any value
+that has an object type.
+
+```ebnf
+GetAttr = "." Identifier;
+```
+
+The given identifier is interpreted as the name of the attribute to access.
+An error is produced if the object to which the operator is applied does not
+have an attribute with the given name.
+
+If the object is an unknown value of a type that has the attribute named, the
+result is an unknown value of the attribute's type.
+
+### Splat Operators
+
+The _splat operators_ allow convenient access to attributes or elements of
+elements in a tuple, list, or set value.
+
+There are two kinds of "splat" operator:
+
+- The _attribute-only_ splat operator supports only attribute lookups into
+  the elements from a list, but supports an arbitrary number of them.
+
+- The _full_ splat operator additionally supports indexing into the elements
+  from a list, and allows any combination of attribute access and index
+  operations.
+
+```ebnf
+Splat = attrSplat | fullSplat;
+attrSplat = "." "*" GetAttr*;
+fullSplat = "[" "*" "]" (GetAttr | Index)*;
+```
+
+The splat operators can be thought of as shorthands for common operations that
+could otherwise be performed using _for expressions_:
+
+- `tuple.*.foo.bar[0]` is approximately equivalent to
+  `[for v in tuple: v.foo.bar][0]`.
+- `tuple[*].foo.bar[0]` is approximately equivalent to
+  `[for v in tuple: v.foo.bar[0]]`
+
+Note the difference in how the trailing index operator is interpreted in
+each case. This different interpretation is the key difference between the
+_attribute-only_ and _full_ splat operators.
+
+Splat operators have one additional behavior compared to the equivalent
+_for expressions_ shown above: if a splat operator is applied to a value that
+is _not_ of tuple, list, or set type, the value is coerced automatically into
+a single-value list of the value type:
+
+- `any_object.*.id` is equivalent to `[any_object.id]`, assuming that `any_object`
+  is a single object.
+- `any_number.*` is equivalent to `[any_number]`, assuming that `any_number`
+  is a single number.
+
+If applied to a null value that is not tuple, list, or set, the result is always
+an empty tuple, which allows conveniently converting a possibly-null scalar
+value into a tuple of zero or one elements. It is illegal to apply a splat
+operator to a null value of tuple, list, or set type.
+
+### Operations
+
+Operations apply a particular operator to either one or two expression terms.
+
+```ebnf
+Operation = unaryOp | binaryOp;
+unaryOp = ("-" | "!") ExprTerm;
+binaryOp = ExprTerm binaryOperator ExprTerm;
+binaryOperator = compareOperator | arithmeticOperator | logicOperator;
+compareOperator = "==" | "!=" | "<" | ">" | "<=" | ">=";
+arithmeticOperator = "+" | "-" | "*" | "/" | "%";
+logicOperator = "&&" | "||" | "!";
+```
+
+The unary operators have the highest precedence.
+
+The binary operators are grouped into the following precedence levels:
+
+```
+Level    Operators
+  6      * / %
+  5      + -
+  4      > >= < <=
+  3      == !=
+  2      &&
+  1      ||
+```
+
+Higher values of "level" bind tighter. Operators within the same precedence
+level have left-to-right associativity. For example, `x / y * z` is equivalent
+to `(x / y) * z`.
+
+### Comparison Operators
+
+Comparison operators always produce boolean values, as a result of testing
+the relationship between two values.
+
+The two equality operators apply to values of any type:
+
+```
+a == b  equal
+a != b  not equal
+```
+
+Two values are equal if the are of identical types and their values are
+equal as defined in the HCL syntax-agnostic information model. The equality
+operators are commutative and opposite, such that `(a == b) == !(a != b)`
+and `(a == b) == (b == a)` for all values `a` and `b`.
+
+The four numeric comparison operators apply only to numbers:
+
+```
+a < b   less than
+a <= b  less than or equal to
+a > b   greater than
+a >= b  greater than or equal to
+```
+
+If either operand of a comparison operator is a correctly-typed unknown value
+or a value of the dynamic pseudo-type, the result is an unknown boolean.
+
+### Arithmetic Operators
+
+Arithmetic operators apply only to number values and always produce number
+values as results.
+
+```
+a + b   sum        (addition)
+a - b   difference (subtraction)
+a * b   product    (multiplication)
+a / b   quotient   (division)
+a % b   remainder  (modulo)
+-a      negation
+```
+
+Arithmetic operations are considered to be performed in an arbitrary-precision
+number space.
+
+If either operand of an arithmetic operator is an unknown number or a value
+of the dynamic pseudo-type, the result is an unknown number.
+
+### Logic Operators
+
+Logic operators apply only to boolean values and always produce boolean values
+as results.
+
+```
+a && b   logical AND
+a || b   logical OR
+!a       logical NOT
+```
+
+If either operand of a logic operator is an unknown bool value or a value
+of the dynamic pseudo-type, the result is an unknown bool value.
+
+### Conditional Operator
+
+The conditional operator allows selecting from one of two expressions based on
+the outcome of a boolean expression.
+
+```ebnf
+Conditional = Expression "?" Expression ":" Expression;
+```
+
+The first expression is the _predicate_, which is evaluated and must produce
+a boolean result. If the predicate value is `true`, the result of the second
+expression is the result of the conditional. If the predicate value is
+`false`, the result of the third expression is the result of the conditional.
+
+The second and third expressions must be of the same type or must be able to
+unify into a common type using the type unification rules defined in the
+HCL syntax-agnostic information model. This unified type is the result type
+of the conditional, with both expressions converted as necessary to the
+unified type.
+
+If the predicate is an unknown boolean value or a value of the dynamic
+pseudo-type then the result is an unknown value of the unified type of the
+other two expressions.
+
+If either the second or third expressions produce errors when evaluated,
+these errors are passed through only if the erroneous expression is selected.
+This allows for expressions such as
+`length(some_list) > 0 ? some_list[0] : default` (given some suitable `length`
+function) without producing an error when the predicate is `false`.
+
+## Templates
+
+The template sub-language is used within template expressions to concisely
+combine strings and other values to produce other strings. It can also be
+used in isolation as a standalone template language.
+
+```ebnf
+Template = (
+    TemplateLiteral |
+    TemplateInterpolation |
+    TemplateDirective
+)*
+TemplateDirective = TemplateIf | TemplateFor;
+```
+
+A template behaves like an expression that always returns a string value.
+The different elements of the template are evaluated and combined into a
+single string to return. If any of the elements produce an unknown string
+or a value of the dynamic pseudo-type, the result is an unknown string.
+
+An important use-case for standalone templates is to enable the use of
+expressions in alternative HCL syntaxes where a native expression grammar is
+not available. For example, the HCL JSON profile treats the values of JSON
+strings as standalone templates when attributes are evaluated in expression
+mode.
+
+### Template Literals
+
+A template literal is a literal sequence of characters to include in the
+resulting string. When the template sub-language is used standalone, a
+template literal can contain any unicode character, with the exception
+of the sequences that introduce interpolations and directives, and for the
+sequences that escape those introductions.
+
+The interpolation and directive introductions are escaped by doubling their
+leading characters. The `${` sequence is escaped as `$${` and the `%{`
+sequence is escaped as `%%{`.
+
+When the template sub-language is embedded in the expression language via
+_template expressions_, additional constraints and transforms are applied to
+template literals as described in the definition of template expressions.
+
+The value of a template literal can be modified by _strip markers_ in any
+interpolations or directives that are adjacent to it. A strip marker is
+a tilde (`~`) placed immediately after the opening `{` or before the closing
+`}` of a template sequence:
+
+- `hello ${~ "world" }` produces `"helloworld"`.
+- `%{ if true ~} hello %{~ endif }` produces `"hello"`.
+
+When a strip marker is present, any spaces adjacent to it in the corresponding
+string literal (if any) are removed before producing the final value. Space
+characters are interpreted as per Unicode's definition.
+
+Stripping is done at syntax level rather than value level. Values returned
+by interpolations or directives are not subject to stripping:
+
+- `${"hello" ~}${" world"}` produces `"hello world"`, and not `"helloworld"`,
+  because the space is not in a template literal directly adjacent to the
+  strip marker.
+
+### Template Interpolations
+
+An _interpolation sequence_ evaluates an expression (written in the
+expression sub-language), converts the result to a string value, and
+replaces itself with the resulting string.
+
+```ebnf
+TemplateInterpolation = ("${" | "${~") Expression ("}" | "~}";
+```
+
+If the expression result cannot be converted to a string, an error is
+produced.
+
+### Template If Directive
+
+The template `if` directive is the template equivalent of the
+_conditional expression_, allowing selection of one of two sub-templates based
+on the value of a predicate expression.
+
+```ebnf
+TemplateIf = (
+    ("%{" | "%{~") "if" Expression ("}" | "~}")
+    Template
+    (
+        ("%{" | "%{~") "else" ("}" | "~}")
+        Template
+    )?
+    ("%{" | "%{~") "endif" ("}" | "~}")
+);
+```
+
+The evaluation of the `if` directive is equivalent to the conditional
+expression, with the following exceptions:
+
+- The two sub-templates always produce strings, and thus the result value is
+  also always a string.
+- The `else` clause may be omitted, in which case the conditional's third
+  expression result is implied to be the empty string.
+
+### Template For Directive
+
+The template `for` directive is the template equivalent of the _for expression_,
+producing zero or more copies of its sub-template based on the elements of
+a collection.
+
+```ebnf
+TemplateFor = (
+    ("%{" | "%{~") "for" Identifier ("," Identifier) "in" Expression ("}" | "~}")
+    Template
+    ("%{" | "%{~") "endfor" ("}" | "~}")
+);
+```
+
+The evaluation of the `for` directive is equivalent to the _for expression_
+when producing a tuple, with the following exceptions:
+
+- The sub-template always produces a string.
+- There is no equivalent of the "if" clause on the for expression.
+- The elements of the resulting tuple are all converted to strings and
+  concatenated to produce a flat string result.
+
+### Template Interpolation Unwrapping
+
+As a special case, a template that consists only of a single interpolation,
+with no surrounding literals, directives or other interpolations, is
+"unwrapped". In this case, the result of the interpolation expression is
+returned verbatim, without conversion to string.
+
+This special case exists primarily to enable the native template language
+to be used inside strings in alternative HCL syntaxes that lack a first-class
+template or expression syntax. Unwrapping allows arbitrary expressions to be
+used to populate attributes when strings in such languages are interpreted
+as templates.
+
+- `${true}` produces the boolean value `true`
+- `${"${true}"}` produces the boolean value `true`, because both the inner
+  and outer interpolations are subject to unwrapping.
+- `hello ${true}` produces the string `"hello true"`
+- `${""}${true}` produces the string `"true"` because there are two
+  interpolation sequences, even though one produces an empty result.
+- `%{ for v in [true] }${v}%{ endif }` produces the string `true` because
+  the presence of the `for` directive circumvents the unwrapping even though
+  the final result is a single value.
+
+In some contexts this unwrapping behavior may be circumvented by the calling
+application, by converting the final template result to string. This is
+necessary, for example, if a standalone template is being used to produce
+the direct contents of a file, since the result in that case must always be a
+string.
+
+## Static Analysis
+
+The HCL static analysis operations are implemented for some expression types
+in the native syntax, as described in the following sections.
+
+A goal for static analysis of the native syntax is for the interpretation to
+be as consistent as possible with the dynamic evaluation interpretation of
+the given expression, though some deviations are intentionally made in order
+to maximize the potential for analysis.
+
+### Static List
+
+The tuple construction syntax can be interpreted as a static list. All of
+the expression elements given are returned as the static list elements,
+with no further interpretation.
+
+### Static Map
+
+The object construction syntax can be interpreted as a static map. All of the
+key/value pairs given are returned as the static pairs, with no further
+interpretation.
+
+The usual requirement that an attribute name be interpretable as a string
+does not apply to this static analysis, allowing callers to provide map-like
+constructs with different key types by building on the map syntax.
+
+### Static Call
+
+The function call syntax can be interpreted as a static call. The called
+function name is returned verbatim and the given argument expressions are
+returned as the static arguments, with no further interpretation.
+
+### Static Traversal
+
+A variable expression and any attached attribute access operations and
+constant index operations can be interpreted as a static traversal.
+
+The keywords `true`, `false` and `null` can also be interpreted as
+static traversals, behaving as if they were references to variables of those
+names, to allow callers to redefine the meaning of those keywords in certain
+contexts.
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure.go
new file mode 100644
index 000000000..2f7470c77
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure.go
@@ -0,0 +1,394 @@
+package hclsyntax
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// AsHCLBlock returns the block data expressed as a *hcl.Block.
+func (b *Block) AsHCLBlock() *hcl.Block {
+	if b == nil {
+		return nil
+	}
+
+	lastHeaderRange := b.TypeRange
+	if len(b.LabelRanges) > 0 {
+		lastHeaderRange = b.LabelRanges[len(b.LabelRanges)-1]
+	}
+
+	return &hcl.Block{
+		Type:   b.Type,
+		Labels: b.Labels,
+		Body:   b.Body,
+
+		DefRange:    hcl.RangeBetween(b.TypeRange, lastHeaderRange),
+		TypeRange:   b.TypeRange,
+		LabelRanges: b.LabelRanges,
+	}
+}
+
+// Body is the implementation of hcl.Body for the HCL native syntax.
+type Body struct {
+	Attributes Attributes
+	Blocks     Blocks
+
+	// These are used with PartialContent to produce a "remaining items"
+	// body to return. They are nil on all bodies fresh out of the parser.
+	hiddenAttrs  map[string]struct{}
+	hiddenBlocks map[string]struct{}
+
+	SrcRange hcl.Range
+	EndRange hcl.Range // Final token of the body, for reporting missing items
+}
+
+// Assert that *Body implements hcl.Body
+var assertBodyImplBody hcl.Body = &Body{}
+
+func (b *Body) walkChildNodes(w internalWalkFunc) {
+	w(b.Attributes)
+	w(b.Blocks)
+}
+
+func (b *Body) Range() hcl.Range {
+	return b.SrcRange
+}
+
+func (b *Body) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
+	content, remainHCL, diags := b.PartialContent(schema)
+
+	// No we'll see if anything actually remains, to produce errors about
+	// extraneous items.
+	remain := remainHCL.(*Body)
+
+	for name, attr := range b.Attributes {
+		if _, hidden := remain.hiddenAttrs[name]; !hidden {
+			var suggestions []string
+			for _, attrS := range schema.Attributes {
+				if _, defined := content.Attributes[attrS.Name]; defined {
+					continue
+				}
+				suggestions = append(suggestions, attrS.Name)
+			}
+			suggestion := nameSuggestion(name, suggestions)
+			if suggestion != "" {
+				suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+			} else {
+				// Is there a block of the same name?
+				for _, blockS := range schema.Blocks {
+					if blockS.Type == name {
+						suggestion = fmt.Sprintf(" Did you mean to define a block of type %q?", name)
+						break
+					}
+				}
+			}
+
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unsupported argument",
+				Detail:   fmt.Sprintf("An argument named %q is not expected here.%s", name, suggestion),
+				Subject:  &attr.NameRange,
+			})
+		}
+	}
+
+	for _, block := range b.Blocks {
+		blockTy := block.Type
+		if _, hidden := remain.hiddenBlocks[blockTy]; !hidden {
+			var suggestions []string
+			for _, blockS := range schema.Blocks {
+				suggestions = append(suggestions, blockS.Type)
+			}
+			suggestion := nameSuggestion(blockTy, suggestions)
+			if suggestion != "" {
+				suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+			} else {
+				// Is there an attribute of the same name?
+				for _, attrS := range schema.Attributes {
+					if attrS.Name == blockTy {
+						suggestion = fmt.Sprintf(" Did you mean to define argument %q? If so, use the equals sign to assign it a value.", blockTy)
+						break
+					}
+				}
+			}
+
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unsupported block type",
+				Detail:   fmt.Sprintf("Blocks of type %q are not expected here.%s", blockTy, suggestion),
+				Subject:  &block.TypeRange,
+			})
+		}
+	}
+
+	return content, diags
+}
+
+func (b *Body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+	attrs := make(hcl.Attributes)
+	var blocks hcl.Blocks
+	var diags hcl.Diagnostics
+	hiddenAttrs := make(map[string]struct{})
+	hiddenBlocks := make(map[string]struct{})
+
+	if b.hiddenAttrs != nil {
+		for k, v := range b.hiddenAttrs {
+			hiddenAttrs[k] = v
+		}
+	}
+	if b.hiddenBlocks != nil {
+		for k, v := range b.hiddenBlocks {
+			hiddenBlocks[k] = v
+		}
+	}
+
+	for _, attrS := range schema.Attributes {
+		name := attrS.Name
+		attr, exists := b.Attributes[name]
+		_, hidden := hiddenAttrs[name]
+		if hidden || !exists {
+			if attrS.Required {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing required argument",
+					Detail:   fmt.Sprintf("The argument %q is required, but no definition was found.", attrS.Name),
+					Subject:  b.MissingItemRange().Ptr(),
+				})
+			}
+			continue
+		}
+
+		hiddenAttrs[name] = struct{}{}
+		attrs[name] = attr.AsHCLAttribute()
+	}
+
+	blocksWanted := make(map[string]hcl.BlockHeaderSchema)
+	for _, blockS := range schema.Blocks {
+		blocksWanted[blockS.Type] = blockS
+	}
+
+	for _, block := range b.Blocks {
+		if _, hidden := hiddenBlocks[block.Type]; hidden {
+			continue
+		}
+		blockS, wanted := blocksWanted[block.Type]
+		if !wanted {
+			continue
+		}
+
+		if len(block.Labels) > len(blockS.LabelNames) {
+			name := block.Type
+			if len(blockS.LabelNames) == 0 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Extraneous label for %s", name),
+					Detail: fmt.Sprintf(
+						"No labels are expected for %s blocks.", name,
+					),
+					Subject: block.LabelRanges[0].Ptr(),
+					Context: hcl.RangeBetween(block.TypeRange, block.OpenBraceRange).Ptr(),
+				})
+			} else {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Extraneous label for %s", name),
+					Detail: fmt.Sprintf(
+						"Only %d labels (%s) are expected for %s blocks.",
+						len(blockS.LabelNames), strings.Join(blockS.LabelNames, ", "), name,
+					),
+					Subject: block.LabelRanges[len(blockS.LabelNames)].Ptr(),
+					Context: hcl.RangeBetween(block.TypeRange, block.OpenBraceRange).Ptr(),
+				})
+			}
+			continue
+		}
+
+		if len(block.Labels) < len(blockS.LabelNames) {
+			name := block.Type
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Missing %s for %s", blockS.LabelNames[len(block.Labels)], name),
+				Detail: fmt.Sprintf(
+					"All %s blocks must have %d labels (%s).",
+					name, len(blockS.LabelNames), strings.Join(blockS.LabelNames, ", "),
+				),
+				Subject: &block.OpenBraceRange,
+				Context: hcl.RangeBetween(block.TypeRange, block.OpenBraceRange).Ptr(),
+			})
+			continue
+		}
+
+		blocks = append(blocks, block.AsHCLBlock())
+	}
+
+	// We hide blocks only after we've processed all of them, since otherwise
+	// we can't process more than one of the same type.
+	for _, blockS := range schema.Blocks {
+		hiddenBlocks[blockS.Type] = struct{}{}
+	}
+
+	remain := &Body{
+		Attributes: b.Attributes,
+		Blocks:     b.Blocks,
+
+		hiddenAttrs:  hiddenAttrs,
+		hiddenBlocks: hiddenBlocks,
+
+		SrcRange: b.SrcRange,
+		EndRange: b.EndRange,
+	}
+
+	return &hcl.BodyContent{
+		Attributes: attrs,
+		Blocks:     blocks,
+
+		MissingItemRange: b.MissingItemRange(),
+	}, remain, diags
+}
+
+func (b *Body) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
+	attrs := make(hcl.Attributes)
+	var diags hcl.Diagnostics
+
+	if len(b.Blocks) > 0 {
+		example := b.Blocks[0]
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Unexpected %q block", example.Type),
+			Detail:   "Blocks are not allowed here.",
+			Subject:  &example.TypeRange,
+		})
+		// we will continue processing anyway, and return the attributes
+		// we are able to find so that certain analyses can still be done
+		// in the face of errors.
+	}
+
+	if b.Attributes == nil {
+		return attrs, diags
+	}
+
+	for name, attr := range b.Attributes {
+		if _, hidden := b.hiddenAttrs[name]; hidden {
+			continue
+		}
+		attrs[name] = attr.AsHCLAttribute()
+	}
+
+	return attrs, diags
+}
+
+func (b *Body) MissingItemRange() hcl.Range {
+	return hcl.Range{
+		Filename: b.SrcRange.Filename,
+		Start:    b.SrcRange.Start,
+		End:      b.SrcRange.Start,
+	}
+}
+
+// Attributes is the collection of attribute definitions within a body.
+type Attributes map[string]*Attribute
+
+func (a Attributes) walkChildNodes(w internalWalkFunc) {
+	for _, attr := range a {
+		w(attr)
+	}
+}
+
+// Range returns the range of some arbitrary point within the set of
+// attributes, or an invalid range if there are no attributes.
+//
+// This is provided only to complete the Node interface, but has no practical
+// use.
+func (a Attributes) Range() hcl.Range {
+	// An attributes doesn't really have a useful range to report, since
+	// it's just a grouping construct. So we'll arbitrarily take the
+	// range of one of the attributes, or produce an invalid range if we have
+	// none. In practice, there's little reason to ask for the range of
+	// an Attributes.
+	for _, attr := range a {
+		return attr.Range()
+	}
+	return hcl.Range{
+		Filename: "<unknown>",
+	}
+}
+
+// Attribute represents a single attribute definition within a body.
+type Attribute struct {
+	Name string
+	Expr Expression
+
+	SrcRange    hcl.Range
+	NameRange   hcl.Range
+	EqualsRange hcl.Range
+}
+
+func (a *Attribute) walkChildNodes(w internalWalkFunc) {
+	w(a.Expr)
+}
+
+func (a *Attribute) Range() hcl.Range {
+	return a.SrcRange
+}
+
+// AsHCLAttribute returns the block data expressed as a *hcl.Attribute.
+func (a *Attribute) AsHCLAttribute() *hcl.Attribute {
+	if a == nil {
+		return nil
+	}
+	return &hcl.Attribute{
+		Name: a.Name,
+		Expr: a.Expr,
+
+		Range:     a.SrcRange,
+		NameRange: a.NameRange,
+	}
+}
+
+// Blocks is the list of nested blocks within a body.
+type Blocks []*Block
+
+func (bs Blocks) walkChildNodes(w internalWalkFunc) {
+	for _, block := range bs {
+		w(block)
+	}
+}
+
+// Range returns the range of some arbitrary point within the list of
+// blocks, or an invalid range if there are no blocks.
+//
+// This is provided only to complete the Node interface, but has no practical
+// use.
+func (bs Blocks) Range() hcl.Range {
+	if len(bs) > 0 {
+		return bs[0].Range()
+	}
+	return hcl.Range{
+		Filename: "<unknown>",
+	}
+}
+
+// Block represents a nested block structure
+type Block struct {
+	Type   string
+	Labels []string
+	Body   *Body
+
+	TypeRange       hcl.Range
+	LabelRanges     []hcl.Range
+	OpenBraceRange  hcl.Range
+	CloseBraceRange hcl.Range
+}
+
+func (b *Block) walkChildNodes(w internalWalkFunc) {
+	w(b.Body)
+}
+
+func (b *Block) Range() hcl.Range {
+	return hcl.RangeBetween(b.TypeRange, b.CloseBraceRange)
+}
+
+func (b *Block) DefRange() hcl.Range {
+	return hcl.RangeBetween(b.TypeRange, b.OpenBraceRange)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure_at_pos.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure_at_pos.go
new file mode 100644
index 000000000..587844ac2
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/structure_at_pos.go
@@ -0,0 +1,118 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// -----------------------------------------------------------------------------
+// The methods in this file are all optional extension methods that serve to
+// implement the methods of the same name on *hcl.File when its root body
+// is provided by this package.
+// -----------------------------------------------------------------------------
+
+// BlocksAtPos implements the method of the same name for an *hcl.File that
+// is backed by a *Body.
+func (b *Body) BlocksAtPos(pos hcl.Pos) []*hcl.Block {
+	list, _ := b.blocksAtPos(pos, true)
+	return list
+}
+
+// InnermostBlockAtPos implements the method of the same name for an *hcl.File
+// that is backed by a *Body.
+func (b *Body) InnermostBlockAtPos(pos hcl.Pos) *hcl.Block {
+	_, innermost := b.blocksAtPos(pos, false)
+	return innermost.AsHCLBlock()
+}
+
+// OutermostBlockAtPos implements the method of the same name for an *hcl.File
+// that is backed by a *Body.
+func (b *Body) OutermostBlockAtPos(pos hcl.Pos) *hcl.Block {
+	return b.outermostBlockAtPos(pos).AsHCLBlock()
+}
+
+// blocksAtPos is the internal engine of both BlocksAtPos and
+// InnermostBlockAtPos, which both need to do the same logic but return a
+// differently-shaped result.
+//
+// list is nil if makeList is false, avoiding an allocation. Innermost is
+// always set, and if the returned list is non-nil it will always match the
+// final element from that list.
+func (b *Body) blocksAtPos(pos hcl.Pos, makeList bool) (list []*hcl.Block, innermost *Block) {
+	current := b
+
+Blocks:
+	for current != nil {
+		for _, block := range current.Blocks {
+			wholeRange := hcl.RangeBetween(block.TypeRange, block.CloseBraceRange)
+			if wholeRange.ContainsPos(pos) {
+				innermost = block
+				if makeList {
+					list = append(list, innermost.AsHCLBlock())
+				}
+				current = block.Body
+				continue Blocks
+			}
+		}
+
+		// If we fall out here then none of the current body's nested blocks
+		// contain the position we are looking for, and so we're done.
+		break
+	}
+
+	return
+}
+
+// outermostBlockAtPos is the internal version of OutermostBlockAtPos that
+// returns a hclsyntax.Block rather than an hcl.Block, allowing for further
+// analysis if necessary.
+func (b *Body) outermostBlockAtPos(pos hcl.Pos) *Block {
+	// This is similar to blocksAtPos, but simpler because we know it only
+	// ever needs to search the first level of nested blocks.
+
+	for _, block := range b.Blocks {
+		wholeRange := hcl.RangeBetween(block.TypeRange, block.CloseBraceRange)
+		if wholeRange.ContainsPos(pos) {
+			return block
+		}
+	}
+
+	return nil
+}
+
+// AttributeAtPos implements the method of the same name for an *hcl.File
+// that is backed by a *Body.
+func (b *Body) AttributeAtPos(pos hcl.Pos) *hcl.Attribute {
+	return b.attributeAtPos(pos).AsHCLAttribute()
+}
+
+// attributeAtPos is the internal version of AttributeAtPos that returns a
+// hclsyntax.Block rather than an hcl.Block, allowing for further analysis if
+// necessary.
+func (b *Body) attributeAtPos(pos hcl.Pos) *Attribute {
+	searchBody := b
+	_, block := b.blocksAtPos(pos, false)
+	if block != nil {
+		searchBody = block.Body
+	}
+
+	for _, attr := range searchBody.Attributes {
+		if attr.SrcRange.ContainsPos(pos) {
+			return attr
+		}
+	}
+
+	return nil
+}
+
+// OutermostExprAtPos implements the method of the same name for an *hcl.File
+// that is backed by a *Body.
+func (b *Body) OutermostExprAtPos(pos hcl.Pos) hcl.Expression {
+	attr := b.attributeAtPos(pos)
+	if attr == nil {
+		return nil
+	}
+	if !attr.Expr.Range().ContainsPos(pos) {
+		return nil
+	}
+	return attr.Expr
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token.go
new file mode 100644
index 000000000..c7ffe2073
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token.go
@@ -0,0 +1,320 @@
+package hclsyntax
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+	"github.com/hashicorp/hcl/v2"
+)
+
+// Token represents a sequence of bytes from some HCL code that has been
+// tagged with a type and its range within the source file.
+type Token struct {
+	Type  TokenType
+	Bytes []byte
+	Range hcl.Range
+}
+
+// Tokens is a slice of Token.
+type Tokens []Token
+
+// TokenType is an enumeration used for the Type field on Token.
+type TokenType rune
+
+const (
+	// Single-character tokens are represented by their own character, for
+	// convenience in producing these within the scanner. However, the values
+	// are otherwise arbitrary and just intended to be mnemonic for humans
+	// who might see them in debug output.
+
+	TokenOBrace   TokenType = '{'
+	TokenCBrace   TokenType = '}'
+	TokenOBrack   TokenType = '['
+	TokenCBrack   TokenType = ']'
+	TokenOParen   TokenType = '('
+	TokenCParen   TokenType = ')'
+	TokenOQuote   TokenType = '«'
+	TokenCQuote   TokenType = '»'
+	TokenOHeredoc TokenType = 'H'
+	TokenCHeredoc TokenType = 'h'
+
+	TokenStar    TokenType = '*'
+	TokenSlash   TokenType = '/'
+	TokenPlus    TokenType = '+'
+	TokenMinus   TokenType = '-'
+	TokenPercent TokenType = '%'
+
+	TokenEqual         TokenType = '='
+	TokenEqualOp       TokenType = '≔'
+	TokenNotEqual      TokenType = '≠'
+	TokenLessThan      TokenType = '<'
+	TokenLessThanEq    TokenType = '≤'
+	TokenGreaterThan   TokenType = '>'
+	TokenGreaterThanEq TokenType = '≥'
+
+	TokenAnd  TokenType = '∧'
+	TokenOr   TokenType = '∨'
+	TokenBang TokenType = '!'
+
+	TokenDot   TokenType = '.'
+	TokenComma TokenType = ','
+
+	TokenEllipsis TokenType = '…'
+	TokenFatArrow TokenType = '⇒'
+
+	TokenQuestion TokenType = '?'
+	TokenColon    TokenType = ':'
+
+	TokenTemplateInterp  TokenType = '∫'
+	TokenTemplateControl TokenType = 'λ'
+	TokenTemplateSeqEnd  TokenType = '∎'
+
+	TokenQuotedLit TokenType = 'Q' // might contain backslash escapes
+	TokenStringLit TokenType = 'S' // cannot contain backslash escapes
+	TokenNumberLit TokenType = 'N'
+	TokenIdent     TokenType = 'I'
+
+	TokenComment TokenType = 'C'
+
+	TokenNewline TokenType = '\n'
+	TokenEOF     TokenType = '␄'
+
+	// The rest are not used in the language but recognized by the scanner so
+	// we can generate good diagnostics in the parser when users try to write
+	// things that might work in other languages they are familiar with, or
+	// simply make incorrect assumptions about the HCL language.
+
+	TokenBitwiseAnd    TokenType = '&'
+	TokenBitwiseOr     TokenType = '|'
+	TokenBitwiseNot    TokenType = '~'
+	TokenBitwiseXor    TokenType = '^'
+	TokenStarStar      TokenType = '➚'
+	TokenApostrophe    TokenType = '\''
+	TokenBacktick      TokenType = '`'
+	TokenSemicolon     TokenType = ';'
+	TokenTabs          TokenType = '␉'
+	TokenInvalid       TokenType = '�'
+	TokenBadUTF8       TokenType = '💩'
+	TokenQuotedNewline TokenType = '␤'
+
+	// TokenNil is a placeholder for when a token is required but none is
+	// available, e.g. when reporting errors. The scanner will never produce
+	// this as part of a token stream.
+	TokenNil TokenType = '\x00'
+)
+
+func (t TokenType) GoString() string {
+	return fmt.Sprintf("hclsyntax.%s", t.String())
+}
+
+type scanMode int
+
+const (
+	scanNormal scanMode = iota
+	scanTemplate
+	scanIdentOnly
+)
+
+type tokenAccum struct {
+	Filename  string
+	Bytes     []byte
+	Pos       hcl.Pos
+	Tokens    []Token
+	StartByte int
+}
+
+func (f *tokenAccum) emitToken(ty TokenType, startOfs, endOfs int) {
+	// Walk through our buffer to figure out how much we need to adjust
+	// the start pos to get our end pos.
+
+	start := f.Pos
+	start.Column += startOfs + f.StartByte - f.Pos.Byte // Safe because only ASCII spaces can be in the offset
+	start.Byte = startOfs + f.StartByte
+
+	end := start
+	end.Byte = endOfs + f.StartByte
+	b := f.Bytes[startOfs:endOfs]
+	for len(b) > 0 {
+		advance, seq, _ := textseg.ScanGraphemeClusters(b, true)
+		if (len(seq) == 1 && seq[0] == '\n') || (len(seq) == 2 && seq[0] == '\r' && seq[1] == '\n') {
+			end.Line++
+			end.Column = 1
+		} else {
+			end.Column++
+		}
+		b = b[advance:]
+	}
+
+	f.Pos = end
+
+	f.Tokens = append(f.Tokens, Token{
+		Type:  ty,
+		Bytes: f.Bytes[startOfs:endOfs],
+		Range: hcl.Range{
+			Filename: f.Filename,
+			Start:    start,
+			End:      end,
+		},
+	})
+}
+
+type heredocInProgress struct {
+	Marker      []byte
+	StartOfLine bool
+}
+
+func tokenOpensFlushHeredoc(tok Token) bool {
+	if tok.Type != TokenOHeredoc {
+		return false
+	}
+	return bytes.HasPrefix(tok.Bytes, []byte{'<', '<', '-'})
+}
+
+// checkInvalidTokens does a simple pass across the given tokens and generates
+// diagnostics for tokens that should _never_ appear in HCL source. This
+// is intended to avoid the need for the parser to have special support
+// for them all over.
+//
+// Returns a diagnostics with no errors if everything seems acceptable.
+// Otherwise, returns zero or more error diagnostics, though tries to limit
+// repetition of the same information.
+func checkInvalidTokens(tokens Tokens) hcl.Diagnostics {
+	var diags hcl.Diagnostics
+
+	toldBitwise := 0
+	toldExponent := 0
+	toldBacktick := 0
+	toldApostrophe := 0
+	toldSemicolon := 0
+	toldTabs := 0
+	toldBadUTF8 := 0
+
+	for _, tok := range tokens {
+		// copy token so it's safe to point to it
+		tok := tok
+
+		switch tok.Type {
+		case TokenBitwiseAnd, TokenBitwiseOr, TokenBitwiseXor, TokenBitwiseNot:
+			if toldBitwise < 4 {
+				var suggestion string
+				switch tok.Type {
+				case TokenBitwiseAnd:
+					suggestion = " Did you mean boolean AND (\"&&\")?"
+				case TokenBitwiseOr:
+					suggestion = " Did you mean boolean OR (\"&&\")?"
+				case TokenBitwiseNot:
+					suggestion = " Did you mean boolean NOT (\"!\")?"
+				}
+
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unsupported operator",
+					Detail:   fmt.Sprintf("Bitwise operators are not supported.%s", suggestion),
+					Subject:  &tok.Range,
+				})
+				toldBitwise++
+			}
+		case TokenStarStar:
+			if toldExponent < 1 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Unsupported operator",
+					Detail:   "\"**\" is not a supported operator. Exponentiation is not supported as an operator.",
+					Subject:  &tok.Range,
+				})
+
+				toldExponent++
+			}
+		case TokenBacktick:
+			// Only report for alternating (even) backticks, so we won't report both start and ends of the same
+			// backtick-quoted string.
+			if (toldBacktick % 2) == 0 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character",
+					Detail:   "The \"`\" character is not valid. To create a multi-line string, use the \"heredoc\" syntax, like \"<<EOT\".",
+					Subject:  &tok.Range,
+				})
+			}
+			if toldBacktick <= 2 {
+				toldBacktick++
+			}
+		case TokenApostrophe:
+			if (toldApostrophe % 2) == 0 {
+				newDiag := &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character",
+					Detail:   "Single quotes are not valid. Use double quotes (\") to enclose strings.",
+					Subject:  &tok.Range,
+				}
+				diags = append(diags, newDiag)
+			}
+			if toldApostrophe <= 2 {
+				toldApostrophe++
+			}
+		case TokenSemicolon:
+			if toldSemicolon < 1 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character",
+					Detail:   "The \";\" character is not valid. Use newlines to separate arguments and blocks, and commas to separate items in collection values.",
+					Subject:  &tok.Range,
+				})
+
+				toldSemicolon++
+			}
+		case TokenTabs:
+			if toldTabs < 1 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character",
+					Detail:   "Tab characters may not be used. The recommended indentation style is two spaces per indent.",
+					Subject:  &tok.Range,
+				})
+
+				toldTabs++
+			}
+		case TokenBadUTF8:
+			if toldBadUTF8 < 1 {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid character encoding",
+					Detail:   "All input files must be UTF-8 encoded. Ensure that UTF-8 encoding is selected in your editor.",
+					Subject:  &tok.Range,
+				})
+
+				toldBadUTF8++
+			}
+		case TokenQuotedNewline:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid multi-line string",
+				Detail:   "Quoted strings may not be split over multiple lines. To produce a multi-line string, either use the \\n escape to represent a newline character or use the \"heredoc\" multi-line template syntax.",
+				Subject:  &tok.Range,
+			})
+		case TokenInvalid:
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid character",
+				Detail:   "This character is not used within the language.",
+				Subject:  &tok.Range,
+			})
+		}
+	}
+	return diags
+}
+
+var utf8BOM = []byte{0xef, 0xbb, 0xbf}
+
+// stripUTF8BOM checks whether the given buffer begins with a UTF-8 byte order
+// mark (0xEF 0xBB 0xBF) and, if so, returns a truncated slice with the same
+// backing array but with the BOM skipped.
+//
+// If there is no BOM present, the given slice is returned verbatim.
+func stripUTF8BOM(src []byte) []byte {
+	if bytes.HasPrefix(src, utf8BOM) {
+		return src[3:]
+	}
+	return src
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token_type_string.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token_type_string.go
new file mode 100644
index 000000000..c23c4f0b7
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/token_type_string.go
@@ -0,0 +1,131 @@
+// Code generated by "stringer -type TokenType -output token_type_string.go"; DO NOT EDIT.
+
+package hclsyntax
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[TokenOBrace-123]
+	_ = x[TokenCBrace-125]
+	_ = x[TokenOBrack-91]
+	_ = x[TokenCBrack-93]
+	_ = x[TokenOParen-40]
+	_ = x[TokenCParen-41]
+	_ = x[TokenOQuote-171]
+	_ = x[TokenCQuote-187]
+	_ = x[TokenOHeredoc-72]
+	_ = x[TokenCHeredoc-104]
+	_ = x[TokenStar-42]
+	_ = x[TokenSlash-47]
+	_ = x[TokenPlus-43]
+	_ = x[TokenMinus-45]
+	_ = x[TokenPercent-37]
+	_ = x[TokenEqual-61]
+	_ = x[TokenEqualOp-8788]
+	_ = x[TokenNotEqual-8800]
+	_ = x[TokenLessThan-60]
+	_ = x[TokenLessThanEq-8804]
+	_ = x[TokenGreaterThan-62]
+	_ = x[TokenGreaterThanEq-8805]
+	_ = x[TokenAnd-8743]
+	_ = x[TokenOr-8744]
+	_ = x[TokenBang-33]
+	_ = x[TokenDot-46]
+	_ = x[TokenComma-44]
+	_ = x[TokenEllipsis-8230]
+	_ = x[TokenFatArrow-8658]
+	_ = x[TokenQuestion-63]
+	_ = x[TokenColon-58]
+	_ = x[TokenTemplateInterp-8747]
+	_ = x[TokenTemplateControl-955]
+	_ = x[TokenTemplateSeqEnd-8718]
+	_ = x[TokenQuotedLit-81]
+	_ = x[TokenStringLit-83]
+	_ = x[TokenNumberLit-78]
+	_ = x[TokenIdent-73]
+	_ = x[TokenComment-67]
+	_ = x[TokenNewline-10]
+	_ = x[TokenEOF-9220]
+	_ = x[TokenBitwiseAnd-38]
+	_ = x[TokenBitwiseOr-124]
+	_ = x[TokenBitwiseNot-126]
+	_ = x[TokenBitwiseXor-94]
+	_ = x[TokenStarStar-10138]
+	_ = x[TokenApostrophe-39]
+	_ = x[TokenBacktick-96]
+	_ = x[TokenSemicolon-59]
+	_ = x[TokenTabs-9225]
+	_ = x[TokenInvalid-65533]
+	_ = x[TokenBadUTF8-128169]
+	_ = x[TokenQuotedNewline-9252]
+	_ = x[TokenNil-0]
+}
+
+const _TokenType_name = "TokenNilTokenNewlineTokenBangTokenPercentTokenBitwiseAndTokenApostropheTokenOParenTokenCParenTokenStarTokenPlusTokenCommaTokenMinusTokenDotTokenSlashTokenColonTokenSemicolonTokenLessThanTokenEqualTokenGreaterThanTokenQuestionTokenCommentTokenOHeredocTokenIdentTokenNumberLitTokenQuotedLitTokenStringLitTokenOBrackTokenCBrackTokenBitwiseXorTokenBacktickTokenCHeredocTokenOBraceTokenBitwiseOrTokenCBraceTokenBitwiseNotTokenOQuoteTokenCQuoteTokenTemplateControlTokenEllipsisTokenFatArrowTokenTemplateSeqEndTokenAndTokenOrTokenTemplateInterpTokenEqualOpTokenNotEqualTokenLessThanEqTokenGreaterThanEqTokenEOFTokenTabsTokenQuotedNewlineTokenStarStarTokenInvalidTokenBadUTF8"
+
+var _TokenType_map = map[TokenType]string{
+	0:      _TokenType_name[0:8],
+	10:     _TokenType_name[8:20],
+	33:     _TokenType_name[20:29],
+	37:     _TokenType_name[29:41],
+	38:     _TokenType_name[41:56],
+	39:     _TokenType_name[56:71],
+	40:     _TokenType_name[71:82],
+	41:     _TokenType_name[82:93],
+	42:     _TokenType_name[93:102],
+	43:     _TokenType_name[102:111],
+	44:     _TokenType_name[111:121],
+	45:     _TokenType_name[121:131],
+	46:     _TokenType_name[131:139],
+	47:     _TokenType_name[139:149],
+	58:     _TokenType_name[149:159],
+	59:     _TokenType_name[159:173],
+	60:     _TokenType_name[173:186],
+	61:     _TokenType_name[186:196],
+	62:     _TokenType_name[196:212],
+	63:     _TokenType_name[212:225],
+	67:     _TokenType_name[225:237],
+	72:     _TokenType_name[237:250],
+	73:     _TokenType_name[250:260],
+	78:     _TokenType_name[260:274],
+	81:     _TokenType_name[274:288],
+	83:     _TokenType_name[288:302],
+	91:     _TokenType_name[302:313],
+	93:     _TokenType_name[313:324],
+	94:     _TokenType_name[324:339],
+	96:     _TokenType_name[339:352],
+	104:    _TokenType_name[352:365],
+	123:    _TokenType_name[365:376],
+	124:    _TokenType_name[376:390],
+	125:    _TokenType_name[390:401],
+	126:    _TokenType_name[401:416],
+	171:    _TokenType_name[416:427],
+	187:    _TokenType_name[427:438],
+	955:    _TokenType_name[438:458],
+	8230:   _TokenType_name[458:471],
+	8658:   _TokenType_name[471:484],
+	8718:   _TokenType_name[484:503],
+	8743:   _TokenType_name[503:511],
+	8744:   _TokenType_name[511:518],
+	8747:   _TokenType_name[518:537],
+	8788:   _TokenType_name[537:549],
+	8800:   _TokenType_name[549:562],
+	8804:   _TokenType_name[562:577],
+	8805:   _TokenType_name[577:595],
+	9220:   _TokenType_name[595:603],
+	9225:   _TokenType_name[603:612],
+	9252:   _TokenType_name[612:630],
+	10138:  _TokenType_name[630:643],
+	65533:  _TokenType_name[643:655],
+	128169: _TokenType_name[655:667],
+}
+
+func (i TokenType) String() string {
+	if str, ok := _TokenType_map[i]; ok {
+		return str
+	}
+	return "TokenType(" + strconv.FormatInt(int64(i), 10) + ")"
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode2ragel.rb b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode2ragel.rb
new file mode 100644
index 000000000..422e4e5cc
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode2ragel.rb
@@ -0,0 +1,335 @@
+#!/usr/bin/env ruby
+#
+# This scripted has been updated to accept more command-line arguments:
+#
+#    -u, --url                        URL to process
+#    -m, --machine                    Machine name
+#    -p, --properties                 Properties to add to the machine
+#    -o, --output                     Write output to file
+#
+# Updated by: Marty Schoch <marty.schoch@gmail.com>
+# 
+# This script uses the unicode spec to generate a Ragel state machine
+# that recognizes unicode alphanumeric characters.  It generates 5
+# character classes: uupper, ulower, ualpha, udigit, and ualnum.
+# Currently supported encodings are UTF-8 [default] and UCS-4.
+#
+# Usage: unicode2ragel.rb [options]
+#    -e, --encoding [ucs4 | utf8]     Data encoding
+#    -h, --help                       Show this message
+#
+# This script was originally written as part of the Ferret search
+# engine library.
+#
+# Author: Rakan El-Khalil <rakan@well.com>
+
+require 'optparse'
+require 'open-uri'
+
+ENCODINGS = [ :utf8, :ucs4 ]
+ALPHTYPES = { :utf8 => "byte", :ucs4 => "rune" }
+DEFAULT_CHART_URL = "http://www.unicode.org/Public/5.1.0/ucd/DerivedCoreProperties.txt"
+DEFAULT_MACHINE_NAME= "WChar"
+
+###
+# Display vars & default option
+
+TOTAL_WIDTH = 80
+RANGE_WIDTH = 23
+@encoding = :utf8
+@chart_url = DEFAULT_CHART_URL
+machine_name = DEFAULT_MACHINE_NAME
+properties = []
+@output = $stdout
+
+###
+# Option parsing
+
+cli_opts = OptionParser.new do |opts|
+  opts.on("-e", "--encoding [ucs4 | utf8]", "Data encoding") do |o|
+    @encoding = o.downcase.to_sym
+  end
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+  opts.on("-u", "--url URL", "URL to process") do |o|
+    @chart_url = o 
+  end
+  opts.on("-m", "--machine MACHINE_NAME", "Machine name") do |o|
+    machine_name = o
+  end
+  opts.on("-p", "--properties x,y,z", Array, "Properties to add to machine") do |o|
+    properties = o
+  end
+  opts.on("-o", "--output FILE", "output file") do |o|
+    @output = File.new(o, "w+")
+  end
+end
+
+cli_opts.parse(ARGV)
+unless ENCODINGS.member? @encoding
+  puts "Invalid encoding: #{@encoding}"
+  puts cli_opts
+  exit
+end
+
+##
+# Downloads the document at url and yields every alpha line's hex
+# range and description.
+
+def each_alpha( url, property ) 
+  open( url ) do |file|
+    file.each_line do |line|
+      next if line =~ /^#/;
+      next if line !~ /; #{property} #/;
+
+      range, description = line.split(/;/)
+      range.strip!
+      description.gsub!(/.*#/, '').strip!
+
+      if range =~ /\.\./
+           start, stop = range.split '..'
+      else start = stop = range
+      end
+
+      yield start.hex .. stop.hex, description
+    end
+  end
+end
+
+###
+# Formats to hex at minimum width
+
+def to_hex( n )
+  r = "%0X" % n
+  r = "0#{r}" unless (r.length % 2).zero?
+  r
+end
+
+###
+# UCS4 is just a straight hex conversion of the unicode codepoint.
+
+def to_ucs4( range )
+  rangestr  =   "0x" + to_hex(range.begin)
+  rangestr << "..0x" + to_hex(range.end) if range.begin != range.end
+  [ rangestr ]
+end
+
+##
+# 0x00     - 0x7f     -> 0zzzzzzz[7]
+# 0x80     - 0x7ff    -> 110yyyyy[5] 10zzzzzz[6]
+# 0x800    - 0xffff   -> 1110xxxx[4] 10yyyyyy[6] 10zzzzzz[6]
+# 0x010000 - 0x10ffff -> 11110www[3] 10xxxxxx[6] 10yyyyyy[6] 10zzzzzz[6] 
+
+UTF8_BOUNDARIES = [0x7f, 0x7ff, 0xffff, 0x10ffff]
+
+def to_utf8_enc( n )
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0x7ff
+    y = 0xc0 | (n >> 6)
+    z = 0x80 | (n & 0x3f)
+    r = y << 8 | z
+  elsif n <= 0xffff
+    x = 0xe0 | (n >> 12)
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = x << 16 | y << 8 | z
+  elsif n <= 0x10ffff
+    w = 0xf0 | (n >> 18)
+    x = 0x80 | (n >> 12) & 0x3f
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = w << 24 | x << 16 | y << 8 | z
+  end
+
+  to_hex(r)
+end
+
+def from_utf8_enc( n )
+  n = n.hex
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0xdfff
+    y = (n >> 8) & 0x1f
+    z =  n       & 0x3f
+    r = y << 6 | z
+  elsif n <= 0xefffff
+    x = (n >> 16) & 0x0f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = x << 10 | y << 6 | z
+  elsif n <= 0xf7ffffff
+    w = (n >> 24) & 0x07
+    x = (n >> 16) & 0x3f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = w << 18 | x << 12 | y << 6 | z
+  end
+  r
+end
+
+###
+# Given a range, splits it up into ranges that can be continuously
+# encoded into utf8.  Eg: 0x00 .. 0xff => [0x00..0x7f, 0x80..0xff]
+# This is not strictly needed since the current [5.1] unicode standard
+# doesn't have ranges that straddle utf8 boundaries.  This is included
+# for completeness as there is no telling if that will ever change.
+
+def utf8_ranges( range )
+  ranges = []
+  UTF8_BOUNDARIES.each do |max|
+    if range.begin <= max
+      if range.end <= max
+        ranges << range
+        return ranges
+      end
+
+      ranges << (range.begin .. max)
+      range = (max + 1) .. range.end
+    end
+  end
+  ranges
+end
+
+def build_range( start, stop )
+  size = start.size/2
+  left = size - 1
+  return [""] if size < 1
+
+  a = start[0..1]
+  b = stop[0..1]
+
+  ###
+  # Shared prefix
+
+  if a == b
+    return build_range(start[2..-1], stop[2..-1]).map do |elt|
+      "0x#{a} " + elt
+    end
+  end
+
+  ###
+  # Unshared prefix, end of run
+
+  return ["0x#{a}..0x#{b} "] if left.zero?
+  
+  ###
+  # Unshared prefix, not end of run
+  # Range can be 0x123456..0x56789A
+  # Which is equivalent to:
+  #     0x123456 .. 0x12FFFF
+  #     0x130000 .. 0x55FFFF
+  #     0x560000 .. 0x56789A
+
+  ret = []
+  ret << build_range(start, a + "FF" * left)
+
+  ###
+  # Only generate middle range if need be.
+
+  if a.hex+1 != b.hex
+    max = to_hex(b.hex - 1)
+    max = "FF" if b == "FF"
+    ret << "0x#{to_hex(a.hex+1)}..0x#{max} " + "0x00..0xFF " * left
+  end
+
+  ###
+  # Don't generate last range if it is covered by first range
+  
+  ret << build_range(b + "00" * left, stop) unless b == "FF"
+  ret.flatten!
+end
+
+def to_utf8( range )
+  utf8_ranges( range ).map do |r|   
+    begin_enc = to_utf8_enc(r.begin)
+    end_enc = to_utf8_enc(r.end)
+    build_range begin_enc, end_enc
+  end.flatten!
+end
+
+##
+# Perform a 3-way comparison of the number of codepoints advertised by
+# the unicode spec for the given range, the originally parsed range,
+# and the resulting utf8 encoded range.
+
+def count_codepoints( code )
+  code.split(' ').inject(1) do |acc, elt|
+    if elt =~ /0x(.+)\.\.0x(.+)/
+      if @encoding == :utf8
+        acc * (from_utf8_enc($2) - from_utf8_enc($1) + 1)
+      else
+        acc * ($2.hex - $1.hex + 1)
+      end
+    else
+      acc
+    end
+  end
+end
+
+def is_valid?( range, desc, codes )
+  spec_count  = 1
+  spec_count  = $1.to_i if desc =~ /\[(\d+)\]/
+  range_count = range.end - range.begin + 1
+
+  sum = codes.inject(0) { |acc, elt| acc + count_codepoints(elt) }
+  sum == spec_count and sum == range_count
+end
+
+##
+# Generate the state maching to stdout
+
+def generate_machine( name, property )
+  pipe = " "
+  @output.puts "    #{name} = "
+  each_alpha( @chart_url, property ) do |range, desc|
+
+    codes = (@encoding == :ucs4) ? to_ucs4(range) : to_utf8(range)
+
+    #raise "Invalid encoding of range #{range}: #{codes.inspect}" unless 
+    #  is_valid? range, desc, codes
+
+    range_width = codes.map { |a| a.size }.max
+    range_width = RANGE_WIDTH if range_width < RANGE_WIDTH
+
+    desc_width  = TOTAL_WIDTH - RANGE_WIDTH - 11
+    desc_width -= (range_width - RANGE_WIDTH) if range_width > RANGE_WIDTH
+
+    if desc.size > desc_width
+      desc = desc[0..desc_width - 4] + "..."
+    end
+
+    codes.each_with_index do |r, idx|
+      desc = "" unless idx.zero?
+      code = "%-#{range_width}s" % r
+      @output.puts "      #{pipe} #{code} ##{desc}"
+      pipe = "|"
+    end
+  end
+  @output.puts "      ;"
+  @output.puts ""
+end
+
+@output.puts <<EOF
+# The following Ragel file was autogenerated with #{$0} 
+# from: #{@chart_url}
+#
+# It defines #{properties}.
+#
+# To use this, make sure that your alphtype is set to #{ALPHTYPES[@encoding]},
+# and that your input is in #{@encoding}.
+
+%%{
+    machine #{machine_name};
+    
+EOF
+
+properties.each { |x| generate_machine( x, x ) }
+
+@output.puts <<EOF
+}%%
+EOF
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode_derived.rl b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode_derived.rl
new file mode 100644
index 000000000..612ad6229
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/unicode_derived.rl
@@ -0,0 +1,2135 @@
+# The following Ragel file was autogenerated with unicode2ragel.rb 
+# from: http://www.unicode.org/Public/9.0.0/ucd/DerivedCoreProperties.txt
+#
+# It defines ["ID_Start", "ID_Continue"].
+#
+# To use this, make sure that your alphtype is set to byte,
+# and that your input is in utf8.
+
+%%{
+    machine UnicodeDerived;
+    
+    ID_Start = 
+        0x41..0x5A              #L&  [26] LATIN CAPITAL LETTER A..LATIN CAPI...
+      | 0x61..0x7A              #L&  [26] LATIN SMALL LETTER A..LATIN SMALL ...
+      | 0xC2 0xAA               #Lo       FEMININE ORDINAL INDICATOR
+      | 0xC2 0xB5               #L&       MICRO SIGN
+      | 0xC2 0xBA               #Lo       MASCULINE ORDINAL INDICATOR
+      | 0xC3 0x80..0x96         #L&  [23] LATIN CAPITAL LETTER A WITH GRAVE....
+      | 0xC3 0x98..0xB6         #L&  [31] LATIN CAPITAL LETTER O WITH STROKE...
+      | 0xC3 0xB8..0xFF         #L& [195] LATIN SMALL LETTER O WITH STROKE.....
+      | 0xC4..0xC5 0x00..0xFF   #
+      | 0xC6 0x00..0xBA         #
+      | 0xC6 0xBB               #Lo       LATIN LETTER TWO WITH STROKE
+      | 0xC6 0xBC..0xBF         #L&   [4] LATIN CAPITAL LETTER TONE FIVE..LA...
+      | 0xC7 0x80..0x83         #Lo   [4] LATIN LETTER DENTAL CLICK..LATIN L...
+      | 0xC7 0x84..0xFF         #L& [208] LATIN CAPITAL LETTER DZ WITH CARON...
+      | 0xC8..0xC9 0x00..0xFF   #
+      | 0xCA 0x00..0x93         #
+      | 0xCA 0x94               #Lo       LATIN LETTER GLOTTAL STOP
+      | 0xCA 0x95..0xAF         #L&  [27] LATIN LETTER PHARYNGEAL VOICED FRI...
+      | 0xCA 0xB0..0xFF         #Lm  [18] MODIFIER LETTER SMALL H..MODIFIER ...
+      | 0xCB 0x00..0x81         #
+      | 0xCB 0x86..0x91         #Lm  [12] MODIFIER LETTER CIRCUMFLEX ACCENT....
+      | 0xCB 0xA0..0xA4         #Lm   [5] MODIFIER LETTER SMALL GAMMA..MODIF...
+      | 0xCB 0xAC               #Lm       MODIFIER LETTER VOICING
+      | 0xCB 0xAE               #Lm       MODIFIER LETTER DOUBLE APOSTROPHE
+      | 0xCD 0xB0..0xB3         #L&   [4] GREEK CAPITAL LETTER HETA..GREEK S...
+      | 0xCD 0xB4               #Lm       GREEK NUMERAL SIGN
+      | 0xCD 0xB6..0xB7         #L&   [2] GREEK CAPITAL LETTER PAMPHYLIAN DI...
+      | 0xCD 0xBA               #Lm       GREEK YPOGEGRAMMENI
+      | 0xCD 0xBB..0xBD         #L&   [3] GREEK SMALL REVERSED LUNATE SIGMA ...
+      | 0xCD 0xBF               #L&       GREEK CAPITAL LETTER YOT
+      | 0xCE 0x86               #L&       GREEK CAPITAL LETTER ALPHA WITH TONOS
+      | 0xCE 0x88..0x8A         #L&   [3] GREEK CAPITAL LETTER EPSILON WITH ...
+      | 0xCE 0x8C               #L&       GREEK CAPITAL LETTER OMICRON WITH ...
+      | 0xCE 0x8E..0xA1         #L&  [20] GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xCE 0xA3..0xFF         #L&  [83] GREEK CAPITAL LETTER SIGMA..GREEK ...
+      | 0xCF 0x00..0xB5         #
+      | 0xCF 0xB7..0xFF         #L& [139] GREEK CAPITAL LETTER SHO..CYRILLIC...
+      | 0xD0..0xD1 0x00..0xFF   #
+      | 0xD2 0x00..0x81         #
+      | 0xD2 0x8A..0xFF         #L& [166] CYRILLIC CAPITAL LETTER SHORT I WI...
+      | 0xD3..0xD3 0x00..0xFF   #
+      | 0xD4 0x00..0xAF         #
+      | 0xD4 0xB1..0xFF         #L&  [38] ARMENIAN CAPITAL LETTER AYB..ARMEN...
+      | 0xD5 0x00..0x96         #
+      | 0xD5 0x99               #Lm       ARMENIAN MODIFIER LETTER LEFT HALF...
+      | 0xD5 0xA1..0xFF         #L&  [39] ARMENIAN SMALL LETTER AYB..ARMENIA...
+      | 0xD6 0x00..0x87         #
+      | 0xD7 0x90..0xAA         #Lo  [27] HEBREW LETTER ALEF..HEBREW LETTER TAV
+      | 0xD7 0xB0..0xB2         #Lo   [3] HEBREW LIGATURE YIDDISH DOUBLE VAV...
+      | 0xD8 0xA0..0xBF         #Lo  [32] ARABIC LETTER KASHMIRI YEH..ARABIC...
+      | 0xD9 0x80               #Lm       ARABIC TATWEEL
+      | 0xD9 0x81..0x8A         #Lo  [10] ARABIC LETTER FEH..ARABIC LETTER YEH
+      | 0xD9 0xAE..0xAF         #Lo   [2] ARABIC LETTER DOTLESS BEH..ARABIC ...
+      | 0xD9 0xB1..0xFF         #Lo  [99] ARABIC LETTER ALEF WASLA..ARABIC L...
+      | 0xDA..0xDA 0x00..0xFF   #
+      | 0xDB 0x00..0x93         #
+      | 0xDB 0x95               #Lo       ARABIC LETTER AE
+      | 0xDB 0xA5..0xA6         #Lm   [2] ARABIC SMALL WAW..ARABIC SMALL YEH
+      | 0xDB 0xAE..0xAF         #Lo   [2] ARABIC LETTER DAL WITH INVERTED V....
+      | 0xDB 0xBA..0xBC         #Lo   [3] ARABIC LETTER SHEEN WITH DOT BELOW...
+      | 0xDB 0xBF               #Lo       ARABIC LETTER HEH WITH INVERTED V
+      | 0xDC 0x90               #Lo       SYRIAC LETTER ALAPH
+      | 0xDC 0x92..0xAF         #Lo  [30] SYRIAC LETTER BETH..SYRIAC LETTER ...
+      | 0xDD 0x8D..0xFF         #Lo  [89] SYRIAC LETTER SOGDIAN ZHAIN..THAAN...
+      | 0xDE 0x00..0xA5         #
+      | 0xDE 0xB1               #Lo       THAANA LETTER NAA
+      | 0xDF 0x8A..0xAA         #Lo  [33] NKO LETTER A..NKO LETTER JONA RA
+      | 0xDF 0xB4..0xB5         #Lm   [2] NKO HIGH TONE APOSTROPHE..NKO LOW ...
+      | 0xDF 0xBA               #Lm       NKO LAJANYALAN
+      | 0xE0 0xA0 0x80..0x95    #Lo  [22] SAMARITAN LETTER ALAF..SAMARITAN L...
+      | 0xE0 0xA0 0x9A          #Lm       SAMARITAN MODIFIER LETTER EPENTHET...
+      | 0xE0 0xA0 0xA4          #Lm       SAMARITAN MODIFIER LETTER SHORT A
+      | 0xE0 0xA0 0xA8          #Lm       SAMARITAN MODIFIER LETTER I
+      | 0xE0 0xA1 0x80..0x98    #Lo  [25] MANDAIC LETTER HALQA..MANDAIC LETT...
+      | 0xE0 0xA2 0xA0..0xB4    #Lo  [21] ARABIC LETTER BEH WITH SMALL V BEL...
+      | 0xE0 0xA2 0xB6..0xBD    #Lo   [8] ARABIC LETTER BEH WITH SMALL MEEM ...
+      | 0xE0 0xA4 0x84..0xB9    #Lo  [54] DEVANAGARI LETTER SHORT A..DEVANAG...
+      | 0xE0 0xA4 0xBD          #Lo       DEVANAGARI SIGN AVAGRAHA
+      | 0xE0 0xA5 0x90          #Lo       DEVANAGARI OM
+      | 0xE0 0xA5 0x98..0xA1    #Lo  [10] DEVANAGARI LETTER QA..DEVANAGARI L...
+      | 0xE0 0xA5 0xB1          #Lm       DEVANAGARI SIGN HIGH SPACING DOT
+      | 0xE0 0xA5 0xB2..0xFF    #Lo  [15] DEVANAGARI LETTER CANDRA A..BENGAL...
+      | 0xE0 0xA6 0x00..0x80    #
+      | 0xE0 0xA6 0x85..0x8C    #Lo   [8] BENGALI LETTER A..BENGALI LETTER V...
+      | 0xE0 0xA6 0x8F..0x90    #Lo   [2] BENGALI LETTER E..BENGALI LETTER AI
+      | 0xE0 0xA6 0x93..0xA8    #Lo  [22] BENGALI LETTER O..BENGALI LETTER NA
+      | 0xE0 0xA6 0xAA..0xB0    #Lo   [7] BENGALI LETTER PA..BENGALI LETTER RA
+      | 0xE0 0xA6 0xB2          #Lo       BENGALI LETTER LA
+      | 0xE0 0xA6 0xB6..0xB9    #Lo   [4] BENGALI LETTER SHA..BENGALI LETTER HA
+      | 0xE0 0xA6 0xBD          #Lo       BENGALI SIGN AVAGRAHA
+      | 0xE0 0xA7 0x8E          #Lo       BENGALI LETTER KHANDA TA
+      | 0xE0 0xA7 0x9C..0x9D    #Lo   [2] BENGALI LETTER RRA..BENGALI LETTER...
+      | 0xE0 0xA7 0x9F..0xA1    #Lo   [3] BENGALI LETTER YYA..BENGALI LETTER...
+      | 0xE0 0xA7 0xB0..0xB1    #Lo   [2] BENGALI LETTER RA WITH MIDDLE DIAG...
+      | 0xE0 0xA8 0x85..0x8A    #Lo   [6] GURMUKHI LETTER A..GURMUKHI LETTER UU
+      | 0xE0 0xA8 0x8F..0x90    #Lo   [2] GURMUKHI LETTER EE..GURMUKHI LETTE...
+      | 0xE0 0xA8 0x93..0xA8    #Lo  [22] GURMUKHI LETTER OO..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xAA..0xB0    #Lo   [7] GURMUKHI LETTER PA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB2..0xB3    #Lo   [2] GURMUKHI LETTER LA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB5..0xB6    #Lo   [2] GURMUKHI LETTER VA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB8..0xB9    #Lo   [2] GURMUKHI LETTER SA..GURMUKHI LETTE...
+      | 0xE0 0xA9 0x99..0x9C    #Lo   [4] GURMUKHI LETTER KHHA..GURMUKHI LET...
+      | 0xE0 0xA9 0x9E          #Lo       GURMUKHI LETTER FA
+      | 0xE0 0xA9 0xB2..0xB4    #Lo   [3] GURMUKHI IRI..GURMUKHI EK ONKAR
+      | 0xE0 0xAA 0x85..0x8D    #Lo   [9] GUJARATI LETTER A..GUJARATI VOWEL ...
+      | 0xE0 0xAA 0x8F..0x91    #Lo   [3] GUJARATI LETTER E..GUJARATI VOWEL ...
+      | 0xE0 0xAA 0x93..0xA8    #Lo  [22] GUJARATI LETTER O..GUJARATI LETTER NA
+      | 0xE0 0xAA 0xAA..0xB0    #Lo   [7] GUJARATI LETTER PA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xB2..0xB3    #Lo   [2] GUJARATI LETTER LA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xB5..0xB9    #Lo   [5] GUJARATI LETTER VA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xBD          #Lo       GUJARATI SIGN AVAGRAHA
+      | 0xE0 0xAB 0x90          #Lo       GUJARATI OM
+      | 0xE0 0xAB 0xA0..0xA1    #Lo   [2] GUJARATI LETTER VOCALIC RR..GUJARA...
+      | 0xE0 0xAB 0xB9          #Lo       GUJARATI LETTER ZHA
+      | 0xE0 0xAC 0x85..0x8C    #Lo   [8] ORIYA LETTER A..ORIYA LETTER VOCAL...
+      | 0xE0 0xAC 0x8F..0x90    #Lo   [2] ORIYA LETTER E..ORIYA LETTER AI
+      | 0xE0 0xAC 0x93..0xA8    #Lo  [22] ORIYA LETTER O..ORIYA LETTER NA
+      | 0xE0 0xAC 0xAA..0xB0    #Lo   [7] ORIYA LETTER PA..ORIYA LETTER RA
+      | 0xE0 0xAC 0xB2..0xB3    #Lo   [2] ORIYA LETTER LA..ORIYA LETTER LLA
+      | 0xE0 0xAC 0xB5..0xB9    #Lo   [5] ORIYA LETTER VA..ORIYA LETTER HA
+      | 0xE0 0xAC 0xBD          #Lo       ORIYA SIGN AVAGRAHA
+      | 0xE0 0xAD 0x9C..0x9D    #Lo   [2] ORIYA LETTER RRA..ORIYA LETTER RHA
+      | 0xE0 0xAD 0x9F..0xA1    #Lo   [3] ORIYA LETTER YYA..ORIYA LETTER VOC...
+      | 0xE0 0xAD 0xB1          #Lo       ORIYA LETTER WA
+      | 0xE0 0xAE 0x83          #Lo       TAMIL SIGN VISARGA
+      | 0xE0 0xAE 0x85..0x8A    #Lo   [6] TAMIL LETTER A..TAMIL LETTER UU
+      | 0xE0 0xAE 0x8E..0x90    #Lo   [3] TAMIL LETTER E..TAMIL LETTER AI
+      | 0xE0 0xAE 0x92..0x95    #Lo   [4] TAMIL LETTER O..TAMIL LETTER KA
+      | 0xE0 0xAE 0x99..0x9A    #Lo   [2] TAMIL LETTER NGA..TAMIL LETTER CA
+      | 0xE0 0xAE 0x9C          #Lo       TAMIL LETTER JA
+      | 0xE0 0xAE 0x9E..0x9F    #Lo   [2] TAMIL LETTER NYA..TAMIL LETTER TTA
+      | 0xE0 0xAE 0xA3..0xA4    #Lo   [2] TAMIL LETTER NNA..TAMIL LETTER TA
+      | 0xE0 0xAE 0xA8..0xAA    #Lo   [3] TAMIL LETTER NA..TAMIL LETTER PA
+      | 0xE0 0xAE 0xAE..0xB9    #Lo  [12] TAMIL LETTER MA..TAMIL LETTER HA
+      | 0xE0 0xAF 0x90          #Lo       TAMIL OM
+      | 0xE0 0xB0 0x85..0x8C    #Lo   [8] TELUGU LETTER A..TELUGU LETTER VOC...
+      | 0xE0 0xB0 0x8E..0x90    #Lo   [3] TELUGU LETTER E..TELUGU LETTER AI
+      | 0xE0 0xB0 0x92..0xA8    #Lo  [23] TELUGU LETTER O..TELUGU LETTER NA
+      | 0xE0 0xB0 0xAA..0xB9    #Lo  [16] TELUGU LETTER PA..TELUGU LETTER HA
+      | 0xE0 0xB0 0xBD          #Lo       TELUGU SIGN AVAGRAHA
+      | 0xE0 0xB1 0x98..0x9A    #Lo   [3] TELUGU LETTER TSA..TELUGU LETTER RRRA
+      | 0xE0 0xB1 0xA0..0xA1    #Lo   [2] TELUGU LETTER VOCALIC RR..TELUGU L...
+      | 0xE0 0xB2 0x80          #Lo       KANNADA SIGN SPACING CANDRABINDU
+      | 0xE0 0xB2 0x85..0x8C    #Lo   [8] KANNADA LETTER A..KANNADA LETTER V...
+      | 0xE0 0xB2 0x8E..0x90    #Lo   [3] KANNADA LETTER E..KANNADA LETTER AI
+      | 0xE0 0xB2 0x92..0xA8    #Lo  [23] KANNADA LETTER O..KANNADA LETTER NA
+      | 0xE0 0xB2 0xAA..0xB3    #Lo  [10] KANNADA LETTER PA..KANNADA LETTER LLA
+      | 0xE0 0xB2 0xB5..0xB9    #Lo   [5] KANNADA LETTER VA..KANNADA LETTER HA
+      | 0xE0 0xB2 0xBD          #Lo       KANNADA SIGN AVAGRAHA
+      | 0xE0 0xB3 0x9E          #Lo       KANNADA LETTER FA
+      | 0xE0 0xB3 0xA0..0xA1    #Lo   [2] KANNADA LETTER VOCALIC RR..KANNADA...
+      | 0xE0 0xB3 0xB1..0xB2    #Lo   [2] KANNADA SIGN JIHVAMULIYA..KANNADA ...
+      | 0xE0 0xB4 0x85..0x8C    #Lo   [8] MALAYALAM LETTER A..MALAYALAM LETT...
+      | 0xE0 0xB4 0x8E..0x90    #Lo   [3] MALAYALAM LETTER E..MALAYALAM LETT...
+      | 0xE0 0xB4 0x92..0xBA    #Lo  [41] MALAYALAM LETTER O..MALAYALAM LETT...
+      | 0xE0 0xB4 0xBD          #Lo       MALAYALAM SIGN AVAGRAHA
+      | 0xE0 0xB5 0x8E          #Lo       MALAYALAM LETTER DOT REPH
+      | 0xE0 0xB5 0x94..0x96    #Lo   [3] MALAYALAM LETTER CHILLU M..MALAYAL...
+      | 0xE0 0xB5 0x9F..0xA1    #Lo   [3] MALAYALAM LETTER ARCHAIC II..MALAY...
+      | 0xE0 0xB5 0xBA..0xBF    #Lo   [6] MALAYALAM LETTER CHILLU NN..MALAYA...
+      | 0xE0 0xB6 0x85..0x96    #Lo  [18] SINHALA LETTER AYANNA..SINHALA LET...
+      | 0xE0 0xB6 0x9A..0xB1    #Lo  [24] SINHALA LETTER ALPAPRAANA KAYANNA....
+      | 0xE0 0xB6 0xB3..0xBB    #Lo   [9] SINHALA LETTER SANYAKA DAYANNA..SI...
+      | 0xE0 0xB6 0xBD          #Lo       SINHALA LETTER DANTAJA LAYANNA
+      | 0xE0 0xB7 0x80..0x86    #Lo   [7] SINHALA LETTER VAYANNA..SINHALA LE...
+      | 0xE0 0xB8 0x81..0xB0    #Lo  [48] THAI CHARACTER KO KAI..THAI CHARAC...
+      | 0xE0 0xB8 0xB2..0xB3    #Lo   [2] THAI CHARACTER SARA AA..THAI CHARA...
+      | 0xE0 0xB9 0x80..0x85    #Lo   [6] THAI CHARACTER SARA E..THAI CHARAC...
+      | 0xE0 0xB9 0x86          #Lm       THAI CHARACTER MAIYAMOK
+      | 0xE0 0xBA 0x81..0x82    #Lo   [2] LAO LETTER KO..LAO LETTER KHO SUNG
+      | 0xE0 0xBA 0x84          #Lo       LAO LETTER KHO TAM
+      | 0xE0 0xBA 0x87..0x88    #Lo   [2] LAO LETTER NGO..LAO LETTER CO
+      | 0xE0 0xBA 0x8A          #Lo       LAO LETTER SO TAM
+      | 0xE0 0xBA 0x8D          #Lo       LAO LETTER NYO
+      | 0xE0 0xBA 0x94..0x97    #Lo   [4] LAO LETTER DO..LAO LETTER THO TAM
+      | 0xE0 0xBA 0x99..0x9F    #Lo   [7] LAO LETTER NO..LAO LETTER FO SUNG
+      | 0xE0 0xBA 0xA1..0xA3    #Lo   [3] LAO LETTER MO..LAO LETTER LO LING
+      | 0xE0 0xBA 0xA5          #Lo       LAO LETTER LO LOOT
+      | 0xE0 0xBA 0xA7          #Lo       LAO LETTER WO
+      | 0xE0 0xBA 0xAA..0xAB    #Lo   [2] LAO LETTER SO SUNG..LAO LETTER HO ...
+      | 0xE0 0xBA 0xAD..0xB0    #Lo   [4] LAO LETTER O..LAO VOWEL SIGN A
+      | 0xE0 0xBA 0xB2..0xB3    #Lo   [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM
+      | 0xE0 0xBA 0xBD          #Lo       LAO SEMIVOWEL SIGN NYO
+      | 0xE0 0xBB 0x80..0x84    #Lo   [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
+      | 0xE0 0xBB 0x86          #Lm       LAO KO LA
+      | 0xE0 0xBB 0x9C..0x9F    #Lo   [4] LAO HO NO..LAO LETTER KHMU NYO
+      | 0xE0 0xBC 0x80          #Lo       TIBETAN SYLLABLE OM
+      | 0xE0 0xBD 0x80..0x87    #Lo   [8] TIBETAN LETTER KA..TIBETAN LETTER JA
+      | 0xE0 0xBD 0x89..0xAC    #Lo  [36] TIBETAN LETTER NYA..TIBETAN LETTER...
+      | 0xE0 0xBE 0x88..0x8C    #Lo   [5] TIBETAN SIGN LCE TSA CAN..TIBETAN ...
+      | 0xE1 0x80 0x80..0xAA    #Lo  [43] MYANMAR LETTER KA..MYANMAR LETTER AU
+      | 0xE1 0x80 0xBF          #Lo       MYANMAR LETTER GREAT SA
+      | 0xE1 0x81 0x90..0x95    #Lo   [6] MYANMAR LETTER SHA..MYANMAR LETTER...
+      | 0xE1 0x81 0x9A..0x9D    #Lo   [4] MYANMAR LETTER MON NGA..MYANMAR LE...
+      | 0xE1 0x81 0xA1          #Lo       MYANMAR LETTER SGAW KAREN SHA
+      | 0xE1 0x81 0xA5..0xA6    #Lo   [2] MYANMAR LETTER WESTERN PWO KAREN T...
+      | 0xE1 0x81 0xAE..0xB0    #Lo   [3] MYANMAR LETTER EASTERN PWO KAREN N...
+      | 0xE1 0x81 0xB5..0xFF    #Lo  [13] MYANMAR LETTER SHAN KA..MYANMAR LE...
+      | 0xE1 0x82 0x00..0x81    #
+      | 0xE1 0x82 0x8E          #Lo       MYANMAR LETTER RUMAI PALAUNG FA
+      | 0xE1 0x82 0xA0..0xFF    #L&  [38] GEORGIAN CAPITAL LETTER AN..GEORGI...
+      | 0xE1 0x83 0x00..0x85    #
+      | 0xE1 0x83 0x87          #L&       GEORGIAN CAPITAL LETTER YN
+      | 0xE1 0x83 0x8D          #L&       GEORGIAN CAPITAL LETTER AEN
+      | 0xE1 0x83 0x90..0xBA    #Lo  [43] GEORGIAN LETTER AN..GEORGIAN LETTE...
+      | 0xE1 0x83 0xBC          #Lm       MODIFIER LETTER GEORGIAN NAR
+      | 0xE1 0x83 0xBD..0xFF        #Lo [332] GEORGIAN LETTER AEN..ETHIOPIC ...
+      | 0xE1 0x84..0x88 0x00..0xFF  #
+      | 0xE1 0x89 0x00..0x88        #
+      | 0xE1 0x89 0x8A..0x8D    #Lo   [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SY...
+      | 0xE1 0x89 0x90..0x96    #Lo   [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SY...
+      | 0xE1 0x89 0x98          #Lo       ETHIOPIC SYLLABLE QHWA
+      | 0xE1 0x89 0x9A..0x9D    #Lo   [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC S...
+      | 0xE1 0x89 0xA0..0xFF    #Lo  [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYL...
+      | 0xE1 0x8A 0x00..0x88    #
+      | 0xE1 0x8A 0x8A..0x8D    #Lo   [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SY...
+      | 0xE1 0x8A 0x90..0xB0    #Lo  [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYL...
+      | 0xE1 0x8A 0xB2..0xB5    #Lo   [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SY...
+      | 0xE1 0x8A 0xB8..0xBE    #Lo   [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SY...
+      | 0xE1 0x8B 0x80          #Lo       ETHIOPIC SYLLABLE KXWA
+      | 0xE1 0x8B 0x82..0x85    #Lo   [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC S...
+      | 0xE1 0x8B 0x88..0x96    #Lo  [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYL...
+      | 0xE1 0x8B 0x98..0xFF    #Lo  [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYL...
+      | 0xE1 0x8C 0x00..0x90    #
+      | 0xE1 0x8C 0x92..0x95    #Lo   [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SY...
+      | 0xE1 0x8C 0x98..0xFF    #Lo  [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SY...
+      | 0xE1 0x8D 0x00..0x9A    #
+      | 0xE1 0x8E 0x80..0x8F    #Lo  [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..E...
+      | 0xE1 0x8E 0xA0..0xFF    #L&  [86] CHEROKEE LETTER A..CHEROKEE LETTER MV
+      | 0xE1 0x8F 0x00..0xB5    #
+      | 0xE1 0x8F 0xB8..0xBD    #L&   [6] CHEROKEE SMALL LETTER YE..CHEROKEE...
+      | 0xE1 0x90 0x81..0xFF        #Lo [620] CANADIAN SYLLABICS E..CANADIAN...
+      | 0xE1 0x91..0x98 0x00..0xFF  #
+      | 0xE1 0x99 0x00..0xAC        #
+      | 0xE1 0x99 0xAF..0xBF    #Lo  [17] CANADIAN SYLLABICS QAI..CANADIAN S...
+      | 0xE1 0x9A 0x81..0x9A    #Lo  [26] OGHAM LETTER BEITH..OGHAM LETTER P...
+      | 0xE1 0x9A 0xA0..0xFF    #Lo  [75] RUNIC LETTER FEHU FEOH FE F..RUNIC...
+      | 0xE1 0x9B 0x00..0xAA    #
+      | 0xE1 0x9B 0xAE..0xB0    #Nl   [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHO...
+      | 0xE1 0x9B 0xB1..0xB8    #Lo   [8] RUNIC LETTER K..RUNIC LETTER FRANK...
+      | 0xE1 0x9C 0x80..0x8C    #Lo  [13] TAGALOG LETTER A..TAGALOG LETTER YA
+      | 0xE1 0x9C 0x8E..0x91    #Lo   [4] TAGALOG LETTER LA..TAGALOG LETTER HA
+      | 0xE1 0x9C 0xA0..0xB1    #Lo  [18] HANUNOO LETTER A..HANUNOO LETTER HA
+      | 0xE1 0x9D 0x80..0x91    #Lo  [18] BUHID LETTER A..BUHID LETTER HA
+      | 0xE1 0x9D 0xA0..0xAC    #Lo  [13] TAGBANWA LETTER A..TAGBANWA LETTER YA
+      | 0xE1 0x9D 0xAE..0xB0    #Lo   [3] TAGBANWA LETTER LA..TAGBANWA LETTE...
+      | 0xE1 0x9E 0x80..0xB3    #Lo  [52] KHMER LETTER KA..KHMER INDEPENDENT...
+      | 0xE1 0x9F 0x97          #Lm       KHMER SIGN LEK TOO
+      | 0xE1 0x9F 0x9C          #Lo       KHMER SIGN AVAKRAHASANYA
+      | 0xE1 0xA0 0xA0..0xFF    #Lo  [35] MONGOLIAN LETTER A..MONGOLIAN LETT...
+      | 0xE1 0xA1 0x00..0x82    #
+      | 0xE1 0xA1 0x83          #Lm       MONGOLIAN LETTER TODO LONG VOWEL SIGN
+      | 0xE1 0xA1 0x84..0xB7    #Lo  [52] MONGOLIAN LETTER TODO E..MONGOLIAN...
+      | 0xE1 0xA2 0x80..0x84    #Lo   [5] MONGOLIAN LETTER ALI GALI ANUSVARA...
+      | 0xE1 0xA2 0x85..0x86    #Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA.....
+      | 0xE1 0xA2 0x87..0xA8    #Lo  [34] MONGOLIAN LETTER ALI GALI A..MONGO...
+      | 0xE1 0xA2 0xAA          #Lo       MONGOLIAN LETTER MANCHU ALI GALI LHA
+      | 0xE1 0xA2 0xB0..0xFF    #Lo  [70] CANADIAN SYLLABICS OY..CANADIAN SY...
+      | 0xE1 0xA3 0x00..0xB5    #
+      | 0xE1 0xA4 0x80..0x9E    #Lo  [31] LIMBU VOWEL-CARRIER LETTER..LIMBU ...
+      | 0xE1 0xA5 0x90..0xAD    #Lo  [30] TAI LE LETTER KA..TAI LE LETTER AI
+      | 0xE1 0xA5 0xB0..0xB4    #Lo   [5] TAI LE LETTER TONE-2..TAI LE LETTE...
+      | 0xE1 0xA6 0x80..0xAB    #Lo  [44] NEW TAI LUE LETTER HIGH QA..NEW TA...
+      | 0xE1 0xA6 0xB0..0xFF    #Lo  [26] NEW TAI LUE VOWEL SIGN VOWEL SHORT...
+      | 0xE1 0xA7 0x00..0x89    #
+      | 0xE1 0xA8 0x80..0x96    #Lo  [23] BUGINESE LETTER KA..BUGINESE LETTE...
+      | 0xE1 0xA8 0xA0..0xFF    #Lo  [53] TAI THAM LETTER HIGH KA..TAI THAM ...
+      | 0xE1 0xA9 0x00..0x94    #
+      | 0xE1 0xAA 0xA7          #Lm       TAI THAM SIGN MAI YAMOK
+      | 0xE1 0xAC 0x85..0xB3    #Lo  [47] BALINESE LETTER AKARA..BALINESE LE...
+      | 0xE1 0xAD 0x85..0x8B    #Lo   [7] BALINESE LETTER KAF SASAK..BALINES...
+      | 0xE1 0xAE 0x83..0xA0    #Lo  [30] SUNDANESE LETTER A..SUNDANESE LETT...
+      | 0xE1 0xAE 0xAE..0xAF    #Lo   [2] SUNDANESE LETTER KHA..SUNDANESE LE...
+      | 0xE1 0xAE 0xBA..0xFF    #Lo  [44] SUNDANESE AVAGRAHA..BATAK LETTER U
+      | 0xE1 0xAF 0x00..0xA5    #
+      | 0xE1 0xB0 0x80..0xA3    #Lo  [36] LEPCHA LETTER KA..LEPCHA LETTER A
+      | 0xE1 0xB1 0x8D..0x8F    #Lo   [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA
+      | 0xE1 0xB1 0x9A..0xB7    #Lo  [30] OL CHIKI LETTER LA..OL CHIKI LETTE...
+      | 0xE1 0xB1 0xB8..0xBD    #Lm   [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD
+      | 0xE1 0xB2 0x80..0x88    #L&   [9] CYRILLIC SMALL LETTER ROUNDED VE.....
+      | 0xE1 0xB3 0xA9..0xAC    #Lo   [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA.....
+      | 0xE1 0xB3 0xAE..0xB1    #Lo   [4] VEDIC SIGN HEXIFORM LONG ANUSVARA....
+      | 0xE1 0xB3 0xB5..0xB6    #Lo   [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN...
+      | 0xE1 0xB4 0x80..0xAB    #L&  [44] LATIN LETTER SMALL CAPITAL A..CYRI...
+      | 0xE1 0xB4 0xAC..0xFF    #Lm  [63] MODIFIER LETTER CAPITAL A..GREEK S...
+      | 0xE1 0xB5 0x00..0xAA    #
+      | 0xE1 0xB5 0xAB..0xB7    #L&  [13] LATIN SMALL LETTER UE..LATIN SMALL...
+      | 0xE1 0xB5 0xB8          #Lm       MODIFIER LETTER CYRILLIC EN
+      | 0xE1 0xB5 0xB9..0xFF    #L&  [34] LATIN SMALL LETTER INSULAR G..LATI...
+      | 0xE1 0xB6 0x00..0x9A    #
+      | 0xE1 0xB6 0x9B..0xBF    #Lm  [37] MODIFIER LETTER SMALL TURNED ALPHA...
+      | 0xE1 0xB8 0x80..0xFF        #L& [278] LATIN CAPITAL LETTER A WITH RI...
+      | 0xE1 0xB9..0xBB 0x00..0xFF  #
+      | 0xE1 0xBC 0x00..0x95        #
+      | 0xE1 0xBC 0x98..0x9D    #L&   [6] GREEK CAPITAL LETTER EPSILON WITH ...
+      | 0xE1 0xBC 0xA0..0xFF    #L&  [38] GREEK SMALL LETTER ETA WITH PSILI....
+      | 0xE1 0xBD 0x00..0x85    #
+      | 0xE1 0xBD 0x88..0x8D    #L&   [6] GREEK CAPITAL LETTER OMICRON WITH ...
+      | 0xE1 0xBD 0x90..0x97    #L&   [8] GREEK SMALL LETTER UPSILON WITH PS...
+      | 0xE1 0xBD 0x99          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9B          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9D          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9F..0xBD    #L&  [31] GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBE 0x80..0xB4    #L&  [53] GREEK SMALL LETTER ALPHA WITH PSIL...
+      | 0xE1 0xBE 0xB6..0xBC    #L&   [7] GREEK SMALL LETTER ALPHA WITH PERI...
+      | 0xE1 0xBE 0xBE          #L&       GREEK PROSGEGRAMMENI
+      | 0xE1 0xBF 0x82..0x84    #L&   [3] GREEK SMALL LETTER ETA WITH VARIA ...
+      | 0xE1 0xBF 0x86..0x8C    #L&   [7] GREEK SMALL LETTER ETA WITH PERISP...
+      | 0xE1 0xBF 0x90..0x93    #L&   [4] GREEK SMALL LETTER IOTA WITH VRACH...
+      | 0xE1 0xBF 0x96..0x9B    #L&   [6] GREEK SMALL LETTER IOTA WITH PERIS...
+      | 0xE1 0xBF 0xA0..0xAC    #L&  [13] GREEK SMALL LETTER UPSILON WITH VR...
+      | 0xE1 0xBF 0xB2..0xB4    #L&   [3] GREEK SMALL LETTER OMEGA WITH VARI...
+      | 0xE1 0xBF 0xB6..0xBC    #L&   [7] GREEK SMALL LETTER OMEGA WITH PERI...
+      | 0xE2 0x81 0xB1          #Lm       SUPERSCRIPT LATIN SMALL LETTER I
+      | 0xE2 0x81 0xBF          #Lm       SUPERSCRIPT LATIN SMALL LETTER N
+      | 0xE2 0x82 0x90..0x9C    #Lm  [13] LATIN SUBSCRIPT SMALL LETTER A..LA...
+      | 0xE2 0x84 0x82          #L&       DOUBLE-STRUCK CAPITAL C
+      | 0xE2 0x84 0x87          #L&       EULER CONSTANT
+      | 0xE2 0x84 0x8A..0x93    #L&  [10] SCRIPT SMALL G..SCRIPT SMALL L
+      | 0xE2 0x84 0x95          #L&       DOUBLE-STRUCK CAPITAL N
+      | 0xE2 0x84 0x98          #Sm       SCRIPT CAPITAL P
+      | 0xE2 0x84 0x99..0x9D    #L&   [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-ST...
+      | 0xE2 0x84 0xA4          #L&       DOUBLE-STRUCK CAPITAL Z
+      | 0xE2 0x84 0xA6          #L&       OHM SIGN
+      | 0xE2 0x84 0xA8          #L&       BLACK-LETTER CAPITAL Z
+      | 0xE2 0x84 0xAA..0xAD    #L&   [4] KELVIN SIGN..BLACK-LETTER CAPITAL C
+      | 0xE2 0x84 0xAE          #So       ESTIMATED SYMBOL
+      | 0xE2 0x84 0xAF..0xB4    #L&   [6] SCRIPT SMALL E..SCRIPT SMALL O
+      | 0xE2 0x84 0xB5..0xB8    #Lo   [4] ALEF SYMBOL..DALET SYMBOL
+      | 0xE2 0x84 0xB9          #L&       INFORMATION SOURCE
+      | 0xE2 0x84 0xBC..0xBF    #L&   [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STR...
+      | 0xE2 0x85 0x85..0x89    #L&   [5] DOUBLE-STRUCK ITALIC CAPITAL D..DO...
+      | 0xE2 0x85 0x8E          #L&       TURNED SMALL F
+      | 0xE2 0x85 0xA0..0xFF    #Nl  [35] ROMAN NUMERAL ONE..ROMAN NUMERAL T...
+      | 0xE2 0x86 0x00..0x82    #
+      | 0xE2 0x86 0x83..0x84    #L&   [2] ROMAN NUMERAL REVERSED ONE HUNDRED...
+      | 0xE2 0x86 0x85..0x88    #Nl   [4] ROMAN NUMERAL SIX LATE FORM..ROMAN...
+      | 0xE2 0xB0 0x80..0xAE    #L&  [47] GLAGOLITIC CAPITAL LETTER AZU..GLA...
+      | 0xE2 0xB0 0xB0..0xFF    #L&  [47] GLAGOLITIC SMALL LETTER AZU..GLAGO...
+      | 0xE2 0xB1 0x00..0x9E    #
+      | 0xE2 0xB1 0xA0..0xBB    #L&  [28] LATIN CAPITAL LETTER L WITH DOUBLE...
+      | 0xE2 0xB1 0xBC..0xBD    #Lm   [2] LATIN SUBSCRIPT SMALL LETTER J..MO...
+      | 0xE2 0xB1 0xBE..0xFF        #L& [103] LATIN CAPITAL LETTER S WITH SW...
+      | 0xE2 0xB2..0xB2 0x00..0xFF  #
+      | 0xE2 0xB3 0x00..0xA4        #
+      | 0xE2 0xB3 0xAB..0xAE    #L&   [4] COPTIC CAPITAL LETTER CRYPTOGRAMMI...
+      | 0xE2 0xB3 0xB2..0xB3    #L&   [2] COPTIC CAPITAL LETTER BOHAIRIC KHE...
+      | 0xE2 0xB4 0x80..0xA5    #L&  [38] GEORGIAN SMALL LETTER AN..GEORGIAN...
+      | 0xE2 0xB4 0xA7          #L&       GEORGIAN SMALL LETTER YN
+      | 0xE2 0xB4 0xAD          #L&       GEORGIAN SMALL LETTER AEN
+      | 0xE2 0xB4 0xB0..0xFF    #Lo  [56] TIFINAGH LETTER YA..TIFINAGH LETTE...
+      | 0xE2 0xB5 0x00..0xA7    #
+      | 0xE2 0xB5 0xAF          #Lm       TIFINAGH MODIFIER LETTER LABIALIZA...
+      | 0xE2 0xB6 0x80..0x96    #Lo  [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xA0..0xA6    #Lo   [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xA8..0xAE    #Lo   [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xB0..0xB6    #Lo   [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xB8..0xBE    #Lo   [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC S...
+      | 0xE2 0xB7 0x80..0x86    #Lo   [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x88..0x8E    #Lo   [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x90..0x96    #Lo   [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x98..0x9E    #Lo   [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SY...
+      | 0xE3 0x80 0x85          #Lm       IDEOGRAPHIC ITERATION MARK
+      | 0xE3 0x80 0x86          #Lo       IDEOGRAPHIC CLOSING MARK
+      | 0xE3 0x80 0x87          #Nl       IDEOGRAPHIC NUMBER ZERO
+      | 0xE3 0x80 0xA1..0xA9    #Nl   [9] HANGZHOU NUMERAL ONE..HANGZHOU NUM...
+      | 0xE3 0x80 0xB1..0xB5    #Lm   [5] VERTICAL KANA REPEAT MARK..VERTICA...
+      | 0xE3 0x80 0xB8..0xBA    #Nl   [3] HANGZHOU NUMERAL TEN..HANGZHOU NUM...
+      | 0xE3 0x80 0xBB          #Lm       VERTICAL IDEOGRAPHIC ITERATION MARK
+      | 0xE3 0x80 0xBC          #Lo       MASU MARK
+      | 0xE3 0x81 0x81..0xFF    #Lo  [86] HIRAGANA LETTER SMALL A..HIRAGANA ...
+      | 0xE3 0x82 0x00..0x96    #
+      | 0xE3 0x82 0x9B..0x9C    #Sk   [2] KATAKANA-HIRAGANA VOICED SOUND MAR...
+      | 0xE3 0x82 0x9D..0x9E    #Lm   [2] HIRAGANA ITERATION MARK..HIRAGANA ...
+      | 0xE3 0x82 0x9F          #Lo       HIRAGANA DIGRAPH YORI
+      | 0xE3 0x82 0xA1..0xFF    #Lo  [90] KATAKANA LETTER SMALL A..KATAKANA ...
+      | 0xE3 0x83 0x00..0xBA    #
+      | 0xE3 0x83 0xBC..0xBE    #Lm   [3] KATAKANA-HIRAGANA PROLONGED SOUND ...
+      | 0xE3 0x83 0xBF          #Lo       KATAKANA DIGRAPH KOTO
+      | 0xE3 0x84 0x85..0xAD    #Lo  [41] BOPOMOFO LETTER B..BOPOMOFO LETTER IH
+      | 0xE3 0x84 0xB1..0xFF        #Lo  [94] HANGUL LETTER KIYEOK..HANGUL L...
+      | 0xE3 0x85..0x85 0x00..0xFF  #
+      | 0xE3 0x86 0x00..0x8E        #
+      | 0xE3 0x86 0xA0..0xBA    #Lo  [27] BOPOMOFO LETTER BU..BOPOMOFO LETTE...
+      | 0xE3 0x87 0xB0..0xBF    #Lo  [16] KATAKANA LETTER SMALL KU..KATAKANA...
+      | 0xE3 0x90 0x80..0xFF        #Lo [6582] CJK UNIFIED IDEOGRAPH-3400..C...
+      | 0xE3 0x91..0xFF 0x00..0xFF  #
+      | 0xE4 0x00 0x00..0xFF        #
+      | 0xE4 0x01..0xB5 0x00..0xFF  #
+      | 0xE4 0xB6 0x00..0xB5        #
+      | 0xE4 0xB8 0x80..0xFF              #Lo [20950] CJK UNIFIED IDEOGRAPH-...
+      | 0xE4 0xB9..0xFF 0x00..0xFF        #
+      | 0xE5..0xE8 0x00..0xFF 0x00..0xFF  #
+      | 0xE9 0x00 0x00..0xFF              #
+      | 0xE9 0x01..0xBE 0x00..0xFF        #
+      | 0xE9 0xBF 0x00..0x95              #
+      | 0xEA 0x80 0x80..0x94    #Lo  [21] YI SYLLABLE IT..YI SYLLABLE E
+      | 0xEA 0x80 0x95          #Lm       YI SYLLABLE WU
+      | 0xEA 0x80 0x96..0xFF        #Lo [1143] YI SYLLABLE BIT..YI SYLLABLE YYR
+      | 0xEA 0x81..0x91 0x00..0xFF  #
+      | 0xEA 0x92 0x00..0x8C        #
+      | 0xEA 0x93 0x90..0xB7    #Lo  [40] LISU LETTER BA..LISU LETTER OE
+      | 0xEA 0x93 0xB8..0xBD    #Lm   [6] LISU LETTER TONE MYA TI..LISU LETT...
+      | 0xEA 0x94 0x80..0xFF        #Lo [268] VAI SYLLABLE EE..VAI SYLLABLE NG
+      | 0xEA 0x95..0x97 0x00..0xFF  #
+      | 0xEA 0x98 0x00..0x8B        #
+      | 0xEA 0x98 0x8C          #Lm       VAI SYLLABLE LENGTHENER
+      | 0xEA 0x98 0x90..0x9F    #Lo  [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL ...
+      | 0xEA 0x98 0xAA..0xAB    #Lo   [2] VAI SYLLABLE NDOLE MA..VAI SYLLABL...
+      | 0xEA 0x99 0x80..0xAD    #L&  [46] CYRILLIC CAPITAL LETTER ZEMLYA..CY...
+      | 0xEA 0x99 0xAE          #Lo       CYRILLIC LETTER MULTIOCULAR O
+      | 0xEA 0x99 0xBF          #Lm       CYRILLIC PAYEROK
+      | 0xEA 0x9A 0x80..0x9B    #L&  [28] CYRILLIC CAPITAL LETTER DWE..CYRIL...
+      | 0xEA 0x9A 0x9C..0x9D    #Lm   [2] MODIFIER LETTER CYRILLIC HARD SIGN...
+      | 0xEA 0x9A 0xA0..0xFF    #Lo  [70] BAMUM LETTER A..BAMUM LETTER KI
+      | 0xEA 0x9B 0x00..0xA5    #
+      | 0xEA 0x9B 0xA6..0xAF    #Nl  [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM
+      | 0xEA 0x9C 0x97..0x9F    #Lm   [9] MODIFIER LETTER DOT VERTICAL BAR.....
+      | 0xEA 0x9C 0xA2..0xFF    #L&  [78] LATIN CAPITAL LETTER EGYPTOLOGICAL...
+      | 0xEA 0x9D 0x00..0xAF    #
+      | 0xEA 0x9D 0xB0          #Lm       MODIFIER LETTER US
+      | 0xEA 0x9D 0xB1..0xFF    #L&  [23] LATIN SMALL LETTER DUM..LATIN SMAL...
+      | 0xEA 0x9E 0x00..0x87    #
+      | 0xEA 0x9E 0x88          #Lm       MODIFIER LETTER LOW CIRCUMFLEX ACCENT
+      | 0xEA 0x9E 0x8B..0x8E    #L&   [4] LATIN CAPITAL LETTER SALTILLO..LAT...
+      | 0xEA 0x9E 0x8F          #Lo       LATIN LETTER SINOLOGICAL DOT
+      | 0xEA 0x9E 0x90..0xAE    #L&  [31] LATIN CAPITAL LETTER N WITH DESCEN...
+      | 0xEA 0x9E 0xB0..0xB7    #L&   [8] LATIN CAPITAL LETTER TURNED K..LAT...
+      | 0xEA 0x9F 0xB7          #Lo       LATIN EPIGRAPHIC LETTER SIDEWAYS I
+      | 0xEA 0x9F 0xB8..0xB9    #Lm   [2] MODIFIER LETTER CAPITAL H WITH STR...
+      | 0xEA 0x9F 0xBA          #L&       LATIN LETTER SMALL CAPITAL TURNED M
+      | 0xEA 0x9F 0xBB..0xFF    #Lo   [7] LATIN EPIGRAPHIC LETTER REVERSED F...
+      | 0xEA 0xA0 0x00..0x81    #
+      | 0xEA 0xA0 0x83..0x85    #Lo   [3] SYLOTI NAGRI LETTER U..SYLOTI NAGR...
+      | 0xEA 0xA0 0x87..0x8A    #Lo   [4] SYLOTI NAGRI LETTER KO..SYLOTI NAG...
+      | 0xEA 0xA0 0x8C..0xA2    #Lo  [23] SYLOTI NAGRI LETTER CO..SYLOTI NAG...
+      | 0xEA 0xA1 0x80..0xB3    #Lo  [52] PHAGS-PA LETTER KA..PHAGS-PA LETTE...
+      | 0xEA 0xA2 0x82..0xB3    #Lo  [50] SAURASHTRA LETTER A..SAURASHTRA LE...
+      | 0xEA 0xA3 0xB2..0xB7    #Lo   [6] DEVANAGARI SIGN SPACING CANDRABIND...
+      | 0xEA 0xA3 0xBB          #Lo       DEVANAGARI HEADSTROKE
+      | 0xEA 0xA3 0xBD          #Lo       DEVANAGARI JAIN OM
+      | 0xEA 0xA4 0x8A..0xA5    #Lo  [28] KAYAH LI LETTER KA..KAYAH LI LETTE...
+      | 0xEA 0xA4 0xB0..0xFF    #Lo  [23] REJANG LETTER KA..REJANG LETTER A
+      | 0xEA 0xA5 0x00..0x86    #
+      | 0xEA 0xA5 0xA0..0xBC    #Lo  [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANG...
+      | 0xEA 0xA6 0x84..0xB2    #Lo  [47] JAVANESE LETTER A..JAVANESE LETTER HA
+      | 0xEA 0xA7 0x8F          #Lm       JAVANESE PANGRANGKEP
+      | 0xEA 0xA7 0xA0..0xA4    #Lo   [5] MYANMAR LETTER SHAN GHA..MYANMAR L...
+      | 0xEA 0xA7 0xA6          #Lm       MYANMAR MODIFIER LETTER SHAN REDUP...
+      | 0xEA 0xA7 0xA7..0xAF    #Lo   [9] MYANMAR LETTER TAI LAING NYA..MYAN...
+      | 0xEA 0xA7 0xBA..0xBE    #Lo   [5] MYANMAR LETTER TAI LAING LLA..MYAN...
+      | 0xEA 0xA8 0x80..0xA8    #Lo  [41] CHAM LETTER A..CHAM LETTER HA
+      | 0xEA 0xA9 0x80..0x82    #Lo   [3] CHAM LETTER FINAL K..CHAM LETTER F...
+      | 0xEA 0xA9 0x84..0x8B    #Lo   [8] CHAM LETTER FINAL CH..CHAM LETTER ...
+      | 0xEA 0xA9 0xA0..0xAF    #Lo  [16] MYANMAR LETTER KHAMTI GA..MYANMAR ...
+      | 0xEA 0xA9 0xB0          #Lm       MYANMAR MODIFIER LETTER KHAMTI RED...
+      | 0xEA 0xA9 0xB1..0xB6    #Lo   [6] MYANMAR LETTER KHAMTI XA..MYANMAR ...
+      | 0xEA 0xA9 0xBA          #Lo       MYANMAR LETTER AITON RA
+      | 0xEA 0xA9 0xBE..0xFF    #Lo  [50] MYANMAR LETTER SHWE PALAUNG CHA..T...
+      | 0xEA 0xAA 0x00..0xAF    #
+      | 0xEA 0xAA 0xB1          #Lo       TAI VIET VOWEL AA
+      | 0xEA 0xAA 0xB5..0xB6    #Lo   [2] TAI VIET VOWEL E..TAI VIET VOWEL O
+      | 0xEA 0xAA 0xB9..0xBD    #Lo   [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN
+      | 0xEA 0xAB 0x80          #Lo       TAI VIET TONE MAI NUENG
+      | 0xEA 0xAB 0x82          #Lo       TAI VIET TONE MAI SONG
+      | 0xEA 0xAB 0x9B..0x9C    #Lo   [2] TAI VIET SYMBOL KON..TAI VIET SYMB...
+      | 0xEA 0xAB 0x9D          #Lm       TAI VIET SYMBOL SAM
+      | 0xEA 0xAB 0xA0..0xAA    #Lo  [11] MEETEI MAYEK LETTER E..MEETEI MAYE...
+      | 0xEA 0xAB 0xB2          #Lo       MEETEI MAYEK ANJI
+      | 0xEA 0xAB 0xB3..0xB4    #Lm   [2] MEETEI MAYEK SYLLABLE REPETITION M...
+      | 0xEA 0xAC 0x81..0x86    #Lo   [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC S...
+      | 0xEA 0xAC 0x89..0x8E    #Lo   [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC S...
+      | 0xEA 0xAC 0x91..0x96    #Lo   [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SY...
+      | 0xEA 0xAC 0xA0..0xA6    #Lo   [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC ...
+      | 0xEA 0xAC 0xA8..0xAE    #Lo   [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SY...
+      | 0xEA 0xAC 0xB0..0xFF    #L&  [43] LATIN SMALL LETTER BARRED ALPHA..L...
+      | 0xEA 0xAD 0x00..0x9A    #
+      | 0xEA 0xAD 0x9C..0x9F    #Lm   [4] MODIFIER LETTER SMALL HENG..MODIFI...
+      | 0xEA 0xAD 0xA0..0xA5    #L&   [6] LATIN SMALL LETTER SAKHA YAT..GREE...
+      | 0xEA 0xAD 0xB0..0xFF    #L&  [80] CHEROKEE SMALL LETTER A..CHEROKEE ...
+      | 0xEA 0xAE 0x00..0xBF    #
+      | 0xEA 0xAF 0x80..0xA2    #Lo  [35] MEETEI MAYEK LETTER KOK..MEETEI MA...
+      | 0xEA 0xB0 0x80..0xFF              #Lo [11172] HANGUL SYLLABLE GA..HA...
+      | 0xEA 0xB1..0xFF 0x00..0xFF        #
+      | 0xEB..0xEC 0x00..0xFF 0x00..0xFF  #
+      | 0xED 0x00 0x00..0xFF              #
+      | 0xED 0x01..0x9D 0x00..0xFF        #
+      | 0xED 0x9E 0x00..0xA3              #
+      | 0xED 0x9E 0xB0..0xFF    #Lo  [23] HANGUL JUNGSEONG O-YEO..HANGUL JUN...
+      | 0xED 0x9F 0x00..0x86    #
+      | 0xED 0x9F 0x8B..0xBB    #Lo  [49] HANGUL JONGSEONG NIEUN-RIEUL..HANG...
+      | 0xEF 0xA4 0x80..0xFF        #Lo [366] CJK COMPATIBILITY IDEOGRAPH-F9...
+      | 0xEF 0xA5..0xA8 0x00..0xFF  #
+      | 0xEF 0xA9 0x00..0xAD        #
+      | 0xEF 0xA9 0xB0..0xFF        #Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA...
+      | 0xEF 0xAA..0xAA 0x00..0xFF  #
+      | 0xEF 0xAB 0x00..0x99        #
+      | 0xEF 0xAC 0x80..0x86    #L&   [7] LATIN SMALL LIGATURE FF..LATIN SMA...
+      | 0xEF 0xAC 0x93..0x97    #L&   [5] ARMENIAN SMALL LIGATURE MEN NOW..A...
+      | 0xEF 0xAC 0x9D          #Lo       HEBREW LETTER YOD WITH HIRIQ
+      | 0xEF 0xAC 0x9F..0xA8    #Lo  [10] HEBREW LIGATURE YIDDISH YOD YOD PA...
+      | 0xEF 0xAC 0xAA..0xB6    #Lo  [13] HEBREW LETTER SHIN WITH SHIN DOT.....
+      | 0xEF 0xAC 0xB8..0xBC    #Lo   [5] HEBREW LETTER TET WITH DAGESH..HEB...
+      | 0xEF 0xAC 0xBE          #Lo       HEBREW LETTER MEM WITH DAGESH
+      | 0xEF 0xAD 0x80..0x81    #Lo   [2] HEBREW LETTER NUN WITH DAGESH..HEB...
+      | 0xEF 0xAD 0x83..0x84    #Lo   [2] HEBREW LETTER FINAL PE WITH DAGESH...
+      | 0xEF 0xAD 0x86..0xFF    #Lo [108] HEBREW LETTER TSADI WITH DAGESH..A...
+      | 0xEF 0xAE 0x00..0xB1    #
+      | 0xEF 0xAF 0x93..0xFF        #Lo [363] ARABIC LETTER NG ISOLATED FORM...
+      | 0xEF 0xB0..0xB3 0x00..0xFF  #
+      | 0xEF 0xB4 0x00..0xBD        #
+      | 0xEF 0xB5 0x90..0xFF    #Lo  [64] ARABIC LIGATURE TEH WITH JEEM WITH...
+      | 0xEF 0xB6 0x00..0x8F    #
+      | 0xEF 0xB6 0x92..0xFF    #Lo  [54] ARABIC LIGATURE MEEM WITH JEEM WIT...
+      | 0xEF 0xB7 0x00..0x87    #
+      | 0xEF 0xB7 0xB0..0xBB    #Lo  [12] ARABIC LIGATURE SALLA USED AS KORA...
+      | 0xEF 0xB9 0xB0..0xB4    #Lo   [5] ARABIC FATHATAN ISOLATED FORM..ARA...
+      | 0xEF 0xB9 0xB6..0xFF        #Lo [135] ARABIC FATHA ISOLATED FORM..AR...
+      | 0xEF 0xBA..0xBA 0x00..0xFF  #
+      | 0xEF 0xBB 0x00..0xBC        #
+      | 0xEF 0xBC 0xA1..0xBA    #L&  [26] FULLWIDTH LATIN CAPITAL LETTER A.....
+      | 0xEF 0xBD 0x81..0x9A    #L&  [26] FULLWIDTH LATIN SMALL LETTER A..FU...
+      | 0xEF 0xBD 0xA6..0xAF    #Lo  [10] HALFWIDTH KATAKANA LETTER WO..HALF...
+      | 0xEF 0xBD 0xB0          #Lm       HALFWIDTH KATAKANA-HIRAGANA PROLON...
+      | 0xEF 0xBD 0xB1..0xFF    #Lo  [45] HALFWIDTH KATAKANA LETTER A..HALFW...
+      | 0xEF 0xBE 0x00..0x9D    #
+      | 0xEF 0xBE 0x9E..0x9F    #Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MA...
+      | 0xEF 0xBE 0xA0..0xBE    #Lo  [31] HALFWIDTH HANGUL FILLER..HALFWIDTH...
+      | 0xEF 0xBF 0x82..0x87    #Lo   [6] HALFWIDTH HANGUL LETTER A..HALFWID...
+      | 0xEF 0xBF 0x8A..0x8F    #Lo   [6] HALFWIDTH HANGUL LETTER YEO..HALFW...
+      | 0xEF 0xBF 0x92..0x97    #Lo   [6] HALFWIDTH HANGUL LETTER YO..HALFWI...
+      | 0xEF 0xBF 0x9A..0x9C    #Lo   [3] HALFWIDTH HANGUL LETTER EU..HALFWI...
+      | 0xF0 0x90 0x80 0x80..0x8B  #Lo  [12] LINEAR B SYLLABLE B008 A..LINEA...
+      | 0xF0 0x90 0x80 0x8D..0xA6  #Lo  [26] LINEAR B SYLLABLE B036 JO..LINE...
+      | 0xF0 0x90 0x80 0xA8..0xBA  #Lo  [19] LINEAR B SYLLABLE B060 RA..LINE...
+      | 0xF0 0x90 0x80 0xBC..0xBD  #Lo   [2] LINEAR B SYLLABLE B017 ZA..LINE...
+      | 0xF0 0x90 0x80 0xBF..0xFF  #Lo  [15] LINEAR B SYLLABLE B020 ZO..LINE...
+      | 0xF0 0x90 0x81 0x00..0x8D  #
+      | 0xF0 0x90 0x81 0x90..0x9D  #Lo  [14] LINEAR B SYMBOL B018..LINEAR B ...
+      | 0xF0 0x90 0x82 0x80..0xFF  #Lo [123] LINEAR B IDEOGRAM B100 MAN..LIN...
+      | 0xF0 0x90 0x83 0x00..0xBA  #
+      | 0xF0 0x90 0x85 0x80..0xB4  #Nl  [53] GREEK ACROPHONIC ATTIC ONE QUAR...
+      | 0xF0 0x90 0x8A 0x80..0x9C  #Lo  [29] LYCIAN LETTER A..LYCIAN LETTER X
+      | 0xF0 0x90 0x8A 0xA0..0xFF  #Lo  [49] CARIAN LETTER A..CARIAN LETTER ...
+      | 0xF0 0x90 0x8B 0x00..0x90  #
+      | 0xF0 0x90 0x8C 0x80..0x9F  #Lo  [32] OLD ITALIC LETTER A..OLD ITALIC...
+      | 0xF0 0x90 0x8C 0xB0..0xFF  #Lo  [17] GOTHIC LETTER AHSA..GOTHIC LETT...
+      | 0xF0 0x90 0x8D 0x00..0x80  #
+      | 0xF0 0x90 0x8D 0x81     #Nl       GOTHIC LETTER NINETY
+      | 0xF0 0x90 0x8D 0x82..0x89  #Lo   [8] GOTHIC LETTER RAIDA..GOTHIC LET...
+      | 0xF0 0x90 0x8D 0x8A     #Nl       GOTHIC LETTER NINE HUNDRED
+      | 0xF0 0x90 0x8D 0x90..0xB5  #Lo  [38] OLD PERMIC LETTER AN..OLD PERMI...
+      | 0xF0 0x90 0x8E 0x80..0x9D  #Lo  [30] UGARITIC LETTER ALPA..UGARITIC ...
+      | 0xF0 0x90 0x8E 0xA0..0xFF  #Lo  [36] OLD PERSIAN SIGN A..OLD PERSIAN...
+      | 0xF0 0x90 0x8F 0x00..0x83  #
+      | 0xF0 0x90 0x8F 0x88..0x8F  #Lo   [8] OLD PERSIAN SIGN AURAMAZDAA..OL...
+      | 0xF0 0x90 0x8F 0x91..0x95  #Nl   [5] OLD PERSIAN NUMBER ONE..OLD PER...
+      | 0xF0 0x90 0x90 0x80..0xFF  #L&  [80] DESERET CAPITAL LETTER LONG I.....
+      | 0xF0 0x90 0x91 0x00..0x8F  #
+      | 0xF0 0x90 0x91 0x90..0xFF  #Lo  [78] SHAVIAN LETTER PEEP..OSMANYA LE...
+      | 0xF0 0x90 0x92 0x00..0x9D  #
+      | 0xF0 0x90 0x92 0xB0..0xFF  #L&  [36] OSAGE CAPITAL LETTER A..OSAGE C...
+      | 0xF0 0x90 0x93 0x00..0x93  #
+      | 0xF0 0x90 0x93 0x98..0xBB  #L&  [36] OSAGE SMALL LETTER A..OSAGE SMA...
+      | 0xF0 0x90 0x94 0x80..0xA7  #Lo  [40] ELBASAN LETTER A..ELBASAN LETTE...
+      | 0xF0 0x90 0x94 0xB0..0xFF  #Lo  [52] CAUCASIAN ALBANIAN LETTER ALT.....
+      | 0xF0 0x90 0x95 0x00..0xA3  #
+      | 0xF0 0x90 0x98 0x80..0xFF        #Lo [311] LINEAR A SIGN AB001..LINE...
+      | 0xF0 0x90 0x99..0x9B 0x00..0xFF  #
+      | 0xF0 0x90 0x9C 0x00..0xB6        #
+      | 0xF0 0x90 0x9D 0x80..0x95  #Lo  [22] LINEAR A SIGN A701 A..LINEAR A ...
+      | 0xF0 0x90 0x9D 0xA0..0xA7  #Lo   [8] LINEAR A SIGN A800..LINEAR A SI...
+      | 0xF0 0x90 0xA0 0x80..0x85  #Lo   [6] CYPRIOT SYLLABLE A..CYPRIOT SYL...
+      | 0xF0 0x90 0xA0 0x88     #Lo       CYPRIOT SYLLABLE JO
+      | 0xF0 0x90 0xA0 0x8A..0xB5  #Lo  [44] CYPRIOT SYLLABLE KA..CYPRIOT SY...
+      | 0xF0 0x90 0xA0 0xB7..0xB8  #Lo   [2] CYPRIOT SYLLABLE XA..CYPRIOT SY...
+      | 0xF0 0x90 0xA0 0xBC     #Lo       CYPRIOT SYLLABLE ZA
+      | 0xF0 0x90 0xA0 0xBF..0xFF  #Lo  [23] CYPRIOT SYLLABLE ZO..IMPERIAL A...
+      | 0xF0 0x90 0xA1 0x00..0x95  #
+      | 0xF0 0x90 0xA1 0xA0..0xB6  #Lo  [23] PALMYRENE LETTER ALEPH..PALMYRE...
+      | 0xF0 0x90 0xA2 0x80..0x9E  #Lo  [31] NABATAEAN LETTER FINAL ALEPH..N...
+      | 0xF0 0x90 0xA3 0xA0..0xB2  #Lo  [19] HATRAN LETTER ALEPH..HATRAN LET...
+      | 0xF0 0x90 0xA3 0xB4..0xB5  #Lo   [2] HATRAN LETTER SHIN..HATRAN LETT...
+      | 0xF0 0x90 0xA4 0x80..0x95  #Lo  [22] PHOENICIAN LETTER ALF..PHOENICI...
+      | 0xF0 0x90 0xA4 0xA0..0xB9  #Lo  [26] LYDIAN LETTER A..LYDIAN LETTER C
+      | 0xF0 0x90 0xA6 0x80..0xB7  #Lo  [56] MEROITIC HIEROGLYPHIC LETTER A....
+      | 0xF0 0x90 0xA6 0xBE..0xBF  #Lo   [2] MEROITIC CURSIVE LOGOGRAM RMT.....
+      | 0xF0 0x90 0xA8 0x80     #Lo       KHAROSHTHI LETTER A
+      | 0xF0 0x90 0xA8 0x90..0x93  #Lo   [4] KHAROSHTHI LETTER KA..KHAROSHTH...
+      | 0xF0 0x90 0xA8 0x95..0x97  #Lo   [3] KHAROSHTHI LETTER CA..KHAROSHTH...
+      | 0xF0 0x90 0xA8 0x99..0xB3  #Lo  [27] KHAROSHTHI LETTER NYA..KHAROSHT...
+      | 0xF0 0x90 0xA9 0xA0..0xBC  #Lo  [29] OLD SOUTH ARABIAN LETTER HE..OL...
+      | 0xF0 0x90 0xAA 0x80..0x9C  #Lo  [29] OLD NORTH ARABIAN LETTER HEH..O...
+      | 0xF0 0x90 0xAB 0x80..0x87  #Lo   [8] MANICHAEAN LETTER ALEPH..MANICH...
+      | 0xF0 0x90 0xAB 0x89..0xA4  #Lo  [28] MANICHAEAN LETTER ZAYIN..MANICH...
+      | 0xF0 0x90 0xAC 0x80..0xB5  #Lo  [54] AVESTAN LETTER A..AVESTAN LETTE...
+      | 0xF0 0x90 0xAD 0x80..0x95  #Lo  [22] INSCRIPTIONAL PARTHIAN LETTER A...
+      | 0xF0 0x90 0xAD 0xA0..0xB2  #Lo  [19] INSCRIPTIONAL PAHLAVI LETTER AL...
+      | 0xF0 0x90 0xAE 0x80..0x91  #Lo  [18] PSALTER PAHLAVI LETTER ALEPH..P...
+      | 0xF0 0x90 0xB0 0x80..0xFF  #Lo  [73] OLD TURKIC LETTER ORKHON A..OLD...
+      | 0xF0 0x90 0xB1 0x00..0x88  #
+      | 0xF0 0x90 0xB2 0x80..0xB2  #L&  [51] OLD HUNGARIAN CAPITAL LETTER A....
+      | 0xF0 0x90 0xB3 0x80..0xB2  #L&  [51] OLD HUNGARIAN SMALL LETTER A..O...
+      | 0xF0 0x91 0x80 0x83..0xB7  #Lo  [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI...
+      | 0xF0 0x91 0x82 0x83..0xAF  #Lo  [45] KAITHI LETTER A..KAITHI LETTER HA
+      | 0xF0 0x91 0x83 0x90..0xA8  #Lo  [25] SORA SOMPENG LETTER SAH..SORA S...
+      | 0xF0 0x91 0x84 0x83..0xA6  #Lo  [36] CHAKMA LETTER AA..CHAKMA LETTER...
+      | 0xF0 0x91 0x85 0x90..0xB2  #Lo  [35] MAHAJANI LETTER A..MAHAJANI LET...
+      | 0xF0 0x91 0x85 0xB6     #Lo       MAHAJANI LIGATURE SHRI
+      | 0xF0 0x91 0x86 0x83..0xB2  #Lo  [48] SHARADA LETTER A..SHARADA LETTE...
+      | 0xF0 0x91 0x87 0x81..0x84  #Lo   [4] SHARADA SIGN AVAGRAHA..SHARADA OM
+      | 0xF0 0x91 0x87 0x9A     #Lo       SHARADA EKAM
+      | 0xF0 0x91 0x87 0x9C     #Lo       SHARADA HEADSTROKE
+      | 0xF0 0x91 0x88 0x80..0x91  #Lo  [18] KHOJKI LETTER A..KHOJKI LETTER JJA
+      | 0xF0 0x91 0x88 0x93..0xAB  #Lo  [25] KHOJKI LETTER NYA..KHOJKI LETTE...
+      | 0xF0 0x91 0x8A 0x80..0x86  #Lo   [7] MULTANI LETTER A..MULTANI LETTE...
+      | 0xF0 0x91 0x8A 0x88     #Lo       MULTANI LETTER GHA
+      | 0xF0 0x91 0x8A 0x8A..0x8D  #Lo   [4] MULTANI LETTER CA..MULTANI LETT...
+      | 0xF0 0x91 0x8A 0x8F..0x9D  #Lo  [15] MULTANI LETTER NYA..MULTANI LET...
+      | 0xF0 0x91 0x8A 0x9F..0xA8  #Lo  [10] MULTANI LETTER BHA..MULTANI LET...
+      | 0xF0 0x91 0x8A 0xB0..0xFF  #Lo  [47] KHUDAWADI LETTER A..KHUDAWADI L...
+      | 0xF0 0x91 0x8B 0x00..0x9E  #
+      | 0xF0 0x91 0x8C 0x85..0x8C  #Lo   [8] GRANTHA LETTER A..GRANTHA LETTE...
+      | 0xF0 0x91 0x8C 0x8F..0x90  #Lo   [2] GRANTHA LETTER EE..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0x93..0xA8  #Lo  [22] GRANTHA LETTER OO..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xAA..0xB0  #Lo   [7] GRANTHA LETTER PA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xB2..0xB3  #Lo   [2] GRANTHA LETTER LA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xB5..0xB9  #Lo   [5] GRANTHA LETTER VA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xBD     #Lo       GRANTHA SIGN AVAGRAHA
+      | 0xF0 0x91 0x8D 0x90     #Lo       GRANTHA OM
+      | 0xF0 0x91 0x8D 0x9D..0xA1  #Lo   [5] GRANTHA SIGN PLUTA..GRANTHA LET...
+      | 0xF0 0x91 0x90 0x80..0xB4  #Lo  [53] NEWA LETTER A..NEWA LETTER HA
+      | 0xF0 0x91 0x91 0x87..0x8A  #Lo   [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI
+      | 0xF0 0x91 0x92 0x80..0xAF  #Lo  [48] TIRHUTA ANJI..TIRHUTA LETTER HA
+      | 0xF0 0x91 0x93 0x84..0x85  #Lo   [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA ...
+      | 0xF0 0x91 0x93 0x87     #Lo       TIRHUTA OM
+      | 0xF0 0x91 0x96 0x80..0xAE  #Lo  [47] SIDDHAM LETTER A..SIDDHAM LETTE...
+      | 0xF0 0x91 0x97 0x98..0x9B  #Lo   [4] SIDDHAM LETTER THREE-CIRCLE ALT...
+      | 0xF0 0x91 0x98 0x80..0xAF  #Lo  [48] MODI LETTER A..MODI LETTER LLA
+      | 0xF0 0x91 0x99 0x84     #Lo       MODI SIGN HUVA
+      | 0xF0 0x91 0x9A 0x80..0xAA  #Lo  [43] TAKRI LETTER A..TAKRI LETTER RRA
+      | 0xF0 0x91 0x9C 0x80..0x99  #Lo  [26] AHOM LETTER KA..AHOM LETTER JHA
+      | 0xF0 0x91 0xA2 0xA0..0xFF  #L&  [64] WARANG CITI CAPITAL LETTER NGAA...
+      | 0xF0 0x91 0xA3 0x00..0x9F  #
+      | 0xF0 0x91 0xA3 0xBF     #Lo       WARANG CITI OM
+      | 0xF0 0x91 0xAB 0x80..0xB8  #Lo  [57] PAU CIN HAU LETTER PA..PAU CIN ...
+      | 0xF0 0x91 0xB0 0x80..0x88  #Lo   [9] BHAIKSUKI LETTER A..BHAIKSUKI L...
+      | 0xF0 0x91 0xB0 0x8A..0xAE  #Lo  [37] BHAIKSUKI LETTER E..BHAIKSUKI L...
+      | 0xF0 0x91 0xB1 0x80     #Lo       BHAIKSUKI SIGN AVAGRAHA
+      | 0xF0 0x91 0xB1 0xB2..0xFF  #Lo  [30] MARCHEN LETTER KA..MARCHEN LETT...
+      | 0xF0 0x91 0xB2 0x00..0x8F  #
+      | 0xF0 0x92 0x80 0x80..0xFF        #Lo [922] CUNEIFORM SIGN A..CUNEIFO...
+      | 0xF0 0x92 0x81..0x8D 0x00..0xFF  #
+      | 0xF0 0x92 0x8E 0x00..0x99        #
+      | 0xF0 0x92 0x90 0x80..0xFF  #Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH....
+      | 0xF0 0x92 0x91 0x00..0xAE  #
+      | 0xF0 0x92 0x92 0x80..0xFF        #Lo [196] CUNEIFORM SIGN AB TIMES N...
+      | 0xF0 0x92 0x93..0x94 0x00..0xFF  #
+      | 0xF0 0x92 0x95 0x00..0x83        #
+      | 0xF0 0x93 0x80 0x80..0xFF        #Lo [1071] EGYPTIAN HIEROGLYPH A001...
+      | 0xF0 0x93 0x81..0x8F 0x00..0xFF  #
+      | 0xF0 0x93 0x90 0x00..0xAE        #
+      | 0xF0 0x94 0x90 0x80..0xFF        #Lo [583] ANATOLIAN HIEROGLYPH A001...
+      | 0xF0 0x94 0x91..0x98 0x00..0xFF  #
+      | 0xF0 0x94 0x99 0x00..0x86        #
+      | 0xF0 0x96 0xA0 0x80..0xFF        #Lo [569] BAMUM LETTER PHASE-A NGKU...
+      | 0xF0 0x96 0xA1..0xA7 0x00..0xFF  #
+      | 0xF0 0x96 0xA8 0x00..0xB8        #
+      | 0xF0 0x96 0xA9 0x80..0x9E  #Lo  [31] MRO LETTER TA..MRO LETTER TEK
+      | 0xF0 0x96 0xAB 0x90..0xAD  #Lo  [30] BASSA VAH LETTER ENNI..BASSA VA...
+      | 0xF0 0x96 0xAC 0x80..0xAF  #Lo  [48] PAHAWH HMONG VOWEL KEEB..PAHAWH...
+      | 0xF0 0x96 0xAD 0x80..0x83  #Lm   [4] PAHAWH HMONG SIGN VOS SEEV..PAH...
+      | 0xF0 0x96 0xAD 0xA3..0xB7  #Lo  [21] PAHAWH HMONG SIGN VOS LUB..PAHA...
+      | 0xF0 0x96 0xAD 0xBD..0xFF  #Lo  [19] PAHAWH HMONG CLAN SIGN TSHEEJ.....
+      | 0xF0 0x96 0xAE 0x00..0x8F  #
+      | 0xF0 0x96 0xBC 0x80..0xFF  #Lo  [69] MIAO LETTER PA..MIAO LETTER HHA
+      | 0xF0 0x96 0xBD 0x00..0x84  #
+      | 0xF0 0x96 0xBD 0x90     #Lo       MIAO LETTER NASALIZATION
+      | 0xF0 0x96 0xBE 0x93..0x9F  #Lm  [13] MIAO LETTER TONE-2..MIAO LETTER...
+      | 0xF0 0x96 0xBF 0xA0     #Lm       TANGUT ITERATION MARK
+      | 0xF0 0x97 0x80 0x80..0xFF        #Lo [6125] TANGUT IDEOGRAPH-17000.....
+      | 0xF0 0x97 0x81..0xFF 0x00..0xFF  #
+      | 0xF0 0x98 0x00 0x00..0xFF        #
+      | 0xF0 0x98 0x01..0x9E 0x00..0xFF  #
+      | 0xF0 0x98 0x9F 0x00..0xAC        #
+      | 0xF0 0x98 0xA0 0x80..0xFF        #Lo [755] TANGUT COMPONENT-001..TAN...
+      | 0xF0 0x98 0xA1..0xAA 0x00..0xFF  #
+      | 0xF0 0x98 0xAB 0x00..0xB2        #
+      | 0xF0 0x9B 0x80 0x80..0x81  #Lo   [2] KATAKANA LETTER ARCHAIC E..HIRA...
+      | 0xF0 0x9B 0xB0 0x80..0xFF  #Lo [107] DUPLOYAN LETTER H..DUPLOYAN LET...
+      | 0xF0 0x9B 0xB1 0x00..0xAA  #
+      | 0xF0 0x9B 0xB1 0xB0..0xBC  #Lo  [13] DUPLOYAN AFFIX LEFT HORIZONTAL ...
+      | 0xF0 0x9B 0xB2 0x80..0x88  #Lo   [9] DUPLOYAN AFFIX HIGH ACUTE..DUPL...
+      | 0xF0 0x9B 0xB2 0x90..0x99  #Lo  [10] DUPLOYAN AFFIX LOW ACUTE..DUPLO...
+      | 0xF0 0x9D 0x90 0x80..0xFF  #L&  [85] MATHEMATICAL BOLD CAPITAL A..MA...
+      | 0xF0 0x9D 0x91 0x00..0x94  #
+      | 0xF0 0x9D 0x91 0x96..0xFF  #L&  [71] MATHEMATICAL ITALIC SMALL I..MA...
+      | 0xF0 0x9D 0x92 0x00..0x9C  #
+      | 0xF0 0x9D 0x92 0x9E..0x9F  #L&   [2] MATHEMATICAL SCRIPT CAPITAL C.....
+      | 0xF0 0x9D 0x92 0xA2     #L&       MATHEMATICAL SCRIPT CAPITAL G
+      | 0xF0 0x9D 0x92 0xA5..0xA6  #L&   [2] MATHEMATICAL SCRIPT CAPITAL J.....
+      | 0xF0 0x9D 0x92 0xA9..0xAC  #L&   [4] MATHEMATICAL SCRIPT CAPITAL N.....
+      | 0xF0 0x9D 0x92 0xAE..0xB9  #L&  [12] MATHEMATICAL SCRIPT CAPITAL S.....
+      | 0xF0 0x9D 0x92 0xBB     #L&       MATHEMATICAL SCRIPT SMALL F
+      | 0xF0 0x9D 0x92 0xBD..0xFF  #L&   [7] MATHEMATICAL SCRIPT SMALL H..MA...
+      | 0xF0 0x9D 0x93 0x00..0x83  #
+      | 0xF0 0x9D 0x93 0x85..0xFF  #L&  [65] MATHEMATICAL SCRIPT SMALL P..MA...
+      | 0xF0 0x9D 0x94 0x00..0x85  #
+      | 0xF0 0x9D 0x94 0x87..0x8A  #L&   [4] MATHEMATICAL FRAKTUR CAPITAL D....
+      | 0xF0 0x9D 0x94 0x8D..0x94  #L&   [8] MATHEMATICAL FRAKTUR CAPITAL J....
+      | 0xF0 0x9D 0x94 0x96..0x9C  #L&   [7] MATHEMATICAL FRAKTUR CAPITAL S....
+      | 0xF0 0x9D 0x94 0x9E..0xB9  #L&  [28] MATHEMATICAL FRAKTUR SMALL A..M...
+      | 0xF0 0x9D 0x94 0xBB..0xBE  #L&   [4] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x80..0x84  #L&   [5] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x86     #L&       MATHEMATICAL DOUBLE-STRUCK CAPITAL O
+      | 0xF0 0x9D 0x95 0x8A..0x90  #L&   [7] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x92..0xFF        #L& [340] MATHEMATICAL DOUBLE-STRUC...
+      | 0xF0 0x9D 0x96..0x99 0x00..0xFF  #
+      | 0xF0 0x9D 0x9A 0x00..0xA5        #
+      | 0xF0 0x9D 0x9A 0xA8..0xFF  #L&  [25] MATHEMATICAL BOLD CAPITAL ALPHA...
+      | 0xF0 0x9D 0x9B 0x00..0x80  #
+      | 0xF0 0x9D 0x9B 0x82..0x9A  #L&  [25] MATHEMATICAL BOLD SMALL ALPHA.....
+      | 0xF0 0x9D 0x9B 0x9C..0xBA  #L&  [31] MATHEMATICAL BOLD EPSILON SYMBO...
+      | 0xF0 0x9D 0x9B 0xBC..0xFF  #L&  [25] MATHEMATICAL ITALIC SMALL ALPHA...
+      | 0xF0 0x9D 0x9C 0x00..0x94  #
+      | 0xF0 0x9D 0x9C 0x96..0xB4  #L&  [31] MATHEMATICAL ITALIC EPSILON SYM...
+      | 0xF0 0x9D 0x9C 0xB6..0xFF  #L&  [25] MATHEMATICAL BOLD ITALIC SMALL ...
+      | 0xF0 0x9D 0x9D 0x00..0x8E  #
+      | 0xF0 0x9D 0x9D 0x90..0xAE  #L&  [31] MATHEMATICAL BOLD ITALIC EPSILO...
+      | 0xF0 0x9D 0x9D 0xB0..0xFF  #L&  [25] MATHEMATICAL SANS-SERIF BOLD SM...
+      | 0xF0 0x9D 0x9E 0x00..0x88  #
+      | 0xF0 0x9D 0x9E 0x8A..0xA8  #L&  [31] MATHEMATICAL SANS-SERIF BOLD EP...
+      | 0xF0 0x9D 0x9E 0xAA..0xFF  #L&  [25] MATHEMATICAL SANS-SERIF BOLD IT...
+      | 0xF0 0x9D 0x9F 0x00..0x82  #
+      | 0xF0 0x9D 0x9F 0x84..0x8B  #L&   [8] MATHEMATICAL SANS-SERIF BOLD IT...
+      | 0xF0 0x9E 0xA0 0x80..0xFF        #Lo [197] MENDE KIKAKUI SYLLABLE M0...
+      | 0xF0 0x9E 0xA1..0xA2 0x00..0xFF  #
+      | 0xF0 0x9E 0xA3 0x00..0x84        #
+      | 0xF0 0x9E 0xA4 0x80..0xFF  #L&  [68] ADLAM CAPITAL LETTER ALIF..ADLA...
+      | 0xF0 0x9E 0xA5 0x00..0x83  #
+      | 0xF0 0x9E 0xB8 0x80..0x83  #Lo   [4] ARABIC MATHEMATICAL ALEF..ARABI...
+      | 0xF0 0x9E 0xB8 0x85..0x9F  #Lo  [27] ARABIC MATHEMATICAL WAW..ARABIC...
+      | 0xF0 0x9E 0xB8 0xA1..0xA2  #Lo   [2] ARABIC MATHEMATICAL INITIAL BEH...
+      | 0xF0 0x9E 0xB8 0xA4     #Lo       ARABIC MATHEMATICAL INITIAL HEH
+      | 0xF0 0x9E 0xB8 0xA7     #Lo       ARABIC MATHEMATICAL INITIAL HAH
+      | 0xF0 0x9E 0xB8 0xA9..0xB2  #Lo  [10] ARABIC MATHEMATICAL INITIAL YEH...
+      | 0xF0 0x9E 0xB8 0xB4..0xB7  #Lo   [4] ARABIC MATHEMATICAL INITIAL SHE...
+      | 0xF0 0x9E 0xB8 0xB9     #Lo       ARABIC MATHEMATICAL INITIAL DAD
+      | 0xF0 0x9E 0xB8 0xBB     #Lo       ARABIC MATHEMATICAL INITIAL GHAIN
+      | 0xF0 0x9E 0xB9 0x82     #Lo       ARABIC MATHEMATICAL TAILED JEEM
+      | 0xF0 0x9E 0xB9 0x87     #Lo       ARABIC MATHEMATICAL TAILED HAH
+      | 0xF0 0x9E 0xB9 0x89     #Lo       ARABIC MATHEMATICAL TAILED YEH
+      | 0xF0 0x9E 0xB9 0x8B     #Lo       ARABIC MATHEMATICAL TAILED LAM
+      | 0xF0 0x9E 0xB9 0x8D..0x8F  #Lo   [3] ARABIC MATHEMATICAL TAILED NOON...
+      | 0xF0 0x9E 0xB9 0x91..0x92  #Lo   [2] ARABIC MATHEMATICAL TAILED SAD....
+      | 0xF0 0x9E 0xB9 0x94     #Lo       ARABIC MATHEMATICAL TAILED SHEEN
+      | 0xF0 0x9E 0xB9 0x97     #Lo       ARABIC MATHEMATICAL TAILED KHAH
+      | 0xF0 0x9E 0xB9 0x99     #Lo       ARABIC MATHEMATICAL TAILED DAD
+      | 0xF0 0x9E 0xB9 0x9B     #Lo       ARABIC MATHEMATICAL TAILED GHAIN
+      | 0xF0 0x9E 0xB9 0x9D     #Lo       ARABIC MATHEMATICAL TAILED DOTLESS...
+      | 0xF0 0x9E 0xB9 0x9F     #Lo       ARABIC MATHEMATICAL TAILED DOTLESS...
+      | 0xF0 0x9E 0xB9 0xA1..0xA2  #Lo   [2] ARABIC MATHEMATICAL STRETCHED B...
+      | 0xF0 0x9E 0xB9 0xA4     #Lo       ARABIC MATHEMATICAL STRETCHED HEH
+      | 0xF0 0x9E 0xB9 0xA7..0xAA  #Lo   [4] ARABIC MATHEMATICAL STRETCHED H...
+      | 0xF0 0x9E 0xB9 0xAC..0xB2  #Lo   [7] ARABIC MATHEMATICAL STRETCHED M...
+      | 0xF0 0x9E 0xB9 0xB4..0xB7  #Lo   [4] ARABIC MATHEMATICAL STRETCHED S...
+      | 0xF0 0x9E 0xB9 0xB9..0xBC  #Lo   [4] ARABIC MATHEMATICAL STRETCHED D...
+      | 0xF0 0x9E 0xB9 0xBE     #Lo       ARABIC MATHEMATICAL STRETCHED DOTL...
+      | 0xF0 0x9E 0xBA 0x80..0x89  #Lo  [10] ARABIC MATHEMATICAL LOOPED ALEF...
+      | 0xF0 0x9E 0xBA 0x8B..0x9B  #Lo  [17] ARABIC MATHEMATICAL LOOPED LAM....
+      | 0xF0 0x9E 0xBA 0xA1..0xA3  #Lo   [3] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0x9E 0xBA 0xA5..0xA9  #Lo   [5] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0x9E 0xBA 0xAB..0xBB  #Lo  [17] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0xA0 0x80 0x80..0xFF              #Lo [42711] CJK UNIFIED IDEOG...
+      | 0xF0 0xA0 0x81..0xFF 0x00..0xFF        #
+      | 0xF0 0xA1..0xA9 0x00..0xFF 0x00..0xFF  #
+      | 0xF0 0xAA 0x00 0x00..0xFF              #
+      | 0xF0 0xAA 0x01..0x9A 0x00..0xFF        #
+      | 0xF0 0xAA 0x9B 0x00..0x96              #
+      | 0xF0 0xAA 0x9C 0x80..0xFF        #Lo [4149] CJK UNIFIED IDEOGRAPH-2A...
+      | 0xF0 0xAA 0x9D..0xFF 0x00..0xFF  #
+      | 0xF0 0xAB 0x00 0x00..0xFF        #
+      | 0xF0 0xAB 0x01..0x9B 0x00..0xFF  #
+      | 0xF0 0xAB 0x9C 0x00..0xB4        #
+      | 0xF0 0xAB 0x9D 0x80..0xFF        #Lo [222] CJK UNIFIED IDEOGRAPH-2B7...
+      | 0xF0 0xAB 0x9E..0x9F 0x00..0xFF  #
+      | 0xF0 0xAB 0xA0 0x00..0x9D        #
+      | 0xF0 0xAB 0xA0 0xA0..0xFF        #Lo [5762] CJK UNIFIED IDEOGRAPH-2B...
+      | 0xF0 0xAB 0xA1..0xFF 0x00..0xFF  #
+      | 0xF0 0xAC 0x00 0x00..0xFF        #
+      | 0xF0 0xAC 0x01..0xB9 0x00..0xFF  #
+      | 0xF0 0xAC 0xBA 0x00..0xA1        #
+      | 0xF0 0xAF 0xA0 0x80..0xFF        #Lo [542] CJK COMPATIBILITY IDEOGRA...
+      | 0xF0 0xAF 0xA1..0xA7 0x00..0xFF  #
+      | 0xF0 0xAF 0xA8 0x00..0x9D        #
+      ;
+
+    ID_Continue = 
+        0x30..0x39              #Nd  [10] DIGIT ZERO..DIGIT NINE
+      | 0x41..0x5A              #L&  [26] LATIN CAPITAL LETTER A..LATIN CAPI...
+      | 0x5F                    #Pc       LOW LINE
+      | 0x61..0x7A              #L&  [26] LATIN SMALL LETTER A..LATIN SMALL ...
+      | 0xC2 0xAA               #Lo       FEMININE ORDINAL INDICATOR
+      | 0xC2 0xB5               #L&       MICRO SIGN
+      | 0xC2 0xB7               #Po       MIDDLE DOT
+      | 0xC2 0xBA               #Lo       MASCULINE ORDINAL INDICATOR
+      | 0xC3 0x80..0x96         #L&  [23] LATIN CAPITAL LETTER A WITH GRAVE....
+      | 0xC3 0x98..0xB6         #L&  [31] LATIN CAPITAL LETTER O WITH STROKE...
+      | 0xC3 0xB8..0xFF         #L& [195] LATIN SMALL LETTER O WITH STROKE.....
+      | 0xC4..0xC5 0x00..0xFF   #
+      | 0xC6 0x00..0xBA         #
+      | 0xC6 0xBB               #Lo       LATIN LETTER TWO WITH STROKE
+      | 0xC6 0xBC..0xBF         #L&   [4] LATIN CAPITAL LETTER TONE FIVE..LA...
+      | 0xC7 0x80..0x83         #Lo   [4] LATIN LETTER DENTAL CLICK..LATIN L...
+      | 0xC7 0x84..0xFF         #L& [208] LATIN CAPITAL LETTER DZ WITH CARON...
+      | 0xC8..0xC9 0x00..0xFF   #
+      | 0xCA 0x00..0x93         #
+      | 0xCA 0x94               #Lo       LATIN LETTER GLOTTAL STOP
+      | 0xCA 0x95..0xAF         #L&  [27] LATIN LETTER PHARYNGEAL VOICED FRI...
+      | 0xCA 0xB0..0xFF         #Lm  [18] MODIFIER LETTER SMALL H..MODIFIER ...
+      | 0xCB 0x00..0x81         #
+      | 0xCB 0x86..0x91         #Lm  [12] MODIFIER LETTER CIRCUMFLEX ACCENT....
+      | 0xCB 0xA0..0xA4         #Lm   [5] MODIFIER LETTER SMALL GAMMA..MODIF...
+      | 0xCB 0xAC               #Lm       MODIFIER LETTER VOICING
+      | 0xCB 0xAE               #Lm       MODIFIER LETTER DOUBLE APOSTROPHE
+      | 0xCC 0x80..0xFF         #Mn [112] COMBINING GRAVE ACCENT..COMBINING ...
+      | 0xCD 0x00..0xAF         #
+      | 0xCD 0xB0..0xB3         #L&   [4] GREEK CAPITAL LETTER HETA..GREEK S...
+      | 0xCD 0xB4               #Lm       GREEK NUMERAL SIGN
+      | 0xCD 0xB6..0xB7         #L&   [2] GREEK CAPITAL LETTER PAMPHYLIAN DI...
+      | 0xCD 0xBA               #Lm       GREEK YPOGEGRAMMENI
+      | 0xCD 0xBB..0xBD         #L&   [3] GREEK SMALL REVERSED LUNATE SIGMA ...
+      | 0xCD 0xBF               #L&       GREEK CAPITAL LETTER YOT
+      | 0xCE 0x86               #L&       GREEK CAPITAL LETTER ALPHA WITH TONOS
+      | 0xCE 0x87               #Po       GREEK ANO TELEIA
+      | 0xCE 0x88..0x8A         #L&   [3] GREEK CAPITAL LETTER EPSILON WITH ...
+      | 0xCE 0x8C               #L&       GREEK CAPITAL LETTER OMICRON WITH ...
+      | 0xCE 0x8E..0xA1         #L&  [20] GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xCE 0xA3..0xFF         #L&  [83] GREEK CAPITAL LETTER SIGMA..GREEK ...
+      | 0xCF 0x00..0xB5         #
+      | 0xCF 0xB7..0xFF         #L& [139] GREEK CAPITAL LETTER SHO..CYRILLIC...
+      | 0xD0..0xD1 0x00..0xFF   #
+      | 0xD2 0x00..0x81         #
+      | 0xD2 0x83..0x87         #Mn   [5] COMBINING CYRILLIC TITLO..COMBININ...
+      | 0xD2 0x8A..0xFF         #L& [166] CYRILLIC CAPITAL LETTER SHORT I WI...
+      | 0xD3..0xD3 0x00..0xFF   #
+      | 0xD4 0x00..0xAF         #
+      | 0xD4 0xB1..0xFF         #L&  [38] ARMENIAN CAPITAL LETTER AYB..ARMEN...
+      | 0xD5 0x00..0x96         #
+      | 0xD5 0x99               #Lm       ARMENIAN MODIFIER LETTER LEFT HALF...
+      | 0xD5 0xA1..0xFF         #L&  [39] ARMENIAN SMALL LETTER AYB..ARMENIA...
+      | 0xD6 0x00..0x87         #
+      | 0xD6 0x91..0xBD         #Mn  [45] HEBREW ACCENT ETNAHTA..HEBREW POIN...
+      | 0xD6 0xBF               #Mn       HEBREW POINT RAFE
+      | 0xD7 0x81..0x82         #Mn   [2] HEBREW POINT SHIN DOT..HEBREW POIN...
+      | 0xD7 0x84..0x85         #Mn   [2] HEBREW MARK UPPER DOT..HEBREW MARK...
+      | 0xD7 0x87               #Mn       HEBREW POINT QAMATS QATAN
+      | 0xD7 0x90..0xAA         #Lo  [27] HEBREW LETTER ALEF..HEBREW LETTER TAV
+      | 0xD7 0xB0..0xB2         #Lo   [3] HEBREW LIGATURE YIDDISH DOUBLE VAV...
+      | 0xD8 0x90..0x9A         #Mn  [11] ARABIC SIGN SALLALLAHOU ALAYHE WAS...
+      | 0xD8 0xA0..0xBF         #Lo  [32] ARABIC LETTER KASHMIRI YEH..ARABIC...
+      | 0xD9 0x80               #Lm       ARABIC TATWEEL
+      | 0xD9 0x81..0x8A         #Lo  [10] ARABIC LETTER FEH..ARABIC LETTER YEH
+      | 0xD9 0x8B..0x9F         #Mn  [21] ARABIC FATHATAN..ARABIC WAVY HAMZA...
+      | 0xD9 0xA0..0xA9         #Nd  [10] ARABIC-INDIC DIGIT ZERO..ARABIC-IN...
+      | 0xD9 0xAE..0xAF         #Lo   [2] ARABIC LETTER DOTLESS BEH..ARABIC ...
+      | 0xD9 0xB0               #Mn       ARABIC LETTER SUPERSCRIPT ALEF
+      | 0xD9 0xB1..0xFF         #Lo  [99] ARABIC LETTER ALEF WASLA..ARABIC L...
+      | 0xDA..0xDA 0x00..0xFF   #
+      | 0xDB 0x00..0x93         #
+      | 0xDB 0x95               #Lo       ARABIC LETTER AE
+      | 0xDB 0x96..0x9C         #Mn   [7] ARABIC SMALL HIGH LIGATURE SAD WIT...
+      | 0xDB 0x9F..0xA4         #Mn   [6] ARABIC SMALL HIGH ROUNDED ZERO..AR...
+      | 0xDB 0xA5..0xA6         #Lm   [2] ARABIC SMALL WAW..ARABIC SMALL YEH
+      | 0xDB 0xA7..0xA8         #Mn   [2] ARABIC SMALL HIGH YEH..ARABIC SMAL...
+      | 0xDB 0xAA..0xAD         #Mn   [4] ARABIC EMPTY CENTRE LOW STOP..ARAB...
+      | 0xDB 0xAE..0xAF         #Lo   [2] ARABIC LETTER DAL WITH INVERTED V....
+      | 0xDB 0xB0..0xB9         #Nd  [10] EXTENDED ARABIC-INDIC DIGIT ZERO.....
+      | 0xDB 0xBA..0xBC         #Lo   [3] ARABIC LETTER SHEEN WITH DOT BELOW...
+      | 0xDB 0xBF               #Lo       ARABIC LETTER HEH WITH INVERTED V
+      | 0xDC 0x90               #Lo       SYRIAC LETTER ALAPH
+      | 0xDC 0x91               #Mn       SYRIAC LETTER SUPERSCRIPT ALAPH
+      | 0xDC 0x92..0xAF         #Lo  [30] SYRIAC LETTER BETH..SYRIAC LETTER ...
+      | 0xDC 0xB0..0xFF         #Mn  [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
+      | 0xDD 0x00..0x8A         #
+      | 0xDD 0x8D..0xFF         #Lo  [89] SYRIAC LETTER SOGDIAN ZHAIN..THAAN...
+      | 0xDE 0x00..0xA5         #
+      | 0xDE 0xA6..0xB0         #Mn  [11] THAANA ABAFILI..THAANA SUKUN
+      | 0xDE 0xB1               #Lo       THAANA LETTER NAA
+      | 0xDF 0x80..0x89         #Nd  [10] NKO DIGIT ZERO..NKO DIGIT NINE
+      | 0xDF 0x8A..0xAA         #Lo  [33] NKO LETTER A..NKO LETTER JONA RA
+      | 0xDF 0xAB..0xB3         #Mn   [9] NKO COMBINING SHORT HIGH TONE..NKO...
+      | 0xDF 0xB4..0xB5         #Lm   [2] NKO HIGH TONE APOSTROPHE..NKO LOW ...
+      | 0xDF 0xBA               #Lm       NKO LAJANYALAN
+      | 0xE0 0xA0 0x80..0x95    #Lo  [22] SAMARITAN LETTER ALAF..SAMARITAN L...
+      | 0xE0 0xA0 0x96..0x99    #Mn   [4] SAMARITAN MARK IN..SAMARITAN MARK ...
+      | 0xE0 0xA0 0x9A          #Lm       SAMARITAN MODIFIER LETTER EPENTHET...
+      | 0xE0 0xA0 0x9B..0xA3    #Mn   [9] SAMARITAN MARK EPENTHETIC YUT..SAM...
+      | 0xE0 0xA0 0xA4          #Lm       SAMARITAN MODIFIER LETTER SHORT A
+      | 0xE0 0xA0 0xA5..0xA7    #Mn   [3] SAMARITAN VOWEL SIGN SHORT A..SAMA...
+      | 0xE0 0xA0 0xA8          #Lm       SAMARITAN MODIFIER LETTER I
+      | 0xE0 0xA0 0xA9..0xAD    #Mn   [5] SAMARITAN VOWEL SIGN LONG I..SAMAR...
+      | 0xE0 0xA1 0x80..0x98    #Lo  [25] MANDAIC LETTER HALQA..MANDAIC LETT...
+      | 0xE0 0xA1 0x99..0x9B    #Mn   [3] MANDAIC AFFRICATION MARK..MANDAIC ...
+      | 0xE0 0xA2 0xA0..0xB4    #Lo  [21] ARABIC LETTER BEH WITH SMALL V BEL...
+      | 0xE0 0xA2 0xB6..0xBD    #Lo   [8] ARABIC LETTER BEH WITH SMALL MEEM ...
+      | 0xE0 0xA3 0x94..0xA1    #Mn  [14] ARABIC SMALL HIGH WORD AR-RUB..ARA...
+      | 0xE0 0xA3 0xA3..0xFF    #Mn  [32] ARABIC TURNED DAMMA BELOW..DEVANAG...
+      | 0xE0 0xA4 0x00..0x82    #
+      | 0xE0 0xA4 0x83          #Mc       DEVANAGARI SIGN VISARGA
+      | 0xE0 0xA4 0x84..0xB9    #Lo  [54] DEVANAGARI LETTER SHORT A..DEVANAG...
+      | 0xE0 0xA4 0xBA          #Mn       DEVANAGARI VOWEL SIGN OE
+      | 0xE0 0xA4 0xBB          #Mc       DEVANAGARI VOWEL SIGN OOE
+      | 0xE0 0xA4 0xBC          #Mn       DEVANAGARI SIGN NUKTA
+      | 0xE0 0xA4 0xBD          #Lo       DEVANAGARI SIGN AVAGRAHA
+      | 0xE0 0xA4 0xBE..0xFF    #Mc   [3] DEVANAGARI VOWEL SIGN AA..DEVANAGA...
+      | 0xE0 0xA5 0x00..0x80    #
+      | 0xE0 0xA5 0x81..0x88    #Mn   [8] DEVANAGARI VOWEL SIGN U..DEVANAGAR...
+      | 0xE0 0xA5 0x89..0x8C    #Mc   [4] DEVANAGARI VOWEL SIGN CANDRA O..DE...
+      | 0xE0 0xA5 0x8D          #Mn       DEVANAGARI SIGN VIRAMA
+      | 0xE0 0xA5 0x8E..0x8F    #Mc   [2] DEVANAGARI VOWEL SIGN PRISHTHAMATR...
+      | 0xE0 0xA5 0x90          #Lo       DEVANAGARI OM
+      | 0xE0 0xA5 0x91..0x97    #Mn   [7] DEVANAGARI STRESS SIGN UDATTA..DEV...
+      | 0xE0 0xA5 0x98..0xA1    #Lo  [10] DEVANAGARI LETTER QA..DEVANAGARI L...
+      | 0xE0 0xA5 0xA2..0xA3    #Mn   [2] DEVANAGARI VOWEL SIGN VOCALIC L..D...
+      | 0xE0 0xA5 0xA6..0xAF    #Nd  [10] DEVANAGARI DIGIT ZERO..DEVANAGARI ...
+      | 0xE0 0xA5 0xB1          #Lm       DEVANAGARI SIGN HIGH SPACING DOT
+      | 0xE0 0xA5 0xB2..0xFF    #Lo  [15] DEVANAGARI LETTER CANDRA A..BENGAL...
+      | 0xE0 0xA6 0x00..0x80    #
+      | 0xE0 0xA6 0x81          #Mn       BENGALI SIGN CANDRABINDU
+      | 0xE0 0xA6 0x82..0x83    #Mc   [2] BENGALI SIGN ANUSVARA..BENGALI SIG...
+      | 0xE0 0xA6 0x85..0x8C    #Lo   [8] BENGALI LETTER A..BENGALI LETTER V...
+      | 0xE0 0xA6 0x8F..0x90    #Lo   [2] BENGALI LETTER E..BENGALI LETTER AI
+      | 0xE0 0xA6 0x93..0xA8    #Lo  [22] BENGALI LETTER O..BENGALI LETTER NA
+      | 0xE0 0xA6 0xAA..0xB0    #Lo   [7] BENGALI LETTER PA..BENGALI LETTER RA
+      | 0xE0 0xA6 0xB2          #Lo       BENGALI LETTER LA
+      | 0xE0 0xA6 0xB6..0xB9    #Lo   [4] BENGALI LETTER SHA..BENGALI LETTER HA
+      | 0xE0 0xA6 0xBC          #Mn       BENGALI SIGN NUKTA
+      | 0xE0 0xA6 0xBD          #Lo       BENGALI SIGN AVAGRAHA
+      | 0xE0 0xA6 0xBE..0xFF    #Mc   [3] BENGALI VOWEL SIGN AA..BENGALI VOW...
+      | 0xE0 0xA7 0x00..0x80    #
+      | 0xE0 0xA7 0x81..0x84    #Mn   [4] BENGALI VOWEL SIGN U..BENGALI VOWE...
+      | 0xE0 0xA7 0x87..0x88    #Mc   [2] BENGALI VOWEL SIGN E..BENGALI VOWE...
+      | 0xE0 0xA7 0x8B..0x8C    #Mc   [2] BENGALI VOWEL SIGN O..BENGALI VOWE...
+      | 0xE0 0xA7 0x8D          #Mn       BENGALI SIGN VIRAMA
+      | 0xE0 0xA7 0x8E          #Lo       BENGALI LETTER KHANDA TA
+      | 0xE0 0xA7 0x97          #Mc       BENGALI AU LENGTH MARK
+      | 0xE0 0xA7 0x9C..0x9D    #Lo   [2] BENGALI LETTER RRA..BENGALI LETTER...
+      | 0xE0 0xA7 0x9F..0xA1    #Lo   [3] BENGALI LETTER YYA..BENGALI LETTER...
+      | 0xE0 0xA7 0xA2..0xA3    #Mn   [2] BENGALI VOWEL SIGN VOCALIC L..BENG...
+      | 0xE0 0xA7 0xA6..0xAF    #Nd  [10] BENGALI DIGIT ZERO..BENGALI DIGIT ...
+      | 0xE0 0xA7 0xB0..0xB1    #Lo   [2] BENGALI LETTER RA WITH MIDDLE DIAG...
+      | 0xE0 0xA8 0x81..0x82    #Mn   [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI...
+      | 0xE0 0xA8 0x83          #Mc       GURMUKHI SIGN VISARGA
+      | 0xE0 0xA8 0x85..0x8A    #Lo   [6] GURMUKHI LETTER A..GURMUKHI LETTER UU
+      | 0xE0 0xA8 0x8F..0x90    #Lo   [2] GURMUKHI LETTER EE..GURMUKHI LETTE...
+      | 0xE0 0xA8 0x93..0xA8    #Lo  [22] GURMUKHI LETTER OO..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xAA..0xB0    #Lo   [7] GURMUKHI LETTER PA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB2..0xB3    #Lo   [2] GURMUKHI LETTER LA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB5..0xB6    #Lo   [2] GURMUKHI LETTER VA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xB8..0xB9    #Lo   [2] GURMUKHI LETTER SA..GURMUKHI LETTE...
+      | 0xE0 0xA8 0xBC          #Mn       GURMUKHI SIGN NUKTA
+      | 0xE0 0xA8 0xBE..0xFF    #Mc   [3] GURMUKHI VOWEL SIGN AA..GURMUKHI V...
+      | 0xE0 0xA9 0x00..0x80    #
+      | 0xE0 0xA9 0x81..0x82    #Mn   [2] GURMUKHI VOWEL SIGN U..GURMUKHI VO...
+      | 0xE0 0xA9 0x87..0x88    #Mn   [2] GURMUKHI VOWEL SIGN EE..GURMUKHI V...
+      | 0xE0 0xA9 0x8B..0x8D    #Mn   [3] GURMUKHI VOWEL SIGN OO..GURMUKHI S...
+      | 0xE0 0xA9 0x91          #Mn       GURMUKHI SIGN UDAAT
+      | 0xE0 0xA9 0x99..0x9C    #Lo   [4] GURMUKHI LETTER KHHA..GURMUKHI LET...
+      | 0xE0 0xA9 0x9E          #Lo       GURMUKHI LETTER FA
+      | 0xE0 0xA9 0xA6..0xAF    #Nd  [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGI...
+      | 0xE0 0xA9 0xB0..0xB1    #Mn   [2] GURMUKHI TIPPI..GURMUKHI ADDAK
+      | 0xE0 0xA9 0xB2..0xB4    #Lo   [3] GURMUKHI IRI..GURMUKHI EK ONKAR
+      | 0xE0 0xA9 0xB5          #Mn       GURMUKHI SIGN YAKASH
+      | 0xE0 0xAA 0x81..0x82    #Mn   [2] GUJARATI SIGN CANDRABINDU..GUJARAT...
+      | 0xE0 0xAA 0x83          #Mc       GUJARATI SIGN VISARGA
+      | 0xE0 0xAA 0x85..0x8D    #Lo   [9] GUJARATI LETTER A..GUJARATI VOWEL ...
+      | 0xE0 0xAA 0x8F..0x91    #Lo   [3] GUJARATI LETTER E..GUJARATI VOWEL ...
+      | 0xE0 0xAA 0x93..0xA8    #Lo  [22] GUJARATI LETTER O..GUJARATI LETTER NA
+      | 0xE0 0xAA 0xAA..0xB0    #Lo   [7] GUJARATI LETTER PA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xB2..0xB3    #Lo   [2] GUJARATI LETTER LA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xB5..0xB9    #Lo   [5] GUJARATI LETTER VA..GUJARATI LETTE...
+      | 0xE0 0xAA 0xBC          #Mn       GUJARATI SIGN NUKTA
+      | 0xE0 0xAA 0xBD          #Lo       GUJARATI SIGN AVAGRAHA
+      | 0xE0 0xAA 0xBE..0xFF    #Mc   [3] GUJARATI VOWEL SIGN AA..GUJARATI V...
+      | 0xE0 0xAB 0x00..0x80    #
+      | 0xE0 0xAB 0x81..0x85    #Mn   [5] GUJARATI VOWEL SIGN U..GUJARATI VO...
+      | 0xE0 0xAB 0x87..0x88    #Mn   [2] GUJARATI VOWEL SIGN E..GUJARATI VO...
+      | 0xE0 0xAB 0x89          #Mc       GUJARATI VOWEL SIGN CANDRA O
+      | 0xE0 0xAB 0x8B..0x8C    #Mc   [2] GUJARATI VOWEL SIGN O..GUJARATI VO...
+      | 0xE0 0xAB 0x8D          #Mn       GUJARATI SIGN VIRAMA
+      | 0xE0 0xAB 0x90          #Lo       GUJARATI OM
+      | 0xE0 0xAB 0xA0..0xA1    #Lo   [2] GUJARATI LETTER VOCALIC RR..GUJARA...
+      | 0xE0 0xAB 0xA2..0xA3    #Mn   [2] GUJARATI VOWEL SIGN VOCALIC L..GUJ...
+      | 0xE0 0xAB 0xA6..0xAF    #Nd  [10] GUJARATI DIGIT ZERO..GUJARATI DIGI...
+      | 0xE0 0xAB 0xB9          #Lo       GUJARATI LETTER ZHA
+      | 0xE0 0xAC 0x81          #Mn       ORIYA SIGN CANDRABINDU
+      | 0xE0 0xAC 0x82..0x83    #Mc   [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VI...
+      | 0xE0 0xAC 0x85..0x8C    #Lo   [8] ORIYA LETTER A..ORIYA LETTER VOCAL...
+      | 0xE0 0xAC 0x8F..0x90    #Lo   [2] ORIYA LETTER E..ORIYA LETTER AI
+      | 0xE0 0xAC 0x93..0xA8    #Lo  [22] ORIYA LETTER O..ORIYA LETTER NA
+      | 0xE0 0xAC 0xAA..0xB0    #Lo   [7] ORIYA LETTER PA..ORIYA LETTER RA
+      | 0xE0 0xAC 0xB2..0xB3    #Lo   [2] ORIYA LETTER LA..ORIYA LETTER LLA
+      | 0xE0 0xAC 0xB5..0xB9    #Lo   [5] ORIYA LETTER VA..ORIYA LETTER HA
+      | 0xE0 0xAC 0xBC          #Mn       ORIYA SIGN NUKTA
+      | 0xE0 0xAC 0xBD          #Lo       ORIYA SIGN AVAGRAHA
+      | 0xE0 0xAC 0xBE          #Mc       ORIYA VOWEL SIGN AA
+      | 0xE0 0xAC 0xBF          #Mn       ORIYA VOWEL SIGN I
+      | 0xE0 0xAD 0x80          #Mc       ORIYA VOWEL SIGN II
+      | 0xE0 0xAD 0x81..0x84    #Mn   [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x87..0x88    #Mc   [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8B..0x8C    #Mc   [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8D          #Mn       ORIYA SIGN VIRAMA
+      | 0xE0 0xAD 0x96          #Mn       ORIYA AI LENGTH MARK
+      | 0xE0 0xAD 0x97          #Mc       ORIYA AU LENGTH MARK
+      | 0xE0 0xAD 0x9C..0x9D    #Lo   [2] ORIYA LETTER RRA..ORIYA LETTER RHA
+      | 0xE0 0xAD 0x9F..0xA1    #Lo   [3] ORIYA LETTER YYA..ORIYA LETTER VOC...
+      | 0xE0 0xAD 0xA2..0xA3    #Mn   [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA ...
+      | 0xE0 0xAD 0xA6..0xAF    #Nd  [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE
+      | 0xE0 0xAD 0xB1          #Lo       ORIYA LETTER WA
+      | 0xE0 0xAE 0x82          #Mn       TAMIL SIGN ANUSVARA
+      | 0xE0 0xAE 0x83          #Lo       TAMIL SIGN VISARGA
+      | 0xE0 0xAE 0x85..0x8A    #Lo   [6] TAMIL LETTER A..TAMIL LETTER UU
+      | 0xE0 0xAE 0x8E..0x90    #Lo   [3] TAMIL LETTER E..TAMIL LETTER AI
+      | 0xE0 0xAE 0x92..0x95    #Lo   [4] TAMIL LETTER O..TAMIL LETTER KA
+      | 0xE0 0xAE 0x99..0x9A    #Lo   [2] TAMIL LETTER NGA..TAMIL LETTER CA
+      | 0xE0 0xAE 0x9C          #Lo       TAMIL LETTER JA
+      | 0xE0 0xAE 0x9E..0x9F    #Lo   [2] TAMIL LETTER NYA..TAMIL LETTER TTA
+      | 0xE0 0xAE 0xA3..0xA4    #Lo   [2] TAMIL LETTER NNA..TAMIL LETTER TA
+      | 0xE0 0xAE 0xA8..0xAA    #Lo   [3] TAMIL LETTER NA..TAMIL LETTER PA
+      | 0xE0 0xAE 0xAE..0xB9    #Lo  [12] TAMIL LETTER MA..TAMIL LETTER HA
+      | 0xE0 0xAE 0xBE..0xBF    #Mc   [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL S...
+      | 0xE0 0xAF 0x80          #Mn       TAMIL VOWEL SIGN II
+      | 0xE0 0xAF 0x81..0x82    #Mc   [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x86..0x88    #Mc   [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x8A..0x8C    #Mc   [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x8D          #Mn       TAMIL SIGN VIRAMA
+      | 0xE0 0xAF 0x90          #Lo       TAMIL OM
+      | 0xE0 0xAF 0x97          #Mc       TAMIL AU LENGTH MARK
+      | 0xE0 0xAF 0xA6..0xAF    #Nd  [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE
+      | 0xE0 0xB0 0x80          #Mn       TELUGU SIGN COMBINING CANDRABINDU ...
+      | 0xE0 0xB0 0x81..0x83    #Mc   [3] TELUGU SIGN CANDRABINDU..TELUGU SI...
+      | 0xE0 0xB0 0x85..0x8C    #Lo   [8] TELUGU LETTER A..TELUGU LETTER VOC...
+      | 0xE0 0xB0 0x8E..0x90    #Lo   [3] TELUGU LETTER E..TELUGU LETTER AI
+      | 0xE0 0xB0 0x92..0xA8    #Lo  [23] TELUGU LETTER O..TELUGU LETTER NA
+      | 0xE0 0xB0 0xAA..0xB9    #Lo  [16] TELUGU LETTER PA..TELUGU LETTER HA
+      | 0xE0 0xB0 0xBD          #Lo       TELUGU SIGN AVAGRAHA
+      | 0xE0 0xB0 0xBE..0xFF    #Mn   [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL...
+      | 0xE0 0xB1 0x00..0x80    #
+      | 0xE0 0xB1 0x81..0x84    #Mc   [4] TELUGU VOWEL SIGN U..TELUGU VOWEL ...
+      | 0xE0 0xB1 0x86..0x88    #Mn   [3] TELUGU VOWEL SIGN E..TELUGU VOWEL ...
+      | 0xE0 0xB1 0x8A..0x8D    #Mn   [4] TELUGU VOWEL SIGN O..TELUGU SIGN V...
+      | 0xE0 0xB1 0x95..0x96    #Mn   [2] TELUGU LENGTH MARK..TELUGU AI LENG...
+      | 0xE0 0xB1 0x98..0x9A    #Lo   [3] TELUGU LETTER TSA..TELUGU LETTER RRRA
+      | 0xE0 0xB1 0xA0..0xA1    #Lo   [2] TELUGU LETTER VOCALIC RR..TELUGU L...
+      | 0xE0 0xB1 0xA2..0xA3    #Mn   [2] TELUGU VOWEL SIGN VOCALIC L..TELUG...
+      | 0xE0 0xB1 0xA6..0xAF    #Nd  [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE
+      | 0xE0 0xB2 0x80          #Lo       KANNADA SIGN SPACING CANDRABINDU
+      | 0xE0 0xB2 0x81          #Mn       KANNADA SIGN CANDRABINDU
+      | 0xE0 0xB2 0x82..0x83    #Mc   [2] KANNADA SIGN ANUSVARA..KANNADA SIG...
+      | 0xE0 0xB2 0x85..0x8C    #Lo   [8] KANNADA LETTER A..KANNADA LETTER V...
+      | 0xE0 0xB2 0x8E..0x90    #Lo   [3] KANNADA LETTER E..KANNADA LETTER AI
+      | 0xE0 0xB2 0x92..0xA8    #Lo  [23] KANNADA LETTER O..KANNADA LETTER NA
+      | 0xE0 0xB2 0xAA..0xB3    #Lo  [10] KANNADA LETTER PA..KANNADA LETTER LLA
+      | 0xE0 0xB2 0xB5..0xB9    #Lo   [5] KANNADA LETTER VA..KANNADA LETTER HA
+      | 0xE0 0xB2 0xBC          #Mn       KANNADA SIGN NUKTA
+      | 0xE0 0xB2 0xBD          #Lo       KANNADA SIGN AVAGRAHA
+      | 0xE0 0xB2 0xBE          #Mc       KANNADA VOWEL SIGN AA
+      | 0xE0 0xB2 0xBF          #Mn       KANNADA VOWEL SIGN I
+      | 0xE0 0xB3 0x80..0x84    #Mc   [5] KANNADA VOWEL SIGN II..KANNADA VOW...
+      | 0xE0 0xB3 0x86          #Mn       KANNADA VOWEL SIGN E
+      | 0xE0 0xB3 0x87..0x88    #Mc   [2] KANNADA VOWEL SIGN EE..KANNADA VOW...
+      | 0xE0 0xB3 0x8A..0x8B    #Mc   [2] KANNADA VOWEL SIGN O..KANNADA VOWE...
+      | 0xE0 0xB3 0x8C..0x8D    #Mn   [2] KANNADA VOWEL SIGN AU..KANNADA SIG...
+      | 0xE0 0xB3 0x95..0x96    #Mc   [2] KANNADA LENGTH MARK..KANNADA AI LE...
+      | 0xE0 0xB3 0x9E          #Lo       KANNADA LETTER FA
+      | 0xE0 0xB3 0xA0..0xA1    #Lo   [2] KANNADA LETTER VOCALIC RR..KANNADA...
+      | 0xE0 0xB3 0xA2..0xA3    #Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANN...
+      | 0xE0 0xB3 0xA6..0xAF    #Nd  [10] KANNADA DIGIT ZERO..KANNADA DIGIT ...
+      | 0xE0 0xB3 0xB1..0xB2    #Lo   [2] KANNADA SIGN JIHVAMULIYA..KANNADA ...
+      | 0xE0 0xB4 0x81          #Mn       MALAYALAM SIGN CANDRABINDU
+      | 0xE0 0xB4 0x82..0x83    #Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM...
+      | 0xE0 0xB4 0x85..0x8C    #Lo   [8] MALAYALAM LETTER A..MALAYALAM LETT...
+      | 0xE0 0xB4 0x8E..0x90    #Lo   [3] MALAYALAM LETTER E..MALAYALAM LETT...
+      | 0xE0 0xB4 0x92..0xBA    #Lo  [41] MALAYALAM LETTER O..MALAYALAM LETT...
+      | 0xE0 0xB4 0xBD          #Lo       MALAYALAM SIGN AVAGRAHA
+      | 0xE0 0xB4 0xBE..0xFF    #Mc   [3] MALAYALAM VOWEL SIGN AA..MALAYALAM...
+      | 0xE0 0xB5 0x00..0x80    #
+      | 0xE0 0xB5 0x81..0x84    #Mn   [4] MALAYALAM VOWEL SIGN U..MALAYALAM ...
+      | 0xE0 0xB5 0x86..0x88    #Mc   [3] MALAYALAM VOWEL SIGN E..MALAYALAM ...
+      | 0xE0 0xB5 0x8A..0x8C    #Mc   [3] MALAYALAM VOWEL SIGN O..MALAYALAM ...
+      | 0xE0 0xB5 0x8D          #Mn       MALAYALAM SIGN VIRAMA
+      | 0xE0 0xB5 0x8E          #Lo       MALAYALAM LETTER DOT REPH
+      | 0xE0 0xB5 0x94..0x96    #Lo   [3] MALAYALAM LETTER CHILLU M..MALAYAL...
+      | 0xE0 0xB5 0x97          #Mc       MALAYALAM AU LENGTH MARK
+      | 0xE0 0xB5 0x9F..0xA1    #Lo   [3] MALAYALAM LETTER ARCHAIC II..MALAY...
+      | 0xE0 0xB5 0xA2..0xA3    #Mn   [2] MALAYALAM VOWEL SIGN VOCALIC L..MA...
+      | 0xE0 0xB5 0xA6..0xAF    #Nd  [10] MALAYALAM DIGIT ZERO..MALAYALAM DI...
+      | 0xE0 0xB5 0xBA..0xBF    #Lo   [6] MALAYALAM LETTER CHILLU NN..MALAYA...
+      | 0xE0 0xB6 0x82..0x83    #Mc   [2] SINHALA SIGN ANUSVARAYA..SINHALA S...
+      | 0xE0 0xB6 0x85..0x96    #Lo  [18] SINHALA LETTER AYANNA..SINHALA LET...
+      | 0xE0 0xB6 0x9A..0xB1    #Lo  [24] SINHALA LETTER ALPAPRAANA KAYANNA....
+      | 0xE0 0xB6 0xB3..0xBB    #Lo   [9] SINHALA LETTER SANYAKA DAYANNA..SI...
+      | 0xE0 0xB6 0xBD          #Lo       SINHALA LETTER DANTAJA LAYANNA
+      | 0xE0 0xB7 0x80..0x86    #Lo   [7] SINHALA LETTER VAYANNA..SINHALA LE...
+      | 0xE0 0xB7 0x8A          #Mn       SINHALA SIGN AL-LAKUNA
+      | 0xE0 0xB7 0x8F..0x91    #Mc   [3] SINHALA VOWEL SIGN AELA-PILLA..SIN...
+      | 0xE0 0xB7 0x92..0x94    #Mn   [3] SINHALA VOWEL SIGN KETTI IS-PILLA....
+      | 0xE0 0xB7 0x96          #Mn       SINHALA VOWEL SIGN DIGA PAA-PILLA
+      | 0xE0 0xB7 0x98..0x9F    #Mc   [8] SINHALA VOWEL SIGN GAETTA-PILLA..S...
+      | 0xE0 0xB7 0xA6..0xAF    #Nd  [10] SINHALA LITH DIGIT ZERO..SINHALA L...
+      | 0xE0 0xB7 0xB2..0xB3    #Mc   [2] SINHALA VOWEL SIGN DIGA GAETTA-PIL...
+      | 0xE0 0xB8 0x81..0xB0    #Lo  [48] THAI CHARACTER KO KAI..THAI CHARAC...
+      | 0xE0 0xB8 0xB1          #Mn       THAI CHARACTER MAI HAN-AKAT
+      | 0xE0 0xB8 0xB2..0xB3    #Lo   [2] THAI CHARACTER SARA AA..THAI CHARA...
+      | 0xE0 0xB8 0xB4..0xBA    #Mn   [7] THAI CHARACTER SARA I..THAI CHARAC...
+      | 0xE0 0xB9 0x80..0x85    #Lo   [6] THAI CHARACTER SARA E..THAI CHARAC...
+      | 0xE0 0xB9 0x86          #Lm       THAI CHARACTER MAIYAMOK
+      | 0xE0 0xB9 0x87..0x8E    #Mn   [8] THAI CHARACTER MAITAIKHU..THAI CHA...
+      | 0xE0 0xB9 0x90..0x99    #Nd  [10] THAI DIGIT ZERO..THAI DIGIT NINE
+      | 0xE0 0xBA 0x81..0x82    #Lo   [2] LAO LETTER KO..LAO LETTER KHO SUNG
+      | 0xE0 0xBA 0x84          #Lo       LAO LETTER KHO TAM
+      | 0xE0 0xBA 0x87..0x88    #Lo   [2] LAO LETTER NGO..LAO LETTER CO
+      | 0xE0 0xBA 0x8A          #Lo       LAO LETTER SO TAM
+      | 0xE0 0xBA 0x8D          #Lo       LAO LETTER NYO
+      | 0xE0 0xBA 0x94..0x97    #Lo   [4] LAO LETTER DO..LAO LETTER THO TAM
+      | 0xE0 0xBA 0x99..0x9F    #Lo   [7] LAO LETTER NO..LAO LETTER FO SUNG
+      | 0xE0 0xBA 0xA1..0xA3    #Lo   [3] LAO LETTER MO..LAO LETTER LO LING
+      | 0xE0 0xBA 0xA5          #Lo       LAO LETTER LO LOOT
+      | 0xE0 0xBA 0xA7          #Lo       LAO LETTER WO
+      | 0xE0 0xBA 0xAA..0xAB    #Lo   [2] LAO LETTER SO SUNG..LAO LETTER HO ...
+      | 0xE0 0xBA 0xAD..0xB0    #Lo   [4] LAO LETTER O..LAO VOWEL SIGN A
+      | 0xE0 0xBA 0xB1          #Mn       LAO VOWEL SIGN MAI KAN
+      | 0xE0 0xBA 0xB2..0xB3    #Lo   [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM
+      | 0xE0 0xBA 0xB4..0xB9    #Mn   [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU
+      | 0xE0 0xBA 0xBB..0xBC    #Mn   [2] LAO VOWEL SIGN MAI KON..LAO SEMIVO...
+      | 0xE0 0xBA 0xBD          #Lo       LAO SEMIVOWEL SIGN NYO
+      | 0xE0 0xBB 0x80..0x84    #Lo   [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
+      | 0xE0 0xBB 0x86          #Lm       LAO KO LA
+      | 0xE0 0xBB 0x88..0x8D    #Mn   [6] LAO TONE MAI EK..LAO NIGGAHITA
+      | 0xE0 0xBB 0x90..0x99    #Nd  [10] LAO DIGIT ZERO..LAO DIGIT NINE
+      | 0xE0 0xBB 0x9C..0x9F    #Lo   [4] LAO HO NO..LAO LETTER KHMU NYO
+      | 0xE0 0xBC 0x80          #Lo       TIBETAN SYLLABLE OM
+      | 0xE0 0xBC 0x98..0x99    #Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD P...
+      | 0xE0 0xBC 0xA0..0xA9    #Nd  [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT ...
+      | 0xE0 0xBC 0xB5          #Mn       TIBETAN MARK NGAS BZUNG NYI ZLA
+      | 0xE0 0xBC 0xB7          #Mn       TIBETAN MARK NGAS BZUNG SGOR RTAGS
+      | 0xE0 0xBC 0xB9          #Mn       TIBETAN MARK TSA -PHRU
+      | 0xE0 0xBC 0xBE..0xBF    #Mc   [2] TIBETAN SIGN YAR TSHES..TIBETAN SI...
+      | 0xE0 0xBD 0x80..0x87    #Lo   [8] TIBETAN LETTER KA..TIBETAN LETTER JA
+      | 0xE0 0xBD 0x89..0xAC    #Lo  [36] TIBETAN LETTER NYA..TIBETAN LETTER...
+      | 0xE0 0xBD 0xB1..0xBE    #Mn  [14] TIBETAN VOWEL SIGN AA..TIBETAN SIG...
+      | 0xE0 0xBD 0xBF          #Mc       TIBETAN SIGN RNAM BCAD
+      | 0xE0 0xBE 0x80..0x84    #Mn   [5] TIBETAN VOWEL SIGN REVERSED I..TIB...
+      | 0xE0 0xBE 0x86..0x87    #Mn   [2] TIBETAN SIGN LCI RTAGS..TIBETAN SI...
+      | 0xE0 0xBE 0x88..0x8C    #Lo   [5] TIBETAN SIGN LCE TSA CAN..TIBETAN ...
+      | 0xE0 0xBE 0x8D..0x97    #Mn  [11] TIBETAN SUBJOINED SIGN LCE TSA CAN...
+      | 0xE0 0xBE 0x99..0xBC    #Mn  [36] TIBETAN SUBJOINED LETTER NYA..TIBE...
+      | 0xE0 0xBF 0x86          #Mn       TIBETAN SYMBOL PADMA GDAN
+      | 0xE1 0x80 0x80..0xAA    #Lo  [43] MYANMAR LETTER KA..MYANMAR LETTER AU
+      | 0xE1 0x80 0xAB..0xAC    #Mc   [2] MYANMAR VOWEL SIGN TALL AA..MYANMA...
+      | 0xE1 0x80 0xAD..0xB0    #Mn   [4] MYANMAR VOWEL SIGN I..MYANMAR VOWE...
+      | 0xE1 0x80 0xB1          #Mc       MYANMAR VOWEL SIGN E
+      | 0xE1 0x80 0xB2..0xB7    #Mn   [6] MYANMAR VOWEL SIGN AI..MYANMAR SIG...
+      | 0xE1 0x80 0xB8          #Mc       MYANMAR SIGN VISARGA
+      | 0xE1 0x80 0xB9..0xBA    #Mn   [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ...
+      | 0xE1 0x80 0xBB..0xBC    #Mc   [2] MYANMAR CONSONANT SIGN MEDIAL YA.....
+      | 0xE1 0x80 0xBD..0xBE    #Mn   [2] MYANMAR CONSONANT SIGN MEDIAL WA.....
+      | 0xE1 0x80 0xBF          #Lo       MYANMAR LETTER GREAT SA
+      | 0xE1 0x81 0x80..0x89    #Nd  [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT ...
+      | 0xE1 0x81 0x90..0x95    #Lo   [6] MYANMAR LETTER SHA..MYANMAR LETTER...
+      | 0xE1 0x81 0x96..0x97    #Mc   [2] MYANMAR VOWEL SIGN VOCALIC R..MYAN...
+      | 0xE1 0x81 0x98..0x99    #Mn   [2] MYANMAR VOWEL SIGN VOCALIC L..MYAN...
+      | 0xE1 0x81 0x9A..0x9D    #Lo   [4] MYANMAR LETTER MON NGA..MYANMAR LE...
+      | 0xE1 0x81 0x9E..0xA0    #Mn   [3] MYANMAR CONSONANT SIGN MON MEDIAL ...
+      | 0xE1 0x81 0xA1          #Lo       MYANMAR LETTER SGAW KAREN SHA
+      | 0xE1 0x81 0xA2..0xA4    #Mc   [3] MYANMAR VOWEL SIGN SGAW KAREN EU.....
+      | 0xE1 0x81 0xA5..0xA6    #Lo   [2] MYANMAR LETTER WESTERN PWO KAREN T...
+      | 0xE1 0x81 0xA7..0xAD    #Mc   [7] MYANMAR VOWEL SIGN WESTERN PWO KAR...
+      | 0xE1 0x81 0xAE..0xB0    #Lo   [3] MYANMAR LETTER EASTERN PWO KAREN N...
+      | 0xE1 0x81 0xB1..0xB4    #Mn   [4] MYANMAR VOWEL SIGN GEBA KAREN I..M...
+      | 0xE1 0x81 0xB5..0xFF    #Lo  [13] MYANMAR LETTER SHAN KA..MYANMAR LE...
+      | 0xE1 0x82 0x00..0x81    #
+      | 0xE1 0x82 0x82          #Mn       MYANMAR CONSONANT SIGN SHAN MEDIAL WA
+      | 0xE1 0x82 0x83..0x84    #Mc   [2] MYANMAR VOWEL SIGN SHAN AA..MYANMA...
+      | 0xE1 0x82 0x85..0x86    #Mn   [2] MYANMAR VOWEL SIGN SHAN E ABOVE..M...
+      | 0xE1 0x82 0x87..0x8C    #Mc   [6] MYANMAR SIGN SHAN TONE-2..MYANMAR ...
+      | 0xE1 0x82 0x8D          #Mn       MYANMAR SIGN SHAN COUNCIL EMPHATIC...
+      | 0xE1 0x82 0x8E          #Lo       MYANMAR LETTER RUMAI PALAUNG FA
+      | 0xE1 0x82 0x8F          #Mc       MYANMAR SIGN RUMAI PALAUNG TONE-5
+      | 0xE1 0x82 0x90..0x99    #Nd  [10] MYANMAR SHAN DIGIT ZERO..MYANMAR S...
+      | 0xE1 0x82 0x9A..0x9C    #Mc   [3] MYANMAR SIGN KHAMTI TONE-1..MYANMA...
+      | 0xE1 0x82 0x9D          #Mn       MYANMAR VOWEL SIGN AITON AI
+      | 0xE1 0x82 0xA0..0xFF    #L&  [38] GEORGIAN CAPITAL LETTER AN..GEORGI...
+      | 0xE1 0x83 0x00..0x85    #
+      | 0xE1 0x83 0x87          #L&       GEORGIAN CAPITAL LETTER YN
+      | 0xE1 0x83 0x8D          #L&       GEORGIAN CAPITAL LETTER AEN
+      | 0xE1 0x83 0x90..0xBA    #Lo  [43] GEORGIAN LETTER AN..GEORGIAN LETTE...
+      | 0xE1 0x83 0xBC          #Lm       MODIFIER LETTER GEORGIAN NAR
+      | 0xE1 0x83 0xBD..0xFF        #Lo [332] GEORGIAN LETTER AEN..ETHIOPIC ...
+      | 0xE1 0x84..0x88 0x00..0xFF  #
+      | 0xE1 0x89 0x00..0x88        #
+      | 0xE1 0x89 0x8A..0x8D    #Lo   [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SY...
+      | 0xE1 0x89 0x90..0x96    #Lo   [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SY...
+      | 0xE1 0x89 0x98          #Lo       ETHIOPIC SYLLABLE QHWA
+      | 0xE1 0x89 0x9A..0x9D    #Lo   [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC S...
+      | 0xE1 0x89 0xA0..0xFF    #Lo  [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYL...
+      | 0xE1 0x8A 0x00..0x88    #
+      | 0xE1 0x8A 0x8A..0x8D    #Lo   [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SY...
+      | 0xE1 0x8A 0x90..0xB0    #Lo  [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYL...
+      | 0xE1 0x8A 0xB2..0xB5    #Lo   [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SY...
+      | 0xE1 0x8A 0xB8..0xBE    #Lo   [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SY...
+      | 0xE1 0x8B 0x80          #Lo       ETHIOPIC SYLLABLE KXWA
+      | 0xE1 0x8B 0x82..0x85    #Lo   [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC S...
+      | 0xE1 0x8B 0x88..0x96    #Lo  [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYL...
+      | 0xE1 0x8B 0x98..0xFF    #Lo  [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYL...
+      | 0xE1 0x8C 0x00..0x90    #
+      | 0xE1 0x8C 0x92..0x95    #Lo   [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SY...
+      | 0xE1 0x8C 0x98..0xFF    #Lo  [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SY...
+      | 0xE1 0x8D 0x00..0x9A    #
+      | 0xE1 0x8D 0x9D..0x9F    #Mn   [3] ETHIOPIC COMBINING GEMINATION AND ...
+      | 0xE1 0x8D 0xA9..0xB1    #No   [9] ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT...
+      | 0xE1 0x8E 0x80..0x8F    #Lo  [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..E...
+      | 0xE1 0x8E 0xA0..0xFF    #L&  [86] CHEROKEE LETTER A..CHEROKEE LETTER MV
+      | 0xE1 0x8F 0x00..0xB5    #
+      | 0xE1 0x8F 0xB8..0xBD    #L&   [6] CHEROKEE SMALL LETTER YE..CHEROKEE...
+      | 0xE1 0x90 0x81..0xFF        #Lo [620] CANADIAN SYLLABICS E..CANADIAN...
+      | 0xE1 0x91..0x98 0x00..0xFF  #
+      | 0xE1 0x99 0x00..0xAC        #
+      | 0xE1 0x99 0xAF..0xBF    #Lo  [17] CANADIAN SYLLABICS QAI..CANADIAN S...
+      | 0xE1 0x9A 0x81..0x9A    #Lo  [26] OGHAM LETTER BEITH..OGHAM LETTER P...
+      | 0xE1 0x9A 0xA0..0xFF    #Lo  [75] RUNIC LETTER FEHU FEOH FE F..RUNIC...
+      | 0xE1 0x9B 0x00..0xAA    #
+      | 0xE1 0x9B 0xAE..0xB0    #Nl   [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHO...
+      | 0xE1 0x9B 0xB1..0xB8    #Lo   [8] RUNIC LETTER K..RUNIC LETTER FRANK...
+      | 0xE1 0x9C 0x80..0x8C    #Lo  [13] TAGALOG LETTER A..TAGALOG LETTER YA
+      | 0xE1 0x9C 0x8E..0x91    #Lo   [4] TAGALOG LETTER LA..TAGALOG LETTER HA
+      | 0xE1 0x9C 0x92..0x94    #Mn   [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN...
+      | 0xE1 0x9C 0xA0..0xB1    #Lo  [18] HANUNOO LETTER A..HANUNOO LETTER HA
+      | 0xE1 0x9C 0xB2..0xB4    #Mn   [3] HANUNOO VOWEL SIGN I..HANUNOO SIGN...
+      | 0xE1 0x9D 0x80..0x91    #Lo  [18] BUHID LETTER A..BUHID LETTER HA
+      | 0xE1 0x9D 0x92..0x93    #Mn   [2] BUHID VOWEL SIGN I..BUHID VOWEL SI...
+      | 0xE1 0x9D 0xA0..0xAC    #Lo  [13] TAGBANWA LETTER A..TAGBANWA LETTER YA
+      | 0xE1 0x9D 0xAE..0xB0    #Lo   [3] TAGBANWA LETTER LA..TAGBANWA LETTE...
+      | 0xE1 0x9D 0xB2..0xB3    #Mn   [2] TAGBANWA VOWEL SIGN I..TAGBANWA VO...
+      | 0xE1 0x9E 0x80..0xB3    #Lo  [52] KHMER LETTER KA..KHMER INDEPENDENT...
+      | 0xE1 0x9E 0xB4..0xB5    #Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOW...
+      | 0xE1 0x9E 0xB6          #Mc       KHMER VOWEL SIGN AA
+      | 0xE1 0x9E 0xB7..0xBD    #Mn   [7] KHMER VOWEL SIGN I..KHMER VOWEL SI...
+      | 0xE1 0x9E 0xBE..0xFF    #Mc   [8] KHMER VOWEL SIGN OE..KHMER VOWEL S...
+      | 0xE1 0x9F 0x00..0x85    #
+      | 0xE1 0x9F 0x86          #Mn       KHMER SIGN NIKAHIT
+      | 0xE1 0x9F 0x87..0x88    #Mc   [2] KHMER SIGN REAHMUK..KHMER SIGN YUU...
+      | 0xE1 0x9F 0x89..0x93    #Mn  [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN...
+      | 0xE1 0x9F 0x97          #Lm       KHMER SIGN LEK TOO
+      | 0xE1 0x9F 0x9C          #Lo       KHMER SIGN AVAKRAHASANYA
+      | 0xE1 0x9F 0x9D          #Mn       KHMER SIGN ATTHACAN
+      | 0xE1 0x9F 0xA0..0xA9    #Nd  [10] KHMER DIGIT ZERO..KHMER DIGIT NINE
+      | 0xE1 0xA0 0x8B..0x8D    #Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ...
+      | 0xE1 0xA0 0x90..0x99    #Nd  [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DI...
+      | 0xE1 0xA0 0xA0..0xFF    #Lo  [35] MONGOLIAN LETTER A..MONGOLIAN LETT...
+      | 0xE1 0xA1 0x00..0x82    #
+      | 0xE1 0xA1 0x83          #Lm       MONGOLIAN LETTER TODO LONG VOWEL SIGN
+      | 0xE1 0xA1 0x84..0xB7    #Lo  [52] MONGOLIAN LETTER TODO E..MONGOLIAN...
+      | 0xE1 0xA2 0x80..0x84    #Lo   [5] MONGOLIAN LETTER ALI GALI ANUSVARA...
+      | 0xE1 0xA2 0x85..0x86    #Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA.....
+      | 0xE1 0xA2 0x87..0xA8    #Lo  [34] MONGOLIAN LETTER ALI GALI A..MONGO...
+      | 0xE1 0xA2 0xA9          #Mn       MONGOLIAN LETTER ALI GALI DAGALGA
+      | 0xE1 0xA2 0xAA          #Lo       MONGOLIAN LETTER MANCHU ALI GALI LHA
+      | 0xE1 0xA2 0xB0..0xFF    #Lo  [70] CANADIAN SYLLABICS OY..CANADIAN SY...
+      | 0xE1 0xA3 0x00..0xB5    #
+      | 0xE1 0xA4 0x80..0x9E    #Lo  [31] LIMBU VOWEL-CARRIER LETTER..LIMBU ...
+      | 0xE1 0xA4 0xA0..0xA2    #Mn   [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xA3..0xA6    #Mc   [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL S...
+      | 0xE1 0xA4 0xA7..0xA8    #Mn   [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xA9..0xAB    #Mc   [3] LIMBU SUBJOINED LETTER YA..LIMBU S...
+      | 0xE1 0xA4 0xB0..0xB1    #Mc   [2] LIMBU SMALL LETTER KA..LIMBU SMALL...
+      | 0xE1 0xA4 0xB2          #Mn       LIMBU SMALL LETTER ANUSVARA
+      | 0xE1 0xA4 0xB3..0xB8    #Mc   [6] LIMBU SMALL LETTER TA..LIMBU SMALL...
+      | 0xE1 0xA4 0xB9..0xBB    #Mn   [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
+      | 0xE1 0xA5 0x86..0x8F    #Nd  [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE
+      | 0xE1 0xA5 0x90..0xAD    #Lo  [30] TAI LE LETTER KA..TAI LE LETTER AI
+      | 0xE1 0xA5 0xB0..0xB4    #Lo   [5] TAI LE LETTER TONE-2..TAI LE LETTE...
+      | 0xE1 0xA6 0x80..0xAB    #Lo  [44] NEW TAI LUE LETTER HIGH QA..NEW TA...
+      | 0xE1 0xA6 0xB0..0xFF    #Lo  [26] NEW TAI LUE VOWEL SIGN VOWEL SHORT...
+      | 0xE1 0xA7 0x00..0x89    #
+      | 0xE1 0xA7 0x90..0x99    #Nd  [10] NEW TAI LUE DIGIT ZERO..NEW TAI LU...
+      | 0xE1 0xA7 0x9A          #No       NEW TAI LUE THAM DIGIT ONE
+      | 0xE1 0xA8 0x80..0x96    #Lo  [23] BUGINESE LETTER KA..BUGINESE LETTE...
+      | 0xE1 0xA8 0x97..0x98    #Mn   [2] BUGINESE VOWEL SIGN I..BUGINESE VO...
+      | 0xE1 0xA8 0x99..0x9A    #Mc   [2] BUGINESE VOWEL SIGN E..BUGINESE VO...
+      | 0xE1 0xA8 0x9B          #Mn       BUGINESE VOWEL SIGN AE
+      | 0xE1 0xA8 0xA0..0xFF    #Lo  [53] TAI THAM LETTER HIGH KA..TAI THAM ...
+      | 0xE1 0xA9 0x00..0x94    #
+      | 0xE1 0xA9 0x95          #Mc       TAI THAM CONSONANT SIGN MEDIAL RA
+      | 0xE1 0xA9 0x96          #Mn       TAI THAM CONSONANT SIGN MEDIAL LA
+      | 0xE1 0xA9 0x97          #Mc       TAI THAM CONSONANT SIGN LA TANG LAI
+      | 0xE1 0xA9 0x98..0x9E    #Mn   [7] TAI THAM SIGN MAI KANG LAI..TAI TH...
+      | 0xE1 0xA9 0xA0          #Mn       TAI THAM SIGN SAKOT
+      | 0xE1 0xA9 0xA1          #Mc       TAI THAM VOWEL SIGN A
+      | 0xE1 0xA9 0xA2          #Mn       TAI THAM VOWEL SIGN MAI SAT
+      | 0xE1 0xA9 0xA3..0xA4    #Mc   [2] TAI THAM VOWEL SIGN AA..TAI THAM V...
+      | 0xE1 0xA9 0xA5..0xAC    #Mn   [8] TAI THAM VOWEL SIGN I..TAI THAM VO...
+      | 0xE1 0xA9 0xAD..0xB2    #Mc   [6] TAI THAM VOWEL SIGN OY..TAI THAM V...
+      | 0xE1 0xA9 0xB3..0xBC    #Mn  [10] TAI THAM VOWEL SIGN OA ABOVE..TAI ...
+      | 0xE1 0xA9 0xBF          #Mn       TAI THAM COMBINING CRYPTOGRAMMIC DOT
+      | 0xE1 0xAA 0x80..0x89    #Nd  [10] TAI THAM HORA DIGIT ZERO..TAI THAM...
+      | 0xE1 0xAA 0x90..0x99    #Nd  [10] TAI THAM THAM DIGIT ZERO..TAI THAM...
+      | 0xE1 0xAA 0xA7          #Lm       TAI THAM SIGN MAI YAMOK
+      | 0xE1 0xAA 0xB0..0xBD    #Mn  [14] COMBINING DOUBLED CIRCUMFLEX ACCEN...
+      | 0xE1 0xAC 0x80..0x83    #Mn   [4] BALINESE SIGN ULU RICEM..BALINESE ...
+      | 0xE1 0xAC 0x84          #Mc       BALINESE SIGN BISAH
+      | 0xE1 0xAC 0x85..0xB3    #Lo  [47] BALINESE LETTER AKARA..BALINESE LE...
+      | 0xE1 0xAC 0xB4          #Mn       BALINESE SIGN REREKAN
+      | 0xE1 0xAC 0xB5          #Mc       BALINESE VOWEL SIGN TEDUNG
+      | 0xE1 0xAC 0xB6..0xBA    #Mn   [5] BALINESE VOWEL SIGN ULU..BALINESE ...
+      | 0xE1 0xAC 0xBB          #Mc       BALINESE VOWEL SIGN RA REPA TEDUNG
+      | 0xE1 0xAC 0xBC          #Mn       BALINESE VOWEL SIGN LA LENGA
+      | 0xE1 0xAC 0xBD..0xFF    #Mc   [5] BALINESE VOWEL SIGN LA LENGA TEDUN...
+      | 0xE1 0xAD 0x00..0x81    #
+      | 0xE1 0xAD 0x82          #Mn       BALINESE VOWEL SIGN PEPET
+      | 0xE1 0xAD 0x83..0x84    #Mc   [2] BALINESE VOWEL SIGN PEPET TEDUNG.....
+      | 0xE1 0xAD 0x85..0x8B    #Lo   [7] BALINESE LETTER KAF SASAK..BALINES...
+      | 0xE1 0xAD 0x90..0x99    #Nd  [10] BALINESE DIGIT ZERO..BALINESE DIGI...
+      | 0xE1 0xAD 0xAB..0xB3    #Mn   [9] BALINESE MUSICAL SYMBOL COMBINING ...
+      | 0xE1 0xAE 0x80..0x81    #Mn   [2] SUNDANESE SIGN PANYECEK..SUNDANESE...
+      | 0xE1 0xAE 0x82          #Mc       SUNDANESE SIGN PANGWISAD
+      | 0xE1 0xAE 0x83..0xA0    #Lo  [30] SUNDANESE LETTER A..SUNDANESE LETT...
+      | 0xE1 0xAE 0xA1          #Mc       SUNDANESE CONSONANT SIGN PAMINGKAL
+      | 0xE1 0xAE 0xA2..0xA5    #Mn   [4] SUNDANESE CONSONANT SIGN PANYAKRA....
+      | 0xE1 0xAE 0xA6..0xA7    #Mc   [2] SUNDANESE VOWEL SIGN PANAELAENG..S...
+      | 0xE1 0xAE 0xA8..0xA9    #Mn   [2] SUNDANESE VOWEL SIGN PAMEPET..SUND...
+      | 0xE1 0xAE 0xAA          #Mc       SUNDANESE SIGN PAMAAEH
+      | 0xE1 0xAE 0xAB..0xAD    #Mn   [3] SUNDANESE SIGN VIRAMA..SUNDANESE C...
+      | 0xE1 0xAE 0xAE..0xAF    #Lo   [2] SUNDANESE LETTER KHA..SUNDANESE LE...
+      | 0xE1 0xAE 0xB0..0xB9    #Nd  [10] SUNDANESE DIGIT ZERO..SUNDANESE DI...
+      | 0xE1 0xAE 0xBA..0xFF    #Lo  [44] SUNDANESE AVAGRAHA..BATAK LETTER U
+      | 0xE1 0xAF 0x00..0xA5    #
+      | 0xE1 0xAF 0xA6          #Mn       BATAK SIGN TOMPI
+      | 0xE1 0xAF 0xA7          #Mc       BATAK VOWEL SIGN E
+      | 0xE1 0xAF 0xA8..0xA9    #Mn   [2] BATAK VOWEL SIGN PAKPAK E..BATAK V...
+      | 0xE1 0xAF 0xAA..0xAC    #Mc   [3] BATAK VOWEL SIGN I..BATAK VOWEL SI...
+      | 0xE1 0xAF 0xAD          #Mn       BATAK VOWEL SIGN KARO O
+      | 0xE1 0xAF 0xAE          #Mc       BATAK VOWEL SIGN U
+      | 0xE1 0xAF 0xAF..0xB1    #Mn   [3] BATAK VOWEL SIGN U FOR SIMALUNGUN ...
+      | 0xE1 0xAF 0xB2..0xB3    #Mc   [2] BATAK PANGOLAT..BATAK PANONGONAN
+      | 0xE1 0xB0 0x80..0xA3    #Lo  [36] LEPCHA LETTER KA..LEPCHA LETTER A
+      | 0xE1 0xB0 0xA4..0xAB    #Mc   [8] LEPCHA SUBJOINED LETTER YA..LEPCHA...
+      | 0xE1 0xB0 0xAC..0xB3    #Mn   [8] LEPCHA VOWEL SIGN E..LEPCHA CONSON...
+      | 0xE1 0xB0 0xB4..0xB5    #Mc   [2] LEPCHA CONSONANT SIGN NYIN-DO..LEP...
+      | 0xE1 0xB0 0xB6..0xB7    #Mn   [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
+      | 0xE1 0xB1 0x80..0x89    #Nd  [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE
+      | 0xE1 0xB1 0x8D..0x8F    #Lo   [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA
+      | 0xE1 0xB1 0x90..0x99    #Nd  [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGI...
+      | 0xE1 0xB1 0x9A..0xB7    #Lo  [30] OL CHIKI LETTER LA..OL CHIKI LETTE...
+      | 0xE1 0xB1 0xB8..0xBD    #Lm   [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD
+      | 0xE1 0xB2 0x80..0x88    #L&   [9] CYRILLIC SMALL LETTER ROUNDED VE.....
+      | 0xE1 0xB3 0x90..0x92    #Mn   [3] VEDIC TONE KARSHANA..VEDIC TONE PR...
+      | 0xE1 0xB3 0x94..0xA0    #Mn  [13] VEDIC SIGN YAJURVEDIC MIDLINE SVAR...
+      | 0xE1 0xB3 0xA1          #Mc       VEDIC TONE ATHARVAVEDIC INDEPENDEN...
+      | 0xE1 0xB3 0xA2..0xA8    #Mn   [7] VEDIC SIGN VISARGA SVARITA..VEDIC ...
+      | 0xE1 0xB3 0xA9..0xAC    #Lo   [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA.....
+      | 0xE1 0xB3 0xAD          #Mn       VEDIC SIGN TIRYAK
+      | 0xE1 0xB3 0xAE..0xB1    #Lo   [4] VEDIC SIGN HEXIFORM LONG ANUSVARA....
+      | 0xE1 0xB3 0xB2..0xB3    #Mc   [2] VEDIC SIGN ARDHAVISARGA..VEDIC SIG...
+      | 0xE1 0xB3 0xB4          #Mn       VEDIC TONE CANDRA ABOVE
+      | 0xE1 0xB3 0xB5..0xB6    #Lo   [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN...
+      | 0xE1 0xB3 0xB8..0xB9    #Mn   [2] VEDIC TONE RING ABOVE..VEDIC TONE ...
+      | 0xE1 0xB4 0x80..0xAB    #L&  [44] LATIN LETTER SMALL CAPITAL A..CYRI...
+      | 0xE1 0xB4 0xAC..0xFF    #Lm  [63] MODIFIER LETTER CAPITAL A..GREEK S...
+      | 0xE1 0xB5 0x00..0xAA    #
+      | 0xE1 0xB5 0xAB..0xB7    #L&  [13] LATIN SMALL LETTER UE..LATIN SMALL...
+      | 0xE1 0xB5 0xB8          #Lm       MODIFIER LETTER CYRILLIC EN
+      | 0xE1 0xB5 0xB9..0xFF    #L&  [34] LATIN SMALL LETTER INSULAR G..LATI...
+      | 0xE1 0xB6 0x00..0x9A    #
+      | 0xE1 0xB6 0x9B..0xBF    #Lm  [37] MODIFIER LETTER SMALL TURNED ALPHA...
+      | 0xE1 0xB7 0x80..0xB5    #Mn  [54] COMBINING DOTTED GRAVE ACCENT..COM...
+      | 0xE1 0xB7 0xBB..0xBF    #Mn   [5] COMBINING DELETION MARK..COMBINING...
+      | 0xE1 0xB8 0x80..0xFF        #L& [278] LATIN CAPITAL LETTER A WITH RI...
+      | 0xE1 0xB9..0xBB 0x00..0xFF  #
+      | 0xE1 0xBC 0x00..0x95        #
+      | 0xE1 0xBC 0x98..0x9D    #L&   [6] GREEK CAPITAL LETTER EPSILON WITH ...
+      | 0xE1 0xBC 0xA0..0xFF    #L&  [38] GREEK SMALL LETTER ETA WITH PSILI....
+      | 0xE1 0xBD 0x00..0x85    #
+      | 0xE1 0xBD 0x88..0x8D    #L&   [6] GREEK CAPITAL LETTER OMICRON WITH ...
+      | 0xE1 0xBD 0x90..0x97    #L&   [8] GREEK SMALL LETTER UPSILON WITH PS...
+      | 0xE1 0xBD 0x99          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9B          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9D          #L&       GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBD 0x9F..0xBD    #L&  [31] GREEK CAPITAL LETTER UPSILON WITH ...
+      | 0xE1 0xBE 0x80..0xB4    #L&  [53] GREEK SMALL LETTER ALPHA WITH PSIL...
+      | 0xE1 0xBE 0xB6..0xBC    #L&   [7] GREEK SMALL LETTER ALPHA WITH PERI...
+      | 0xE1 0xBE 0xBE          #L&       GREEK PROSGEGRAMMENI
+      | 0xE1 0xBF 0x82..0x84    #L&   [3] GREEK SMALL LETTER ETA WITH VARIA ...
+      | 0xE1 0xBF 0x86..0x8C    #L&   [7] GREEK SMALL LETTER ETA WITH PERISP...
+      | 0xE1 0xBF 0x90..0x93    #L&   [4] GREEK SMALL LETTER IOTA WITH VRACH...
+      | 0xE1 0xBF 0x96..0x9B    #L&   [6] GREEK SMALL LETTER IOTA WITH PERIS...
+      | 0xE1 0xBF 0xA0..0xAC    #L&  [13] GREEK SMALL LETTER UPSILON WITH VR...
+      | 0xE1 0xBF 0xB2..0xB4    #L&   [3] GREEK SMALL LETTER OMEGA WITH VARI...
+      | 0xE1 0xBF 0xB6..0xBC    #L&   [7] GREEK SMALL LETTER OMEGA WITH PERI...
+      | 0xE2 0x80 0xBF..0xFF    #Pc   [2] UNDERTIE..CHARACTER TIE
+      | 0xE2 0x81 0x00..0x80    #
+      | 0xE2 0x81 0x94          #Pc       INVERTED UNDERTIE
+      | 0xE2 0x81 0xB1          #Lm       SUPERSCRIPT LATIN SMALL LETTER I
+      | 0xE2 0x81 0xBF          #Lm       SUPERSCRIPT LATIN SMALL LETTER N
+      | 0xE2 0x82 0x90..0x9C    #Lm  [13] LATIN SUBSCRIPT SMALL LETTER A..LA...
+      | 0xE2 0x83 0x90..0x9C    #Mn  [13] COMBINING LEFT HARPOON ABOVE..COMB...
+      | 0xE2 0x83 0xA1          #Mn       COMBINING LEFT RIGHT ARROW ABOVE
+      | 0xE2 0x83 0xA5..0xB0    #Mn  [12] COMBINING REVERSE SOLIDUS OVERLAY....
+      | 0xE2 0x84 0x82          #L&       DOUBLE-STRUCK CAPITAL C
+      | 0xE2 0x84 0x87          #L&       EULER CONSTANT
+      | 0xE2 0x84 0x8A..0x93    #L&  [10] SCRIPT SMALL G..SCRIPT SMALL L
+      | 0xE2 0x84 0x95          #L&       DOUBLE-STRUCK CAPITAL N
+      | 0xE2 0x84 0x98          #Sm       SCRIPT CAPITAL P
+      | 0xE2 0x84 0x99..0x9D    #L&   [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-ST...
+      | 0xE2 0x84 0xA4          #L&       DOUBLE-STRUCK CAPITAL Z
+      | 0xE2 0x84 0xA6          #L&       OHM SIGN
+      | 0xE2 0x84 0xA8          #L&       BLACK-LETTER CAPITAL Z
+      | 0xE2 0x84 0xAA..0xAD    #L&   [4] KELVIN SIGN..BLACK-LETTER CAPITAL C
+      | 0xE2 0x84 0xAE          #So       ESTIMATED SYMBOL
+      | 0xE2 0x84 0xAF..0xB4    #L&   [6] SCRIPT SMALL E..SCRIPT SMALL O
+      | 0xE2 0x84 0xB5..0xB8    #Lo   [4] ALEF SYMBOL..DALET SYMBOL
+      | 0xE2 0x84 0xB9          #L&       INFORMATION SOURCE
+      | 0xE2 0x84 0xBC..0xBF    #L&   [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STR...
+      | 0xE2 0x85 0x85..0x89    #L&   [5] DOUBLE-STRUCK ITALIC CAPITAL D..DO...
+      | 0xE2 0x85 0x8E          #L&       TURNED SMALL F
+      | 0xE2 0x85 0xA0..0xFF    #Nl  [35] ROMAN NUMERAL ONE..ROMAN NUMERAL T...
+      | 0xE2 0x86 0x00..0x82    #
+      | 0xE2 0x86 0x83..0x84    #L&   [2] ROMAN NUMERAL REVERSED ONE HUNDRED...
+      | 0xE2 0x86 0x85..0x88    #Nl   [4] ROMAN NUMERAL SIX LATE FORM..ROMAN...
+      | 0xE2 0xB0 0x80..0xAE    #L&  [47] GLAGOLITIC CAPITAL LETTER AZU..GLA...
+      | 0xE2 0xB0 0xB0..0xFF    #L&  [47] GLAGOLITIC SMALL LETTER AZU..GLAGO...
+      | 0xE2 0xB1 0x00..0x9E    #
+      | 0xE2 0xB1 0xA0..0xBB    #L&  [28] LATIN CAPITAL LETTER L WITH DOUBLE...
+      | 0xE2 0xB1 0xBC..0xBD    #Lm   [2] LATIN SUBSCRIPT SMALL LETTER J..MO...
+      | 0xE2 0xB1 0xBE..0xFF        #L& [103] LATIN CAPITAL LETTER S WITH SW...
+      | 0xE2 0xB2..0xB2 0x00..0xFF  #
+      | 0xE2 0xB3 0x00..0xA4        #
+      | 0xE2 0xB3 0xAB..0xAE    #L&   [4] COPTIC CAPITAL LETTER CRYPTOGRAMMI...
+      | 0xE2 0xB3 0xAF..0xB1    #Mn   [3] COPTIC COMBINING NI ABOVE..COPTIC ...
+      | 0xE2 0xB3 0xB2..0xB3    #L&   [2] COPTIC CAPITAL LETTER BOHAIRIC KHE...
+      | 0xE2 0xB4 0x80..0xA5    #L&  [38] GEORGIAN SMALL LETTER AN..GEORGIAN...
+      | 0xE2 0xB4 0xA7          #L&       GEORGIAN SMALL LETTER YN
+      | 0xE2 0xB4 0xAD          #L&       GEORGIAN SMALL LETTER AEN
+      | 0xE2 0xB4 0xB0..0xFF    #Lo  [56] TIFINAGH LETTER YA..TIFINAGH LETTE...
+      | 0xE2 0xB5 0x00..0xA7    #
+      | 0xE2 0xB5 0xAF          #Lm       TIFINAGH MODIFIER LETTER LABIALIZA...
+      | 0xE2 0xB5 0xBF          #Mn       TIFINAGH CONSONANT JOINER
+      | 0xE2 0xB6 0x80..0x96    #Lo  [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xA0..0xA6    #Lo   [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xA8..0xAE    #Lo   [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xB0..0xB6    #Lo   [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SY...
+      | 0xE2 0xB6 0xB8..0xBE    #Lo   [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC S...
+      | 0xE2 0xB7 0x80..0x86    #Lo   [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x88..0x8E    #Lo   [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x90..0x96    #Lo   [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0x98..0x9E    #Lo   [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SY...
+      | 0xE2 0xB7 0xA0..0xBF    #Mn  [32] COMBINING CYRILLIC LETTER BE..COMB...
+      | 0xE3 0x80 0x85          #Lm       IDEOGRAPHIC ITERATION MARK
+      | 0xE3 0x80 0x86          #Lo       IDEOGRAPHIC CLOSING MARK
+      | 0xE3 0x80 0x87          #Nl       IDEOGRAPHIC NUMBER ZERO
+      | 0xE3 0x80 0xA1..0xA9    #Nl   [9] HANGZHOU NUMERAL ONE..HANGZHOU NUM...
+      | 0xE3 0x80 0xAA..0xAD    #Mn   [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOG...
+      | 0xE3 0x80 0xAE..0xAF    #Mc   [2] HANGUL SINGLE DOT TONE MARK..HANGU...
+      | 0xE3 0x80 0xB1..0xB5    #Lm   [5] VERTICAL KANA REPEAT MARK..VERTICA...
+      | 0xE3 0x80 0xB8..0xBA    #Nl   [3] HANGZHOU NUMERAL TEN..HANGZHOU NUM...
+      | 0xE3 0x80 0xBB          #Lm       VERTICAL IDEOGRAPHIC ITERATION MARK
+      | 0xE3 0x80 0xBC          #Lo       MASU MARK
+      | 0xE3 0x81 0x81..0xFF    #Lo  [86] HIRAGANA LETTER SMALL A..HIRAGANA ...
+      | 0xE3 0x82 0x00..0x96    #
+      | 0xE3 0x82 0x99..0x9A    #Mn   [2] COMBINING KATAKANA-HIRAGANA VOICED...
+      | 0xE3 0x82 0x9B..0x9C    #Sk   [2] KATAKANA-HIRAGANA VOICED SOUND MAR...
+      | 0xE3 0x82 0x9D..0x9E    #Lm   [2] HIRAGANA ITERATION MARK..HIRAGANA ...
+      | 0xE3 0x82 0x9F          #Lo       HIRAGANA DIGRAPH YORI
+      | 0xE3 0x82 0xA1..0xFF    #Lo  [90] KATAKANA LETTER SMALL A..KATAKANA ...
+      | 0xE3 0x83 0x00..0xBA    #
+      | 0xE3 0x83 0xBC..0xBE    #Lm   [3] KATAKANA-HIRAGANA PROLONGED SOUND ...
+      | 0xE3 0x83 0xBF          #Lo       KATAKANA DIGRAPH KOTO
+      | 0xE3 0x84 0x85..0xAD    #Lo  [41] BOPOMOFO LETTER B..BOPOMOFO LETTER IH
+      | 0xE3 0x84 0xB1..0xFF        #Lo  [94] HANGUL LETTER KIYEOK..HANGUL L...
+      | 0xE3 0x85..0x85 0x00..0xFF  #
+      | 0xE3 0x86 0x00..0x8E        #
+      | 0xE3 0x86 0xA0..0xBA    #Lo  [27] BOPOMOFO LETTER BU..BOPOMOFO LETTE...
+      | 0xE3 0x87 0xB0..0xBF    #Lo  [16] KATAKANA LETTER SMALL KU..KATAKANA...
+      | 0xE3 0x90 0x80..0xFF        #Lo [6582] CJK UNIFIED IDEOGRAPH-3400..C...
+      | 0xE3 0x91..0xFF 0x00..0xFF  #
+      | 0xE4 0x00 0x00..0xFF        #
+      | 0xE4 0x01..0xB5 0x00..0xFF  #
+      | 0xE4 0xB6 0x00..0xB5        #
+      | 0xE4 0xB8 0x80..0xFF              #Lo [20950] CJK UNIFIED IDEOGRAPH-...
+      | 0xE4 0xB9..0xFF 0x00..0xFF        #
+      | 0xE5..0xE8 0x00..0xFF 0x00..0xFF  #
+      | 0xE9 0x00 0x00..0xFF              #
+      | 0xE9 0x01..0xBE 0x00..0xFF        #
+      | 0xE9 0xBF 0x00..0x95              #
+      | 0xEA 0x80 0x80..0x94    #Lo  [21] YI SYLLABLE IT..YI SYLLABLE E
+      | 0xEA 0x80 0x95          #Lm       YI SYLLABLE WU
+      | 0xEA 0x80 0x96..0xFF        #Lo [1143] YI SYLLABLE BIT..YI SYLLABLE YYR
+      | 0xEA 0x81..0x91 0x00..0xFF  #
+      | 0xEA 0x92 0x00..0x8C        #
+      | 0xEA 0x93 0x90..0xB7    #Lo  [40] LISU LETTER BA..LISU LETTER OE
+      | 0xEA 0x93 0xB8..0xBD    #Lm   [6] LISU LETTER TONE MYA TI..LISU LETT...
+      | 0xEA 0x94 0x80..0xFF        #Lo [268] VAI SYLLABLE EE..VAI SYLLABLE NG
+      | 0xEA 0x95..0x97 0x00..0xFF  #
+      | 0xEA 0x98 0x00..0x8B        #
+      | 0xEA 0x98 0x8C          #Lm       VAI SYLLABLE LENGTHENER
+      | 0xEA 0x98 0x90..0x9F    #Lo  [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL ...
+      | 0xEA 0x98 0xA0..0xA9    #Nd  [10] VAI DIGIT ZERO..VAI DIGIT NINE
+      | 0xEA 0x98 0xAA..0xAB    #Lo   [2] VAI SYLLABLE NDOLE MA..VAI SYLLABL...
+      | 0xEA 0x99 0x80..0xAD    #L&  [46] CYRILLIC CAPITAL LETTER ZEMLYA..CY...
+      | 0xEA 0x99 0xAE          #Lo       CYRILLIC LETTER MULTIOCULAR O
+      | 0xEA 0x99 0xAF          #Mn       COMBINING CYRILLIC VZMET
+      | 0xEA 0x99 0xB4..0xBD    #Mn  [10] COMBINING CYRILLIC LETTER UKRAINIA...
+      | 0xEA 0x99 0xBF          #Lm       CYRILLIC PAYEROK
+      | 0xEA 0x9A 0x80..0x9B    #L&  [28] CYRILLIC CAPITAL LETTER DWE..CYRIL...
+      | 0xEA 0x9A 0x9C..0x9D    #Lm   [2] MODIFIER LETTER CYRILLIC HARD SIGN...
+      | 0xEA 0x9A 0x9E..0x9F    #Mn   [2] COMBINING CYRILLIC LETTER EF..COMB...
+      | 0xEA 0x9A 0xA0..0xFF    #Lo  [70] BAMUM LETTER A..BAMUM LETTER KI
+      | 0xEA 0x9B 0x00..0xA5    #
+      | 0xEA 0x9B 0xA6..0xAF    #Nl  [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM
+      | 0xEA 0x9B 0xB0..0xB1    #Mn   [2] BAMUM COMBINING MARK KOQNDON..BAMU...
+      | 0xEA 0x9C 0x97..0x9F    #Lm   [9] MODIFIER LETTER DOT VERTICAL BAR.....
+      | 0xEA 0x9C 0xA2..0xFF    #L&  [78] LATIN CAPITAL LETTER EGYPTOLOGICAL...
+      | 0xEA 0x9D 0x00..0xAF    #
+      | 0xEA 0x9D 0xB0          #Lm       MODIFIER LETTER US
+      | 0xEA 0x9D 0xB1..0xFF    #L&  [23] LATIN SMALL LETTER DUM..LATIN SMAL...
+      | 0xEA 0x9E 0x00..0x87    #
+      | 0xEA 0x9E 0x88          #Lm       MODIFIER LETTER LOW CIRCUMFLEX ACCENT
+      | 0xEA 0x9E 0x8B..0x8E    #L&   [4] LATIN CAPITAL LETTER SALTILLO..LAT...
+      | 0xEA 0x9E 0x8F          #Lo       LATIN LETTER SINOLOGICAL DOT
+      | 0xEA 0x9E 0x90..0xAE    #L&  [31] LATIN CAPITAL LETTER N WITH DESCEN...
+      | 0xEA 0x9E 0xB0..0xB7    #L&   [8] LATIN CAPITAL LETTER TURNED K..LAT...
+      | 0xEA 0x9F 0xB7          #Lo       LATIN EPIGRAPHIC LETTER SIDEWAYS I
+      | 0xEA 0x9F 0xB8..0xB9    #Lm   [2] MODIFIER LETTER CAPITAL H WITH STR...
+      | 0xEA 0x9F 0xBA          #L&       LATIN LETTER SMALL CAPITAL TURNED M
+      | 0xEA 0x9F 0xBB..0xFF    #Lo   [7] LATIN EPIGRAPHIC LETTER REVERSED F...
+      | 0xEA 0xA0 0x00..0x81    #
+      | 0xEA 0xA0 0x82          #Mn       SYLOTI NAGRI SIGN DVISVARA
+      | 0xEA 0xA0 0x83..0x85    #Lo   [3] SYLOTI NAGRI LETTER U..SYLOTI NAGR...
+      | 0xEA 0xA0 0x86          #Mn       SYLOTI NAGRI SIGN HASANTA
+      | 0xEA 0xA0 0x87..0x8A    #Lo   [4] SYLOTI NAGRI LETTER KO..SYLOTI NAG...
+      | 0xEA 0xA0 0x8B          #Mn       SYLOTI NAGRI SIGN ANUSVARA
+      | 0xEA 0xA0 0x8C..0xA2    #Lo  [23] SYLOTI NAGRI LETTER CO..SYLOTI NAG...
+      | 0xEA 0xA0 0xA3..0xA4    #Mc   [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI ...
+      | 0xEA 0xA0 0xA5..0xA6    #Mn   [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI ...
+      | 0xEA 0xA0 0xA7          #Mc       SYLOTI NAGRI VOWEL SIGN OO
+      | 0xEA 0xA1 0x80..0xB3    #Lo  [52] PHAGS-PA LETTER KA..PHAGS-PA LETTE...
+      | 0xEA 0xA2 0x80..0x81    #Mc   [2] SAURASHTRA SIGN ANUSVARA..SAURASHT...
+      | 0xEA 0xA2 0x82..0xB3    #Lo  [50] SAURASHTRA LETTER A..SAURASHTRA LE...
+      | 0xEA 0xA2 0xB4..0xFF    #Mc  [16] SAURASHTRA CONSONANT SIGN HAARU..S...
+      | 0xEA 0xA3 0x00..0x83    #
+      | 0xEA 0xA3 0x84..0x85    #Mn   [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA...
+      | 0xEA 0xA3 0x90..0x99    #Nd  [10] SAURASHTRA DIGIT ZERO..SAURASHTRA ...
+      | 0xEA 0xA3 0xA0..0xB1    #Mn  [18] COMBINING DEVANAGARI DIGIT ZERO..C...
+      | 0xEA 0xA3 0xB2..0xB7    #Lo   [6] DEVANAGARI SIGN SPACING CANDRABIND...
+      | 0xEA 0xA3 0xBB          #Lo       DEVANAGARI HEADSTROKE
+      | 0xEA 0xA3 0xBD          #Lo       DEVANAGARI JAIN OM
+      | 0xEA 0xA4 0x80..0x89    #Nd  [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGI...
+      | 0xEA 0xA4 0x8A..0xA5    #Lo  [28] KAYAH LI LETTER KA..KAYAH LI LETTE...
+      | 0xEA 0xA4 0xA6..0xAD    #Mn   [8] KAYAH LI VOWEL UE..KAYAH LI TONE C...
+      | 0xEA 0xA4 0xB0..0xFF    #Lo  [23] REJANG LETTER KA..REJANG LETTER A
+      | 0xEA 0xA5 0x00..0x86    #
+      | 0xEA 0xA5 0x87..0x91    #Mn  [11] REJANG VOWEL SIGN I..REJANG CONSON...
+      | 0xEA 0xA5 0x92..0x93    #Mc   [2] REJANG CONSONANT SIGN H..REJANG VI...
+      | 0xEA 0xA5 0xA0..0xBC    #Lo  [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANG...
+      | 0xEA 0xA6 0x80..0x82    #Mn   [3] JAVANESE SIGN PANYANGGA..JAVANESE ...
+      | 0xEA 0xA6 0x83          #Mc       JAVANESE SIGN WIGNYAN
+      | 0xEA 0xA6 0x84..0xB2    #Lo  [47] JAVANESE LETTER A..JAVANESE LETTER HA
+      | 0xEA 0xA6 0xB3          #Mn       JAVANESE SIGN CECAK TELU
+      | 0xEA 0xA6 0xB4..0xB5    #Mc   [2] JAVANESE VOWEL SIGN TARUNG..JAVANE...
+      | 0xEA 0xA6 0xB6..0xB9    #Mn   [4] JAVANESE VOWEL SIGN WULU..JAVANESE...
+      | 0xEA 0xA6 0xBA..0xBB    #Mc   [2] JAVANESE VOWEL SIGN TALING..JAVANE...
+      | 0xEA 0xA6 0xBC          #Mn       JAVANESE VOWEL SIGN PEPET
+      | 0xEA 0xA6 0xBD..0xFF    #Mc   [4] JAVANESE CONSONANT SIGN KERET..JAV...
+      | 0xEA 0xA7 0x00..0x80    #
+      | 0xEA 0xA7 0x8F          #Lm       JAVANESE PANGRANGKEP
+      | 0xEA 0xA7 0x90..0x99    #Nd  [10] JAVANESE DIGIT ZERO..JAVANESE DIGI...
+      | 0xEA 0xA7 0xA0..0xA4    #Lo   [5] MYANMAR LETTER SHAN GHA..MYANMAR L...
+      | 0xEA 0xA7 0xA5          #Mn       MYANMAR SIGN SHAN SAW
+      | 0xEA 0xA7 0xA6          #Lm       MYANMAR MODIFIER LETTER SHAN REDUP...
+      | 0xEA 0xA7 0xA7..0xAF    #Lo   [9] MYANMAR LETTER TAI LAING NYA..MYAN...
+      | 0xEA 0xA7 0xB0..0xB9    #Nd  [10] MYANMAR TAI LAING DIGIT ZERO..MYAN...
+      | 0xEA 0xA7 0xBA..0xBE    #Lo   [5] MYANMAR LETTER TAI LAING LLA..MYAN...
+      | 0xEA 0xA8 0x80..0xA8    #Lo  [41] CHAM LETTER A..CHAM LETTER HA
+      | 0xEA 0xA8 0xA9..0xAE    #Mn   [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xAF..0xB0    #Mc   [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
+      | 0xEA 0xA8 0xB1..0xB2    #Mn   [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xB3..0xB4    #Mc   [2] CHAM CONSONANT SIGN YA..CHAM CONSO...
+      | 0xEA 0xA8 0xB5..0xB6    #Mn   [2] CHAM CONSONANT SIGN LA..CHAM CONSO...
+      | 0xEA 0xA9 0x80..0x82    #Lo   [3] CHAM LETTER FINAL K..CHAM LETTER F...
+      | 0xEA 0xA9 0x83          #Mn       CHAM CONSONANT SIGN FINAL NG
+      | 0xEA 0xA9 0x84..0x8B    #Lo   [8] CHAM LETTER FINAL CH..CHAM LETTER ...
+      | 0xEA 0xA9 0x8C          #Mn       CHAM CONSONANT SIGN FINAL M
+      | 0xEA 0xA9 0x8D          #Mc       CHAM CONSONANT SIGN FINAL H
+      | 0xEA 0xA9 0x90..0x99    #Nd  [10] CHAM DIGIT ZERO..CHAM DIGIT NINE
+      | 0xEA 0xA9 0xA0..0xAF    #Lo  [16] MYANMAR LETTER KHAMTI GA..MYANMAR ...
+      | 0xEA 0xA9 0xB0          #Lm       MYANMAR MODIFIER LETTER KHAMTI RED...
+      | 0xEA 0xA9 0xB1..0xB6    #Lo   [6] MYANMAR LETTER KHAMTI XA..MYANMAR ...
+      | 0xEA 0xA9 0xBA          #Lo       MYANMAR LETTER AITON RA
+      | 0xEA 0xA9 0xBB          #Mc       MYANMAR SIGN PAO KAREN TONE
+      | 0xEA 0xA9 0xBC          #Mn       MYANMAR SIGN TAI LAING TONE-2
+      | 0xEA 0xA9 0xBD          #Mc       MYANMAR SIGN TAI LAING TONE-5
+      | 0xEA 0xA9 0xBE..0xFF    #Lo  [50] MYANMAR LETTER SHWE PALAUNG CHA..T...
+      | 0xEA 0xAA 0x00..0xAF    #
+      | 0xEA 0xAA 0xB0          #Mn       TAI VIET MAI KANG
+      | 0xEA 0xAA 0xB1          #Lo       TAI VIET VOWEL AA
+      | 0xEA 0xAA 0xB2..0xB4    #Mn   [3] TAI VIET VOWEL I..TAI VIET VOWEL U
+      | 0xEA 0xAA 0xB5..0xB6    #Lo   [2] TAI VIET VOWEL E..TAI VIET VOWEL O
+      | 0xEA 0xAA 0xB7..0xB8    #Mn   [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
+      | 0xEA 0xAA 0xB9..0xBD    #Lo   [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN
+      | 0xEA 0xAA 0xBE..0xBF    #Mn   [2] TAI VIET VOWEL AM..TAI VIET TONE M...
+      | 0xEA 0xAB 0x80          #Lo       TAI VIET TONE MAI NUENG
+      | 0xEA 0xAB 0x81          #Mn       TAI VIET TONE MAI THO
+      | 0xEA 0xAB 0x82          #Lo       TAI VIET TONE MAI SONG
+      | 0xEA 0xAB 0x9B..0x9C    #Lo   [2] TAI VIET SYMBOL KON..TAI VIET SYMB...
+      | 0xEA 0xAB 0x9D          #Lm       TAI VIET SYMBOL SAM
+      | 0xEA 0xAB 0xA0..0xAA    #Lo  [11] MEETEI MAYEK LETTER E..MEETEI MAYE...
+      | 0xEA 0xAB 0xAB          #Mc       MEETEI MAYEK VOWEL SIGN II
+      | 0xEA 0xAB 0xAC..0xAD    #Mn   [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI...
+      | 0xEA 0xAB 0xAE..0xAF    #Mc   [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI...
+      | 0xEA 0xAB 0xB2          #Lo       MEETEI MAYEK ANJI
+      | 0xEA 0xAB 0xB3..0xB4    #Lm   [2] MEETEI MAYEK SYLLABLE REPETITION M...
+      | 0xEA 0xAB 0xB5          #Mc       MEETEI MAYEK VOWEL SIGN VISARGA
+      | 0xEA 0xAB 0xB6          #Mn       MEETEI MAYEK VIRAMA
+      | 0xEA 0xAC 0x81..0x86    #Lo   [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC S...
+      | 0xEA 0xAC 0x89..0x8E    #Lo   [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC S...
+      | 0xEA 0xAC 0x91..0x96    #Lo   [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SY...
+      | 0xEA 0xAC 0xA0..0xA6    #Lo   [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC ...
+      | 0xEA 0xAC 0xA8..0xAE    #Lo   [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SY...
+      | 0xEA 0xAC 0xB0..0xFF    #L&  [43] LATIN SMALL LETTER BARRED ALPHA..L...
+      | 0xEA 0xAD 0x00..0x9A    #
+      | 0xEA 0xAD 0x9C..0x9F    #Lm   [4] MODIFIER LETTER SMALL HENG..MODIFI...
+      | 0xEA 0xAD 0xA0..0xA5    #L&   [6] LATIN SMALL LETTER SAKHA YAT..GREE...
+      | 0xEA 0xAD 0xB0..0xFF    #L&  [80] CHEROKEE SMALL LETTER A..CHEROKEE ...
+      | 0xEA 0xAE 0x00..0xBF    #
+      | 0xEA 0xAF 0x80..0xA2    #Lo  [35] MEETEI MAYEK LETTER KOK..MEETEI MA...
+      | 0xEA 0xAF 0xA3..0xA4    #Mc   [2] MEETEI MAYEK VOWEL SIGN ONAP..MEET...
+      | 0xEA 0xAF 0xA5          #Mn       MEETEI MAYEK VOWEL SIGN ANAP
+      | 0xEA 0xAF 0xA6..0xA7    #Mc   [2] MEETEI MAYEK VOWEL SIGN YENAP..MEE...
+      | 0xEA 0xAF 0xA8          #Mn       MEETEI MAYEK VOWEL SIGN UNAP
+      | 0xEA 0xAF 0xA9..0xAA    #Mc   [2] MEETEI MAYEK VOWEL SIGN CHEINAP..M...
+      | 0xEA 0xAF 0xAC          #Mc       MEETEI MAYEK LUM IYEK
+      | 0xEA 0xAF 0xAD          #Mn       MEETEI MAYEK APUN IYEK
+      | 0xEA 0xAF 0xB0..0xB9    #Nd  [10] MEETEI MAYEK DIGIT ZERO..MEETEI MA...
+      | 0xEA 0xB0 0x80..0xFF              #Lo [11172] HANGUL SYLLABLE GA..HA...
+      | 0xEA 0xB1..0xFF 0x00..0xFF        #
+      | 0xEB..0xEC 0x00..0xFF 0x00..0xFF  #
+      | 0xED 0x00 0x00..0xFF              #
+      | 0xED 0x01..0x9D 0x00..0xFF        #
+      | 0xED 0x9E 0x00..0xA3              #
+      | 0xED 0x9E 0xB0..0xFF    #Lo  [23] HANGUL JUNGSEONG O-YEO..HANGUL JUN...
+      | 0xED 0x9F 0x00..0x86    #
+      | 0xED 0x9F 0x8B..0xBB    #Lo  [49] HANGUL JONGSEONG NIEUN-RIEUL..HANG...
+      | 0xEF 0xA4 0x80..0xFF        #Lo [366] CJK COMPATIBILITY IDEOGRAPH-F9...
+      | 0xEF 0xA5..0xA8 0x00..0xFF  #
+      | 0xEF 0xA9 0x00..0xAD        #
+      | 0xEF 0xA9 0xB0..0xFF        #Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA...
+      | 0xEF 0xAA..0xAA 0x00..0xFF  #
+      | 0xEF 0xAB 0x00..0x99        #
+      | 0xEF 0xAC 0x80..0x86    #L&   [7] LATIN SMALL LIGATURE FF..LATIN SMA...
+      | 0xEF 0xAC 0x93..0x97    #L&   [5] ARMENIAN SMALL LIGATURE MEN NOW..A...
+      | 0xEF 0xAC 0x9D          #Lo       HEBREW LETTER YOD WITH HIRIQ
+      | 0xEF 0xAC 0x9E          #Mn       HEBREW POINT JUDEO-SPANISH VARIKA
+      | 0xEF 0xAC 0x9F..0xA8    #Lo  [10] HEBREW LIGATURE YIDDISH YOD YOD PA...
+      | 0xEF 0xAC 0xAA..0xB6    #Lo  [13] HEBREW LETTER SHIN WITH SHIN DOT.....
+      | 0xEF 0xAC 0xB8..0xBC    #Lo   [5] HEBREW LETTER TET WITH DAGESH..HEB...
+      | 0xEF 0xAC 0xBE          #Lo       HEBREW LETTER MEM WITH DAGESH
+      | 0xEF 0xAD 0x80..0x81    #Lo   [2] HEBREW LETTER NUN WITH DAGESH..HEB...
+      | 0xEF 0xAD 0x83..0x84    #Lo   [2] HEBREW LETTER FINAL PE WITH DAGESH...
+      | 0xEF 0xAD 0x86..0xFF    #Lo [108] HEBREW LETTER TSADI WITH DAGESH..A...
+      | 0xEF 0xAE 0x00..0xB1    #
+      | 0xEF 0xAF 0x93..0xFF        #Lo [363] ARABIC LETTER NG ISOLATED FORM...
+      | 0xEF 0xB0..0xB3 0x00..0xFF  #
+      | 0xEF 0xB4 0x00..0xBD        #
+      | 0xEF 0xB5 0x90..0xFF    #Lo  [64] ARABIC LIGATURE TEH WITH JEEM WITH...
+      | 0xEF 0xB6 0x00..0x8F    #
+      | 0xEF 0xB6 0x92..0xFF    #Lo  [54] ARABIC LIGATURE MEEM WITH JEEM WIT...
+      | 0xEF 0xB7 0x00..0x87    #
+      | 0xEF 0xB7 0xB0..0xBB    #Lo  [12] ARABIC LIGATURE SALLA USED AS KORA...
+      | 0xEF 0xB8 0x80..0x8F    #Mn  [16] VARIATION SELECTOR-1..VARIATION SE...
+      | 0xEF 0xB8 0xA0..0xAF    #Mn  [16] COMBINING LIGATURE LEFT HALF..COMB...
+      | 0xEF 0xB8 0xB3..0xB4    #Pc   [2] PRESENTATION FORM FOR VERTICAL LOW...
+      | 0xEF 0xB9 0x8D..0x8F    #Pc   [3] DASHED LOW LINE..WAVY LOW LINE
+      | 0xEF 0xB9 0xB0..0xB4    #Lo   [5] ARABIC FATHATAN ISOLATED FORM..ARA...
+      | 0xEF 0xB9 0xB6..0xFF        #Lo [135] ARABIC FATHA ISOLATED FORM..AR...
+      | 0xEF 0xBA..0xBA 0x00..0xFF  #
+      | 0xEF 0xBB 0x00..0xBC        #
+      | 0xEF 0xBC 0x90..0x99    #Nd  [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DI...
+      | 0xEF 0xBC 0xA1..0xBA    #L&  [26] FULLWIDTH LATIN CAPITAL LETTER A.....
+      | 0xEF 0xBC 0xBF          #Pc       FULLWIDTH LOW LINE
+      | 0xEF 0xBD 0x81..0x9A    #L&  [26] FULLWIDTH LATIN SMALL LETTER A..FU...
+      | 0xEF 0xBD 0xA6..0xAF    #Lo  [10] HALFWIDTH KATAKANA LETTER WO..HALF...
+      | 0xEF 0xBD 0xB0          #Lm       HALFWIDTH KATAKANA-HIRAGANA PROLON...
+      | 0xEF 0xBD 0xB1..0xFF    #Lo  [45] HALFWIDTH KATAKANA LETTER A..HALFW...
+      | 0xEF 0xBE 0x00..0x9D    #
+      | 0xEF 0xBE 0x9E..0x9F    #Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MA...
+      | 0xEF 0xBE 0xA0..0xBE    #Lo  [31] HALFWIDTH HANGUL FILLER..HALFWIDTH...
+      | 0xEF 0xBF 0x82..0x87    #Lo   [6] HALFWIDTH HANGUL LETTER A..HALFWID...
+      | 0xEF 0xBF 0x8A..0x8F    #Lo   [6] HALFWIDTH HANGUL LETTER YEO..HALFW...
+      | 0xEF 0xBF 0x92..0x97    #Lo   [6] HALFWIDTH HANGUL LETTER YO..HALFWI...
+      | 0xEF 0xBF 0x9A..0x9C    #Lo   [3] HALFWIDTH HANGUL LETTER EU..HALFWI...
+      | 0xF0 0x90 0x80 0x80..0x8B  #Lo  [12] LINEAR B SYLLABLE B008 A..LINEA...
+      | 0xF0 0x90 0x80 0x8D..0xA6  #Lo  [26] LINEAR B SYLLABLE B036 JO..LINE...
+      | 0xF0 0x90 0x80 0xA8..0xBA  #Lo  [19] LINEAR B SYLLABLE B060 RA..LINE...
+      | 0xF0 0x90 0x80 0xBC..0xBD  #Lo   [2] LINEAR B SYLLABLE B017 ZA..LINE...
+      | 0xF0 0x90 0x80 0xBF..0xFF  #Lo  [15] LINEAR B SYLLABLE B020 ZO..LINE...
+      | 0xF0 0x90 0x81 0x00..0x8D  #
+      | 0xF0 0x90 0x81 0x90..0x9D  #Lo  [14] LINEAR B SYMBOL B018..LINEAR B ...
+      | 0xF0 0x90 0x82 0x80..0xFF  #Lo [123] LINEAR B IDEOGRAM B100 MAN..LIN...
+      | 0xF0 0x90 0x83 0x00..0xBA  #
+      | 0xF0 0x90 0x85 0x80..0xB4  #Nl  [53] GREEK ACROPHONIC ATTIC ONE QUAR...
+      | 0xF0 0x90 0x87 0xBD     #Mn       PHAISTOS DISC SIGN COMBINING OBLIQ...
+      | 0xF0 0x90 0x8A 0x80..0x9C  #Lo  [29] LYCIAN LETTER A..LYCIAN LETTER X
+      | 0xF0 0x90 0x8A 0xA0..0xFF  #Lo  [49] CARIAN LETTER A..CARIAN LETTER ...
+      | 0xF0 0x90 0x8B 0x00..0x90  #
+      | 0xF0 0x90 0x8B 0xA0     #Mn       COPTIC EPACT THOUSANDS MARK
+      | 0xF0 0x90 0x8C 0x80..0x9F  #Lo  [32] OLD ITALIC LETTER A..OLD ITALIC...
+      | 0xF0 0x90 0x8C 0xB0..0xFF  #Lo  [17] GOTHIC LETTER AHSA..GOTHIC LETT...
+      | 0xF0 0x90 0x8D 0x00..0x80  #
+      | 0xF0 0x90 0x8D 0x81     #Nl       GOTHIC LETTER NINETY
+      | 0xF0 0x90 0x8D 0x82..0x89  #Lo   [8] GOTHIC LETTER RAIDA..GOTHIC LET...
+      | 0xF0 0x90 0x8D 0x8A     #Nl       GOTHIC LETTER NINE HUNDRED
+      | 0xF0 0x90 0x8D 0x90..0xB5  #Lo  [38] OLD PERMIC LETTER AN..OLD PERMI...
+      | 0xF0 0x90 0x8D 0xB6..0xBA  #Mn   [5] COMBINING OLD PERMIC LETTER AN....
+      | 0xF0 0x90 0x8E 0x80..0x9D  #Lo  [30] UGARITIC LETTER ALPA..UGARITIC ...
+      | 0xF0 0x90 0x8E 0xA0..0xFF  #Lo  [36] OLD PERSIAN SIGN A..OLD PERSIAN...
+      | 0xF0 0x90 0x8F 0x00..0x83  #
+      | 0xF0 0x90 0x8F 0x88..0x8F  #Lo   [8] OLD PERSIAN SIGN AURAMAZDAA..OL...
+      | 0xF0 0x90 0x8F 0x91..0x95  #Nl   [5] OLD PERSIAN NUMBER ONE..OLD PER...
+      | 0xF0 0x90 0x90 0x80..0xFF  #L&  [80] DESERET CAPITAL LETTER LONG I.....
+      | 0xF0 0x90 0x91 0x00..0x8F  #
+      | 0xF0 0x90 0x91 0x90..0xFF  #Lo  [78] SHAVIAN LETTER PEEP..OSMANYA LE...
+      | 0xF0 0x90 0x92 0x00..0x9D  #
+      | 0xF0 0x90 0x92 0xA0..0xA9  #Nd  [10] OSMANYA DIGIT ZERO..OSMANYA DIG...
+      | 0xF0 0x90 0x92 0xB0..0xFF  #L&  [36] OSAGE CAPITAL LETTER A..OSAGE C...
+      | 0xF0 0x90 0x93 0x00..0x93  #
+      | 0xF0 0x90 0x93 0x98..0xBB  #L&  [36] OSAGE SMALL LETTER A..OSAGE SMA...
+      | 0xF0 0x90 0x94 0x80..0xA7  #Lo  [40] ELBASAN LETTER A..ELBASAN LETTE...
+      | 0xF0 0x90 0x94 0xB0..0xFF  #Lo  [52] CAUCASIAN ALBANIAN LETTER ALT.....
+      | 0xF0 0x90 0x95 0x00..0xA3  #
+      | 0xF0 0x90 0x98 0x80..0xFF        #Lo [311] LINEAR A SIGN AB001..LINE...
+      | 0xF0 0x90 0x99..0x9B 0x00..0xFF  #
+      | 0xF0 0x90 0x9C 0x00..0xB6        #
+      | 0xF0 0x90 0x9D 0x80..0x95  #Lo  [22] LINEAR A SIGN A701 A..LINEAR A ...
+      | 0xF0 0x90 0x9D 0xA0..0xA7  #Lo   [8] LINEAR A SIGN A800..LINEAR A SI...
+      | 0xF0 0x90 0xA0 0x80..0x85  #Lo   [6] CYPRIOT SYLLABLE A..CYPRIOT SYL...
+      | 0xF0 0x90 0xA0 0x88     #Lo       CYPRIOT SYLLABLE JO
+      | 0xF0 0x90 0xA0 0x8A..0xB5  #Lo  [44] CYPRIOT SYLLABLE KA..CYPRIOT SY...
+      | 0xF0 0x90 0xA0 0xB7..0xB8  #Lo   [2] CYPRIOT SYLLABLE XA..CYPRIOT SY...
+      | 0xF0 0x90 0xA0 0xBC     #Lo       CYPRIOT SYLLABLE ZA
+      | 0xF0 0x90 0xA0 0xBF..0xFF  #Lo  [23] CYPRIOT SYLLABLE ZO..IMPERIAL A...
+      | 0xF0 0x90 0xA1 0x00..0x95  #
+      | 0xF0 0x90 0xA1 0xA0..0xB6  #Lo  [23] PALMYRENE LETTER ALEPH..PALMYRE...
+      | 0xF0 0x90 0xA2 0x80..0x9E  #Lo  [31] NABATAEAN LETTER FINAL ALEPH..N...
+      | 0xF0 0x90 0xA3 0xA0..0xB2  #Lo  [19] HATRAN LETTER ALEPH..HATRAN LET...
+      | 0xF0 0x90 0xA3 0xB4..0xB5  #Lo   [2] HATRAN LETTER SHIN..HATRAN LETT...
+      | 0xF0 0x90 0xA4 0x80..0x95  #Lo  [22] PHOENICIAN LETTER ALF..PHOENICI...
+      | 0xF0 0x90 0xA4 0xA0..0xB9  #Lo  [26] LYDIAN LETTER A..LYDIAN LETTER C
+      | 0xF0 0x90 0xA6 0x80..0xB7  #Lo  [56] MEROITIC HIEROGLYPHIC LETTER A....
+      | 0xF0 0x90 0xA6 0xBE..0xBF  #Lo   [2] MEROITIC CURSIVE LOGOGRAM RMT.....
+      | 0xF0 0x90 0xA8 0x80     #Lo       KHAROSHTHI LETTER A
+      | 0xF0 0x90 0xA8 0x81..0x83  #Mn   [3] KHAROSHTHI VOWEL SIGN I..KHAROS...
+      | 0xF0 0x90 0xA8 0x85..0x86  #Mn   [2] KHAROSHTHI VOWEL SIGN E..KHAROS...
+      | 0xF0 0x90 0xA8 0x8C..0x8F  #Mn   [4] KHAROSHTHI VOWEL LENGTH MARK..K...
+      | 0xF0 0x90 0xA8 0x90..0x93  #Lo   [4] KHAROSHTHI LETTER KA..KHAROSHTH...
+      | 0xF0 0x90 0xA8 0x95..0x97  #Lo   [3] KHAROSHTHI LETTER CA..KHAROSHTH...
+      | 0xF0 0x90 0xA8 0x99..0xB3  #Lo  [27] KHAROSHTHI LETTER NYA..KHAROSHT...
+      | 0xF0 0x90 0xA8 0xB8..0xBA  #Mn   [3] KHAROSHTHI SIGN BAR ABOVE..KHAR...
+      | 0xF0 0x90 0xA8 0xBF     #Mn       KHAROSHTHI VIRAMA
+      | 0xF0 0x90 0xA9 0xA0..0xBC  #Lo  [29] OLD SOUTH ARABIAN LETTER HE..OL...
+      | 0xF0 0x90 0xAA 0x80..0x9C  #Lo  [29] OLD NORTH ARABIAN LETTER HEH..O...
+      | 0xF0 0x90 0xAB 0x80..0x87  #Lo   [8] MANICHAEAN LETTER ALEPH..MANICH...
+      | 0xF0 0x90 0xAB 0x89..0xA4  #Lo  [28] MANICHAEAN LETTER ZAYIN..MANICH...
+      | 0xF0 0x90 0xAB 0xA5..0xA6  #Mn   [2] MANICHAEAN ABBREVIATION MARK AB...
+      | 0xF0 0x90 0xAC 0x80..0xB5  #Lo  [54] AVESTAN LETTER A..AVESTAN LETTE...
+      | 0xF0 0x90 0xAD 0x80..0x95  #Lo  [22] INSCRIPTIONAL PARTHIAN LETTER A...
+      | 0xF0 0x90 0xAD 0xA0..0xB2  #Lo  [19] INSCRIPTIONAL PAHLAVI LETTER AL...
+      | 0xF0 0x90 0xAE 0x80..0x91  #Lo  [18] PSALTER PAHLAVI LETTER ALEPH..P...
+      | 0xF0 0x90 0xB0 0x80..0xFF  #Lo  [73] OLD TURKIC LETTER ORKHON A..OLD...
+      | 0xF0 0x90 0xB1 0x00..0x88  #
+      | 0xF0 0x90 0xB2 0x80..0xB2  #L&  [51] OLD HUNGARIAN CAPITAL LETTER A....
+      | 0xF0 0x90 0xB3 0x80..0xB2  #L&  [51] OLD HUNGARIAN SMALL LETTER A..O...
+      | 0xF0 0x91 0x80 0x80     #Mc       BRAHMI SIGN CANDRABINDU
+      | 0xF0 0x91 0x80 0x81     #Mn       BRAHMI SIGN ANUSVARA
+      | 0xF0 0x91 0x80 0x82     #Mc       BRAHMI SIGN VISARGA
+      | 0xF0 0x91 0x80 0x83..0xB7  #Lo  [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI...
+      | 0xF0 0x91 0x80 0xB8..0xFF  #Mn  [15] BRAHMI VOWEL SIGN AA..BRAHMI VI...
+      | 0xF0 0x91 0x81 0x00..0x86  #
+      | 0xF0 0x91 0x81 0xA6..0xAF  #Nd  [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT...
+      | 0xF0 0x91 0x81 0xBF..0xFF  #Mn   [3] BRAHMI NUMBER JOINER..KAITHI SI...
+      | 0xF0 0x91 0x82 0x00..0x81  #
+      | 0xF0 0x91 0x82 0x82     #Mc       KAITHI SIGN VISARGA
+      | 0xF0 0x91 0x82 0x83..0xAF  #Lo  [45] KAITHI LETTER A..KAITHI LETTER HA
+      | 0xF0 0x91 0x82 0xB0..0xB2  #Mc   [3] KAITHI VOWEL SIGN AA..KAITHI VO...
+      | 0xF0 0x91 0x82 0xB3..0xB6  #Mn   [4] KAITHI VOWEL SIGN U..KAITHI VOW...
+      | 0xF0 0x91 0x82 0xB7..0xB8  #Mc   [2] KAITHI VOWEL SIGN O..KAITHI VOW...
+      | 0xF0 0x91 0x82 0xB9..0xBA  #Mn   [2] KAITHI SIGN VIRAMA..KAITHI SIGN...
+      | 0xF0 0x91 0x83 0x90..0xA8  #Lo  [25] SORA SOMPENG LETTER SAH..SORA S...
+      | 0xF0 0x91 0x83 0xB0..0xB9  #Nd  [10] SORA SOMPENG DIGIT ZERO..SORA S...
+      | 0xF0 0x91 0x84 0x80..0x82  #Mn   [3] CHAKMA SIGN CANDRABINDU..CHAKMA...
+      | 0xF0 0x91 0x84 0x83..0xA6  #Lo  [36] CHAKMA LETTER AA..CHAKMA LETTER...
+      | 0xF0 0x91 0x84 0xA7..0xAB  #Mn   [5] CHAKMA VOWEL SIGN A..CHAKMA VOW...
+      | 0xF0 0x91 0x84 0xAC     #Mc       CHAKMA VOWEL SIGN E
+      | 0xF0 0x91 0x84 0xAD..0xB4  #Mn   [8] CHAKMA VOWEL SIGN AI..CHAKMA MA...
+      | 0xF0 0x91 0x84 0xB6..0xBF  #Nd  [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT...
+      | 0xF0 0x91 0x85 0x90..0xB2  #Lo  [35] MAHAJANI LETTER A..MAHAJANI LET...
+      | 0xF0 0x91 0x85 0xB3     #Mn       MAHAJANI SIGN NUKTA
+      | 0xF0 0x91 0x85 0xB6     #Lo       MAHAJANI LIGATURE SHRI
+      | 0xF0 0x91 0x86 0x80..0x81  #Mn   [2] SHARADA SIGN CANDRABINDU..SHARA...
+      | 0xF0 0x91 0x86 0x82     #Mc       SHARADA SIGN VISARGA
+      | 0xF0 0x91 0x86 0x83..0xB2  #Lo  [48] SHARADA LETTER A..SHARADA LETTE...
+      | 0xF0 0x91 0x86 0xB3..0xB5  #Mc   [3] SHARADA VOWEL SIGN AA..SHARADA ...
+      | 0xF0 0x91 0x86 0xB6..0xBE  #Mn   [9] SHARADA VOWEL SIGN U..SHARADA V...
+      | 0xF0 0x91 0x86 0xBF..0xFF  #Mc   [2] SHARADA VOWEL SIGN AU..SHARADA ...
+      | 0xF0 0x91 0x87 0x00..0x80  #
+      | 0xF0 0x91 0x87 0x81..0x84  #Lo   [4] SHARADA SIGN AVAGRAHA..SHARADA OM
+      | 0xF0 0x91 0x87 0x8A..0x8C  #Mn   [3] SHARADA SIGN NUKTA..SHARADA EXT...
+      | 0xF0 0x91 0x87 0x90..0x99  #Nd  [10] SHARADA DIGIT ZERO..SHARADA DIG...
+      | 0xF0 0x91 0x87 0x9A     #Lo       SHARADA EKAM
+      | 0xF0 0x91 0x87 0x9C     #Lo       SHARADA HEADSTROKE
+      | 0xF0 0x91 0x88 0x80..0x91  #Lo  [18] KHOJKI LETTER A..KHOJKI LETTER JJA
+      | 0xF0 0x91 0x88 0x93..0xAB  #Lo  [25] KHOJKI LETTER NYA..KHOJKI LETTE...
+      | 0xF0 0x91 0x88 0xAC..0xAE  #Mc   [3] KHOJKI VOWEL SIGN AA..KHOJKI VO...
+      | 0xF0 0x91 0x88 0xAF..0xB1  #Mn   [3] KHOJKI VOWEL SIGN U..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB2..0xB3  #Mc   [2] KHOJKI VOWEL SIGN O..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB4     #Mn       KHOJKI SIGN ANUSVARA
+      | 0xF0 0x91 0x88 0xB5     #Mc       KHOJKI SIGN VIRAMA
+      | 0xF0 0x91 0x88 0xB6..0xB7  #Mn   [2] KHOJKI SIGN NUKTA..KHOJKI SIGN ...
+      | 0xF0 0x91 0x88 0xBE     #Mn       KHOJKI SIGN SUKUN
+      | 0xF0 0x91 0x8A 0x80..0x86  #Lo   [7] MULTANI LETTER A..MULTANI LETTE...
+      | 0xF0 0x91 0x8A 0x88     #Lo       MULTANI LETTER GHA
+      | 0xF0 0x91 0x8A 0x8A..0x8D  #Lo   [4] MULTANI LETTER CA..MULTANI LETT...
+      | 0xF0 0x91 0x8A 0x8F..0x9D  #Lo  [15] MULTANI LETTER NYA..MULTANI LET...
+      | 0xF0 0x91 0x8A 0x9F..0xA8  #Lo  [10] MULTANI LETTER BHA..MULTANI LET...
+      | 0xF0 0x91 0x8A 0xB0..0xFF  #Lo  [47] KHUDAWADI LETTER A..KHUDAWADI L...
+      | 0xF0 0x91 0x8B 0x00..0x9E  #
+      | 0xF0 0x91 0x8B 0x9F     #Mn       KHUDAWADI SIGN ANUSVARA
+      | 0xF0 0x91 0x8B 0xA0..0xA2  #Mc   [3] KHUDAWADI VOWEL SIGN AA..KHUDAW...
+      | 0xF0 0x91 0x8B 0xA3..0xAA  #Mn   [8] KHUDAWADI VOWEL SIGN U..KHUDAWA...
+      | 0xF0 0x91 0x8B 0xB0..0xB9  #Nd  [10] KHUDAWADI DIGIT ZERO..KHUDAWADI...
+      | 0xF0 0x91 0x8C 0x80..0x81  #Mn   [2] GRANTHA SIGN COMBINING ANUSVARA...
+      | 0xF0 0x91 0x8C 0x82..0x83  #Mc   [2] GRANTHA SIGN ANUSVARA..GRANTHA ...
+      | 0xF0 0x91 0x8C 0x85..0x8C  #Lo   [8] GRANTHA LETTER A..GRANTHA LETTE...
+      | 0xF0 0x91 0x8C 0x8F..0x90  #Lo   [2] GRANTHA LETTER EE..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0x93..0xA8  #Lo  [22] GRANTHA LETTER OO..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xAA..0xB0  #Lo   [7] GRANTHA LETTER PA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xB2..0xB3  #Lo   [2] GRANTHA LETTER LA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xB5..0xB9  #Lo   [5] GRANTHA LETTER VA..GRANTHA LETT...
+      | 0xF0 0x91 0x8C 0xBC     #Mn       GRANTHA SIGN NUKTA
+      | 0xF0 0x91 0x8C 0xBD     #Lo       GRANTHA SIGN AVAGRAHA
+      | 0xF0 0x91 0x8C 0xBE..0xBF  #Mc   [2] GRANTHA VOWEL SIGN AA..GRANTHA ...
+      | 0xF0 0x91 0x8D 0x80     #Mn       GRANTHA VOWEL SIGN II
+      | 0xF0 0x91 0x8D 0x81..0x84  #Mc   [4] GRANTHA VOWEL SIGN U..GRANTHA V...
+      | 0xF0 0x91 0x8D 0x87..0x88  #Mc   [2] GRANTHA VOWEL SIGN EE..GRANTHA ...
+      | 0xF0 0x91 0x8D 0x8B..0x8D  #Mc   [3] GRANTHA VOWEL SIGN OO..GRANTHA ...
+      | 0xF0 0x91 0x8D 0x90     #Lo       GRANTHA OM
+      | 0xF0 0x91 0x8D 0x97     #Mc       GRANTHA AU LENGTH MARK
+      | 0xF0 0x91 0x8D 0x9D..0xA1  #Lo   [5] GRANTHA SIGN PLUTA..GRANTHA LET...
+      | 0xF0 0x91 0x8D 0xA2..0xA3  #Mc   [2] GRANTHA VOWEL SIGN VOCALIC L..G...
+      | 0xF0 0x91 0x8D 0xA6..0xAC  #Mn   [7] COMBINING GRANTHA DIGIT ZERO..C...
+      | 0xF0 0x91 0x8D 0xB0..0xB4  #Mn   [5] COMBINING GRANTHA LETTER A..COM...
+      | 0xF0 0x91 0x90 0x80..0xB4  #Lo  [53] NEWA LETTER A..NEWA LETTER HA
+      | 0xF0 0x91 0x90 0xB5..0xB7  #Mc   [3] NEWA VOWEL SIGN AA..NEWA VOWEL ...
+      | 0xF0 0x91 0x90 0xB8..0xBF  #Mn   [8] NEWA VOWEL SIGN U..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x80..0x81  #Mc   [2] NEWA VOWEL SIGN O..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x82..0x84  #Mn   [3] NEWA SIGN VIRAMA..NEWA SIGN ANU...
+      | 0xF0 0x91 0x91 0x85     #Mc       NEWA SIGN VISARGA
+      | 0xF0 0x91 0x91 0x86     #Mn       NEWA SIGN NUKTA
+      | 0xF0 0x91 0x91 0x87..0x8A  #Lo   [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI
+      | 0xF0 0x91 0x91 0x90..0x99  #Nd  [10] NEWA DIGIT ZERO..NEWA DIGIT NINE
+      | 0xF0 0x91 0x92 0x80..0xAF  #Lo  [48] TIRHUTA ANJI..TIRHUTA LETTER HA
+      | 0xF0 0x91 0x92 0xB0..0xB2  #Mc   [3] TIRHUTA VOWEL SIGN AA..TIRHUTA ...
+      | 0xF0 0x91 0x92 0xB3..0xB8  #Mn   [6] TIRHUTA VOWEL SIGN U..TIRHUTA V...
+      | 0xF0 0x91 0x92 0xB9     #Mc       TIRHUTA VOWEL SIGN E
+      | 0xF0 0x91 0x92 0xBA     #Mn       TIRHUTA VOWEL SIGN SHORT E
+      | 0xF0 0x91 0x92 0xBB..0xBE  #Mc   [4] TIRHUTA VOWEL SIGN AI..TIRHUTA ...
+      | 0xF0 0x91 0x92 0xBF..0xFF  #Mn   [2] TIRHUTA SIGN CANDRABINDU..TIRHU...
+      | 0xF0 0x91 0x93 0x00..0x80  #
+      | 0xF0 0x91 0x93 0x81     #Mc       TIRHUTA SIGN VISARGA
+      | 0xF0 0x91 0x93 0x82..0x83  #Mn   [2] TIRHUTA SIGN VIRAMA..TIRHUTA SI...
+      | 0xF0 0x91 0x93 0x84..0x85  #Lo   [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA ...
+      | 0xF0 0x91 0x93 0x87     #Lo       TIRHUTA OM
+      | 0xF0 0x91 0x93 0x90..0x99  #Nd  [10] TIRHUTA DIGIT ZERO..TIRHUTA DIG...
+      | 0xF0 0x91 0x96 0x80..0xAE  #Lo  [47] SIDDHAM LETTER A..SIDDHAM LETTE...
+      | 0xF0 0x91 0x96 0xAF..0xB1  #Mc   [3] SIDDHAM VOWEL SIGN AA..SIDDHAM ...
+      | 0xF0 0x91 0x96 0xB2..0xB5  #Mn   [4] SIDDHAM VOWEL SIGN U..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xB8..0xBB  #Mc   [4] SIDDHAM VOWEL SIGN E..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xBC..0xBD  #Mn   [2] SIDDHAM SIGN CANDRABINDU..SIDDH...
+      | 0xF0 0x91 0x96 0xBE     #Mc       SIDDHAM SIGN VISARGA
+      | 0xF0 0x91 0x96 0xBF..0xFF  #Mn   [2] SIDDHAM SIGN VIRAMA..SIDDHAM SI...
+      | 0xF0 0x91 0x97 0x00..0x80  #
+      | 0xF0 0x91 0x97 0x98..0x9B  #Lo   [4] SIDDHAM LETTER THREE-CIRCLE ALT...
+      | 0xF0 0x91 0x97 0x9C..0x9D  #Mn   [2] SIDDHAM VOWEL SIGN ALTERNATE U....
+      | 0xF0 0x91 0x98 0x80..0xAF  #Lo  [48] MODI LETTER A..MODI LETTER LLA
+      | 0xF0 0x91 0x98 0xB0..0xB2  #Mc   [3] MODI VOWEL SIGN AA..MODI VOWEL ...
+      | 0xF0 0x91 0x98 0xB3..0xBA  #Mn   [8] MODI VOWEL SIGN U..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBB..0xBC  #Mc   [2] MODI VOWEL SIGN O..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBD     #Mn       MODI SIGN ANUSVARA
+      | 0xF0 0x91 0x98 0xBE     #Mc       MODI SIGN VISARGA
+      | 0xF0 0x91 0x98 0xBF..0xFF  #Mn   [2] MODI SIGN VIRAMA..MODI SIGN ARD...
+      | 0xF0 0x91 0x99 0x00..0x80  #
+      | 0xF0 0x91 0x99 0x84     #Lo       MODI SIGN HUVA
+      | 0xF0 0x91 0x99 0x90..0x99  #Nd  [10] MODI DIGIT ZERO..MODI DIGIT NINE
+      | 0xF0 0x91 0x9A 0x80..0xAA  #Lo  [43] TAKRI LETTER A..TAKRI LETTER RRA
+      | 0xF0 0x91 0x9A 0xAB     #Mn       TAKRI SIGN ANUSVARA
+      | 0xF0 0x91 0x9A 0xAC     #Mc       TAKRI SIGN VISARGA
+      | 0xF0 0x91 0x9A 0xAD     #Mn       TAKRI VOWEL SIGN AA
+      | 0xF0 0x91 0x9A 0xAE..0xAF  #Mc   [2] TAKRI VOWEL SIGN I..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB0..0xB5  #Mn   [6] TAKRI VOWEL SIGN U..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB6     #Mc       TAKRI SIGN VIRAMA
+      | 0xF0 0x91 0x9A 0xB7     #Mn       TAKRI SIGN NUKTA
+      | 0xF0 0x91 0x9B 0x80..0x89  #Nd  [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE
+      | 0xF0 0x91 0x9C 0x80..0x99  #Lo  [26] AHOM LETTER KA..AHOM LETTER JHA
+      | 0xF0 0x91 0x9C 0x9D..0x9F  #Mn   [3] AHOM CONSONANT SIGN MEDIAL LA.....
+      | 0xF0 0x91 0x9C 0xA0..0xA1  #Mc   [2] AHOM VOWEL SIGN A..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA2..0xA5  #Mn   [4] AHOM VOWEL SIGN I..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA6     #Mc       AHOM VOWEL SIGN E
+      | 0xF0 0x91 0x9C 0xA7..0xAB  #Mn   [5] AHOM VOWEL SIGN AW..AHOM SIGN K...
+      | 0xF0 0x91 0x9C 0xB0..0xB9  #Nd  [10] AHOM DIGIT ZERO..AHOM DIGIT NINE
+      | 0xF0 0x91 0xA2 0xA0..0xFF  #L&  [64] WARANG CITI CAPITAL LETTER NGAA...
+      | 0xF0 0x91 0xA3 0x00..0x9F  #
+      | 0xF0 0x91 0xA3 0xA0..0xA9  #Nd  [10] WARANG CITI DIGIT ZERO..WARANG ...
+      | 0xF0 0x91 0xA3 0xBF     #Lo       WARANG CITI OM
+      | 0xF0 0x91 0xAB 0x80..0xB8  #Lo  [57] PAU CIN HAU LETTER PA..PAU CIN ...
+      | 0xF0 0x91 0xB0 0x80..0x88  #Lo   [9] BHAIKSUKI LETTER A..BHAIKSUKI L...
+      | 0xF0 0x91 0xB0 0x8A..0xAE  #Lo  [37] BHAIKSUKI LETTER E..BHAIKSUKI L...
+      | 0xF0 0x91 0xB0 0xAF     #Mc       BHAIKSUKI VOWEL SIGN AA
+      | 0xF0 0x91 0xB0 0xB0..0xB6  #Mn   [7] BHAIKSUKI VOWEL SIGN I..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xB8..0xBD  #Mn   [6] BHAIKSUKI VOWEL SIGN E..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xBE     #Mc       BHAIKSUKI SIGN VISARGA
+      | 0xF0 0x91 0xB0 0xBF     #Mn       BHAIKSUKI SIGN VIRAMA
+      | 0xF0 0x91 0xB1 0x80     #Lo       BHAIKSUKI SIGN AVAGRAHA
+      | 0xF0 0x91 0xB1 0x90..0x99  #Nd  [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI...
+      | 0xF0 0x91 0xB1 0xB2..0xFF  #Lo  [30] MARCHEN LETTER KA..MARCHEN LETT...
+      | 0xF0 0x91 0xB2 0x00..0x8F  #
+      | 0xF0 0x91 0xB2 0x92..0xA7  #Mn  [22] MARCHEN SUBJOINED LETTER KA..MA...
+      | 0xF0 0x91 0xB2 0xA9     #Mc       MARCHEN SUBJOINED LETTER YA
+      | 0xF0 0x91 0xB2 0xAA..0xB0  #Mn   [7] MARCHEN SUBJOINED LETTER RA..MA...
+      | 0xF0 0x91 0xB2 0xB1     #Mc       MARCHEN VOWEL SIGN I
+      | 0xF0 0x91 0xB2 0xB2..0xB3  #Mn   [2] MARCHEN VOWEL SIGN U..MARCHEN V...
+      | 0xF0 0x91 0xB2 0xB4     #Mc       MARCHEN VOWEL SIGN O
+      | 0xF0 0x91 0xB2 0xB5..0xB6  #Mn   [2] MARCHEN SIGN ANUSVARA..MARCHEN ...
+      | 0xF0 0x92 0x80 0x80..0xFF        #Lo [922] CUNEIFORM SIGN A..CUNEIFO...
+      | 0xF0 0x92 0x81..0x8D 0x00..0xFF  #
+      | 0xF0 0x92 0x8E 0x00..0x99        #
+      | 0xF0 0x92 0x90 0x80..0xFF  #Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH....
+      | 0xF0 0x92 0x91 0x00..0xAE  #
+      | 0xF0 0x92 0x92 0x80..0xFF        #Lo [196] CUNEIFORM SIGN AB TIMES N...
+      | 0xF0 0x92 0x93..0x94 0x00..0xFF  #
+      | 0xF0 0x92 0x95 0x00..0x83        #
+      | 0xF0 0x93 0x80 0x80..0xFF        #Lo [1071] EGYPTIAN HIEROGLYPH A001...
+      | 0xF0 0x93 0x81..0x8F 0x00..0xFF  #
+      | 0xF0 0x93 0x90 0x00..0xAE        #
+      | 0xF0 0x94 0x90 0x80..0xFF        #Lo [583] ANATOLIAN HIEROGLYPH A001...
+      | 0xF0 0x94 0x91..0x98 0x00..0xFF  #
+      | 0xF0 0x94 0x99 0x00..0x86        #
+      | 0xF0 0x96 0xA0 0x80..0xFF        #Lo [569] BAMUM LETTER PHASE-A NGKU...
+      | 0xF0 0x96 0xA1..0xA7 0x00..0xFF  #
+      | 0xF0 0x96 0xA8 0x00..0xB8        #
+      | 0xF0 0x96 0xA9 0x80..0x9E  #Lo  [31] MRO LETTER TA..MRO LETTER TEK
+      | 0xF0 0x96 0xA9 0xA0..0xA9  #Nd  [10] MRO DIGIT ZERO..MRO DIGIT NINE
+      | 0xF0 0x96 0xAB 0x90..0xAD  #Lo  [30] BASSA VAH LETTER ENNI..BASSA VA...
+      | 0xF0 0x96 0xAB 0xB0..0xB4  #Mn   [5] BASSA VAH COMBINING HIGH TONE.....
+      | 0xF0 0x96 0xAC 0x80..0xAF  #Lo  [48] PAHAWH HMONG VOWEL KEEB..PAHAWH...
+      | 0xF0 0x96 0xAC 0xB0..0xB6  #Mn   [7] PAHAWH HMONG MARK CIM TUB..PAHA...
+      | 0xF0 0x96 0xAD 0x80..0x83  #Lm   [4] PAHAWH HMONG SIGN VOS SEEV..PAH...
+      | 0xF0 0x96 0xAD 0x90..0x99  #Nd  [10] PAHAWH HMONG DIGIT ZERO..PAHAWH...
+      | 0xF0 0x96 0xAD 0xA3..0xB7  #Lo  [21] PAHAWH HMONG SIGN VOS LUB..PAHA...
+      | 0xF0 0x96 0xAD 0xBD..0xFF  #Lo  [19] PAHAWH HMONG CLAN SIGN TSHEEJ.....
+      | 0xF0 0x96 0xAE 0x00..0x8F  #
+      | 0xF0 0x96 0xBC 0x80..0xFF  #Lo  [69] MIAO LETTER PA..MIAO LETTER HHA
+      | 0xF0 0x96 0xBD 0x00..0x84  #
+      | 0xF0 0x96 0xBD 0x90     #Lo       MIAO LETTER NASALIZATION
+      | 0xF0 0x96 0xBD 0x91..0xBE  #Mc  [46] MIAO SIGN ASPIRATION..MIAO VOWE...
+      | 0xF0 0x96 0xBE 0x8F..0x92  #Mn   [4] MIAO TONE RIGHT..MIAO TONE BELOW
+      | 0xF0 0x96 0xBE 0x93..0x9F  #Lm  [13] MIAO LETTER TONE-2..MIAO LETTER...
+      | 0xF0 0x96 0xBF 0xA0     #Lm       TANGUT ITERATION MARK
+      | 0xF0 0x97 0x80 0x80..0xFF        #Lo [6125] TANGUT IDEOGRAPH-17000.....
+      | 0xF0 0x97 0x81..0xFF 0x00..0xFF  #
+      | 0xF0 0x98 0x00 0x00..0xFF        #
+      | 0xF0 0x98 0x01..0x9E 0x00..0xFF  #
+      | 0xF0 0x98 0x9F 0x00..0xAC        #
+      | 0xF0 0x98 0xA0 0x80..0xFF        #Lo [755] TANGUT COMPONENT-001..TAN...
+      | 0xF0 0x98 0xA1..0xAA 0x00..0xFF  #
+      | 0xF0 0x98 0xAB 0x00..0xB2        #
+      | 0xF0 0x9B 0x80 0x80..0x81  #Lo   [2] KATAKANA LETTER ARCHAIC E..HIRA...
+      | 0xF0 0x9B 0xB0 0x80..0xFF  #Lo [107] DUPLOYAN LETTER H..DUPLOYAN LET...
+      | 0xF0 0x9B 0xB1 0x00..0xAA  #
+      | 0xF0 0x9B 0xB1 0xB0..0xBC  #Lo  [13] DUPLOYAN AFFIX LEFT HORIZONTAL ...
+      | 0xF0 0x9B 0xB2 0x80..0x88  #Lo   [9] DUPLOYAN AFFIX HIGH ACUTE..DUPL...
+      | 0xF0 0x9B 0xB2 0x90..0x99  #Lo  [10] DUPLOYAN AFFIX LOW ACUTE..DUPLO...
+      | 0xF0 0x9B 0xB2 0x9D..0x9E  #Mn   [2] DUPLOYAN THICK LETTER SELECTOR....
+      | 0xF0 0x9D 0x85 0xA5..0xA6  #Mc   [2] MUSICAL SYMBOL COMBINING STEM.....
+      | 0xF0 0x9D 0x85 0xA7..0xA9  #Mn   [3] MUSICAL SYMBOL COMBINING TREMOL...
+      | 0xF0 0x9D 0x85 0xAD..0xB2  #Mc   [6] MUSICAL SYMBOL COMBINING AUGMEN...
+      | 0xF0 0x9D 0x85 0xBB..0xFF  #Mn   [8] MUSICAL SYMBOL COMBINING ACCENT...
+      | 0xF0 0x9D 0x86 0x00..0x82  #
+      | 0xF0 0x9D 0x86 0x85..0x8B  #Mn   [7] MUSICAL SYMBOL COMBINING DOIT.....
+      | 0xF0 0x9D 0x86 0xAA..0xAD  #Mn   [4] MUSICAL SYMBOL COMBINING DOWN B...
+      | 0xF0 0x9D 0x89 0x82..0x84  #Mn   [3] COMBINING GREEK MUSICAL TRISEME...
+      | 0xF0 0x9D 0x90 0x80..0xFF  #L&  [85] MATHEMATICAL BOLD CAPITAL A..MA...
+      | 0xF0 0x9D 0x91 0x00..0x94  #
+      | 0xF0 0x9D 0x91 0x96..0xFF  #L&  [71] MATHEMATICAL ITALIC SMALL I..MA...
+      | 0xF0 0x9D 0x92 0x00..0x9C  #
+      | 0xF0 0x9D 0x92 0x9E..0x9F  #L&   [2] MATHEMATICAL SCRIPT CAPITAL C.....
+      | 0xF0 0x9D 0x92 0xA2     #L&       MATHEMATICAL SCRIPT CAPITAL G
+      | 0xF0 0x9D 0x92 0xA5..0xA6  #L&   [2] MATHEMATICAL SCRIPT CAPITAL J.....
+      | 0xF0 0x9D 0x92 0xA9..0xAC  #L&   [4] MATHEMATICAL SCRIPT CAPITAL N.....
+      | 0xF0 0x9D 0x92 0xAE..0xB9  #L&  [12] MATHEMATICAL SCRIPT CAPITAL S.....
+      | 0xF0 0x9D 0x92 0xBB     #L&       MATHEMATICAL SCRIPT SMALL F
+      | 0xF0 0x9D 0x92 0xBD..0xFF  #L&   [7] MATHEMATICAL SCRIPT SMALL H..MA...
+      | 0xF0 0x9D 0x93 0x00..0x83  #
+      | 0xF0 0x9D 0x93 0x85..0xFF  #L&  [65] MATHEMATICAL SCRIPT SMALL P..MA...
+      | 0xF0 0x9D 0x94 0x00..0x85  #
+      | 0xF0 0x9D 0x94 0x87..0x8A  #L&   [4] MATHEMATICAL FRAKTUR CAPITAL D....
+      | 0xF0 0x9D 0x94 0x8D..0x94  #L&   [8] MATHEMATICAL FRAKTUR CAPITAL J....
+      | 0xF0 0x9D 0x94 0x96..0x9C  #L&   [7] MATHEMATICAL FRAKTUR CAPITAL S....
+      | 0xF0 0x9D 0x94 0x9E..0xB9  #L&  [28] MATHEMATICAL FRAKTUR SMALL A..M...
+      | 0xF0 0x9D 0x94 0xBB..0xBE  #L&   [4] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x80..0x84  #L&   [5] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x86     #L&       MATHEMATICAL DOUBLE-STRUCK CAPITAL O
+      | 0xF0 0x9D 0x95 0x8A..0x90  #L&   [7] MATHEMATICAL DOUBLE-STRUCK CAPI...
+      | 0xF0 0x9D 0x95 0x92..0xFF        #L& [340] MATHEMATICAL DOUBLE-STRUC...
+      | 0xF0 0x9D 0x96..0x99 0x00..0xFF  #
+      | 0xF0 0x9D 0x9A 0x00..0xA5        #
+      | 0xF0 0x9D 0x9A 0xA8..0xFF  #L&  [25] MATHEMATICAL BOLD CAPITAL ALPHA...
+      | 0xF0 0x9D 0x9B 0x00..0x80  #
+      | 0xF0 0x9D 0x9B 0x82..0x9A  #L&  [25] MATHEMATICAL BOLD SMALL ALPHA.....
+      | 0xF0 0x9D 0x9B 0x9C..0xBA  #L&  [31] MATHEMATICAL BOLD EPSILON SYMBO...
+      | 0xF0 0x9D 0x9B 0xBC..0xFF  #L&  [25] MATHEMATICAL ITALIC SMALL ALPHA...
+      | 0xF0 0x9D 0x9C 0x00..0x94  #
+      | 0xF0 0x9D 0x9C 0x96..0xB4  #L&  [31] MATHEMATICAL ITALIC EPSILON SYM...
+      | 0xF0 0x9D 0x9C 0xB6..0xFF  #L&  [25] MATHEMATICAL BOLD ITALIC SMALL ...
+      | 0xF0 0x9D 0x9D 0x00..0x8E  #
+      | 0xF0 0x9D 0x9D 0x90..0xAE  #L&  [31] MATHEMATICAL BOLD ITALIC EPSILO...
+      | 0xF0 0x9D 0x9D 0xB0..0xFF  #L&  [25] MATHEMATICAL SANS-SERIF BOLD SM...
+      | 0xF0 0x9D 0x9E 0x00..0x88  #
+      | 0xF0 0x9D 0x9E 0x8A..0xA8  #L&  [31] MATHEMATICAL SANS-SERIF BOLD EP...
+      | 0xF0 0x9D 0x9E 0xAA..0xFF  #L&  [25] MATHEMATICAL SANS-SERIF BOLD IT...
+      | 0xF0 0x9D 0x9F 0x00..0x82  #
+      | 0xF0 0x9D 0x9F 0x84..0x8B  #L&   [8] MATHEMATICAL SANS-SERIF BOLD IT...
+      | 0xF0 0x9D 0x9F 0x8E..0xBF  #Nd  [50] MATHEMATICAL BOLD DIGIT ZERO..M...
+      | 0xF0 0x9D 0xA8 0x80..0xB6  #Mn  [55] SIGNWRITING HEAD RIM..SIGNWRITI...
+      | 0xF0 0x9D 0xA8 0xBB..0xFF  #Mn  [50] SIGNWRITING MOUTH CLOSED NEUTRA...
+      | 0xF0 0x9D 0xA9 0x00..0xAC  #
+      | 0xF0 0x9D 0xA9 0xB5     #Mn       SIGNWRITING UPPER BODY TILTING FRO...
+      | 0xF0 0x9D 0xAA 0x84     #Mn       SIGNWRITING LOCATION HEAD NECK
+      | 0xF0 0x9D 0xAA 0x9B..0x9F  #Mn   [5] SIGNWRITING FILL MODIFIER-2..SI...
+      | 0xF0 0x9D 0xAA 0xA1..0xAF  #Mn  [15] SIGNWRITING ROTATION MODIFIER-2...
+      | 0xF0 0x9E 0x80 0x80..0x86  #Mn   [7] COMBINING GLAGOLITIC LETTER AZU...
+      | 0xF0 0x9E 0x80 0x88..0x98  #Mn  [17] COMBINING GLAGOLITIC LETTER ZEM...
+      | 0xF0 0x9E 0x80 0x9B..0xA1  #Mn   [7] COMBINING GLAGOLITIC LETTER SHT...
+      | 0xF0 0x9E 0x80 0xA3..0xA4  #Mn   [2] COMBINING GLAGOLITIC LETTER YU....
+      | 0xF0 0x9E 0x80 0xA6..0xAA  #Mn   [5] COMBINING GLAGOLITIC LETTER YO....
+      | 0xF0 0x9E 0xA0 0x80..0xFF        #Lo [197] MENDE KIKAKUI SYLLABLE M0...
+      | 0xF0 0x9E 0xA1..0xA2 0x00..0xFF  #
+      | 0xF0 0x9E 0xA3 0x00..0x84        #
+      | 0xF0 0x9E 0xA3 0x90..0x96  #Mn   [7] MENDE KIKAKUI COMBINING NUMBER ...
+      | 0xF0 0x9E 0xA4 0x80..0xFF  #L&  [68] ADLAM CAPITAL LETTER ALIF..ADLA...
+      | 0xF0 0x9E 0xA5 0x00..0x83  #
+      | 0xF0 0x9E 0xA5 0x84..0x8A  #Mn   [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA
+      | 0xF0 0x9E 0xA5 0x90..0x99  #Nd  [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE
+      | 0xF0 0x9E 0xB8 0x80..0x83  #Lo   [4] ARABIC MATHEMATICAL ALEF..ARABI...
+      | 0xF0 0x9E 0xB8 0x85..0x9F  #Lo  [27] ARABIC MATHEMATICAL WAW..ARABIC...
+      | 0xF0 0x9E 0xB8 0xA1..0xA2  #Lo   [2] ARABIC MATHEMATICAL INITIAL BEH...
+      | 0xF0 0x9E 0xB8 0xA4     #Lo       ARABIC MATHEMATICAL INITIAL HEH
+      | 0xF0 0x9E 0xB8 0xA7     #Lo       ARABIC MATHEMATICAL INITIAL HAH
+      | 0xF0 0x9E 0xB8 0xA9..0xB2  #Lo  [10] ARABIC MATHEMATICAL INITIAL YEH...
+      | 0xF0 0x9E 0xB8 0xB4..0xB7  #Lo   [4] ARABIC MATHEMATICAL INITIAL SHE...
+      | 0xF0 0x9E 0xB8 0xB9     #Lo       ARABIC MATHEMATICAL INITIAL DAD
+      | 0xF0 0x9E 0xB8 0xBB     #Lo       ARABIC MATHEMATICAL INITIAL GHAIN
+      | 0xF0 0x9E 0xB9 0x82     #Lo       ARABIC MATHEMATICAL TAILED JEEM
+      | 0xF0 0x9E 0xB9 0x87     #Lo       ARABIC MATHEMATICAL TAILED HAH
+      | 0xF0 0x9E 0xB9 0x89     #Lo       ARABIC MATHEMATICAL TAILED YEH
+      | 0xF0 0x9E 0xB9 0x8B     #Lo       ARABIC MATHEMATICAL TAILED LAM
+      | 0xF0 0x9E 0xB9 0x8D..0x8F  #Lo   [3] ARABIC MATHEMATICAL TAILED NOON...
+      | 0xF0 0x9E 0xB9 0x91..0x92  #Lo   [2] ARABIC MATHEMATICAL TAILED SAD....
+      | 0xF0 0x9E 0xB9 0x94     #Lo       ARABIC MATHEMATICAL TAILED SHEEN
+      | 0xF0 0x9E 0xB9 0x97     #Lo       ARABIC MATHEMATICAL TAILED KHAH
+      | 0xF0 0x9E 0xB9 0x99     #Lo       ARABIC MATHEMATICAL TAILED DAD
+      | 0xF0 0x9E 0xB9 0x9B     #Lo       ARABIC MATHEMATICAL TAILED GHAIN
+      | 0xF0 0x9E 0xB9 0x9D     #Lo       ARABIC MATHEMATICAL TAILED DOTLESS...
+      | 0xF0 0x9E 0xB9 0x9F     #Lo       ARABIC MATHEMATICAL TAILED DOTLESS...
+      | 0xF0 0x9E 0xB9 0xA1..0xA2  #Lo   [2] ARABIC MATHEMATICAL STRETCHED B...
+      | 0xF0 0x9E 0xB9 0xA4     #Lo       ARABIC MATHEMATICAL STRETCHED HEH
+      | 0xF0 0x9E 0xB9 0xA7..0xAA  #Lo   [4] ARABIC MATHEMATICAL STRETCHED H...
+      | 0xF0 0x9E 0xB9 0xAC..0xB2  #Lo   [7] ARABIC MATHEMATICAL STRETCHED M...
+      | 0xF0 0x9E 0xB9 0xB4..0xB7  #Lo   [4] ARABIC MATHEMATICAL STRETCHED S...
+      | 0xF0 0x9E 0xB9 0xB9..0xBC  #Lo   [4] ARABIC MATHEMATICAL STRETCHED D...
+      | 0xF0 0x9E 0xB9 0xBE     #Lo       ARABIC MATHEMATICAL STRETCHED DOTL...
+      | 0xF0 0x9E 0xBA 0x80..0x89  #Lo  [10] ARABIC MATHEMATICAL LOOPED ALEF...
+      | 0xF0 0x9E 0xBA 0x8B..0x9B  #Lo  [17] ARABIC MATHEMATICAL LOOPED LAM....
+      | 0xF0 0x9E 0xBA 0xA1..0xA3  #Lo   [3] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0x9E 0xBA 0xA5..0xA9  #Lo   [5] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0x9E 0xBA 0xAB..0xBB  #Lo  [17] ARABIC MATHEMATICAL DOUBLE-STRU...
+      | 0xF0 0xA0 0x80 0x80..0xFF              #Lo [42711] CJK UNIFIED IDEOG...
+      | 0xF0 0xA0 0x81..0xFF 0x00..0xFF        #
+      | 0xF0 0xA1..0xA9 0x00..0xFF 0x00..0xFF  #
+      | 0xF0 0xAA 0x00 0x00..0xFF              #
+      | 0xF0 0xAA 0x01..0x9A 0x00..0xFF        #
+      | 0xF0 0xAA 0x9B 0x00..0x96              #
+      | 0xF0 0xAA 0x9C 0x80..0xFF        #Lo [4149] CJK UNIFIED IDEOGRAPH-2A...
+      | 0xF0 0xAA 0x9D..0xFF 0x00..0xFF  #
+      | 0xF0 0xAB 0x00 0x00..0xFF        #
+      | 0xF0 0xAB 0x01..0x9B 0x00..0xFF  #
+      | 0xF0 0xAB 0x9C 0x00..0xB4        #
+      | 0xF0 0xAB 0x9D 0x80..0xFF        #Lo [222] CJK UNIFIED IDEOGRAPH-2B7...
+      | 0xF0 0xAB 0x9E..0x9F 0x00..0xFF  #
+      | 0xF0 0xAB 0xA0 0x00..0x9D        #
+      | 0xF0 0xAB 0xA0 0xA0..0xFF        #Lo [5762] CJK UNIFIED IDEOGRAPH-2B...
+      | 0xF0 0xAB 0xA1..0xFF 0x00..0xFF  #
+      | 0xF0 0xAC 0x00 0x00..0xFF        #
+      | 0xF0 0xAC 0x01..0xB9 0x00..0xFF  #
+      | 0xF0 0xAC 0xBA 0x00..0xA1        #
+      | 0xF0 0xAF 0xA0 0x80..0xFF        #Lo [542] CJK COMPATIBILITY IDEOGRA...
+      | 0xF0 0xAF 0xA1..0xA7 0x00..0xFF  #
+      | 0xF0 0xAF 0xA8 0x00..0x9D        #
+      | 0xF3 0xA0 0x84 0x80..0xFF        #Mn [240] VARIATION SELECTOR-17..VA...
+      | 0xF3 0xA0 0x85..0x86 0x00..0xFF  #
+      | 0xF3 0xA0 0x87 0x00..0xAF        #
+      ;
+
+}%%
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/variables.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/variables.go
new file mode 100644
index 000000000..3d68c4139
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/variables.go
@@ -0,0 +1,86 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// Variables returns all of the variables referenced within a given experssion.
+//
+// This is the implementation of the "Variables" method on every native
+// expression.
+func Variables(expr Expression) []hcl.Traversal {
+	var vars []hcl.Traversal
+
+	walker := &variablesWalker{
+		Callback: func(t hcl.Traversal) {
+			vars = append(vars, t)
+		},
+	}
+
+	Walk(expr, walker)
+
+	return vars
+}
+
+// variablesWalker is a Walker implementation that calls its callback for any
+// root scope traversal found while walking.
+type variablesWalker struct {
+	Callback    func(hcl.Traversal)
+	localScopes []map[string]struct{}
+}
+
+func (w *variablesWalker) Enter(n Node) hcl.Diagnostics {
+	switch tn := n.(type) {
+	case *ScopeTraversalExpr:
+		t := tn.Traversal
+
+		// Check if the given root name appears in any of the active
+		// local scopes. We don't want to return local variables here, since
+		// the goal of walking variables is to tell the calling application
+		// which names it needs to populate in the _root_ scope.
+		name := t.RootName()
+		for _, names := range w.localScopes {
+			if _, localized := names[name]; localized {
+				return nil
+			}
+		}
+
+		w.Callback(t)
+	case ChildScope:
+		w.localScopes = append(w.localScopes, tn.LocalNames)
+	}
+	return nil
+}
+
+func (w *variablesWalker) Exit(n Node) hcl.Diagnostics {
+	switch n.(type) {
+	case ChildScope:
+		// pop the latest local scope, assuming that the walker will
+		// behave symmetrically as promised.
+		w.localScopes = w.localScopes[:len(w.localScopes)-1]
+	}
+	return nil
+}
+
+// ChildScope is a synthetic AST node that is visited during a walk to
+// indicate that its descendent will be evaluated in a child scope, which
+// may mask certain variables from the parent scope as locals.
+//
+// ChildScope nodes don't really exist in the AST, but are rather synthesized
+// on the fly during walk. Therefore it doesn't do any good to transform them;
+// instead, transform either parent node that created a scope or the expression
+// that the child scope struct wraps.
+type ChildScope struct {
+	LocalNames map[string]struct{}
+	Expr       Expression
+}
+
+func (e ChildScope) walkChildNodes(w internalWalkFunc) {
+	w(e.Expr)
+}
+
+// Range returns the range of the expression that the ChildScope is
+// encapsulating. It isn't really very useful to call Range on a ChildScope.
+func (e ChildScope) Range() hcl.Range {
+	return e.Expr.Range()
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclsyntax/walk.go b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/walk.go
new file mode 100644
index 000000000..89bfe676e
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclsyntax/walk.go
@@ -0,0 +1,41 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl/v2"
+)
+
+// VisitFunc is the callback signature for VisitAll.
+type VisitFunc func(node Node) hcl.Diagnostics
+
+// VisitAll is a basic way to traverse the AST beginning with a particular
+// node. The given function will be called once for each AST node in
+// depth-first order, but no context is provided about the shape of the tree.
+//
+// The VisitFunc may return diagnostics, in which case they will be accumulated
+// and returned as a single set.
+func VisitAll(node Node, f VisitFunc) hcl.Diagnostics {
+	diags := f(node)
+	node.walkChildNodes(func(node Node) {
+		diags = append(diags, VisitAll(node, f)...)
+	})
+	return diags
+}
+
+// Walker is an interface used with Walk.
+type Walker interface {
+	Enter(node Node) hcl.Diagnostics
+	Exit(node Node) hcl.Diagnostics
+}
+
+// Walk is a more complex way to traverse the AST starting with a particular
+// node, which provides information about the tree structure via separate
+// Enter and Exit functions.
+func Walk(node Node, w Walker) hcl.Diagnostics {
+	diags := w.Enter(node)
+	node.walkChildNodes(func(node Node) {
+		diags = append(diags, Walk(node, w)...)
+	})
+	moreDiags := w.Exit(node)
+	diags = append(diags, moreDiags...)
+	return diags
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast.go
new file mode 100644
index 000000000..090416528
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast.go
@@ -0,0 +1,121 @@
+package hclwrite
+
+import (
+	"bytes"
+	"io"
+)
+
+type File struct {
+	inTree
+
+	srcBytes []byte
+	body     *node
+}
+
+// NewEmptyFile constructs a new file with no content, ready to be mutated
+// by other calls that append to its body.
+func NewEmptyFile() *File {
+	f := &File{
+		inTree: newInTree(),
+	}
+	body := newBody()
+	f.body = f.children.Append(body)
+	return f
+}
+
+// Body returns the root body of the file, which contains the top-level
+// attributes and blocks.
+func (f *File) Body() *Body {
+	return f.body.content.(*Body)
+}
+
+// WriteTo writes the tokens underlying the receiving file to the given writer.
+//
+// The tokens first have a simple formatting pass applied that adjusts only
+// the spaces between them.
+func (f *File) WriteTo(wr io.Writer) (int64, error) {
+	tokens := f.inTree.children.BuildTokens(nil)
+	format(tokens)
+	return tokens.WriteTo(wr)
+}
+
+// Bytes returns a buffer containing the source code resulting from the
+// tokens underlying the receiving file. If any updates have been made via
+// the AST API, these will be reflected in the result.
+func (f *File) Bytes() []byte {
+	buf := &bytes.Buffer{}
+	f.WriteTo(buf)
+	return buf.Bytes()
+}
+
+type comments struct {
+	leafNode
+
+	parent *node
+	tokens Tokens
+}
+
+func newComments(tokens Tokens) *comments {
+	return &comments{
+		tokens: tokens,
+	}
+}
+
+func (c *comments) BuildTokens(to Tokens) Tokens {
+	return c.tokens.BuildTokens(to)
+}
+
+type identifier struct {
+	leafNode
+
+	parent *node
+	token  *Token
+}
+
+func newIdentifier(token *Token) *identifier {
+	return &identifier{
+		token: token,
+	}
+}
+
+func (i *identifier) BuildTokens(to Tokens) Tokens {
+	return append(to, i.token)
+}
+
+func (i *identifier) hasName(name string) bool {
+	return name == string(i.token.Bytes)
+}
+
+type number struct {
+	leafNode
+
+	parent *node
+	token  *Token
+}
+
+func newNumber(token *Token) *number {
+	return &number{
+		token: token,
+	}
+}
+
+func (n *number) BuildTokens(to Tokens) Tokens {
+	return append(to, n.token)
+}
+
+type quoted struct {
+	leafNode
+
+	parent *node
+	tokens Tokens
+}
+
+func newQuoted(tokens Tokens) *quoted {
+	return &quoted{
+		tokens: tokens,
+	}
+}
+
+func (q *quoted) BuildTokens(to Tokens) Tokens {
+	return q.tokens.BuildTokens(to)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_attribute.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_attribute.go
new file mode 100644
index 000000000..609419fff
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_attribute.go
@@ -0,0 +1,48 @@
+package hclwrite
+
+import (
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+type Attribute struct {
+	inTree
+
+	leadComments *node
+	name         *node
+	expr         *node
+	lineComments *node
+}
+
+func newAttribute() *Attribute {
+	return &Attribute{
+		inTree: newInTree(),
+	}
+}
+
+func (a *Attribute) init(name string, expr *Expression) {
+	expr.assertUnattached()
+
+	nameTok := newIdentToken(name)
+	nameObj := newIdentifier(nameTok)
+	a.leadComments = a.children.Append(newComments(nil))
+	a.name = a.children.Append(nameObj)
+	a.children.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenEqual,
+			Bytes: []byte{'='},
+		},
+	})
+	a.expr = a.children.Append(expr)
+	a.expr.list = a.children
+	a.lineComments = a.children.Append(newComments(nil))
+	a.children.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenNewline,
+			Bytes: []byte{'\n'},
+		},
+	})
+}
+
+func (a *Attribute) Expr() *Expression {
+	return a.expr.content.(*Expression)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_block.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_block.go
new file mode 100644
index 000000000..f7d3921b4
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_block.go
@@ -0,0 +1,118 @@
+package hclwrite
+
+import (
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type Block struct {
+	inTree
+
+	leadComments *node
+	typeName     *node
+	labels       nodeSet
+	open         *node
+	body         *node
+	close        *node
+}
+
+func newBlock() *Block {
+	return &Block{
+		inTree: newInTree(),
+		labels: newNodeSet(),
+	}
+}
+
+// NewBlock constructs a new, empty block with the given type name and labels.
+func NewBlock(typeName string, labels []string) *Block {
+	block := newBlock()
+	block.init(typeName, labels)
+	return block
+}
+
+func (b *Block) init(typeName string, labels []string) {
+	nameTok := newIdentToken(typeName)
+	nameObj := newIdentifier(nameTok)
+	b.leadComments = b.children.Append(newComments(nil))
+	b.typeName = b.children.Append(nameObj)
+	for _, label := range labels {
+		labelToks := TokensForValue(cty.StringVal(label))
+		labelObj := newQuoted(labelToks)
+		labelNode := b.children.Append(labelObj)
+		b.labels.Add(labelNode)
+	}
+	b.open = b.children.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenOBrace,
+			Bytes: []byte{'{'},
+		},
+		{
+			Type:  hclsyntax.TokenNewline,
+			Bytes: []byte{'\n'},
+		},
+	})
+	body := newBody() // initially totally empty; caller can append to it subsequently
+	b.body = b.children.Append(body)
+	b.close = b.children.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenCBrace,
+			Bytes: []byte{'}'},
+		},
+		{
+			Type:  hclsyntax.TokenNewline,
+			Bytes: []byte{'\n'},
+		},
+	})
+}
+
+// Body returns the body that represents the content of the receiving block.
+//
+// Appending to or otherwise modifying this body will make changes to the
+// tokens that are generated between the blocks open and close braces.
+func (b *Block) Body() *Body {
+	return b.body.content.(*Body)
+}
+
+// Type returns the type name of the block.
+func (b *Block) Type() string {
+	typeNameObj := b.typeName.content.(*identifier)
+	return string(typeNameObj.token.Bytes)
+}
+
+// Labels returns the labels of the block.
+func (b *Block) Labels() []string {
+	labelNames := make([]string, 0, len(b.labels))
+	list := b.labels.List()
+
+	for _, label := range list {
+		switch labelObj := label.content.(type) {
+		case *identifier:
+			if labelObj.token.Type == hclsyntax.TokenIdent {
+				labelString := string(labelObj.token.Bytes)
+				labelNames = append(labelNames, labelString)
+			}
+
+		case *quoted:
+			tokens := labelObj.tokens
+			if len(tokens) == 3 &&
+				tokens[0].Type == hclsyntax.TokenOQuote &&
+				tokens[1].Type == hclsyntax.TokenQuotedLit &&
+				tokens[2].Type == hclsyntax.TokenCQuote {
+				// Note that TokenQuotedLit may contain escape sequences.
+				labelString, diags := hclsyntax.ParseStringLiteralToken(tokens[1].asHCLSyntax())
+
+				// If parsing the string literal returns error diagnostics
+				// then we can just assume the label doesn't match, because it's invalid in some way.
+				if !diags.HasErrors() {
+					labelNames = append(labelNames, labelString)
+				}
+			}
+
+		default:
+			// If neither of the previous cases are true (should be impossible)
+			// then we can just ignore it, because it's invalid too.
+		}
+	}
+
+	return labelNames
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_body.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_body.go
new file mode 100644
index 000000000..c16d13e3a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_body.go
@@ -0,0 +1,219 @@
+package hclwrite
+
+import (
+	"reflect"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type Body struct {
+	inTree
+
+	items nodeSet
+}
+
+func newBody() *Body {
+	return &Body{
+		inTree: newInTree(),
+		items:  newNodeSet(),
+	}
+}
+
+func (b *Body) appendItem(c nodeContent) *node {
+	nn := b.children.Append(c)
+	b.items.Add(nn)
+	return nn
+}
+
+func (b *Body) appendItemNode(nn *node) *node {
+	nn.assertUnattached()
+	b.children.AppendNode(nn)
+	b.items.Add(nn)
+	return nn
+}
+
+// Clear removes all of the items from the body, making it empty.
+func (b *Body) Clear() {
+	b.children.Clear()
+}
+
+func (b *Body) AppendUnstructuredTokens(ts Tokens) {
+	b.inTree.children.Append(ts)
+}
+
+// Attributes returns a new map of all of the attributes in the body, with
+// the attribute names as the keys.
+func (b *Body) Attributes() map[string]*Attribute {
+	ret := make(map[string]*Attribute)
+	for n := range b.items {
+		if attr, isAttr := n.content.(*Attribute); isAttr {
+			nameObj := attr.name.content.(*identifier)
+			name := string(nameObj.token.Bytes)
+			ret[name] = attr
+		}
+	}
+	return ret
+}
+
+// Blocks returns a new slice of all the blocks in the body.
+func (b *Body) Blocks() []*Block {
+	ret := make([]*Block, 0, len(b.items))
+	for n := range b.items {
+		if block, isBlock := n.content.(*Block); isBlock {
+			ret = append(ret, block)
+		}
+	}
+	return ret
+}
+
+// GetAttribute returns the attribute from the body that has the given name,
+// or returns nil if there is currently no matching attribute.
+func (b *Body) GetAttribute(name string) *Attribute {
+	for n := range b.items {
+		if attr, isAttr := n.content.(*Attribute); isAttr {
+			nameObj := attr.name.content.(*identifier)
+			if nameObj.hasName(name) {
+				// We've found it!
+				return attr
+			}
+		}
+	}
+
+	return nil
+}
+
+// getAttributeNode is like GetAttribute but it returns the node containing
+// the selected attribute (if one is found) rather than the attribute itself.
+func (b *Body) getAttributeNode(name string) *node {
+	for n := range b.items {
+		if attr, isAttr := n.content.(*Attribute); isAttr {
+			nameObj := attr.name.content.(*identifier)
+			if nameObj.hasName(name) {
+				// We've found it!
+				return n
+			}
+		}
+	}
+
+	return nil
+}
+
+// FirstMatchingBlock returns a first matching block from the body that has the
+// given name and labels or returns nil if there is currently no matching
+// block.
+func (b *Body) FirstMatchingBlock(typeName string, labels []string) *Block {
+	for _, block := range b.Blocks() {
+		if typeName == block.Type() {
+			labelNames := block.Labels()
+			if len(labels) == 0 && len(labelNames) == 0 {
+				return block
+			}
+			if reflect.DeepEqual(labels, labelNames) {
+				return block
+			}
+		}
+	}
+
+	return nil
+}
+
+// RemoveBlock removes the given block from the body, if it's in that body.
+// If it isn't present, this is a no-op.
+//
+// Returns true if it removed something, or false otherwise.
+func (b *Body) RemoveBlock(block *Block) bool {
+	for n := range b.items {
+		if n.content == block {
+			n.Detach()
+			b.items.Remove(n)
+			return true
+		}
+	}
+	return false
+}
+
+// SetAttributeValue either replaces the expression of an existing attribute
+// of the given name or adds a new attribute definition to the end of the block.
+//
+// The value is given as a cty.Value, and must therefore be a literal. To set
+// a variable reference or other traversal, use SetAttributeTraversal.
+//
+// The return value is the attribute that was either modified in-place or
+// created.
+func (b *Body) SetAttributeValue(name string, val cty.Value) *Attribute {
+	attr := b.GetAttribute(name)
+	expr := NewExpressionLiteral(val)
+	if attr != nil {
+		attr.expr = attr.expr.ReplaceWith(expr)
+	} else {
+		attr := newAttribute()
+		attr.init(name, expr)
+		b.appendItem(attr)
+	}
+	return attr
+}
+
+// SetAttributeTraversal either replaces the expression of an existing attribute
+// of the given name or adds a new attribute definition to the end of the body.
+//
+// The new expression is given as a hcl.Traversal, which must be an absolute
+// traversal. To set a literal value, use SetAttributeValue.
+//
+// The return value is the attribute that was either modified in-place or
+// created.
+func (b *Body) SetAttributeTraversal(name string, traversal hcl.Traversal) *Attribute {
+	attr := b.GetAttribute(name)
+	expr := NewExpressionAbsTraversal(traversal)
+	if attr != nil {
+		attr.expr = attr.expr.ReplaceWith(expr)
+	} else {
+		attr := newAttribute()
+		attr.init(name, expr)
+		b.appendItem(attr)
+	}
+	return attr
+}
+
+// RemoveAttribute removes the attribute with the given name from the body.
+//
+// The return value is the attribute that was removed, or nil if there was
+// no such attribute (in which case the call was a no-op).
+func (b *Body) RemoveAttribute(name string) *Attribute {
+	node := b.getAttributeNode(name)
+	if node == nil {
+		return nil
+	}
+	node.Detach()
+	b.items.Remove(node)
+	return node.content.(*Attribute)
+}
+
+// AppendBlock appends an existing block (which must not be already attached
+// to a body) to the end of the receiving body.
+func (b *Body) AppendBlock(block *Block) *Block {
+	b.appendItem(block)
+	return block
+}
+
+// AppendNewBlock appends a new nested block to the end of the receiving body
+// with the given type name and labels.
+func (b *Body) AppendNewBlock(typeName string, labels []string) *Block {
+	block := newBlock()
+	block.init(typeName, labels)
+	b.appendItem(block)
+	return block
+}
+
+// AppendNewline appends a newline token to th end of the receiving body,
+// which generally serves as a separator between different sets of body
+// contents.
+func (b *Body) AppendNewline() {
+	b.AppendUnstructuredTokens(Tokens{
+		{
+			Type:  hclsyntax.TokenNewline,
+			Bytes: []byte{'\n'},
+		},
+	})
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_expression.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_expression.go
new file mode 100644
index 000000000..854e71690
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/ast_expression.go
@@ -0,0 +1,201 @@
+package hclwrite
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+type Expression struct {
+	inTree
+
+	absTraversals nodeSet
+}
+
+func newExpression() *Expression {
+	return &Expression{
+		inTree:        newInTree(),
+		absTraversals: newNodeSet(),
+	}
+}
+
+// NewExpressionLiteral constructs an an expression that represents the given
+// literal value.
+//
+// Since an unknown value cannot be represented in source code, this function
+// will panic if the given value is unknown or contains a nested unknown value.
+// Use val.IsWhollyKnown before calling to be sure.
+//
+// HCL native syntax does not directly represent lists, maps, and sets, and
+// instead relies on the automatic conversions to those collection types from
+// either list or tuple constructor syntax. Therefore converting collection
+// values to source code and re-reading them will lose type information, and
+// the reader must provide a suitable type at decode time to recover the
+// original value.
+func NewExpressionLiteral(val cty.Value) *Expression {
+	toks := TokensForValue(val)
+	expr := newExpression()
+	expr.children.AppendUnstructuredTokens(toks)
+	return expr
+}
+
+// NewExpressionAbsTraversal constructs an expression that represents the
+// given traversal, which must be absolute or this function will panic.
+func NewExpressionAbsTraversal(traversal hcl.Traversal) *Expression {
+	if traversal.IsRelative() {
+		panic("can't construct expression from relative traversal")
+	}
+
+	physT := newTraversal()
+	rootName := traversal.RootName()
+	steps := traversal[1:]
+
+	{
+		tn := newTraverseName()
+		tn.name = tn.children.Append(newIdentifier(&Token{
+			Type:  hclsyntax.TokenIdent,
+			Bytes: []byte(rootName),
+		}))
+		physT.steps.Add(physT.children.Append(tn))
+	}
+
+	for _, step := range steps {
+		switch ts := step.(type) {
+		case hcl.TraverseAttr:
+			tn := newTraverseName()
+			tn.children.AppendUnstructuredTokens(Tokens{
+				{
+					Type:  hclsyntax.TokenDot,
+					Bytes: []byte{'.'},
+				},
+			})
+			tn.name = tn.children.Append(newIdentifier(&Token{
+				Type:  hclsyntax.TokenIdent,
+				Bytes: []byte(ts.Name),
+			}))
+			physT.steps.Add(physT.children.Append(tn))
+		case hcl.TraverseIndex:
+			ti := newTraverseIndex()
+			ti.children.AppendUnstructuredTokens(Tokens{
+				{
+					Type:  hclsyntax.TokenOBrack,
+					Bytes: []byte{'['},
+				},
+			})
+			indexExpr := NewExpressionLiteral(ts.Key)
+			ti.key = ti.children.Append(indexExpr)
+			ti.children.AppendUnstructuredTokens(Tokens{
+				{
+					Type:  hclsyntax.TokenCBrack,
+					Bytes: []byte{']'},
+				},
+			})
+			physT.steps.Add(physT.children.Append(ti))
+		}
+	}
+
+	expr := newExpression()
+	expr.absTraversals.Add(expr.children.Append(physT))
+	return expr
+}
+
+// Variables returns the absolute traversals that exist within the receiving
+// expression.
+func (e *Expression) Variables() []*Traversal {
+	nodes := e.absTraversals.List()
+	ret := make([]*Traversal, len(nodes))
+	for i, node := range nodes {
+		ret[i] = node.content.(*Traversal)
+	}
+	return ret
+}
+
+// RenameVariablePrefix examines each of the absolute traversals in the
+// receiving expression to see if they have the given sequence of names as
+// a prefix prefix. If so, they are updated in place to have the given
+// replacement names instead of that prefix.
+//
+// This can be used to implement symbol renaming. The calling application can
+// visit all relevant expressions in its input and apply the same renaming
+// to implement a global symbol rename.
+//
+// The search and replacement traversals must be the same length, or this
+// method will panic. Only attribute access operations can be matched and
+// replaced. Index steps never match the prefix.
+func (e *Expression) RenameVariablePrefix(search, replacement []string) {
+	if len(search) != len(replacement) {
+		panic(fmt.Sprintf("search and replacement length mismatch (%d and %d)", len(search), len(replacement)))
+	}
+Traversals:
+	for node := range e.absTraversals {
+		traversal := node.content.(*Traversal)
+		if len(traversal.steps) < len(search) {
+			// If it's shorter then it can't have our prefix
+			continue
+		}
+
+		stepNodes := traversal.steps.List()
+		for i, name := range search {
+			step, isName := stepNodes[i].content.(*TraverseName)
+			if !isName {
+				continue Traversals // only name nodes can match
+			}
+			foundNameBytes := step.name.content.(*identifier).token.Bytes
+			if len(foundNameBytes) != len(name) {
+				continue Traversals
+			}
+			if string(foundNameBytes) != name {
+				continue Traversals
+			}
+		}
+
+		// If we get here then the prefix matched, so now we'll swap in
+		// the replacement strings.
+		for i, name := range replacement {
+			step := stepNodes[i].content.(*TraverseName)
+			token := step.name.content.(*identifier).token
+			token.Bytes = []byte(name)
+		}
+	}
+}
+
+// Traversal represents a sequence of variable, attribute, and/or index
+// operations.
+type Traversal struct {
+	inTree
+
+	steps nodeSet
+}
+
+func newTraversal() *Traversal {
+	return &Traversal{
+		inTree: newInTree(),
+		steps:  newNodeSet(),
+	}
+}
+
+type TraverseName struct {
+	inTree
+
+	name *node
+}
+
+func newTraverseName() *TraverseName {
+	return &TraverseName{
+		inTree: newInTree(),
+	}
+}
+
+type TraverseIndex struct {
+	inTree
+
+	key *node
+}
+
+func newTraverseIndex() *TraverseIndex {
+	return &TraverseIndex{
+		inTree: newInTree(),
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/doc.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/doc.go
new file mode 100644
index 000000000..56d5b7752
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/doc.go
@@ -0,0 +1,11 @@
+// Package hclwrite deals with the problem of generating HCL configuration
+// and of making specific surgical changes to existing HCL configurations.
+//
+// It operates at a different level of abstraction than the main HCL parser
+// and AST, since details such as the placement of comments and newlines
+// are preserved when unchanged.
+//
+// The hclwrite API follows a similar principle to XML/HTML DOM, allowing nodes
+// to be read out, created and inserted, etc. Nodes represent syntax constructs
+// rather than semantic concepts.
+package hclwrite
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/format.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/format.go
new file mode 100644
index 000000000..b94bee38d
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/format.go
@@ -0,0 +1,463 @@
+package hclwrite
+
+import (
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+var inKeyword = hclsyntax.Keyword([]byte{'i', 'n'})
+
+// placeholder token used when we don't have a token but we don't want
+// to pass a real "nil" and complicate things with nil pointer checks
+var nilToken = &Token{
+	Type:         hclsyntax.TokenNil,
+	Bytes:        []byte{},
+	SpacesBefore: 0,
+}
+
+// format rewrites tokens within the given sequence, in-place, to adjust the
+// whitespace around their content to achieve canonical formatting.
+func format(tokens Tokens) {
+	// Formatting is a multi-pass process. More details on the passes below,
+	// but this is the overview:
+	// - adjust the leading space on each line to create appropriate
+	//   indentation
+	// - adjust spaces between tokens in a single cell using a set of rules
+	// - adjust the leading space in the "assign" and "comment" cells on each
+	//   line to vertically align with neighboring lines.
+	// All of these steps operate in-place on the given tokens, so a caller
+	// may collect a flat sequence of all of the tokens underlying an AST
+	// and pass it here and we will then indirectly modify the AST itself.
+	// Formatting must change only whitespace. Specifically, that means
+	// changing the SpacesBefore attribute on a token while leaving the
+	// other token attributes unchanged.
+
+	lines := linesForFormat(tokens)
+	formatIndent(lines)
+	formatSpaces(lines)
+	formatCells(lines)
+}
+
+func formatIndent(lines []formatLine) {
+	// Our methodology for indents is to take the input one line at a time
+	// and count the bracketing delimiters on each line. If a line has a net
+	// increase in open brackets, we increase the indent level by one and
+	// remember how many new openers we had. If the line has a net _decrease_,
+	// we'll compare it to the most recent number of openers and decrease the
+	// dedent level by one each time we pass an indent level remembered
+	// earlier.
+	// The "indent stack" used here allows for us to recognize degenerate
+	// input where brackets are not symmetrical within lines and avoid
+	// pushing things too far left or right, creating confusion.
+
+	// We'll start our indent stack at a reasonable capacity to minimize the
+	// chance of us needing to grow it; 10 here means 10 levels of indent,
+	// which should be more than enough for reasonable HCL uses.
+	indents := make([]int, 0, 10)
+
+	for i := range lines {
+		line := &lines[i]
+		if len(line.lead) == 0 {
+			continue
+		}
+
+		if line.lead[0].Type == hclsyntax.TokenNewline {
+			// Never place spaces before a newline
+			line.lead[0].SpacesBefore = 0
+			continue
+		}
+
+		netBrackets := 0
+		for _, token := range line.lead {
+			netBrackets += tokenBracketChange(token)
+			if token.Type == hclsyntax.TokenOHeredoc {
+				break
+			}
+		}
+
+		for _, token := range line.assign {
+			netBrackets += tokenBracketChange(token)
+		}
+
+		switch {
+		case netBrackets > 0:
+			line.lead[0].SpacesBefore = 2 * len(indents)
+			indents = append(indents, netBrackets)
+		case netBrackets < 0:
+			closed := -netBrackets
+			for closed > 0 && len(indents) > 0 {
+				switch {
+
+				case closed > indents[len(indents)-1]:
+					closed -= indents[len(indents)-1]
+					indents = indents[:len(indents)-1]
+
+				case closed < indents[len(indents)-1]:
+					indents[len(indents)-1] -= closed
+					closed = 0
+
+				default:
+					indents = indents[:len(indents)-1]
+					closed = 0
+				}
+			}
+			line.lead[0].SpacesBefore = 2 * len(indents)
+		default:
+			line.lead[0].SpacesBefore = 2 * len(indents)
+		}
+	}
+}
+
+func formatSpaces(lines []formatLine) {
+	for _, line := range lines {
+		for i, token := range line.lead {
+			var before, after *Token
+			if i > 0 {
+				before = line.lead[i-1]
+			} else {
+				before = nilToken
+			}
+			if i < (len(line.lead) - 1) {
+				after = line.lead[i+1]
+			} else {
+				after = nilToken
+			}
+			if spaceAfterToken(token, before, after) {
+				after.SpacesBefore = 1
+			} else {
+				after.SpacesBefore = 0
+			}
+		}
+		for i, token := range line.assign {
+			if i == 0 {
+				// first token in "assign" always has one space before to
+				// separate the equals sign from what it's assigning.
+				token.SpacesBefore = 1
+			}
+
+			var before, after *Token
+			if i > 0 {
+				before = line.assign[i-1]
+			} else {
+				before = nilToken
+			}
+			if i < (len(line.assign) - 1) {
+				after = line.assign[i+1]
+			} else {
+				after = nilToken
+			}
+			if spaceAfterToken(token, before, after) {
+				after.SpacesBefore = 1
+			} else {
+				after.SpacesBefore = 0
+			}
+		}
+
+	}
+}
+
+func formatCells(lines []formatLine) {
+
+	chainStart := -1
+	maxColumns := 0
+
+	// We'll deal with the "assign" cell first, since moving that will
+	// also impact the "comment" cell.
+	closeAssignChain := func(i int) {
+		for _, chainLine := range lines[chainStart:i] {
+			columns := chainLine.lead.Columns()
+			spaces := (maxColumns - columns) + 1
+			chainLine.assign[0].SpacesBefore = spaces
+		}
+		chainStart = -1
+		maxColumns = 0
+	}
+	for i, line := range lines {
+		if line.assign == nil {
+			if chainStart != -1 {
+				closeAssignChain(i)
+			}
+		} else {
+			if chainStart == -1 {
+				chainStart = i
+			}
+			columns := line.lead.Columns()
+			if columns > maxColumns {
+				maxColumns = columns
+			}
+		}
+	}
+	if chainStart != -1 {
+		closeAssignChain(len(lines))
+	}
+
+	// Now we'll deal with the comments
+	closeCommentChain := func(i int) {
+		for _, chainLine := range lines[chainStart:i] {
+			columns := chainLine.lead.Columns() + chainLine.assign.Columns()
+			spaces := (maxColumns - columns) + 1
+			chainLine.comment[0].SpacesBefore = spaces
+		}
+		chainStart = -1
+		maxColumns = 0
+	}
+	for i, line := range lines {
+		if line.comment == nil {
+			if chainStart != -1 {
+				closeCommentChain(i)
+			}
+		} else {
+			if chainStart == -1 {
+				chainStart = i
+			}
+			columns := line.lead.Columns() + line.assign.Columns()
+			if columns > maxColumns {
+				maxColumns = columns
+			}
+		}
+	}
+	if chainStart != -1 {
+		closeCommentChain(len(lines))
+	}
+
+}
+
+// spaceAfterToken decides whether a particular subject token should have a
+// space after it when surrounded by the given before and after tokens.
+// "before" can be TokenNil, if the subject token is at the start of a sequence.
+func spaceAfterToken(subject, before, after *Token) bool {
+	switch {
+
+	case after.Type == hclsyntax.TokenNewline || after.Type == hclsyntax.TokenNil:
+		// Never add spaces before a newline
+		return false
+
+	case subject.Type == hclsyntax.TokenIdent && after.Type == hclsyntax.TokenOParen:
+		// Don't split a function name from open paren in a call
+		return false
+
+	case subject.Type == hclsyntax.TokenDot || after.Type == hclsyntax.TokenDot:
+		// Don't use spaces around attribute access dots
+		return false
+
+	case after.Type == hclsyntax.TokenComma || after.Type == hclsyntax.TokenEllipsis:
+		// No space right before a comma or ... in an argument list
+		return false
+
+	case subject.Type == hclsyntax.TokenComma:
+		// Always a space after a comma
+		return true
+
+	case subject.Type == hclsyntax.TokenQuotedLit || subject.Type == hclsyntax.TokenStringLit || subject.Type == hclsyntax.TokenOQuote || subject.Type == hclsyntax.TokenOHeredoc || after.Type == hclsyntax.TokenQuotedLit || after.Type == hclsyntax.TokenStringLit || after.Type == hclsyntax.TokenCQuote || after.Type == hclsyntax.TokenCHeredoc:
+		// No extra spaces within templates
+		return false
+
+	case inKeyword.TokenMatches(subject.asHCLSyntax()) && before.Type == hclsyntax.TokenIdent:
+		// This is a special case for inside for expressions where a user
+		// might want to use a literal tuple constructor:
+		// [for x in [foo]: x]
+		// ... in that case, we would normally produce in[foo] thinking that
+		// in is a reference, but we'll recognize it as a keyword here instead
+		// to make the result less confusing.
+		return true
+
+	case after.Type == hclsyntax.TokenOBrack && (subject.Type == hclsyntax.TokenIdent || subject.Type == hclsyntax.TokenNumberLit || tokenBracketChange(subject) < 0):
+		return false
+
+	case subject.Type == hclsyntax.TokenMinus:
+		// Since a minus can either be subtraction or negation, and the latter
+		// should _not_ have a space after it, we need to use some heuristics
+		// to decide which case this is.
+		// We guess that we have a negation if the token before doesn't look
+		// like it could be the end of an expression.
+
+		switch before.Type {
+
+		case hclsyntax.TokenNil:
+			// Minus at the start of input must be a negation
+			return false
+
+		case hclsyntax.TokenOParen, hclsyntax.TokenOBrace, hclsyntax.TokenOBrack, hclsyntax.TokenEqual, hclsyntax.TokenColon, hclsyntax.TokenComma, hclsyntax.TokenQuestion:
+			// Minus immediately after an opening bracket or separator must be a negation.
+			return false
+
+		case hclsyntax.TokenPlus, hclsyntax.TokenStar, hclsyntax.TokenSlash, hclsyntax.TokenPercent, hclsyntax.TokenMinus:
+			// Minus immediately after another arithmetic operator must be negation.
+			return false
+
+		case hclsyntax.TokenEqualOp, hclsyntax.TokenNotEqual, hclsyntax.TokenGreaterThan, hclsyntax.TokenGreaterThanEq, hclsyntax.TokenLessThan, hclsyntax.TokenLessThanEq:
+			// Minus immediately after another comparison operator must be negation.
+			return false
+
+		case hclsyntax.TokenAnd, hclsyntax.TokenOr, hclsyntax.TokenBang:
+			// Minus immediately after logical operator doesn't make sense but probably intended as negation.
+			return false
+
+		default:
+			return true
+		}
+
+	case subject.Type == hclsyntax.TokenOBrace || after.Type == hclsyntax.TokenCBrace:
+		// Unlike other bracket types, braces have spaces on both sides of them,
+		// both in single-line nested blocks foo { bar = baz } and in object
+		// constructor expressions foo = { bar = baz }.
+		if subject.Type == hclsyntax.TokenOBrace && after.Type == hclsyntax.TokenCBrace {
+			// An open brace followed by a close brace is an exception, however.
+			// e.g. foo {} rather than foo { }
+			return false
+		}
+		return true
+
+	// In the unlikely event that an interpolation expression is just
+	// a single object constructor, we'll put a space between the ${ and
+	// the following { to make this more obvious, and then the same
+	// thing for the two braces at the end.
+	case (subject.Type == hclsyntax.TokenTemplateInterp || subject.Type == hclsyntax.TokenTemplateControl) && after.Type == hclsyntax.TokenOBrace:
+		return true
+	case subject.Type == hclsyntax.TokenCBrace && after.Type == hclsyntax.TokenTemplateSeqEnd:
+		return true
+
+	// Don't add spaces between interpolated items
+	case subject.Type == hclsyntax.TokenTemplateSeqEnd && (after.Type == hclsyntax.TokenTemplateInterp || after.Type == hclsyntax.TokenTemplateControl):
+		return false
+
+	case tokenBracketChange(subject) > 0:
+		// No spaces after open brackets
+		return false
+
+	case tokenBracketChange(after) < 0:
+		// No spaces before close brackets
+		return false
+
+	default:
+		// Most tokens are space-separated
+		return true
+
+	}
+}
+
+func linesForFormat(tokens Tokens) []formatLine {
+	if len(tokens) == 0 {
+		return make([]formatLine, 0)
+	}
+
+	// first we'll count our lines, so we can allocate the array for them in
+	// a single block. (We want to minimize memory pressure in this codepath,
+	// so it can be run somewhat-frequently by editor integrations.)
+	lineCount := 1 // if there are zero newlines then there is one line
+	for _, tok := range tokens {
+		if tokenIsNewline(tok) {
+			lineCount++
+		}
+	}
+
+	// To start, we'll just put everything in the "lead" cell on each line,
+	// and then do another pass over the lines afterwards to adjust.
+	lines := make([]formatLine, lineCount)
+	li := 0
+	lineStart := 0
+	for i, tok := range tokens {
+		if tok.Type == hclsyntax.TokenEOF {
+			// The EOF token doesn't belong to any line, and terminates the
+			// token sequence.
+			lines[li].lead = tokens[lineStart:i]
+			break
+		}
+
+		if tokenIsNewline(tok) {
+			lines[li].lead = tokens[lineStart : i+1]
+			lineStart = i + 1
+			li++
+		}
+	}
+
+	// If a set of tokens doesn't end in TokenEOF (e.g. because it's a
+	// fragment of tokens from the middle of a file) then we might fall
+	// out here with a line still pending.
+	if lineStart < len(tokens) {
+		lines[li].lead = tokens[lineStart:]
+		if lines[li].lead[len(lines[li].lead)-1].Type == hclsyntax.TokenEOF {
+			lines[li].lead = lines[li].lead[:len(lines[li].lead)-1]
+		}
+	}
+
+	// Now we'll pick off any trailing comments and attribute assignments
+	// to shuffle off into the "comment" and "assign" cells.
+	for i := range lines {
+		line := &lines[i]
+
+		if len(line.lead) == 0 {
+			// if the line is empty then there's nothing for us to do
+			// (this should happen only for the final line, because all other
+			// lines would have a newline token of some kind)
+			continue
+		}
+
+		if len(line.lead) > 1 && line.lead[len(line.lead)-1].Type == hclsyntax.TokenComment {
+			line.comment = line.lead[len(line.lead)-1:]
+			line.lead = line.lead[:len(line.lead)-1]
+		}
+
+		for i, tok := range line.lead {
+			if i > 0 && tok.Type == hclsyntax.TokenEqual {
+				// We only move the tokens into "assign" if the RHS seems to
+				// be a whole expression, which we determine by counting
+				// brackets. If there's a net positive number of brackets
+				// then that suggests we're introducing a multi-line expression.
+				netBrackets := 0
+				for _, token := range line.lead[i:] {
+					netBrackets += tokenBracketChange(token)
+				}
+
+				if netBrackets == 0 {
+					line.assign = line.lead[i:]
+					line.lead = line.lead[:i]
+				}
+				break
+			}
+		}
+	}
+
+	return lines
+}
+
+func tokenIsNewline(tok *Token) bool {
+	if tok.Type == hclsyntax.TokenNewline {
+		return true
+	} else if tok.Type == hclsyntax.TokenComment {
+		// Single line tokens (# and //) consume their terminating newline,
+		// so we need to treat them as newline tokens as well.
+		if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' {
+			return true
+		}
+	}
+	return false
+}
+
+func tokenBracketChange(tok *Token) int {
+	switch tok.Type {
+	case hclsyntax.TokenOBrace, hclsyntax.TokenOBrack, hclsyntax.TokenOParen, hclsyntax.TokenTemplateControl, hclsyntax.TokenTemplateInterp:
+		return 1
+	case hclsyntax.TokenCBrace, hclsyntax.TokenCBrack, hclsyntax.TokenCParen, hclsyntax.TokenTemplateSeqEnd:
+		return -1
+	default:
+		return 0
+	}
+}
+
+// formatLine represents a single line of source code for formatting purposes,
+// splitting its tokens into up to three "cells":
+//
+// lead: always present, representing everything up to one of the others
+// assign: if line contains an attribute assignment, represents the tokens
+//    starting at (and including) the equals symbol
+// comment: if line contains any non-comment tokens and ends with a
+//    single-line comment token, represents the comment.
+//
+// When formatting, the leading spaces of the first tokens in each of these
+// cells is adjusted to align vertically their occurences on consecutive
+// rows.
+type formatLine struct {
+	lead    Tokens
+	assign  Tokens
+	comment Tokens
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/generate.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/generate.go
new file mode 100644
index 000000000..289a30d68
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/generate.go
@@ -0,0 +1,250 @@
+package hclwrite
+
+import (
+	"fmt"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// TokensForValue returns a sequence of tokens that represents the given
+// constant value.
+//
+// This function only supports types that are used by HCL. In particular, it
+// does not support capsule types and will panic if given one.
+//
+// It is not possible to express an unknown value in source code, so this
+// function will panic if the given value is unknown or contains any unknown
+// values. A caller can call the value's IsWhollyKnown method to verify that
+// no unknown values are present before calling TokensForValue.
+func TokensForValue(val cty.Value) Tokens {
+	toks := appendTokensForValue(val, nil)
+	format(toks) // fiddle with the SpacesBefore field to get canonical spacing
+	return toks
+}
+
+// TokensForTraversal returns a sequence of tokens that represents the given
+// traversal.
+//
+// If the traversal is absolute then the result is a self-contained, valid
+// reference expression. If the traversal is relative then the returned tokens
+// could be appended to some other expression tokens to traverse into the
+// represented expression.
+func TokensForTraversal(traversal hcl.Traversal) Tokens {
+	toks := appendTokensForTraversal(traversal, nil)
+	format(toks) // fiddle with the SpacesBefore field to get canonical spacing
+	return toks
+}
+
+func appendTokensForValue(val cty.Value, toks Tokens) Tokens {
+	switch {
+
+	case !val.IsKnown():
+		panic("cannot produce tokens for unknown value")
+
+	case val.IsNull():
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenIdent,
+			Bytes: []byte(`null`),
+		})
+
+	case val.Type() == cty.Bool:
+		var src []byte
+		if val.True() {
+			src = []byte(`true`)
+		} else {
+			src = []byte(`false`)
+		}
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenIdent,
+			Bytes: src,
+		})
+
+	case val.Type() == cty.Number:
+		bf := val.AsBigFloat()
+		srcStr := bf.Text('f', -1)
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenNumberLit,
+			Bytes: []byte(srcStr),
+		})
+
+	case val.Type() == cty.String:
+		// TODO: If it's a multi-line string ending in a newline, format
+		// it as a HEREDOC instead.
+		src := escapeQuotedStringLit(val.AsString())
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenOQuote,
+			Bytes: []byte{'"'},
+		})
+		if len(src) > 0 {
+			toks = append(toks, &Token{
+				Type:  hclsyntax.TokenQuotedLit,
+				Bytes: src,
+			})
+		}
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenCQuote,
+			Bytes: []byte{'"'},
+		})
+
+	case val.Type().IsListType() || val.Type().IsSetType() || val.Type().IsTupleType():
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenOBrack,
+			Bytes: []byte{'['},
+		})
+
+		i := 0
+		for it := val.ElementIterator(); it.Next(); {
+			if i > 0 {
+				toks = append(toks, &Token{
+					Type:  hclsyntax.TokenComma,
+					Bytes: []byte{','},
+				})
+			}
+			_, eVal := it.Element()
+			toks = appendTokensForValue(eVal, toks)
+			i++
+		}
+
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenCBrack,
+			Bytes: []byte{']'},
+		})
+
+	case val.Type().IsMapType() || val.Type().IsObjectType():
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenOBrace,
+			Bytes: []byte{'{'},
+		})
+
+		i := 0
+		for it := val.ElementIterator(); it.Next(); {
+			if i > 0 {
+				toks = append(toks, &Token{
+					Type:  hclsyntax.TokenComma,
+					Bytes: []byte{','},
+				})
+			}
+			eKey, eVal := it.Element()
+			if hclsyntax.ValidIdentifier(eKey.AsString()) {
+				toks = append(toks, &Token{
+					Type:  hclsyntax.TokenIdent,
+					Bytes: []byte(eKey.AsString()),
+				})
+			} else {
+				toks = appendTokensForValue(eKey, toks)
+			}
+			toks = append(toks, &Token{
+				Type:  hclsyntax.TokenEqual,
+				Bytes: []byte{'='},
+			})
+			toks = appendTokensForValue(eVal, toks)
+			i++
+		}
+
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenCBrace,
+			Bytes: []byte{'}'},
+		})
+
+	default:
+		panic(fmt.Sprintf("cannot produce tokens for %#v", val))
+	}
+
+	return toks
+}
+
+func appendTokensForTraversal(traversal hcl.Traversal, toks Tokens) Tokens {
+	for _, step := range traversal {
+		appendTokensForTraversalStep(step, toks)
+	}
+	return toks
+}
+
+func appendTokensForTraversalStep(step hcl.Traverser, toks Tokens) {
+	switch ts := step.(type) {
+	case hcl.TraverseRoot:
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenIdent,
+			Bytes: []byte(ts.Name),
+		})
+	case hcl.TraverseAttr:
+		toks = append(
+			toks,
+			&Token{
+				Type:  hclsyntax.TokenDot,
+				Bytes: []byte{'.'},
+			},
+			&Token{
+				Type:  hclsyntax.TokenIdent,
+				Bytes: []byte(ts.Name),
+			},
+		)
+	case hcl.TraverseIndex:
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenOBrack,
+			Bytes: []byte{'['},
+		})
+		appendTokensForValue(ts.Key, toks)
+		toks = append(toks, &Token{
+			Type:  hclsyntax.TokenCBrack,
+			Bytes: []byte{']'},
+		})
+	default:
+		panic(fmt.Sprintf("unsupported traversal step type %T", step))
+	}
+}
+
+func escapeQuotedStringLit(s string) []byte {
+	if len(s) == 0 {
+		return nil
+	}
+	buf := make([]byte, 0, len(s))
+	for i, r := range s {
+		switch r {
+		case '\n':
+			buf = append(buf, '\\', 'n')
+		case '\r':
+			buf = append(buf, '\\', 'r')
+		case '\t':
+			buf = append(buf, '\\', 't')
+		case '"':
+			buf = append(buf, '\\', '"')
+		case '\\':
+			buf = append(buf, '\\', '\\')
+		case '$', '%':
+			buf = appendRune(buf, r)
+			remain := s[i+1:]
+			if len(remain) > 0 && remain[0] == '{' {
+				// Double up our template introducer symbol to escape it.
+				buf = appendRune(buf, r)
+			}
+		default:
+			if !unicode.IsPrint(r) {
+				var fmted string
+				if r < 65536 {
+					fmted = fmt.Sprintf("\\u%04x", r)
+				} else {
+					fmted = fmt.Sprintf("\\U%08x", r)
+				}
+				buf = append(buf, fmted...)
+			} else {
+				buf = appendRune(buf, r)
+			}
+		}
+	}
+	return buf
+}
+
+func appendRune(b []byte, r rune) []byte {
+	l := utf8.RuneLen(r)
+	for i := 0; i < l; i++ {
+		b = append(b, 0) // make room at the end of our buffer
+	}
+	ch := b[len(b)-l:]
+	utf8.EncodeRune(ch, r)
+	return b
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/native_node_sorter.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/native_node_sorter.go
new file mode 100644
index 000000000..cedf68627
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/native_node_sorter.go
@@ -0,0 +1,23 @@
+package hclwrite
+
+import (
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+type nativeNodeSorter struct {
+	Nodes []hclsyntax.Node
+}
+
+func (s nativeNodeSorter) Len() int {
+	return len(s.Nodes)
+}
+
+func (s nativeNodeSorter) Less(i, j int) bool {
+	rangeI := s.Nodes[i].Range()
+	rangeJ := s.Nodes[j].Range()
+	return rangeI.Start.Byte < rangeJ.Start.Byte
+}
+
+func (s nativeNodeSorter) Swap(i, j int) {
+	s.Nodes[i], s.Nodes[j] = s.Nodes[j], s.Nodes[i]
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/node.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/node.go
new file mode 100644
index 000000000..45669f7f9
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/node.go
@@ -0,0 +1,260 @@
+package hclwrite
+
+import (
+	"fmt"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+// node represents a node in the AST.
+type node struct {
+	content nodeContent
+
+	list          *nodes
+	before, after *node
+}
+
+func newNode(c nodeContent) *node {
+	return &node{
+		content: c,
+	}
+}
+
+func (n *node) Equal(other *node) bool {
+	return cmp.Equal(n.content, other.content)
+}
+
+func (n *node) BuildTokens(to Tokens) Tokens {
+	return n.content.BuildTokens(to)
+}
+
+// Detach removes the receiver from the list it currently belongs to. If the
+// node is not currently in a list, this is a no-op.
+func (n *node) Detach() {
+	if n.list == nil {
+		return
+	}
+	if n.before != nil {
+		n.before.after = n.after
+	}
+	if n.after != nil {
+		n.after.before = n.before
+	}
+	if n.list.first == n {
+		n.list.first = n.after
+	}
+	if n.list.last == n {
+		n.list.last = n.before
+	}
+	n.list = nil
+	n.before = nil
+	n.after = nil
+}
+
+// ReplaceWith removes the receiver from the list it currently belongs to and
+// inserts a new node with the given content in its place. If the node is not
+// currently in a list, this function will panic.
+//
+// The return value is the newly-constructed node, containing the given content.
+// After this function returns, the reciever is no longer attached to a list.
+func (n *node) ReplaceWith(c nodeContent) *node {
+	if n.list == nil {
+		panic("can't replace node that is not in a list")
+	}
+
+	before := n.before
+	after := n.after
+	list := n.list
+	n.before, n.after, n.list = nil, nil, nil
+
+	nn := newNode(c)
+	nn.before = before
+	nn.after = after
+	nn.list = list
+	if before != nil {
+		before.after = nn
+	}
+	if after != nil {
+		after.before = nn
+	}
+	return nn
+}
+
+func (n *node) assertUnattached() {
+	if n.list != nil {
+		panic(fmt.Sprintf("attempt to attach already-attached node %#v", n))
+	}
+}
+
+// nodeContent is the interface type implemented by all AST content types.
+type nodeContent interface {
+	walkChildNodes(w internalWalkFunc)
+	BuildTokens(to Tokens) Tokens
+}
+
+// nodes is a list of nodes.
+type nodes struct {
+	first, last *node
+}
+
+func (ns *nodes) BuildTokens(to Tokens) Tokens {
+	for n := ns.first; n != nil; n = n.after {
+		to = n.BuildTokens(to)
+	}
+	return to
+}
+
+func (ns *nodes) Clear() {
+	ns.first = nil
+	ns.last = nil
+}
+
+func (ns *nodes) Append(c nodeContent) *node {
+	n := &node{
+		content: c,
+	}
+	ns.AppendNode(n)
+	n.list = ns
+	return n
+}
+
+func (ns *nodes) AppendNode(n *node) {
+	if ns.last != nil {
+		n.before = ns.last
+		ns.last.after = n
+	}
+	n.list = ns
+	ns.last = n
+	if ns.first == nil {
+		ns.first = n
+	}
+}
+
+func (ns *nodes) AppendUnstructuredTokens(tokens Tokens) *node {
+	if len(tokens) == 0 {
+		return nil
+	}
+	n := newNode(tokens)
+	ns.AppendNode(n)
+	n.list = ns
+	return n
+}
+
+// FindNodeWithContent searches the nodes for a node whose content equals
+// the given content. If it finds one then it returns it. Otherwise it returns
+// nil.
+func (ns *nodes) FindNodeWithContent(content nodeContent) *node {
+	for n := ns.first; n != nil; n = n.after {
+		if n.content == content {
+			return n
+		}
+	}
+	return nil
+}
+
+// nodeSet is an unordered set of nodes. It is used to describe a set of nodes
+// that all belong to the same list that have some role or characteristic
+// in common.
+type nodeSet map[*node]struct{}
+
+func newNodeSet() nodeSet {
+	return make(nodeSet)
+}
+
+func (ns nodeSet) Has(n *node) bool {
+	if ns == nil {
+		return false
+	}
+	_, exists := ns[n]
+	return exists
+}
+
+func (ns nodeSet) Add(n *node) {
+	ns[n] = struct{}{}
+}
+
+func (ns nodeSet) Remove(n *node) {
+	delete(ns, n)
+}
+
+func (ns nodeSet) List() []*node {
+	if len(ns) == 0 {
+		return nil
+	}
+
+	ret := make([]*node, 0, len(ns))
+
+	// Determine which list we are working with. We assume here that all of
+	// the nodes belong to the same list, since that is part of the contract
+	// for nodeSet.
+	var list *nodes
+	for n := range ns {
+		list = n.list
+		break
+	}
+
+	// We recover the order by iterating over the whole list. This is not
+	// the most efficient way to do it, but our node lists should always be
+	// small so not worth making things more complex.
+	for n := list.first; n != nil; n = n.after {
+		if ns.Has(n) {
+			ret = append(ret, n)
+		}
+	}
+	return ret
+}
+
+// FindNodeWithContent searches the nodes for a node whose content equals
+// the given content. If it finds one then it returns it. Otherwise it returns
+// nil.
+func (ns nodeSet) FindNodeWithContent(content nodeContent) *node {
+	for n := range ns {
+		if n.content == content {
+			return n
+		}
+	}
+	return nil
+}
+
+type internalWalkFunc func(*node)
+
+// inTree can be embedded into a content struct that has child nodes to get
+// a standard implementation of the NodeContent interface and a record of
+// a potential parent node.
+type inTree struct {
+	parent   *node
+	children *nodes
+}
+
+func newInTree() inTree {
+	return inTree{
+		children: &nodes{},
+	}
+}
+
+func (it *inTree) assertUnattached() {
+	if it.parent != nil {
+		panic(fmt.Sprintf("node is already attached to %T", it.parent.content))
+	}
+}
+
+func (it *inTree) walkChildNodes(w internalWalkFunc) {
+	for n := it.children.first; n != nil; n = n.after {
+		w(n)
+	}
+}
+
+func (it *inTree) BuildTokens(to Tokens) Tokens {
+	for n := it.children.first; n != nil; n = n.after {
+		to = n.BuildTokens(to)
+	}
+	return to
+}
+
+// leafNode can be embedded into a content struct to give it a do-nothing
+// implementation of walkChildNodes
+type leafNode struct {
+}
+
+func (n *leafNode) walkChildNodes(w internalWalkFunc) {
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/parser.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/parser.go
new file mode 100644
index 000000000..d6cf532ea
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/parser.go
@@ -0,0 +1,599 @@
+package hclwrite
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Our "parser" here is actually not doing any parsing of its own. Instead,
+// it leans on the native parser in hclsyntax, and then uses the source ranges
+// from the AST to partition the raw token sequence to match the raw tokens
+// up to AST nodes.
+//
+// This strategy feels somewhat counter-intuitive, since most of the work the
+// parser does is thrown away here, but this strategy is chosen because the
+// normal parsing work done by hclsyntax is considered to be the "main case",
+// while modifying and re-printing source is more of an edge case, used only
+// in ancillary tools, and so it's good to keep all the main parsing logic
+// with the main case but keep all of the extra complexity of token wrangling
+// out of the main parser, which is already rather complex just serving the
+// use-cases it already serves.
+//
+// If the parsing step produces any errors, the returned File is nil because
+// we can't reliably extract tokens from the partial AST produced by an
+// erroneous parse.
+func parse(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics) {
+	file, diags := hclsyntax.ParseConfig(src, filename, start)
+	if diags.HasErrors() {
+		return nil, diags
+	}
+
+	// To do our work here, we use the "native" tokens (those from hclsyntax)
+	// to match against source ranges in the AST, but ultimately produce
+	// slices from our sequence of "writer" tokens, which contain only
+	// *relative* position information that is more appropriate for
+	// transformation/writing use-cases.
+	nativeTokens, diags := hclsyntax.LexConfig(src, filename, start)
+	if diags.HasErrors() {
+		// should never happen, since we would've caught these diags in
+		// the first call above.
+		return nil, diags
+	}
+	writerTokens := writerTokens(nativeTokens)
+
+	from := inputTokens{
+		nativeTokens: nativeTokens,
+		writerTokens: writerTokens,
+	}
+
+	before, root, after := parseBody(file.Body.(*hclsyntax.Body), from)
+	ret := &File{
+		inTree: newInTree(),
+
+		srcBytes: src,
+		body:     root,
+	}
+
+	nodes := ret.inTree.children
+	nodes.Append(before.Tokens())
+	nodes.AppendNode(root)
+	nodes.Append(after.Tokens())
+
+	return ret, diags
+}
+
+type inputTokens struct {
+	nativeTokens hclsyntax.Tokens
+	writerTokens Tokens
+}
+
+func (it inputTokens) Partition(rng hcl.Range) (before, within, after inputTokens) {
+	start, end := partitionTokens(it.nativeTokens, rng)
+	before = it.Slice(0, start)
+	within = it.Slice(start, end)
+	after = it.Slice(end, len(it.nativeTokens))
+	return
+}
+
+func (it inputTokens) PartitionType(ty hclsyntax.TokenType) (before, within, after inputTokens) {
+	for i, t := range it.writerTokens {
+		if t.Type == ty {
+			return it.Slice(0, i), it.Slice(i, i+1), it.Slice(i+1, len(it.nativeTokens))
+		}
+	}
+	panic(fmt.Sprintf("didn't find any token of type %s", ty))
+}
+
+func (it inputTokens) PartitionTypeSingle(ty hclsyntax.TokenType) (before inputTokens, found *Token, after inputTokens) {
+	before, within, after := it.PartitionType(ty)
+	if within.Len() != 1 {
+		panic("PartitionType found more than one token")
+	}
+	return before, within.Tokens()[0], after
+}
+
+// PartitionIncludeComments is like Partition except the returned "within"
+// range includes any lead and line comments associated with the range.
+func (it inputTokens) PartitionIncludingComments(rng hcl.Range) (before, within, after inputTokens) {
+	start, end := partitionTokens(it.nativeTokens, rng)
+	start = partitionLeadCommentTokens(it.nativeTokens[:start])
+	_, afterNewline := partitionLineEndTokens(it.nativeTokens[end:])
+	end += afterNewline
+
+	before = it.Slice(0, start)
+	within = it.Slice(start, end)
+	after = it.Slice(end, len(it.nativeTokens))
+	return
+
+}
+
+// PartitionBlockItem is similar to PartitionIncludeComments but it returns
+// the comments as separate token sequences so that they can be captured into
+// AST attributes. It makes assumptions that apply only to block items, so
+// should not be used for other constructs.
+func (it inputTokens) PartitionBlockItem(rng hcl.Range) (before, leadComments, within, lineComments, newline, after inputTokens) {
+	before, within, after = it.Partition(rng)
+	before, leadComments = before.PartitionLeadComments()
+	lineComments, newline, after = after.PartitionLineEndTokens()
+	return
+}
+
+func (it inputTokens) PartitionLeadComments() (before, within inputTokens) {
+	start := partitionLeadCommentTokens(it.nativeTokens)
+	before = it.Slice(0, start)
+	within = it.Slice(start, len(it.nativeTokens))
+	return
+}
+
+func (it inputTokens) PartitionLineEndTokens() (comments, newline, after inputTokens) {
+	afterComments, afterNewline := partitionLineEndTokens(it.nativeTokens)
+	comments = it.Slice(0, afterComments)
+	newline = it.Slice(afterComments, afterNewline)
+	after = it.Slice(afterNewline, len(it.nativeTokens))
+	return
+}
+
+func (it inputTokens) Slice(start, end int) inputTokens {
+	// When we slice, we create a new slice with no additional capacity because
+	// we expect that these slices will be mutated in order to insert
+	// new code into the AST, and we want to ensure that a new underlying
+	// array gets allocated in that case, rather than writing into some
+	// following slice and corrupting it.
+	return inputTokens{
+		nativeTokens: it.nativeTokens[start:end:end],
+		writerTokens: it.writerTokens[start:end:end],
+	}
+}
+
+func (it inputTokens) Len() int {
+	return len(it.nativeTokens)
+}
+
+func (it inputTokens) Tokens() Tokens {
+	return it.writerTokens
+}
+
+func (it inputTokens) Types() []hclsyntax.TokenType {
+	ret := make([]hclsyntax.TokenType, len(it.nativeTokens))
+	for i, tok := range it.nativeTokens {
+		ret[i] = tok.Type
+	}
+	return ret
+}
+
+// parseBody locates the given body within the given input tokens and returns
+// the resulting *Body object as well as the tokens that appeared before and
+// after it.
+func parseBody(nativeBody *hclsyntax.Body, from inputTokens) (inputTokens, *node, inputTokens) {
+	before, within, after := from.PartitionIncludingComments(nativeBody.SrcRange)
+
+	// The main AST doesn't retain the original source ordering of the
+	// body items, so we need to reconstruct that ordering by inspecting
+	// their source ranges.
+	nativeItems := make([]hclsyntax.Node, 0, len(nativeBody.Attributes)+len(nativeBody.Blocks))
+	for _, nativeAttr := range nativeBody.Attributes {
+		nativeItems = append(nativeItems, nativeAttr)
+	}
+	for _, nativeBlock := range nativeBody.Blocks {
+		nativeItems = append(nativeItems, nativeBlock)
+	}
+	sort.Sort(nativeNodeSorter{nativeItems})
+
+	body := &Body{
+		inTree: newInTree(),
+		items:  newNodeSet(),
+	}
+
+	remain := within
+	for _, nativeItem := range nativeItems {
+		beforeItem, item, afterItem := parseBodyItem(nativeItem, remain)
+
+		if beforeItem.Len() > 0 {
+			body.AppendUnstructuredTokens(beforeItem.Tokens())
+		}
+		body.appendItemNode(item)
+
+		remain = afterItem
+	}
+
+	if remain.Len() > 0 {
+		body.AppendUnstructuredTokens(remain.Tokens())
+	}
+
+	return before, newNode(body), after
+}
+
+func parseBodyItem(nativeItem hclsyntax.Node, from inputTokens) (inputTokens, *node, inputTokens) {
+	before, leadComments, within, lineComments, newline, after := from.PartitionBlockItem(nativeItem.Range())
+
+	var item *node
+
+	switch tItem := nativeItem.(type) {
+	case *hclsyntax.Attribute:
+		item = parseAttribute(tItem, within, leadComments, lineComments, newline)
+	case *hclsyntax.Block:
+		item = parseBlock(tItem, within, leadComments, lineComments, newline)
+	default:
+		// should never happen if caller is behaving
+		panic("unsupported native item type")
+	}
+
+	return before, item, after
+}
+
+func parseAttribute(nativeAttr *hclsyntax.Attribute, from, leadComments, lineComments, newline inputTokens) *node {
+	attr := &Attribute{
+		inTree: newInTree(),
+	}
+	children := attr.inTree.children
+
+	{
+		cn := newNode(newComments(leadComments.Tokens()))
+		attr.leadComments = cn
+		children.AppendNode(cn)
+	}
+
+	before, nameTokens, from := from.Partition(nativeAttr.NameRange)
+	{
+		children.AppendUnstructuredTokens(before.Tokens())
+		if nameTokens.Len() != 1 {
+			// Should never happen with valid input
+			panic("attribute name is not exactly one token")
+		}
+		token := nameTokens.Tokens()[0]
+		in := newNode(newIdentifier(token))
+		attr.name = in
+		children.AppendNode(in)
+	}
+
+	before, equalsTokens, from := from.Partition(nativeAttr.EqualsRange)
+	children.AppendUnstructuredTokens(before.Tokens())
+	children.AppendUnstructuredTokens(equalsTokens.Tokens())
+
+	before, exprTokens, from := from.Partition(nativeAttr.Expr.Range())
+	{
+		children.AppendUnstructuredTokens(before.Tokens())
+		exprNode := parseExpression(nativeAttr.Expr, exprTokens)
+		attr.expr = exprNode
+		children.AppendNode(exprNode)
+	}
+
+	{
+		cn := newNode(newComments(lineComments.Tokens()))
+		attr.lineComments = cn
+		children.AppendNode(cn)
+	}
+
+	children.AppendUnstructuredTokens(newline.Tokens())
+
+	// Collect any stragglers, though there shouldn't be any
+	children.AppendUnstructuredTokens(from.Tokens())
+
+	return newNode(attr)
+}
+
+func parseBlock(nativeBlock *hclsyntax.Block, from, leadComments, lineComments, newline inputTokens) *node {
+	block := &Block{
+		inTree: newInTree(),
+		labels: newNodeSet(),
+	}
+	children := block.inTree.children
+
+	{
+		cn := newNode(newComments(leadComments.Tokens()))
+		block.leadComments = cn
+		children.AppendNode(cn)
+	}
+
+	before, typeTokens, from := from.Partition(nativeBlock.TypeRange)
+	{
+		children.AppendUnstructuredTokens(before.Tokens())
+		if typeTokens.Len() != 1 {
+			// Should never happen with valid input
+			panic("block type name is not exactly one token")
+		}
+		token := typeTokens.Tokens()[0]
+		in := newNode(newIdentifier(token))
+		block.typeName = in
+		children.AppendNode(in)
+	}
+
+	for _, rng := range nativeBlock.LabelRanges {
+		var labelTokens inputTokens
+		before, labelTokens, from = from.Partition(rng)
+		children.AppendUnstructuredTokens(before.Tokens())
+		tokens := labelTokens.Tokens()
+		var ln *node
+		if len(tokens) == 1 && tokens[0].Type == hclsyntax.TokenIdent {
+			ln = newNode(newIdentifier(tokens[0]))
+		} else {
+			ln = newNode(newQuoted(tokens))
+		}
+		block.labels.Add(ln)
+		children.AppendNode(ln)
+	}
+
+	before, oBrace, from := from.Partition(nativeBlock.OpenBraceRange)
+	children.AppendUnstructuredTokens(before.Tokens())
+	children.AppendUnstructuredTokens(oBrace.Tokens())
+
+	// We go a bit out of order here: we go hunting for the closing brace
+	// so that we have a delimited body, but then we'll deal with the body
+	// before we actually append the closing brace and any straggling tokens
+	// that appear after it.
+	bodyTokens, cBrace, from := from.Partition(nativeBlock.CloseBraceRange)
+	before, body, after := parseBody(nativeBlock.Body, bodyTokens)
+	children.AppendUnstructuredTokens(before.Tokens())
+	block.body = body
+	children.AppendNode(body)
+	children.AppendUnstructuredTokens(after.Tokens())
+
+	children.AppendUnstructuredTokens(cBrace.Tokens())
+
+	// stragglers
+	children.AppendUnstructuredTokens(from.Tokens())
+	if lineComments.Len() > 0 {
+		// blocks don't actually have line comments, so we'll just treat
+		// them as extra stragglers
+		children.AppendUnstructuredTokens(lineComments.Tokens())
+	}
+	children.AppendUnstructuredTokens(newline.Tokens())
+
+	return newNode(block)
+}
+
+func parseExpression(nativeExpr hclsyntax.Expression, from inputTokens) *node {
+	expr := newExpression()
+	children := expr.inTree.children
+
+	nativeVars := nativeExpr.Variables()
+
+	for _, nativeTraversal := range nativeVars {
+		before, traversal, after := parseTraversal(nativeTraversal, from)
+		children.AppendUnstructuredTokens(before.Tokens())
+		children.AppendNode(traversal)
+		expr.absTraversals.Add(traversal)
+		from = after
+	}
+	// Attach any stragglers that don't belong to a traversal to the expression
+	// itself. In an expression with no traversals at all, this is just the
+	// entirety of "from".
+	children.AppendUnstructuredTokens(from.Tokens())
+
+	return newNode(expr)
+}
+
+func parseTraversal(nativeTraversal hcl.Traversal, from inputTokens) (before inputTokens, n *node, after inputTokens) {
+	traversal := newTraversal()
+	children := traversal.inTree.children
+	before, from, after = from.Partition(nativeTraversal.SourceRange())
+
+	stepAfter := from
+	for _, nativeStep := range nativeTraversal {
+		before, step, after := parseTraversalStep(nativeStep, stepAfter)
+		children.AppendUnstructuredTokens(before.Tokens())
+		children.AppendNode(step)
+		traversal.steps.Add(step)
+		stepAfter = after
+	}
+
+	return before, newNode(traversal), after
+}
+
+func parseTraversalStep(nativeStep hcl.Traverser, from inputTokens) (before inputTokens, n *node, after inputTokens) {
+	var children *nodes
+	switch tNativeStep := nativeStep.(type) {
+
+	case hcl.TraverseRoot, hcl.TraverseAttr:
+		step := newTraverseName()
+		children = step.inTree.children
+		before, from, after = from.Partition(nativeStep.SourceRange())
+		inBefore, token, inAfter := from.PartitionTypeSingle(hclsyntax.TokenIdent)
+		name := newIdentifier(token)
+		children.AppendUnstructuredTokens(inBefore.Tokens())
+		step.name = children.Append(name)
+		children.AppendUnstructuredTokens(inAfter.Tokens())
+		return before, newNode(step), after
+
+	case hcl.TraverseIndex:
+		step := newTraverseIndex()
+		children = step.inTree.children
+		before, from, after = from.Partition(nativeStep.SourceRange())
+
+		var inBefore, oBrack, keyTokens, cBrack inputTokens
+		inBefore, oBrack, from = from.PartitionType(hclsyntax.TokenOBrack)
+		children.AppendUnstructuredTokens(inBefore.Tokens())
+		children.AppendUnstructuredTokens(oBrack.Tokens())
+		keyTokens, cBrack, from = from.PartitionType(hclsyntax.TokenCBrack)
+
+		keyVal := tNativeStep.Key
+		switch keyVal.Type() {
+		case cty.String:
+			key := newQuoted(keyTokens.Tokens())
+			step.key = children.Append(key)
+		case cty.Number:
+			valBefore, valToken, valAfter := keyTokens.PartitionTypeSingle(hclsyntax.TokenNumberLit)
+			children.AppendUnstructuredTokens(valBefore.Tokens())
+			key := newNumber(valToken)
+			step.key = children.Append(key)
+			children.AppendUnstructuredTokens(valAfter.Tokens())
+		}
+
+		children.AppendUnstructuredTokens(cBrack.Tokens())
+		children.AppendUnstructuredTokens(from.Tokens())
+
+		return before, newNode(step), after
+	default:
+		panic(fmt.Sprintf("unsupported traversal step type %T", nativeStep))
+	}
+
+}
+
+// writerTokens takes a sequence of tokens as produced by the main hclsyntax
+// package and transforms it into an equivalent sequence of tokens using
+// this package's own token model.
+//
+// The resulting list contains the same number of tokens and uses the same
+// indices as the input, allowing the two sets of tokens to be correlated
+// by index.
+func writerTokens(nativeTokens hclsyntax.Tokens) Tokens {
+	// Ultimately we want a slice of token _pointers_, but since we can
+	// predict how much memory we're going to devote to tokens we'll allocate
+	// it all as a single flat buffer and thus give the GC less work to do.
+	tokBuf := make([]Token, len(nativeTokens))
+	var lastByteOffset int
+	for i, mainToken := range nativeTokens {
+		// Create a copy of the bytes so that we can mutate without
+		// corrupting the original token stream.
+		bytes := make([]byte, len(mainToken.Bytes))
+		copy(bytes, mainToken.Bytes)
+
+		tokBuf[i] = Token{
+			Type:  mainToken.Type,
+			Bytes: bytes,
+
+			// We assume here that spaces are always ASCII spaces, since
+			// that's what the scanner also assumes, and thus the number
+			// of bytes skipped is also the number of space characters.
+			SpacesBefore: mainToken.Range.Start.Byte - lastByteOffset,
+		}
+
+		lastByteOffset = mainToken.Range.End.Byte
+	}
+
+	// Now make a slice of pointers into the previous slice.
+	ret := make(Tokens, len(tokBuf))
+	for i := range ret {
+		ret[i] = &tokBuf[i]
+	}
+
+	return ret
+}
+
+// partitionTokens takes a sequence of tokens and a hcl.Range and returns
+// two indices within the token sequence that correspond with the range
+// boundaries, such that the slice operator could be used to produce
+// three token sequences for before, within, and after respectively:
+//
+//     start, end := partitionTokens(toks, rng)
+//     before := toks[:start]
+//     within := toks[start:end]
+//     after := toks[end:]
+//
+// This works best when the range is aligned with token boundaries (e.g.
+// because it was produced in terms of the scanner's result) but if that isn't
+// true then it will make a best effort that may produce strange results at
+// the boundaries.
+//
+// Native hclsyntax tokens are used here, because they contain the necessary
+// absolute position information. However, since writerTokens produces a
+// correlatable sequence of writer tokens, the resulting indices can be
+// used also to index into its result, allowing the partitioning of writer
+// tokens to be driven by the partitioning of native tokens.
+//
+// The tokens are assumed to be in source order and non-overlapping, which
+// will be true if the token sequence from the scanner is used directly.
+func partitionTokens(toks hclsyntax.Tokens, rng hcl.Range) (start, end int) {
+	// We us a linear search here because we assume tha in most cases our
+	// target range is close to the beginning of the sequence, and the seqences
+	// are generally small for most reasonable files anyway.
+	for i := 0; ; i++ {
+		if i >= len(toks) {
+			// No tokens for the given range at all!
+			return len(toks), len(toks)
+		}
+
+		if toks[i].Range.Start.Byte >= rng.Start.Byte {
+			start = i
+			break
+		}
+	}
+
+	for i := start; ; i++ {
+		if i >= len(toks) {
+			// The range "hangs off" the end of the token sequence
+			return start, len(toks)
+		}
+
+		if toks[i].Range.Start.Byte >= rng.End.Byte {
+			end = i // end marker is exclusive
+			break
+		}
+	}
+
+	return start, end
+}
+
+// partitionLeadCommentTokens takes a sequence of tokens that is assumed
+// to immediately precede a construct that can have lead comment tokens,
+// and returns the index into that sequence where the lead comments begin.
+//
+// Lead comments are defined as whole lines containing only comment tokens
+// with no blank lines between. If no such lines are found, the returned
+// index will be len(toks).
+func partitionLeadCommentTokens(toks hclsyntax.Tokens) int {
+	// single-line comments (which is what we're interested in here)
+	// consume their trailing newline, so we can just walk backwards
+	// until we stop seeing comment tokens.
+	for i := len(toks) - 1; i >= 0; i-- {
+		if toks[i].Type != hclsyntax.TokenComment {
+			return i + 1
+		}
+	}
+	return 0
+}
+
+// partitionLineEndTokens takes a sequence of tokens that is assumed
+// to immediately follow a construct that can have a line comment, and
+// returns first the index where any line comments end and then second
+// the index immediately after the trailing newline.
+//
+// Line comments are defined as comments that appear immediately after
+// a construct on the same line where its significant tokens ended.
+//
+// Since single-line comment tokens (# and //) include the newline that
+// terminates them, in the presence of these the two returned indices
+// will be the same since the comment itself serves as the line end.
+func partitionLineEndTokens(toks hclsyntax.Tokens) (afterComment, afterNewline int) {
+	for i := 0; i < len(toks); i++ {
+		tok := toks[i]
+		if tok.Type != hclsyntax.TokenComment {
+			switch tok.Type {
+			case hclsyntax.TokenNewline:
+				return i, i + 1
+			case hclsyntax.TokenEOF:
+				// Although this is valid, we mustn't include the EOF
+				// itself as our "newline" or else strange things will
+				// happen when we try to append new items.
+				return i, i
+			default:
+				// If we have well-formed input here then nothing else should be
+				// possible. This path should never happen, because we only try
+				// to extract tokens from the sequence if the parser succeeded,
+				// and it should catch this problem itself.
+				panic("malformed line trailers: expected only comments and newlines")
+			}
+		}
+
+		if len(tok.Bytes) > 0 && tok.Bytes[len(tok.Bytes)-1] == '\n' {
+			// Newline at the end of a single-line comment serves both as
+			// the end of comments *and* the end of the line.
+			return i + 1, i + 1
+		}
+	}
+	return len(toks), len(toks)
+}
+
+// lexConfig uses the hclsyntax scanner to get a token stream and then
+// rewrites it into this package's token model.
+//
+// Any errors produced during scanning are ignored, so the results of this
+// function should be used with care.
+func lexConfig(src []byte) Tokens {
+	mainTokens, _ := hclsyntax.LexConfig(src, "", hcl.Pos{Byte: 0, Line: 1, Column: 1})
+	return writerTokens(mainTokens)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/public.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/public.go
new file mode 100644
index 000000000..678a3aa45
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/public.go
@@ -0,0 +1,44 @@
+package hclwrite
+
+import (
+	"bytes"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// NewFile creates a new file object that is empty and ready to have constructs
+// added t it.
+func NewFile() *File {
+	body := &Body{
+		inTree: newInTree(),
+		items:  newNodeSet(),
+	}
+	file := &File{
+		inTree: newInTree(),
+	}
+	file.body = file.inTree.children.Append(body)
+	return file
+}
+
+// ParseConfig interprets the given source bytes into a *hclwrite.File. The
+// resulting AST can be used to perform surgical edits on the source code
+// before turning it back into bytes again.
+func ParseConfig(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics) {
+	return parse(src, filename, start)
+}
+
+// Format takes source code and performs simple whitespace changes to transform
+// it to a canonical layout style.
+//
+// Format skips constructing an AST and works directly with tokens, so it
+// is less expensive than formatting via the AST for situations where no other
+// changes will be made. It also ignores syntax errors and can thus be applied
+// to partial source code, although the result in that case may not be
+// desirable.
+func Format(src []byte) []byte {
+	tokens := lexConfig(src)
+	format(tokens)
+	buf := &bytes.Buffer{}
+	tokens.WriteTo(buf)
+	return buf.Bytes()
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/hclwrite/tokens.go b/vendor/github.com/hashicorp/hcl/v2/hclwrite/tokens.go
new file mode 100644
index 000000000..3bd3e5f48
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/hclwrite/tokens.go
@@ -0,0 +1,122 @@
+package hclwrite
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+)
+
+// Token is a single sequence of bytes annotated with a type. It is similar
+// in purpose to hclsyntax.Token, but discards the source position information
+// since that is not useful in code generation.
+type Token struct {
+	Type  hclsyntax.TokenType
+	Bytes []byte
+
+	// We record the number of spaces before each token so that we can
+	// reproduce the exact layout of the original file when we're making
+	// surgical changes in-place. When _new_ code is created it will always
+	// be in the canonical style, but we preserve layout of existing code.
+	SpacesBefore int
+}
+
+// asHCLSyntax returns the receiver expressed as an incomplete hclsyntax.Token.
+// A complete token is not possible since we don't have source location
+// information here, and so this method is unexported so we can be sure it will
+// only be used for internal purposes where we know the range isn't important.
+//
+// This is primarily intended to allow us to re-use certain functionality from
+// hclsyntax rather than re-implementing it against our own token type here.
+func (t *Token) asHCLSyntax() hclsyntax.Token {
+	return hclsyntax.Token{
+		Type:  t.Type,
+		Bytes: t.Bytes,
+		Range: hcl.Range{
+			Filename: "<invalid>",
+		},
+	}
+}
+
+// Tokens is a flat list of tokens.
+type Tokens []*Token
+
+func (ts Tokens) Bytes() []byte {
+	buf := &bytes.Buffer{}
+	ts.WriteTo(buf)
+	return buf.Bytes()
+}
+
+func (ts Tokens) testValue() string {
+	return string(ts.Bytes())
+}
+
+// Columns returns the number of columns (grapheme clusters) the token sequence
+// occupies. The result is not meaningful if there are newline or single-line
+// comment tokens in the sequence.
+func (ts Tokens) Columns() int {
+	ret := 0
+	for _, token := range ts {
+		ret += token.SpacesBefore // spaces are always worth one column each
+		ct, _ := textseg.TokenCount(token.Bytes, textseg.ScanGraphemeClusters)
+		ret += ct
+	}
+	return ret
+}
+
+// WriteTo takes an io.Writer and writes the bytes for each token to it,
+// along with the spacing that separates each token. In other words, this
+// allows serializing the tokens to a file or other such byte stream.
+func (ts Tokens) WriteTo(wr io.Writer) (int64, error) {
+	// We know we're going to be writing a lot of small chunks of repeated
+	// space characters, so we'll prepare a buffer of these that we can
+	// easily pass to wr.Write without any further allocation.
+	spaces := make([]byte, 40)
+	for i := range spaces {
+		spaces[i] = ' '
+	}
+
+	var n int64
+	var err error
+	for _, token := range ts {
+		if err != nil {
+			return n, err
+		}
+
+		for spacesBefore := token.SpacesBefore; spacesBefore > 0; spacesBefore -= len(spaces) {
+			thisChunk := spacesBefore
+			if thisChunk > len(spaces) {
+				thisChunk = len(spaces)
+			}
+			var thisN int
+			thisN, err = wr.Write(spaces[:thisChunk])
+			n += int64(thisN)
+			if err != nil {
+				return n, err
+			}
+		}
+
+		var thisN int
+		thisN, err = wr.Write(token.Bytes)
+		n += int64(thisN)
+	}
+
+	return n, err
+}
+
+func (ts Tokens) walkChildNodes(w internalWalkFunc) {
+	// Unstructured tokens have no child nodes
+}
+
+func (ts Tokens) BuildTokens(to Tokens) Tokens {
+	return append(to, ts...)
+}
+
+func newIdentToken(name string) *Token {
+	return &Token{
+		Type:  hclsyntax.TokenIdent,
+		Bytes: []byte(name),
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/ast.go b/vendor/github.com/hashicorp/hcl/v2/json/ast.go
new file mode 100644
index 000000000..9c580ca34
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/ast.go
@@ -0,0 +1,121 @@
+package json
+
+import (
+	"math/big"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+type node interface {
+	Range() hcl.Range
+	StartRange() hcl.Range
+}
+
+type objectVal struct {
+	Attrs      []*objectAttr
+	SrcRange   hcl.Range // range of the entire object, brace-to-brace
+	OpenRange  hcl.Range // range of the opening brace
+	CloseRange hcl.Range // range of the closing brace
+}
+
+func (n *objectVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *objectVal) StartRange() hcl.Range {
+	return n.OpenRange
+}
+
+type objectAttr struct {
+	Name      string
+	Value     node
+	NameRange hcl.Range // range of the name string
+}
+
+func (n *objectAttr) Range() hcl.Range {
+	return n.NameRange
+}
+
+func (n *objectAttr) StartRange() hcl.Range {
+	return n.NameRange
+}
+
+type arrayVal struct {
+	Values    []node
+	SrcRange  hcl.Range // range of the entire object, bracket-to-bracket
+	OpenRange hcl.Range // range of the opening bracket
+}
+
+func (n *arrayVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *arrayVal) StartRange() hcl.Range {
+	return n.OpenRange
+}
+
+type booleanVal struct {
+	Value    bool
+	SrcRange hcl.Range
+}
+
+func (n *booleanVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *booleanVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
+
+type numberVal struct {
+	Value    *big.Float
+	SrcRange hcl.Range
+}
+
+func (n *numberVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *numberVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
+
+type stringVal struct {
+	Value    string
+	SrcRange hcl.Range
+}
+
+func (n *stringVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *stringVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
+
+type nullVal struct {
+	SrcRange hcl.Range
+}
+
+func (n *nullVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n *nullVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
+
+// invalidVal is used as a placeholder where a value is needed for a valid
+// parse tree but the input was invalid enough to prevent one from being
+// created.
+type invalidVal struct {
+	SrcRange hcl.Range
+}
+
+func (n invalidVal) Range() hcl.Range {
+	return n.SrcRange
+}
+
+func (n invalidVal) StartRange() hcl.Range {
+	return n.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/didyoumean.go b/vendor/github.com/hashicorp/hcl/v2/json/didyoumean.go
new file mode 100644
index 000000000..fbdd8bff5
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/didyoumean.go
@@ -0,0 +1,33 @@
+package json
+
+import (
+	"github.com/agext/levenshtein"
+)
+
+var keywords = []string{"false", "true", "null"}
+
+// keywordSuggestion tries to find a valid JSON keyword that is close to the
+// given string and returns it if found. If no keyword is close enough, returns
+// the empty string.
+func keywordSuggestion(given string) string {
+	return nameSuggestion(given, keywords)
+}
+
+// nameSuggestion tries to find a name from the given slice of suggested names
+// that is close to the given name and returns it if found. If no suggestion
+// is close enough, returns the empty string.
+//
+// The suggestions are tried in order, so earlier suggestions take precedence
+// if the given string is similar to two or more suggestions.
+//
+// This function is intended to be used with a relatively-small number of
+// suggestions. It's not optimized for hundreds or thousands of them.
+func nameSuggestion(given string, suggestions []string) string {
+	for _, suggestion := range suggestions {
+		dist := levenshtein.Distance(given, suggestion, nil)
+		if dist < 3 { // threshold determined experimentally
+			return suggestion
+		}
+	}
+	return ""
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/doc.go b/vendor/github.com/hashicorp/hcl/v2/json/doc.go
new file mode 100644
index 000000000..84d731939
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/doc.go
@@ -0,0 +1,12 @@
+// Package json is the JSON parser for HCL. It parses JSON files and returns
+// implementations of the core HCL structural interfaces in terms of the
+// JSON data inside.
+//
+// This is not a generic JSON parser. Instead, it deals with the mapping from
+// the JSON information model to the HCL information model, using a number
+// of hard-coded structural conventions.
+//
+// In most cases applications will not import this package directly, but will
+// instead access its functionality indirectly through functions in the main
+// "hcl" package and in the "hclparse" package.
+package json
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/navigation.go b/vendor/github.com/hashicorp/hcl/v2/json/navigation.go
new file mode 100644
index 000000000..bc8a97f74
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/navigation.go
@@ -0,0 +1,70 @@
+package json
+
+import (
+	"fmt"
+	"strings"
+)
+
+type navigation struct {
+	root node
+}
+
+// Implementation of hcled.ContextString
+func (n navigation) ContextString(offset int) string {
+	steps := navigationStepsRev(n.root, offset)
+	if steps == nil {
+		return ""
+	}
+
+	// We built our slice backwards, so we'll reverse it in-place now.
+	half := len(steps) / 2 // integer division
+	for i := 0; i < half; i++ {
+		steps[i], steps[len(steps)-1-i] = steps[len(steps)-1-i], steps[i]
+	}
+
+	ret := strings.Join(steps, "")
+	if len(ret) > 0 && ret[0] == '.' {
+		ret = ret[1:]
+	}
+	return ret
+}
+
+func navigationStepsRev(v node, offset int) []string {
+	switch tv := v.(type) {
+	case *objectVal:
+		// Do any of our properties have an object that contains the target
+		// offset?
+		for _, attr := range tv.Attrs {
+			k := attr.Name
+			av := attr.Value
+
+			switch av.(type) {
+			case *objectVal, *arrayVal:
+				// okay
+			default:
+				continue
+			}
+
+			if av.Range().ContainsOffset(offset) {
+				return append(navigationStepsRev(av, offset), "."+k)
+			}
+		}
+	case *arrayVal:
+		// Do any of our elements contain the target offset?
+		for i, elem := range tv.Values {
+
+			switch elem.(type) {
+			case *objectVal, *arrayVal:
+				// okay
+			default:
+				continue
+			}
+
+			if elem.Range().ContainsOffset(offset) {
+				return append(navigationStepsRev(elem, offset), fmt.Sprintf("[%d]", i))
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/parser.go b/vendor/github.com/hashicorp/hcl/v2/json/parser.go
new file mode 100644
index 000000000..7a54c51b6
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/parser.go
@@ -0,0 +1,496 @@
+package json
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty"
+)
+
+func parseFileContent(buf []byte, filename string) (node, hcl.Diagnostics) {
+	tokens := scan(buf, pos{
+		Filename: filename,
+		Pos: hcl.Pos{
+			Byte:   0,
+			Line:   1,
+			Column: 1,
+		},
+	})
+	p := newPeeker(tokens)
+	node, diags := parseValue(p)
+	if len(diags) == 0 && p.Peek().Type != tokenEOF {
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Extraneous data after value",
+			Detail:   "Extra characters appear after the JSON value.",
+			Subject:  p.Peek().Range.Ptr(),
+		})
+	}
+	return node, diags
+}
+
+func parseValue(p *peeker) (node, hcl.Diagnostics) {
+	tok := p.Peek()
+
+	wrapInvalid := func(n node, diags hcl.Diagnostics) (node, hcl.Diagnostics) {
+		if n != nil {
+			return n, diags
+		}
+		return invalidVal{tok.Range}, diags
+	}
+
+	switch tok.Type {
+	case tokenBraceO:
+		return wrapInvalid(parseObject(p))
+	case tokenBrackO:
+		return wrapInvalid(parseArray(p))
+	case tokenNumber:
+		return wrapInvalid(parseNumber(p))
+	case tokenString:
+		return wrapInvalid(parseString(p))
+	case tokenKeyword:
+		return wrapInvalid(parseKeyword(p))
+	case tokenBraceC:
+		return wrapInvalid(nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Missing JSON value",
+				Detail:   "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.",
+				Subject:  &tok.Range,
+			},
+		})
+	case tokenBrackC:
+		return wrapInvalid(nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Missing array element value",
+				Detail:   "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.",
+				Subject:  &tok.Range,
+			},
+		})
+	case tokenEOF:
+		return wrapInvalid(nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Missing value",
+				Detail:   "The JSON data ends prematurely.",
+				Subject:  &tok.Range,
+			},
+		})
+	default:
+		return wrapInvalid(nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid start of value",
+				Detail:   "A JSON value must start with a brace, a bracket, a number, a string, or a keyword.",
+				Subject:  &tok.Range,
+			},
+		})
+	}
+}
+
+func tokenCanStartValue(tok token) bool {
+	switch tok.Type {
+	case tokenBraceO, tokenBrackO, tokenNumber, tokenString, tokenKeyword:
+		return true
+	default:
+		return false
+	}
+}
+
+func parseObject(p *peeker) (node, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	open := p.Read()
+	attrs := []*objectAttr{}
+
+	// recover is used to shift the peeker to what seems to be the end of
+	// our object, so that when we encounter an error we leave the peeker
+	// at a reasonable point in the token stream to continue parsing.
+	recover := func(tok token) {
+		open := 1
+		for {
+			switch tok.Type {
+			case tokenBraceO:
+				open++
+			case tokenBraceC:
+				open--
+				if open <= 1 {
+					return
+				}
+			case tokenEOF:
+				// Ran out of source before we were able to recover,
+				// so we'll bail here and let the caller deal with it.
+				return
+			}
+			tok = p.Read()
+		}
+	}
+
+Token:
+	for {
+		if p.Peek().Type == tokenBraceC {
+			break Token
+		}
+
+		keyNode, keyDiags := parseValue(p)
+		diags = diags.Extend(keyDiags)
+		if keyNode == nil {
+			return nil, diags
+		}
+
+		keyStrNode, ok := keyNode.(*stringVal)
+		if !ok {
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid object property name",
+				Detail:   "A JSON object property name must be a string",
+				Subject:  keyNode.StartRange().Ptr(),
+			})
+		}
+
+		key := keyStrNode.Value
+
+		colon := p.Read()
+		if colon.Type != tokenColon {
+			recover(colon)
+
+			if colon.Type == tokenBraceC || colon.Type == tokenComma {
+				// Catch common mistake of using braces instead of brackets
+				// for an object.
+				return nil, diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing object value",
+					Detail:   "A JSON object attribute must have a value, introduced by a colon.",
+					Subject:  &colon.Range,
+				})
+			}
+
+			if colon.Type == tokenEquals {
+				// Possible confusion with native HCL syntax.
+				return nil, diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing property value colon",
+					Detail:   "JSON uses a colon as its name/value delimiter, not an equals sign.",
+					Subject:  &colon.Range,
+				})
+			}
+
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing property value colon",
+				Detail:   "A colon must appear between an object property's name and its value.",
+				Subject:  &colon.Range,
+			})
+		}
+
+		valNode, valDiags := parseValue(p)
+		diags = diags.Extend(valDiags)
+		if valNode == nil {
+			return nil, diags
+		}
+
+		attrs = append(attrs, &objectAttr{
+			Name:      key,
+			Value:     valNode,
+			NameRange: keyStrNode.SrcRange,
+		})
+
+		switch p.Peek().Type {
+		case tokenComma:
+			comma := p.Read()
+			if p.Peek().Type == tokenBraceC {
+				// Special error message for this common mistake
+				return nil, diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Trailing comma in object",
+					Detail:   "JSON does not permit a trailing comma after the final property in an object.",
+					Subject:  &comma.Range,
+				})
+			}
+			continue Token
+		case tokenEOF:
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unclosed object",
+				Detail:   "No closing brace was found for this JSON object.",
+				Subject:  &open.Range,
+			})
+		case tokenBrackC:
+			// Consume the bracket anyway, so that we don't return with the peeker
+			// at a strange place.
+			p.Read()
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Mismatched braces",
+				Detail:   "A JSON object must be closed with a brace, not a bracket.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		case tokenBraceC:
+			break Token
+		default:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing attribute seperator comma",
+				Detail:   "A comma must appear between each property definition in an object.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		}
+
+	}
+
+	close := p.Read()
+	return &objectVal{
+		Attrs:      attrs,
+		SrcRange:   hcl.RangeBetween(open.Range, close.Range),
+		OpenRange:  open.Range,
+		CloseRange: close.Range,
+	}, diags
+}
+
+func parseArray(p *peeker) (node, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	open := p.Read()
+	vals := []node{}
+
+	// recover is used to shift the peeker to what seems to be the end of
+	// our array, so that when we encounter an error we leave the peeker
+	// at a reasonable point in the token stream to continue parsing.
+	recover := func(tok token) {
+		open := 1
+		for {
+			switch tok.Type {
+			case tokenBrackO:
+				open++
+			case tokenBrackC:
+				open--
+				if open <= 1 {
+					return
+				}
+			case tokenEOF:
+				// Ran out of source before we were able to recover,
+				// so we'll bail here and let the caller deal with it.
+				return
+			}
+			tok = p.Read()
+		}
+	}
+
+Token:
+	for {
+		if p.Peek().Type == tokenBrackC {
+			break Token
+		}
+
+		valNode, valDiags := parseValue(p)
+		diags = diags.Extend(valDiags)
+		if valNode == nil {
+			return nil, diags
+		}
+
+		vals = append(vals, valNode)
+
+		switch p.Peek().Type {
+		case tokenComma:
+			comma := p.Read()
+			if p.Peek().Type == tokenBrackC {
+				// Special error message for this common mistake
+				return nil, diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Trailing comma in array",
+					Detail:   "JSON does not permit a trailing comma after the final value in an array.",
+					Subject:  &comma.Range,
+				})
+			}
+			continue Token
+		case tokenColon:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid array value",
+				Detail:   "A colon is not used to introduce values in a JSON array.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		case tokenEOF:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Unclosed object",
+				Detail:   "No closing bracket was found for this JSON array.",
+				Subject:  &open.Range,
+			})
+		case tokenBraceC:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Mismatched brackets",
+				Detail:   "A JSON array must be closed with a bracket, not a brace.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		case tokenBrackC:
+			break Token
+		default:
+			recover(p.Read())
+			return nil, diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing attribute seperator comma",
+				Detail:   "A comma must appear between each value in an array.",
+				Subject:  p.Peek().Range.Ptr(),
+			})
+		}
+
+	}
+
+	close := p.Read()
+	return &arrayVal{
+		Values:    vals,
+		SrcRange:  hcl.RangeBetween(open.Range, close.Range),
+		OpenRange: open.Range,
+	}, diags
+}
+
+func parseNumber(p *peeker) (node, hcl.Diagnostics) {
+	tok := p.Read()
+
+	// Use encoding/json to validate the number syntax.
+	// TODO: Do this more directly to produce better diagnostics.
+	var num json.Number
+	err := json.Unmarshal(tok.Bytes, &num)
+	if err != nil {
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON number",
+				Detail:   fmt.Sprintf("There is a syntax error in the given JSON number."),
+				Subject:  &tok.Range,
+			},
+		}
+	}
+
+	// We want to guarantee that we parse numbers the same way as cty (and thus
+	// native syntax HCL) would here, so we'll use the cty parser even though
+	// in most other cases we don't actually introduce cty concepts until
+	// decoding time. We'll unwrap the parsed float immediately afterwards, so
+	// the cty value is just a temporary helper.
+	nv, err := cty.ParseNumberVal(string(num))
+	if err != nil {
+		// Should never happen if above passed, since JSON numbers are a subset
+		// of what cty can parse...
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON number",
+				Detail:   fmt.Sprintf("There is a syntax error in the given JSON number."),
+				Subject:  &tok.Range,
+			},
+		}
+	}
+
+	return &numberVal{
+		Value:    nv.AsBigFloat(),
+		SrcRange: tok.Range,
+	}, nil
+}
+
+func parseString(p *peeker) (node, hcl.Diagnostics) {
+	tok := p.Read()
+	var str string
+	err := json.Unmarshal(tok.Bytes, &str)
+
+	if err != nil {
+		var errRange hcl.Range
+		if serr, ok := err.(*json.SyntaxError); ok {
+			errOfs := serr.Offset
+			errPos := tok.Range.Start
+			errPos.Byte += int(errOfs)
+
+			// TODO: Use the byte offset to properly count unicode
+			// characters for the column, and mark the whole of the
+			// character that was wrong as part of our range.
+			errPos.Column += int(errOfs)
+
+			errEndPos := errPos
+			errEndPos.Byte++
+			errEndPos.Column++
+
+			errRange = hcl.Range{
+				Filename: tok.Range.Filename,
+				Start:    errPos,
+				End:      errEndPos,
+			}
+		} else {
+			errRange = tok.Range
+		}
+
+		var contextRange *hcl.Range
+		if errRange != tok.Range {
+			contextRange = &tok.Range
+		}
+
+		// FIXME: Eventually we should parse strings directly here so
+		// we can produce a more useful error message in the face fo things
+		// such as invalid escapes, etc.
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON string",
+				Detail:   fmt.Sprintf("There is a syntax error in the given JSON string."),
+				Subject:  &errRange,
+				Context:  contextRange,
+			},
+		}
+	}
+
+	return &stringVal{
+		Value:    str,
+		SrcRange: tok.Range,
+	}, nil
+}
+
+func parseKeyword(p *peeker) (node, hcl.Diagnostics) {
+	tok := p.Read()
+	s := string(tok.Bytes)
+
+	switch s {
+	case "true":
+		return &booleanVal{
+			Value:    true,
+			SrcRange: tok.Range,
+		}, nil
+	case "false":
+		return &booleanVal{
+			Value:    false,
+			SrcRange: tok.Range,
+		}, nil
+	case "null":
+		return &nullVal{
+			SrcRange: tok.Range,
+		}, nil
+	case "undefined", "NaN", "Infinity":
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON keyword",
+				Detail:   fmt.Sprintf("The JavaScript identifier %q cannot be used in JSON.", s),
+				Subject:  &tok.Range,
+			},
+		}
+	default:
+		var dym string
+		if suggest := keywordSuggestion(s); suggest != "" {
+			dym = fmt.Sprintf(" Did you mean %q?", suggest)
+		}
+
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Invalid JSON keyword",
+				Detail:   fmt.Sprintf("%q is not a valid JSON keyword.%s", s, dym),
+				Subject:  &tok.Range,
+			},
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/peeker.go b/vendor/github.com/hashicorp/hcl/v2/json/peeker.go
new file mode 100644
index 000000000..fc7bbf582
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/peeker.go
@@ -0,0 +1,25 @@
+package json
+
+type peeker struct {
+	tokens []token
+	pos    int
+}
+
+func newPeeker(tokens []token) *peeker {
+	return &peeker{
+		tokens: tokens,
+		pos:    0,
+	}
+}
+
+func (p *peeker) Peek() token {
+	return p.tokens[p.pos]
+}
+
+func (p *peeker) Read() token {
+	ret := p.tokens[p.pos]
+	if ret.Type != tokenEOF {
+		p.pos++
+	}
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/public.go b/vendor/github.com/hashicorp/hcl/v2/json/public.go
new file mode 100644
index 000000000..8dc4a36af
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/public.go
@@ -0,0 +1,94 @@
+package json
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"github.com/hashicorp/hcl/v2"
+)
+
+// Parse attempts to parse the given buffer as JSON and, if successful, returns
+// a hcl.File for the HCL configuration represented by it.
+//
+// This is not a generic JSON parser. Instead, it deals only with the profile
+// of JSON used to express HCL configuration.
+//
+// The returned file is valid only if the returned diagnostics returns false
+// from its HasErrors method. If HasErrors returns true, the file represents
+// the subset of data that was able to be parsed, which may be none.
+func Parse(src []byte, filename string) (*hcl.File, hcl.Diagnostics) {
+	rootNode, diags := parseFileContent(src, filename)
+
+	switch rootNode.(type) {
+	case *objectVal, *arrayVal:
+		// okay
+	default:
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Root value must be object",
+			Detail:   "The root value in a JSON-based configuration must be either a JSON object or a JSON array of objects.",
+			Subject:  rootNode.StartRange().Ptr(),
+		})
+
+		// Since we've already produced an error message for this being
+		// invalid, we'll return an empty placeholder here so that trying to
+		// extract content from our root body won't produce a redundant
+		// error saying the same thing again in more general terms.
+		fakePos := hcl.Pos{
+			Byte:   0,
+			Line:   1,
+			Column: 1,
+		}
+		fakeRange := hcl.Range{
+			Filename: filename,
+			Start:    fakePos,
+			End:      fakePos,
+		}
+		rootNode = &objectVal{
+			Attrs:     []*objectAttr{},
+			SrcRange:  fakeRange,
+			OpenRange: fakeRange,
+		}
+	}
+
+	file := &hcl.File{
+		Body: &body{
+			val: rootNode,
+		},
+		Bytes: src,
+		Nav:   navigation{rootNode},
+	}
+	return file, diags
+}
+
+// ParseFile is a convenience wrapper around Parse that first attempts to load
+// data from the given filename, passing the result to Parse if successful.
+//
+// If the file cannot be read, an error diagnostic with nil context is returned.
+func ParseFile(filename string) (*hcl.File, hcl.Diagnostics) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Failed to open file",
+				Detail:   fmt.Sprintf("The file %q could not be opened.", filename),
+			},
+		}
+	}
+	defer f.Close()
+
+	src, err := ioutil.ReadAll(f)
+	if err != nil {
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Failed to read file",
+				Detail:   fmt.Sprintf("The file %q was opened, but an error occured while reading it.", filename),
+			},
+		}
+	}
+
+	return Parse(src, filename)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/scanner.go b/vendor/github.com/hashicorp/hcl/v2/json/scanner.go
new file mode 100644
index 000000000..912eabce2
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/scanner.go
@@ -0,0 +1,297 @@
+package json
+
+import (
+	"fmt"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+	"github.com/hashicorp/hcl/v2"
+)
+
+//go:generate stringer -type tokenType scanner.go
+type tokenType rune
+
+const (
+	tokenBraceO  tokenType = '{'
+	tokenBraceC  tokenType = '}'
+	tokenBrackO  tokenType = '['
+	tokenBrackC  tokenType = ']'
+	tokenComma   tokenType = ','
+	tokenColon   tokenType = ':'
+	tokenKeyword tokenType = 'K'
+	tokenString  tokenType = 'S'
+	tokenNumber  tokenType = 'N'
+	tokenEOF     tokenType = '␄'
+	tokenInvalid tokenType = 0
+	tokenEquals  tokenType = '=' // used only for reminding the user of JSON syntax
+)
+
+type token struct {
+	Type  tokenType
+	Bytes []byte
+	Range hcl.Range
+}
+
+// scan returns the primary tokens for the given JSON buffer in sequence.
+//
+// The responsibility of this pass is to just mark the slices of the buffer
+// as being of various types. It is lax in how it interprets the multi-byte
+// token types keyword, string and number, preferring to capture erroneous
+// extra bytes that we presume the user intended to be part of the token
+// so that we can generate more helpful diagnostics in the parser.
+func scan(buf []byte, start pos) []token {
+	var tokens []token
+	p := start
+	for {
+		if len(buf) == 0 {
+			tokens = append(tokens, token{
+				Type:  tokenEOF,
+				Bytes: nil,
+				Range: posRange(p, p),
+			})
+			return tokens
+		}
+
+		buf, p = skipWhitespace(buf, p)
+
+		if len(buf) == 0 {
+			tokens = append(tokens, token{
+				Type:  tokenEOF,
+				Bytes: nil,
+				Range: posRange(p, p),
+			})
+			return tokens
+		}
+
+		start = p
+
+		first := buf[0]
+		switch {
+		case first == '{' || first == '}' || first == '[' || first == ']' || first == ',' || first == ':' || first == '=':
+			p.Pos.Column++
+			p.Pos.Byte++
+			tokens = append(tokens, token{
+				Type:  tokenType(first),
+				Bytes: buf[0:1],
+				Range: posRange(start, p),
+			})
+			buf = buf[1:]
+		case first == '"':
+			var tokBuf []byte
+			tokBuf, buf, p = scanString(buf, p)
+			tokens = append(tokens, token{
+				Type:  tokenString,
+				Bytes: tokBuf,
+				Range: posRange(start, p),
+			})
+		case byteCanStartNumber(first):
+			var tokBuf []byte
+			tokBuf, buf, p = scanNumber(buf, p)
+			tokens = append(tokens, token{
+				Type:  tokenNumber,
+				Bytes: tokBuf,
+				Range: posRange(start, p),
+			})
+		case byteCanStartKeyword(first):
+			var tokBuf []byte
+			tokBuf, buf, p = scanKeyword(buf, p)
+			tokens = append(tokens, token{
+				Type:  tokenKeyword,
+				Bytes: tokBuf,
+				Range: posRange(start, p),
+			})
+		default:
+			tokens = append(tokens, token{
+				Type:  tokenInvalid,
+				Bytes: buf[:1],
+				Range: start.Range(1, 1),
+			})
+			// If we've encountered an invalid then we might as well stop
+			// scanning since the parser won't proceed beyond this point.
+			return tokens
+		}
+	}
+}
+
+func byteCanStartNumber(b byte) bool {
+	switch b {
+	// We are slightly more tolerant than JSON requires here since we
+	// expect the parser will make a stricter interpretation of the
+	// number bytes, but we specifically don't allow 'e' or 'E' here
+	// since we want the scanner to treat that as the start of an
+	// invalid keyword instead, to produce more intelligible error messages.
+	case '-', '+', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		return true
+	default:
+		return false
+	}
+}
+
+func scanNumber(buf []byte, start pos) ([]byte, []byte, pos) {
+	// The scanner doesn't check that the sequence of digit-ish bytes is
+	// in a valid order. The parser must do this when decoding a number
+	// token.
+	var i int
+	p := start
+Byte:
+	for i = 0; i < len(buf); i++ {
+		switch buf[i] {
+		case '-', '+', '.', 'e', 'E', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			p.Pos.Byte++
+			p.Pos.Column++
+		default:
+			break Byte
+		}
+	}
+	return buf[:i], buf[i:], p
+}
+
+func byteCanStartKeyword(b byte) bool {
+	switch {
+	// We allow any sequence of alphabetical characters here, even though
+	// JSON is more constrained, so that we can collect what we presume
+	// the user intended to be a single keyword and then check its validity
+	// in the parser, where we can generate better diagnostics.
+	// So e.g. we want to be able to say:
+	//   unrecognized keyword "True". Did you mean "true"?
+	case isAlphabetical(b):
+		return true
+	default:
+		return false
+	}
+}
+
+func scanKeyword(buf []byte, start pos) ([]byte, []byte, pos) {
+	var i int
+	p := start
+Byte:
+	for i = 0; i < len(buf); i++ {
+		b := buf[i]
+		switch {
+		case isAlphabetical(b) || b == '_':
+			p.Pos.Byte++
+			p.Pos.Column++
+		default:
+			break Byte
+		}
+	}
+	return buf[:i], buf[i:], p
+}
+
+func scanString(buf []byte, start pos) ([]byte, []byte, pos) {
+	// The scanner doesn't validate correct use of escapes, etc. It pays
+	// attention to escapes only for the purpose of identifying the closing
+	// quote character. It's the parser's responsibility to do proper
+	// validation.
+	//
+	// The scanner also doesn't specifically detect unterminated string
+	// literals, though they can be identified in the parser by checking if
+	// the final byte in a string token is the double-quote character.
+
+	// Skip the opening quote symbol
+	i := 1
+	p := start
+	p.Pos.Byte++
+	p.Pos.Column++
+	escaping := false
+Byte:
+	for i < len(buf) {
+		b := buf[i]
+
+		switch {
+		case b == '\\':
+			escaping = !escaping
+			p.Pos.Byte++
+			p.Pos.Column++
+			i++
+		case b == '"':
+			p.Pos.Byte++
+			p.Pos.Column++
+			i++
+			if !escaping {
+				break Byte
+			}
+			escaping = false
+		case b < 32:
+			break Byte
+		default:
+			// Advance by one grapheme cluster, so that we consider each
+			// grapheme to be a "column".
+			// Ignoring error because this scanner cannot produce errors.
+			advance, _, _ := textseg.ScanGraphemeClusters(buf[i:], true)
+
+			p.Pos.Byte += advance
+			p.Pos.Column++
+			i += advance
+
+			escaping = false
+		}
+	}
+	return buf[:i], buf[i:], p
+}
+
+func skipWhitespace(buf []byte, start pos) ([]byte, pos) {
+	var i int
+	p := start
+Byte:
+	for i = 0; i < len(buf); i++ {
+		switch buf[i] {
+		case ' ':
+			p.Pos.Byte++
+			p.Pos.Column++
+		case '\n':
+			p.Pos.Byte++
+			p.Pos.Column = 1
+			p.Pos.Line++
+		case '\r':
+			// For the purpose of line/column counting we consider a
+			// carriage return to take up no space, assuming that it will
+			// be paired up with a newline (on Windows, for example) that
+			// will account for both of them.
+			p.Pos.Byte++
+		case '\t':
+			// We arbitrarily count a tab as if it were two spaces, because
+			// we need to choose _some_ number here. This means any system
+			// that renders code on-screen with markers must itself treat
+			// tabs as a pair of spaces for rendering purposes, or instead
+			// use the byte offset and back into its own column position.
+			p.Pos.Byte++
+			p.Pos.Column += 2
+		default:
+			break Byte
+		}
+	}
+	return buf[i:], p
+}
+
+type pos struct {
+	Filename string
+	Pos      hcl.Pos
+}
+
+func (p *pos) Range(byteLen, charLen int) hcl.Range {
+	start := p.Pos
+	end := p.Pos
+	end.Byte += byteLen
+	end.Column += charLen
+	return hcl.Range{
+		Filename: p.Filename,
+		Start:    start,
+		End:      end,
+	}
+}
+
+func posRange(start, end pos) hcl.Range {
+	return hcl.Range{
+		Filename: start.Filename,
+		Start:    start.Pos,
+		End:      end.Pos,
+	}
+}
+
+func (t token) GoString() string {
+	return fmt.Sprintf("json.token{json.%s, []byte(%q), %#v}", t.Type, t.Bytes, t.Range)
+}
+
+func isAlphabetical(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/spec.md b/vendor/github.com/hashicorp/hcl/v2/json/spec.md
new file mode 100644
index 000000000..dac5729d4
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/spec.md
@@ -0,0 +1,405 @@
+# HCL JSON Syntax Specification
+
+This is the specification for the JSON serialization for hcl. HCL is a system
+for defining configuration languages for applications. The HCL information
+model is designed to support multiple concrete syntaxes for configuration,
+and this JSON-based format complements [the native syntax](../hclsyntax/spec.md)
+by being easy to machine-generate, whereas the native syntax is oriented
+towards human authoring and maintenance
+
+This syntax is defined in terms of JSON as defined in
+[RFC7159](https://tools.ietf.org/html/rfc7159). As such it inherits the JSON
+grammar as-is, and merely defines a specific methodology for interpreting
+JSON constructs into HCL structural elements and expressions.
+
+This mapping is defined such that valid JSON-serialized HCL input can be
+_produced_ using standard JSON implementations in various programming languages.
+_Parsing_ such JSON has some additional constraints not beyond what is normally
+supported by JSON parsers, so a specialized parser may be required that
+is able to:
+
+- Preserve the relative ordering of properties defined in an object.
+- Preserve multiple definitions of the same property name.
+- Preserve numeric values to the precision required by the number type
+  in [the HCL syntax-agnostic information model](../spec.md).
+- Retain source location information for parsed tokens/constructs in order
+  to produce good error messages.
+
+## Structural Elements
+
+[The HCL syntax-agnostic information model](../spec.md) defines a _body_ as an
+abstract container for attribute definitions and child blocks. A body is
+represented in JSON as either a single JSON object or a JSON array of objects.
+
+Body processing is in terms of JSON object properties, visited in the order
+they appear in the input. Where a body is represented by a single JSON object,
+the properties of that object are visited in order. Where a body is
+represented by a JSON array, each of its elements are visited in order and
+each element has its properties visited in order. If any element of the array
+is not a JSON object then the input is erroneous.
+
+When a body is being processed in the _dynamic attributes_ mode, the allowance
+of a JSON array in the previous paragraph does not apply and instead a single
+JSON object is always required.
+
+As defined in the language-agnostic model, body processing is in terms
+of a schema which provides context for interpreting the body's content. For
+JSON bodies, the schema is crucial to allow differentiation of attribute
+definitions and block definitions, both of which are represented via object
+properties.
+
+The special property name `"//"`, when used in an object representing a HCL
+body, is parsed and ignored. A property with this name can be used to
+include human-readable comments. (This special property name is _not_
+processed in this way for any _other_ HCL constructs that are represented as
+JSON objects.)
+
+### Attributes
+
+Where the given schema describes an attribute with a given name, the object
+property with the matching name — if present — serves as the attribute's
+definition.
+
+When a body is being processed in the _dynamic attributes_ mode, each object
+property serves as an attribute definition for the attribute whose name
+matches the property name.
+
+The value of an attribute definition property is interpreted as an _expression_,
+as described in a later section.
+
+Given a schema that calls for an attribute named "foo", a JSON object like
+the following provides a definition for that attribute:
+
+```json
+{
+  "foo": "bar baz"
+}
+```
+
+### Blocks
+
+Where the given schema describes a block with a given type name, each object
+property with the matching name serves as a definition of zero or more blocks
+of that type.
+
+Processing of child blocks is in terms of nested JSON objects and arrays.
+If the schema defines one or more _labels_ for the block type, a nested JSON
+object or JSON array of objects is required for each labelling level. These
+are flattened to a single ordered sequence of object properties using the
+same algorithm as for body content as defined above. Each object property
+serves as a label value at the corresponding level.
+
+After any labelling levels, the next nested value is either a JSON object
+representing a single block body, or a JSON array of JSON objects that each
+represent a single block body. Use of an array accommodates the definition
+of multiple blocks that have identical type and labels.
+
+Given a schema that calls for a block type named "foo" with no labels, the
+following JSON objects are all valid definitions of zero or more blocks of this
+type:
+
+```json
+{
+  "foo": {
+    "child_attr": "baz"
+  }
+}
+```
+
+```json
+{
+  "foo": [
+    {
+      "child_attr": "baz"
+    },
+    {
+      "child_attr": "boz"
+    }
+  ]
+}
+```
+
+```json
+{
+  "foo": []
+}
+```
+
+The first of these defines a single child block of type "foo". The second
+defines _two_ such blocks. The final example shows a degenerate definition
+of zero blocks, though generators should prefer to omit the property entirely
+in this scenario.
+
+Given a schema that calls for a block type named "foo" with _two_ labels, the
+extra label levels must be represented as objects or arrays of objects as in
+the following examples:
+
+```json
+{
+  "foo": {
+    "bar": {
+      "baz": {
+        "child_attr": "baz"
+      },
+      "boz": {
+        "child_attr": "baz"
+      }
+    },
+    "boz": {
+      "baz": {
+        "child_attr": "baz"
+      }
+    }
+  }
+}
+```
+
+```json
+{
+  "foo": {
+    "bar": {
+      "baz": {
+        "child_attr": "baz"
+      },
+      "boz": {
+        "child_attr": "baz"
+      }
+    },
+    "boz": {
+      "baz": [
+        {
+          "child_attr": "baz"
+        },
+        {
+          "child_attr": "boz"
+        }
+      ]
+    }
+  }
+}
+```
+
+```json
+{
+  "foo": [
+    {
+      "bar": {
+        "baz": {
+          "child_attr": "baz"
+        },
+        "boz": {
+          "child_attr": "baz"
+        }
+      }
+    },
+    {
+      "bar": {
+        "baz": [
+          {
+            "child_attr": "baz"
+          },
+          {
+            "child_attr": "boz"
+          }
+        ]
+      }
+    }
+  ]
+}
+```
+
+```json
+{
+  "foo": {
+    "bar": {
+      "baz": {
+        "child_attr": "baz"
+      },
+      "boz": {
+        "child_attr": "baz"
+      }
+    },
+    "bar": {
+      "baz": [
+        {
+          "child_attr": "baz"
+        },
+        {
+          "child_attr": "boz"
+        }
+      ]
+    }
+  }
+}
+```
+
+Arrays can be introduced at either the label definition or block body
+definition levels to define multiple definitions of the same block type
+or labels while preserving order.
+
+A JSON HCL parser _must_ support duplicate definitions of the same property
+name within a single object, preserving all of them and the relative ordering
+between them. The array-based forms are also required so that JSON HCL
+configurations can be produced with JSON producing libraries that are not
+able to preserve property definition order and multiple definitions of
+the same property.
+
+## Expressions
+
+JSON lacks a native expression syntax, so the HCL JSON syntax instead defines
+a mapping for each of the JSON value types, including a special mapping for
+strings that allows optional use of arbitrary expressions.
+
+### Objects
+
+When interpreted as an expression, a JSON object represents a value of a HCL
+object type.
+
+Each property of the JSON object represents an attribute of the HCL object type.
+The property name string given in the JSON input is interpreted as a string
+expression as described below, and its result is converted to string as defined
+by the syntax-agnostic information model. If such a conversion is not possible,
+an error is produced and evaluation fails.
+
+An instance of the constructed object type is then created, whose values
+are interpreted by again recursively applying the mapping rules defined in
+this section to each of the property values.
+
+If any evaluated property name strings produce null values, an error is
+produced and evaluation fails. If any produce _unknown_ values, the _entire
+object's_ result is an unknown value of the dynamic pseudo-type, signalling
+that the type of the object cannot be determined.
+
+It is an error to define the same property name multiple times within a single
+JSON object interpreted as an expression. In full expression mode, this
+constraint applies to the name expression results after conversion to string,
+rather than the raw string that may contain interpolation expressions.
+
+### Arrays
+
+When interpreted as an expression, a JSON array represents a value of a HCL
+tuple type.
+
+Each element of the JSON array represents an element of the HCL tuple type.
+The tuple type is constructed by enumerating the JSON array elements, creating
+for each an element whose type is the result of recursively applying the
+expression mapping rules. Correspondence is preserved between the array element
+indices and the tuple element indices.
+
+An instance of the constructed tuple type is then created, whose values are
+interpreted by again recursively applying the mapping rules defined in this
+section.
+
+### Numbers
+
+When interpreted as an expression, a JSON number represents a HCL number value.
+
+HCL numbers are arbitrary-precision decimal values, so a JSON HCL parser must
+be able to translate exactly the value given to a number of corresponding
+precision, within the constraints set by the HCL syntax-agnostic information
+model.
+
+In practice, off-the-shelf JSON serializers often do not support customizing the
+processing of numbers, and instead force processing as 32-bit or 64-bit
+floating point values.
+
+A _producer_ of JSON HCL that uses such a serializer can provide numeric values
+as JSON strings where they have precision too great for representation in the
+serializer's chosen numeric type in situations where the result will be
+converted to number (using the standard conversion rules) by a calling
+application.
+
+Alternatively, for expressions that are evaluated in full expression mode an
+embedded template interpolation can be used to faithfully represent a number,
+such as `"${1e150}"`, which will then be evaluated by the underlying HCL native
+syntax expression evaluator.
+
+### Boolean Values
+
+The JSON boolean values `true` and `false`, when interpreted as expressions,
+represent the corresponding HCL boolean values.
+
+### The Null Value
+
+The JSON value `null`, when interpreted as an expression, represents a
+HCL null value of the dynamic pseudo-type.
+
+### Strings
+
+When interpreted as an expression, a JSON string may be interpreted in one of
+two ways depending on the evaluation mode.
+
+If evaluating in literal-only mode (as defined by the syntax-agnostic
+information model) the literal string is intepreted directly as a HCL string
+value, by directly using the exact sequence of unicode characters represented.
+Template interpolations and directives MUST NOT be processed in this mode,
+allowing any characters that appear as introduction sequences to pass through
+literally:
+
+```json
+"Hello world! Template sequences like ${ are not intepreted here."
+```
+
+When evaluating in full expression mode (again, as defined by the syntax-
+agnostic information model) the literal string is instead interpreted as a
+_standalone template_ in the HCL Native Syntax. The expression evaluation
+result is then the direct result of evaluating that template with the current
+variable scope and function table.
+
+```json
+"Hello, ${name}! Template sequences are interpreted in full expression mode."
+```
+
+In particular the _Template Interpolation Unwrapping_ requirement from the
+HCL native syntax specification must be implemented, allowing the use of
+single-interpolation templates to represent expressions that would not
+otherwise be representable in JSON, such as the following example where
+the result must be a number, rather than a string representation of a number:
+
+```json
+"${ a + b }"
+```
+
+## Static Analysis
+
+The HCL static analysis operations are implemented for JSON values that
+represent expressions, as described in the following sections.
+
+Due to the limited expressive power of the JSON syntax alone, use of these
+static analyses functions rather than normal expression evaluation is used
+as additional context for how a JSON value is to be interpreted, which means
+that static analyses can result in a different interpretation of a given
+expression than normal evaluation.
+
+### Static List
+
+An expression interpreted as a static list must be a JSON array. Each of the
+values in the array is interpreted as an expression and returned.
+
+### Static Map
+
+An expression interpreted as a static map must be a JSON object. Each of the
+key/value pairs in the object is presented as a pair of expressions. Since
+object property names are always strings, evaluating the key expression with
+a non-`nil` evaluation context will evaluate any template sequences given
+in the property name.
+
+### Static Call
+
+An expression interpreted as a static call must be a string. The content of
+the string is interpreted as a native syntax expression (not a _template_,
+unlike normal evaluation) and then the static call analysis is delegated to
+that expression.
+
+If the original expression is not a string or its contents cannot be parsed
+as a native syntax expression then static call analysis is not supported.
+
+### Static Traversal
+
+An expression interpreted as a static traversal must be a string. The content
+of the string is interpreted as a native syntax expression (not a _template_,
+unlike normal evaluation) and then static traversal analysis is delegated
+to that expression.
+
+If the original expression is not a string or its contents cannot be parsed
+as a native syntax expression then static call analysis is not supported.
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/structure.go b/vendor/github.com/hashicorp/hcl/v2/json/structure.go
new file mode 100644
index 000000000..76c9d7399
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/structure.go
@@ -0,0 +1,637 @@
+package json
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+// body is the implementation of "Body" used for files processed with the JSON
+// parser.
+type body struct {
+	val node
+
+	// If non-nil, the keys of this map cause the corresponding attributes to
+	// be treated as non-existing. This is used when Body.PartialContent is
+	// called, to produce the "remaining content" Body.
+	hiddenAttrs map[string]struct{}
+}
+
+// expression is the implementation of "Expression" used for files processed
+// with the JSON parser.
+type expression struct {
+	src node
+}
+
+func (b *body) Content(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Diagnostics) {
+	content, newBody, diags := b.PartialContent(schema)
+
+	hiddenAttrs := newBody.(*body).hiddenAttrs
+
+	var nameSuggestions []string
+	for _, attrS := range schema.Attributes {
+		if _, ok := hiddenAttrs[attrS.Name]; !ok {
+			// Only suggest an attribute name if we didn't use it already.
+			nameSuggestions = append(nameSuggestions, attrS.Name)
+		}
+	}
+	for _, blockS := range schema.Blocks {
+		// Blocks can appear multiple times, so we'll suggest their type
+		// names regardless of whether they've already been used.
+		nameSuggestions = append(nameSuggestions, blockS.Type)
+	}
+
+	jsonAttrs, attrDiags := b.collectDeepAttrs(b.val, nil)
+	diags = append(diags, attrDiags...)
+
+	for _, attr := range jsonAttrs {
+		k := attr.Name
+		if k == "//" {
+			// Ignore "//" keys in objects representing bodies, to allow
+			// their use as comments.
+			continue
+		}
+
+		if _, ok := hiddenAttrs[k]; !ok {
+			suggestion := nameSuggestion(k, nameSuggestions)
+			if suggestion != "" {
+				suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+			}
+
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Extraneous JSON object property",
+				Detail:   fmt.Sprintf("No argument or block type is named %q.%s", k, suggestion),
+				Subject:  &attr.NameRange,
+				Context:  attr.Range().Ptr(),
+			})
+		}
+	}
+
+	return content, diags
+}
+
+func (b *body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	jsonAttrs, attrDiags := b.collectDeepAttrs(b.val, nil)
+	diags = append(diags, attrDiags...)
+
+	usedNames := map[string]struct{}{}
+	if b.hiddenAttrs != nil {
+		for k := range b.hiddenAttrs {
+			usedNames[k] = struct{}{}
+		}
+	}
+
+	content := &hcl.BodyContent{
+		Attributes: map[string]*hcl.Attribute{},
+		Blocks:     nil,
+
+		MissingItemRange: b.MissingItemRange(),
+	}
+
+	// Create some more convenient data structures for our work below.
+	attrSchemas := map[string]hcl.AttributeSchema{}
+	blockSchemas := map[string]hcl.BlockHeaderSchema{}
+	for _, attrS := range schema.Attributes {
+		attrSchemas[attrS.Name] = attrS
+	}
+	for _, blockS := range schema.Blocks {
+		blockSchemas[blockS.Type] = blockS
+	}
+
+	for _, jsonAttr := range jsonAttrs {
+		attrName := jsonAttr.Name
+		if _, used := b.hiddenAttrs[attrName]; used {
+			continue
+		}
+
+		if attrS, defined := attrSchemas[attrName]; defined {
+			if existing, exists := content.Attributes[attrName]; exists {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Duplicate argument",
+					Detail:   fmt.Sprintf("The argument %q was already set at %s.", attrName, existing.Range),
+					Subject:  &jsonAttr.NameRange,
+					Context:  jsonAttr.Range().Ptr(),
+				})
+				continue
+			}
+
+			content.Attributes[attrS.Name] = &hcl.Attribute{
+				Name:      attrS.Name,
+				Expr:      &expression{src: jsonAttr.Value},
+				Range:     hcl.RangeBetween(jsonAttr.NameRange, jsonAttr.Value.Range()),
+				NameRange: jsonAttr.NameRange,
+			}
+			usedNames[attrName] = struct{}{}
+
+		} else if blockS, defined := blockSchemas[attrName]; defined {
+			bv := jsonAttr.Value
+			blockDiags := b.unpackBlock(bv, blockS.Type, &jsonAttr.NameRange, blockS.LabelNames, nil, nil, &content.Blocks)
+			diags = append(diags, blockDiags...)
+			usedNames[attrName] = struct{}{}
+		}
+
+		// We ignore anything that isn't defined because that's the
+		// PartialContent contract. The Content method will catch leftovers.
+	}
+
+	// Make sure we got all the required attributes.
+	for _, attrS := range schema.Attributes {
+		if !attrS.Required {
+			continue
+		}
+		if _, defined := content.Attributes[attrS.Name]; !defined {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing required argument",
+				Detail:   fmt.Sprintf("The argument %q is required, but no definition was found.", attrS.Name),
+				Subject:  b.MissingItemRange().Ptr(),
+			})
+		}
+	}
+
+	unusedBody := &body{
+		val:         b.val,
+		hiddenAttrs: usedNames,
+	}
+
+	return content, unusedBody, diags
+}
+
+// JustAttributes for JSON bodies interprets all properties of the wrapped
+// JSON object as attributes and returns them.
+func (b *body) JustAttributes() (hcl.Attributes, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	attrs := make(map[string]*hcl.Attribute)
+
+	obj, ok := b.val.(*objectVal)
+	if !ok {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Incorrect JSON value type",
+			Detail:   "A JSON object is required here, setting the arguments for this block.",
+			Subject:  b.val.StartRange().Ptr(),
+		})
+		return attrs, diags
+	}
+
+	for _, jsonAttr := range obj.Attrs {
+		name := jsonAttr.Name
+		if name == "//" {
+			// Ignore "//" keys in objects representing bodies, to allow
+			// their use as comments.
+			continue
+		}
+
+		if _, hidden := b.hiddenAttrs[name]; hidden {
+			continue
+		}
+
+		if existing, exists := attrs[name]; exists {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Duplicate attribute definition",
+				Detail:   fmt.Sprintf("The argument %q was already set at %s.", name, existing.Range),
+				Subject:  &jsonAttr.NameRange,
+			})
+			continue
+		}
+
+		attrs[name] = &hcl.Attribute{
+			Name:      name,
+			Expr:      &expression{src: jsonAttr.Value},
+			Range:     hcl.RangeBetween(jsonAttr.NameRange, jsonAttr.Value.Range()),
+			NameRange: jsonAttr.NameRange,
+		}
+	}
+
+	// No diagnostics possible here, since the parser already took care of
+	// finding duplicates and every JSON value can be a valid attribute value.
+	return attrs, diags
+}
+
+func (b *body) MissingItemRange() hcl.Range {
+	switch tv := b.val.(type) {
+	case *objectVal:
+		return tv.CloseRange
+	case *arrayVal:
+		return tv.OpenRange
+	default:
+		// Should not happen in correct operation, but might show up if the
+		// input is invalid and we are producing partial results.
+		return tv.StartRange()
+	}
+}
+
+func (b *body) unpackBlock(v node, typeName string, typeRange *hcl.Range, labelsLeft []string, labelsUsed []string, labelRanges []hcl.Range, blocks *hcl.Blocks) (diags hcl.Diagnostics) {
+	if len(labelsLeft) > 0 {
+		labelName := labelsLeft[0]
+		jsonAttrs, attrDiags := b.collectDeepAttrs(v, &labelName)
+		diags = append(diags, attrDiags...)
+
+		if len(jsonAttrs) == 0 {
+			diags = diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Missing block label",
+				Detail:   fmt.Sprintf("At least one object property is required, whose name represents the %s block's %s.", typeName, labelName),
+				Subject:  v.StartRange().Ptr(),
+			})
+			return
+		}
+		labelsUsed := append(labelsUsed, "")
+		labelRanges := append(labelRanges, hcl.Range{})
+		for _, p := range jsonAttrs {
+			pk := p.Name
+			labelsUsed[len(labelsUsed)-1] = pk
+			labelRanges[len(labelRanges)-1] = p.NameRange
+			diags = append(diags, b.unpackBlock(p.Value, typeName, typeRange, labelsLeft[1:], labelsUsed, labelRanges, blocks)...)
+		}
+		return
+	}
+
+	// By the time we get here, we've peeled off all the labels and we're ready
+	// to deal with the block's actual content.
+
+	// need to copy the label slices because their underlying arrays will
+	// continue to be mutated after we return.
+	labels := make([]string, len(labelsUsed))
+	copy(labels, labelsUsed)
+	labelR := make([]hcl.Range, len(labelRanges))
+	copy(labelR, labelRanges)
+
+	switch tv := v.(type) {
+	case *nullVal:
+		// There is no block content, e.g the value is null.
+		return
+	case *objectVal:
+		// Single instance of the block
+		*blocks = append(*blocks, &hcl.Block{
+			Type:   typeName,
+			Labels: labels,
+			Body: &body{
+				val: tv,
+			},
+
+			DefRange:    tv.OpenRange,
+			TypeRange:   *typeRange,
+			LabelRanges: labelR,
+		})
+	case *arrayVal:
+		// Multiple instances of the block
+		for _, av := range tv.Values {
+			*blocks = append(*blocks, &hcl.Block{
+				Type:   typeName,
+				Labels: labels,
+				Body: &body{
+					val: av, // might be mistyped; we'll find out when content is requested for this body
+				},
+
+				DefRange:    tv.OpenRange,
+				TypeRange:   *typeRange,
+				LabelRanges: labelR,
+			})
+		}
+	default:
+		diags = diags.Append(&hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Incorrect JSON value type",
+			Detail:   fmt.Sprintf("Either a JSON object or a JSON array is required, representing the contents of one or more %q blocks.", typeName),
+			Subject:  v.StartRange().Ptr(),
+		})
+	}
+	return
+}
+
+// collectDeepAttrs takes either a single object or an array of objects and
+// flattens it into a list of object attributes, collecting attributes from
+// all of the objects in a given array.
+//
+// Ordering is preserved, so a list of objects that each have one property
+// will result in those properties being returned in the same order as the
+// objects appeared in the array.
+//
+// This is appropriate for use only for objects representing bodies or labels
+// within a block.
+//
+// The labelName argument, if non-null, is used to tailor returned error
+// messages to refer to block labels rather than attributes and child blocks.
+// It has no other effect.
+func (b *body) collectDeepAttrs(v node, labelName *string) ([]*objectAttr, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+	var attrs []*objectAttr
+
+	switch tv := v.(type) {
+	case *nullVal:
+		// If a value is null, then we don't return any attributes or return an error.
+
+	case *objectVal:
+		attrs = append(attrs, tv.Attrs...)
+
+	case *arrayVal:
+		for _, ev := range tv.Values {
+			switch tev := ev.(type) {
+			case *objectVal:
+				attrs = append(attrs, tev.Attrs...)
+			default:
+				if labelName != nil {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Incorrect JSON value type",
+						Detail:   fmt.Sprintf("A JSON object is required here, to specify %s labels for this block.", *labelName),
+						Subject:  ev.StartRange().Ptr(),
+					})
+				} else {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Incorrect JSON value type",
+						Detail:   "A JSON object is required here, to define arguments and child blocks.",
+						Subject:  ev.StartRange().Ptr(),
+					})
+				}
+			}
+		}
+
+	default:
+		if labelName != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Incorrect JSON value type",
+				Detail:   fmt.Sprintf("Either a JSON object or JSON array of objects is required here, to specify %s labels for this block.", *labelName),
+				Subject:  v.StartRange().Ptr(),
+			})
+		} else {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Incorrect JSON value type",
+				Detail:   "Either a JSON object or JSON array of objects is required here, to define arguments and child blocks.",
+				Subject:  v.StartRange().Ptr(),
+			})
+		}
+	}
+
+	return attrs, diags
+}
+
+func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	switch v := e.src.(type) {
+	case *stringVal:
+		if ctx != nil {
+			// Parse string contents as a HCL native language expression.
+			// We only do this if we have a context, so passing a nil context
+			// is how the caller specifies that interpolations are not allowed
+			// and that the string should just be returned verbatim.
+			templateSrc := v.Value
+			expr, diags := hclsyntax.ParseTemplate(
+				[]byte(templateSrc),
+				v.SrcRange.Filename,
+
+				// This won't produce _exactly_ the right result, since
+				// the hclsyntax parser can't "see" any escapes we removed
+				// while parsing JSON, but it's better than nothing.
+				hcl.Pos{
+					Line: v.SrcRange.Start.Line,
+
+					// skip over the opening quote mark
+					Byte:   v.SrcRange.Start.Byte + 1,
+					Column: v.SrcRange.Start.Column + 1,
+				},
+			)
+			if diags.HasErrors() {
+				return cty.DynamicVal, diags
+			}
+			val, evalDiags := expr.Value(ctx)
+			diags = append(diags, evalDiags...)
+			return val, diags
+		}
+
+		return cty.StringVal(v.Value), nil
+	case *numberVal:
+		return cty.NumberVal(v.Value), nil
+	case *booleanVal:
+		return cty.BoolVal(v.Value), nil
+	case *arrayVal:
+		var diags hcl.Diagnostics
+		vals := []cty.Value{}
+		for _, jsonVal := range v.Values {
+			val, valDiags := (&expression{src: jsonVal}).Value(ctx)
+			vals = append(vals, val)
+			diags = append(diags, valDiags...)
+		}
+		return cty.TupleVal(vals), diags
+	case *objectVal:
+		var diags hcl.Diagnostics
+		attrs := map[string]cty.Value{}
+		attrRanges := map[string]hcl.Range{}
+		known := true
+		for _, jsonAttr := range v.Attrs {
+			// In this one context we allow keys to contain interpolation
+			// expressions too, assuming we're evaluating in interpolation
+			// mode. This achieves parity with the native syntax where
+			// object expressions can have dynamic keys, while block contents
+			// may not.
+			name, nameDiags := (&expression{src: &stringVal{
+				Value:    jsonAttr.Name,
+				SrcRange: jsonAttr.NameRange,
+			}}).Value(ctx)
+			valExpr := &expression{src: jsonAttr.Value}
+			val, valDiags := valExpr.Value(ctx)
+			diags = append(diags, nameDiags...)
+			diags = append(diags, valDiags...)
+
+			var err error
+			name, err = convert.Convert(name, cty.String)
+			if err != nil {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity:    hcl.DiagError,
+					Summary:     "Invalid object key expression",
+					Detail:      fmt.Sprintf("Cannot use this expression as an object key: %s.", err),
+					Subject:     &jsonAttr.NameRange,
+					Expression:  valExpr,
+					EvalContext: ctx,
+				})
+				continue
+			}
+			if name.IsNull() {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity:    hcl.DiagError,
+					Summary:     "Invalid object key expression",
+					Detail:      "Cannot use null value as an object key.",
+					Subject:     &jsonAttr.NameRange,
+					Expression:  valExpr,
+					EvalContext: ctx,
+				})
+				continue
+			}
+			if !name.IsKnown() {
+				// This is a bit of a weird case, since our usual rules require
+				// us to tolerate unknowns and just represent the result as
+				// best we can but if we don't know the key then we can't
+				// know the type of our object at all, and thus we must turn
+				// the whole thing into cty.DynamicVal. This is consistent with
+				// how this situation is handled in the native syntax.
+				// We'll keep iterating so we can collect other errors in
+				// subsequent attributes.
+				known = false
+				continue
+			}
+			nameStr := name.AsString()
+			if _, defined := attrs[nameStr]; defined {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity:    hcl.DiagError,
+					Summary:     "Duplicate object attribute",
+					Detail:      fmt.Sprintf("An attribute named %q was already defined at %s.", nameStr, attrRanges[nameStr]),
+					Subject:     &jsonAttr.NameRange,
+					Expression:  e,
+					EvalContext: ctx,
+				})
+				continue
+			}
+			attrs[nameStr] = val
+			attrRanges[nameStr] = jsonAttr.NameRange
+		}
+		if !known {
+			// We encountered an unknown key somewhere along the way, so
+			// we can't know what our type will eventually be.
+			return cty.DynamicVal, diags
+		}
+		return cty.ObjectVal(attrs), diags
+	case *nullVal:
+		return cty.NullVal(cty.DynamicPseudoType), nil
+	default:
+		// Default to DynamicVal so that ASTs containing invalid nodes can
+		// still be partially-evaluated.
+		return cty.DynamicVal, nil
+	}
+}
+
+func (e *expression) Variables() []hcl.Traversal {
+	var vars []hcl.Traversal
+
+	switch v := e.src.(type) {
+	case *stringVal:
+		templateSrc := v.Value
+		expr, diags := hclsyntax.ParseTemplate(
+			[]byte(templateSrc),
+			v.SrcRange.Filename,
+
+			// This won't produce _exactly_ the right result, since
+			// the hclsyntax parser can't "see" any escapes we removed
+			// while parsing JSON, but it's better than nothing.
+			hcl.Pos{
+				Line: v.SrcRange.Start.Line,
+
+				// skip over the opening quote mark
+				Byte:   v.SrcRange.Start.Byte + 1,
+				Column: v.SrcRange.Start.Column + 1,
+			},
+		)
+		if diags.HasErrors() {
+			return vars
+		}
+		return expr.Variables()
+
+	case *arrayVal:
+		for _, jsonVal := range v.Values {
+			vars = append(vars, (&expression{src: jsonVal}).Variables()...)
+		}
+	case *objectVal:
+		for _, jsonAttr := range v.Attrs {
+			keyExpr := &stringVal{ // we're going to treat key as an expression in this context
+				Value:    jsonAttr.Name,
+				SrcRange: jsonAttr.NameRange,
+			}
+			vars = append(vars, (&expression{src: keyExpr}).Variables()...)
+			vars = append(vars, (&expression{src: jsonAttr.Value}).Variables()...)
+		}
+	}
+
+	return vars
+}
+
+func (e *expression) Range() hcl.Range {
+	return e.src.Range()
+}
+
+func (e *expression) StartRange() hcl.Range {
+	return e.src.StartRange()
+}
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *expression) AsTraversal() hcl.Traversal {
+	// In JSON-based syntax a traversal is given as a string containing
+	// traversal syntax as defined by hclsyntax.ParseTraversalAbs.
+
+	switch v := e.src.(type) {
+	case *stringVal:
+		traversal, diags := hclsyntax.ParseTraversalAbs([]byte(v.Value), v.SrcRange.Filename, v.SrcRange.Start)
+		if diags.HasErrors() {
+			return nil
+		}
+		return traversal
+	default:
+		return nil
+	}
+}
+
+// Implementation for hcl.ExprCall.
+func (e *expression) ExprCall() *hcl.StaticCall {
+	// In JSON-based syntax a static call is given as a string containing
+	// an expression in the native syntax that also supports ExprCall.
+
+	switch v := e.src.(type) {
+	case *stringVal:
+		expr, diags := hclsyntax.ParseExpression([]byte(v.Value), v.SrcRange.Filename, v.SrcRange.Start)
+		if diags.HasErrors() {
+			return nil
+		}
+
+		call, diags := hcl.ExprCall(expr)
+		if diags.HasErrors() {
+			return nil
+		}
+
+		return call
+	default:
+		return nil
+	}
+}
+
+// Implementation for hcl.ExprList.
+func (e *expression) ExprList() []hcl.Expression {
+	switch v := e.src.(type) {
+	case *arrayVal:
+		ret := make([]hcl.Expression, len(v.Values))
+		for i, node := range v.Values {
+			ret[i] = &expression{src: node}
+		}
+		return ret
+	default:
+		return nil
+	}
+}
+
+// Implementation for hcl.ExprMap.
+func (e *expression) ExprMap() []hcl.KeyValuePair {
+	switch v := e.src.(type) {
+	case *objectVal:
+		ret := make([]hcl.KeyValuePair, len(v.Attrs))
+		for i, jsonAttr := range v.Attrs {
+			ret[i] = hcl.KeyValuePair{
+				Key: &expression{src: &stringVal{
+					Value:    jsonAttr.Name,
+					SrcRange: jsonAttr.NameRange,
+				}},
+				Value: &expression{src: jsonAttr.Value},
+			}
+		}
+		return ret
+	default:
+		return nil
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/json/tokentype_string.go b/vendor/github.com/hashicorp/hcl/v2/json/tokentype_string.go
new file mode 100644
index 000000000..bbcce5b30
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/json/tokentype_string.go
@@ -0,0 +1,29 @@
+// Code generated by "stringer -type tokenType scanner.go"; DO NOT EDIT.
+
+package json
+
+import "strconv"
+
+const _tokenType_name = "tokenInvalidtokenCommatokenColontokenEqualstokenKeywordtokenNumbertokenStringtokenBrackOtokenBrackCtokenBraceOtokenBraceCtokenEOF"
+
+var _tokenType_map = map[tokenType]string{
+	0:    _tokenType_name[0:12],
+	44:   _tokenType_name[12:22],
+	58:   _tokenType_name[22:32],
+	61:   _tokenType_name[32:43],
+	75:   _tokenType_name[43:55],
+	78:   _tokenType_name[55:66],
+	83:   _tokenType_name[66:77],
+	91:   _tokenType_name[77:88],
+	93:   _tokenType_name[88:99],
+	123:  _tokenType_name[99:110],
+	125:  _tokenType_name[110:121],
+	9220: _tokenType_name[121:129],
+}
+
+func (i tokenType) String() string {
+	if str, ok := _tokenType_map[i]; ok {
+		return str
+	}
+	return "tokenType(" + strconv.FormatInt(int64(i), 10) + ")"
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/merged.go b/vendor/github.com/hashicorp/hcl/v2/merged.go
new file mode 100644
index 000000000..96e62a58d
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/merged.go
@@ -0,0 +1,226 @@
+package hcl
+
+import (
+	"fmt"
+)
+
+// MergeFiles combines the given files to produce a single body that contains
+// configuration from all of the given files.
+//
+// The ordering of the given files decides the order in which contained
+// elements will be returned. If any top-level attributes are defined with
+// the same name across multiple files, a diagnostic will be produced from
+// the Content and PartialContent methods describing this error in a
+// user-friendly way.
+func MergeFiles(files []*File) Body {
+	var bodies []Body
+	for _, file := range files {
+		bodies = append(bodies, file.Body)
+	}
+	return MergeBodies(bodies)
+}
+
+// MergeBodies is like MergeFiles except it deals directly with bodies, rather
+// than with entire files.
+func MergeBodies(bodies []Body) Body {
+	if len(bodies) == 0 {
+		// Swap out for our singleton empty body, to reduce the number of
+		// empty slices we have hanging around.
+		return emptyBody
+	}
+
+	// If any of the given bodies are already merged bodies, we'll unpack
+	// to flatten to a single mergedBodies, since that's conceptually simpler.
+	// This also, as a side-effect, eliminates any empty bodies, since
+	// empties are merged bodies with no inner bodies.
+	var newLen int
+	var flatten bool
+	for _, body := range bodies {
+		if children, merged := body.(mergedBodies); merged {
+			newLen += len(children)
+			flatten = true
+		} else {
+			newLen++
+		}
+	}
+
+	if !flatten { // not just newLen == len, because we might have mergedBodies with single bodies inside
+		return mergedBodies(bodies)
+	}
+
+	if newLen == 0 {
+		// Don't allocate a new empty when we already have one
+		return emptyBody
+	}
+
+	new := make([]Body, 0, newLen)
+	for _, body := range bodies {
+		if children, merged := body.(mergedBodies); merged {
+			new = append(new, children...)
+		} else {
+			new = append(new, body)
+		}
+	}
+	return mergedBodies(new)
+}
+
+var emptyBody = mergedBodies([]Body{})
+
+// EmptyBody returns a body with no content. This body can be used as a
+// placeholder when a body is required but no body content is available.
+func EmptyBody() Body {
+	return emptyBody
+}
+
+type mergedBodies []Body
+
+// Content returns the content produced by applying the given schema to all
+// of the merged bodies and merging the result.
+//
+// Although required attributes _are_ supported, they should be used sparingly
+// with merged bodies since in this case there is no contextual information
+// with which to return good diagnostics. Applications working with merged
+// bodies may wish to mark all attributes as optional and then check for
+// required attributes afterwards, to produce better diagnostics.
+func (mb mergedBodies) Content(schema *BodySchema) (*BodyContent, Diagnostics) {
+	// the returned body will always be empty in this case, because mergedContent
+	// will only ever call Content on the child bodies.
+	content, _, diags := mb.mergedContent(schema, false)
+	return content, diags
+}
+
+func (mb mergedBodies) PartialContent(schema *BodySchema) (*BodyContent, Body, Diagnostics) {
+	return mb.mergedContent(schema, true)
+}
+
+func (mb mergedBodies) JustAttributes() (Attributes, Diagnostics) {
+	attrs := make(map[string]*Attribute)
+	var diags Diagnostics
+
+	for _, body := range mb {
+		thisAttrs, thisDiags := body.JustAttributes()
+
+		if len(thisDiags) != 0 {
+			diags = append(diags, thisDiags...)
+		}
+
+		if thisAttrs != nil {
+			for name, attr := range thisAttrs {
+				if existing := attrs[name]; existing != nil {
+					diags = diags.Append(&Diagnostic{
+						Severity: DiagError,
+						Summary:  "Duplicate argument",
+						Detail: fmt.Sprintf(
+							"Argument %q was already set at %s",
+							name, existing.NameRange.String(),
+						),
+						Subject: &attr.NameRange,
+					})
+					continue
+				}
+
+				attrs[name] = attr
+			}
+		}
+	}
+
+	return attrs, diags
+}
+
+func (mb mergedBodies) MissingItemRange() Range {
+	if len(mb) == 0 {
+		// Nothing useful to return here, so we'll return some garbage.
+		return Range{
+			Filename: "<empty>",
+		}
+	}
+
+	// arbitrarily use the first body's missing item range
+	return mb[0].MissingItemRange()
+}
+
+func (mb mergedBodies) mergedContent(schema *BodySchema, partial bool) (*BodyContent, Body, Diagnostics) {
+	// We need to produce a new schema with none of the attributes marked as
+	// required, since _any one_ of our bodies can contribute an attribute value.
+	// We'll separately check that all required attributes are present at
+	// the end.
+	mergedSchema := &BodySchema{
+		Blocks: schema.Blocks,
+	}
+	for _, attrS := range schema.Attributes {
+		mergedAttrS := attrS
+		mergedAttrS.Required = false
+		mergedSchema.Attributes = append(mergedSchema.Attributes, mergedAttrS)
+	}
+
+	var mergedLeftovers []Body
+	content := &BodyContent{
+		Attributes: map[string]*Attribute{},
+	}
+
+	var diags Diagnostics
+	for _, body := range mb {
+		var thisContent *BodyContent
+		var thisLeftovers Body
+		var thisDiags Diagnostics
+
+		if partial {
+			thisContent, thisLeftovers, thisDiags = body.PartialContent(mergedSchema)
+		} else {
+			thisContent, thisDiags = body.Content(mergedSchema)
+		}
+
+		if thisLeftovers != nil {
+			mergedLeftovers = append(mergedLeftovers, thisLeftovers)
+		}
+		if len(thisDiags) != 0 {
+			diags = append(diags, thisDiags...)
+		}
+
+		if thisContent.Attributes != nil {
+			for name, attr := range thisContent.Attributes {
+				if existing := content.Attributes[name]; existing != nil {
+					diags = diags.Append(&Diagnostic{
+						Severity: DiagError,
+						Summary:  "Duplicate argument",
+						Detail: fmt.Sprintf(
+							"Argument %q was already set at %s",
+							name, existing.NameRange.String(),
+						),
+						Subject: &attr.NameRange,
+					})
+					continue
+				}
+				content.Attributes[name] = attr
+			}
+		}
+
+		if len(thisContent.Blocks) != 0 {
+			content.Blocks = append(content.Blocks, thisContent.Blocks...)
+		}
+	}
+
+	// Finally, we check for required attributes.
+	for _, attrS := range schema.Attributes {
+		if !attrS.Required {
+			continue
+		}
+
+		if content.Attributes[attrS.Name] == nil {
+			// We don't have any context here to produce a good diagnostic,
+			// which is why we warn in the Content docstring to minimize the
+			// use of required attributes on merged bodies.
+			diags = diags.Append(&Diagnostic{
+				Severity: DiagError,
+				Summary:  "Missing required argument",
+				Detail: fmt.Sprintf(
+					"The argument %q is required, but was not set.",
+					attrS.Name,
+				),
+			})
+		}
+	}
+
+	leftoverBody := MergeBodies(mergedLeftovers)
+	return content, leftoverBody, diags
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/ops.go b/vendor/github.com/hashicorp/hcl/v2/ops.go
new file mode 100644
index 000000000..5d2910c13
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/ops.go
@@ -0,0 +1,288 @@
+package hcl
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+// Index is a helper function that performs the same operation as the index
+// operator in the HCL expression language. That is, the result is the
+// same as it would be for collection[key] in a configuration expression.
+//
+// This is exported so that applications can perform indexing in a manner
+// consistent with how the language does it, including handling of null and
+// unknown values, etc.
+//
+// Diagnostics are produced if the given combination of values is not valid.
+// Therefore a pointer to a source range must be provided to use in diagnostics,
+// though nil can be provided if the calling application is going to
+// ignore the subject of the returned diagnostics anyway.
+func Index(collection, key cty.Value, srcRange *Range) (cty.Value, Diagnostics) {
+	if collection.IsNull() {
+		return cty.DynamicVal, Diagnostics{
+			{
+				Severity: DiagError,
+				Summary:  "Attempt to index null value",
+				Detail:   "This value is null, so it does not have any indices.",
+				Subject:  srcRange,
+			},
+		}
+	}
+	if key.IsNull() {
+		return cty.DynamicVal, Diagnostics{
+			{
+				Severity: DiagError,
+				Summary:  "Invalid index",
+				Detail:   "Can't use a null value as an indexing key.",
+				Subject:  srcRange,
+			},
+		}
+	}
+	ty := collection.Type()
+	kty := key.Type()
+	if kty == cty.DynamicPseudoType || ty == cty.DynamicPseudoType {
+		return cty.DynamicVal, nil
+	}
+
+	switch {
+
+	case ty.IsListType() || ty.IsTupleType() || ty.IsMapType():
+		var wantType cty.Type
+		switch {
+		case ty.IsListType() || ty.IsTupleType():
+			wantType = cty.Number
+		case ty.IsMapType():
+			wantType = cty.String
+		default:
+			// should never happen
+			panic("don't know what key type we want")
+		}
+
+		key, keyErr := convert.Convert(key, wantType)
+		if keyErr != nil {
+			return cty.DynamicVal, Diagnostics{
+				{
+					Severity: DiagError,
+					Summary:  "Invalid index",
+					Detail: fmt.Sprintf(
+						"The given key does not identify an element in this collection value: %s.",
+						keyErr.Error(),
+					),
+					Subject: srcRange,
+				},
+			}
+		}
+
+		has := collection.HasIndex(key)
+		if !has.IsKnown() {
+			if ty.IsTupleType() {
+				return cty.DynamicVal, nil
+			} else {
+				return cty.UnknownVal(ty.ElementType()), nil
+			}
+		}
+		if has.False() {
+			// We have a more specialized error message for the situation of
+			// using a fractional number to index into a sequence, because
+			// that will tend to happen if the user is trying to use division
+			// to calculate an index and not realizing that HCL does float
+			// division rather than integer division.
+			if (ty.IsListType() || ty.IsTupleType()) && key.Type().Equals(cty.Number) {
+				if key.IsKnown() && !key.IsNull() {
+					bf := key.AsBigFloat()
+					if _, acc := bf.Int(nil); acc != big.Exact {
+						return cty.DynamicVal, Diagnostics{
+							{
+								Severity: DiagError,
+								Summary:  "Invalid index",
+								Detail:   fmt.Sprintf("The given key does not identify an element in this collection value: indexing a sequence requires a whole number, but the given index (%g) has a fractional part.", bf),
+								Subject:  srcRange,
+							},
+						}
+					}
+				}
+			}
+
+			return cty.DynamicVal, Diagnostics{
+				{
+					Severity: DiagError,
+					Summary:  "Invalid index",
+					Detail:   "The given key does not identify an element in this collection value.",
+					Subject:  srcRange,
+				},
+			}
+		}
+
+		return collection.Index(key), nil
+
+	case ty.IsObjectType():
+		key, keyErr := convert.Convert(key, cty.String)
+		if keyErr != nil {
+			return cty.DynamicVal, Diagnostics{
+				{
+					Severity: DiagError,
+					Summary:  "Invalid index",
+					Detail: fmt.Sprintf(
+						"The given key does not identify an element in this collection value: %s.",
+						keyErr.Error(),
+					),
+					Subject: srcRange,
+				},
+			}
+		}
+		if !collection.IsKnown() {
+			return cty.DynamicVal, nil
+		}
+		if !key.IsKnown() {
+			return cty.DynamicVal, nil
+		}
+
+		attrName := key.AsString()
+
+		if !ty.HasAttribute(attrName) {
+			return cty.DynamicVal, Diagnostics{
+				{
+					Severity: DiagError,
+					Summary:  "Invalid index",
+					Detail:   "The given key does not identify an element in this collection value.",
+					Subject:  srcRange,
+				},
+			}
+		}
+
+		return collection.GetAttr(attrName), nil
+
+	default:
+		return cty.DynamicVal, Diagnostics{
+			{
+				Severity: DiagError,
+				Summary:  "Invalid index",
+				Detail:   "This value does not have any indices.",
+				Subject:  srcRange,
+			},
+		}
+	}
+
+}
+
+// GetAttr is a helper function that performs the same operation as the
+// attribute access in the HCL expression language. That is, the result is the
+// same as it would be for obj.attr in a configuration expression.
+//
+// This is exported so that applications can access attributes in a manner
+// consistent with how the language does it, including handling of null and
+// unknown values, etc.
+//
+// Diagnostics are produced if the given combination of values is not valid.
+// Therefore a pointer to a source range must be provided to use in diagnostics,
+// though nil can be provided if the calling application is going to
+// ignore the subject of the returned diagnostics anyway.
+func GetAttr(obj cty.Value, attrName string, srcRange *Range) (cty.Value, Diagnostics) {
+	if obj.IsNull() {
+		return cty.DynamicVal, Diagnostics{
+			{
+				Severity: DiagError,
+				Summary:  "Attempt to get attribute from null value",
+				Detail:   "This value is null, so it does not have any attributes.",
+				Subject:  srcRange,
+			},
+		}
+	}
+
+	ty := obj.Type()
+	switch {
+	case ty.IsObjectType():
+		if !ty.HasAttribute(attrName) {
+			return cty.DynamicVal, Diagnostics{
+				{
+					Severity: DiagError,
+					Summary:  "Unsupported attribute",
+					Detail:   fmt.Sprintf("This object does not have an attribute named %q.", attrName),
+					Subject:  srcRange,
+				},
+			}
+		}
+
+		if !obj.IsKnown() {
+			return cty.UnknownVal(ty.AttributeType(attrName)), nil
+		}
+
+		return obj.GetAttr(attrName), nil
+	case ty.IsMapType():
+		if !obj.IsKnown() {
+			return cty.UnknownVal(ty.ElementType()), nil
+		}
+
+		idx := cty.StringVal(attrName)
+		if obj.HasIndex(idx).False() {
+			return cty.DynamicVal, Diagnostics{
+				{
+					Severity: DiagError,
+					Summary:  "Missing map element",
+					Detail:   fmt.Sprintf("This map does not have an element with the key %q.", attrName),
+					Subject:  srcRange,
+				},
+			}
+		}
+
+		return obj.Index(idx), nil
+	case ty == cty.DynamicPseudoType:
+		return cty.DynamicVal, nil
+	default:
+		return cty.DynamicVal, Diagnostics{
+			{
+				Severity: DiagError,
+				Summary:  "Unsupported attribute",
+				Detail:   "This value does not have any attributes.",
+				Subject:  srcRange,
+			},
+		}
+	}
+
+}
+
+// ApplyPath is a helper function that applies a cty.Path to a value using the
+// indexing and attribute access operations from HCL.
+//
+// This is similar to calling the path's own Apply method, but ApplyPath uses
+// the more relaxed typing rules that apply to these operations in HCL, rather
+// than cty's relatively-strict rules. ApplyPath is implemented in terms of
+// Index and GetAttr, and so it has the same behavior for individual steps
+// but will stop and return any errors returned by intermediate steps.
+//
+// Diagnostics are produced if the given path cannot be applied to the given
+// value. Therefore a pointer to a source range must be provided to use in
+// diagnostics, though nil can be provided if the calling application is going
+// to ignore the subject of the returned diagnostics anyway.
+func ApplyPath(val cty.Value, path cty.Path, srcRange *Range) (cty.Value, Diagnostics) {
+	var diags Diagnostics
+
+	for _, step := range path {
+		var stepDiags Diagnostics
+		switch ts := step.(type) {
+		case cty.IndexStep:
+			val, stepDiags = Index(val, ts.Key, srcRange)
+		case cty.GetAttrStep:
+			val, stepDiags = GetAttr(val, ts.Name, srcRange)
+		default:
+			// Should never happen because the above are all of the step types.
+			diags = diags.Append(&Diagnostic{
+				Severity: DiagError,
+				Summary:  "Invalid path step",
+				Detail:   fmt.Sprintf("Go type %T is not a valid path step. This is a bug in this program.", step),
+				Subject:  srcRange,
+			})
+			return cty.DynamicVal, diags
+		}
+
+		diags = append(diags, stepDiags...)
+		if stepDiags.HasErrors() {
+			return cty.DynamicVal, diags
+		}
+	}
+
+	return val, diags
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/pos.go b/vendor/github.com/hashicorp/hcl/v2/pos.go
new file mode 100644
index 000000000..06db8bfbd
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/pos.go
@@ -0,0 +1,275 @@
+package hcl
+
+import "fmt"
+
+// Pos represents a single position in a source file, by addressing the
+// start byte of a unicode character encoded in UTF-8.
+//
+// Pos is generally used only in the context of a Range, which then defines
+// which source file the position is within.
+type Pos struct {
+	// Line is the source code line where this position points. Lines are
+	// counted starting at 1 and incremented for each newline character
+	// encountered.
+	Line int
+
+	// Column is the source code column where this position points, in
+	// unicode characters, with counting starting at 1.
+	//
+	// Column counts characters as they appear visually, so for example a
+	// latin letter with a combining diacritic mark counts as one character.
+	// This is intended for rendering visual markers against source code in
+	// contexts where these diacritics would be rendered in a single character
+	// cell. Technically speaking, Column is counting grapheme clusters as
+	// used in unicode normalization.
+	Column int
+
+	// Byte is the byte offset into the file where the indicated character
+	// begins. This is a zero-based offset to the first byte of the first
+	// UTF-8 codepoint sequence in the character, and thus gives a position
+	// that can be resolved _without_ awareness of Unicode characters.
+	Byte int
+}
+
+// InitialPos is a suitable position to use to mark the start of a file.
+var InitialPos = Pos{Byte: 0, Line: 1, Column: 1}
+
+// Range represents a span of characters between two positions in a source
+// file.
+//
+// This struct is usually used by value in types that represent AST nodes,
+// but by pointer in types that refer to the positions of other objects,
+// such as in diagnostics.
+type Range struct {
+	// Filename is the name of the file into which this range's positions
+	// point.
+	Filename string
+
+	// Start and End represent the bounds of this range. Start is inclusive
+	// and End is exclusive.
+	Start, End Pos
+}
+
+// RangeBetween returns a new range that spans from the beginning of the
+// start range to the end of the end range.
+//
+// The result is meaningless if the two ranges do not belong to the same
+// source file or if the end range appears before the start range.
+func RangeBetween(start, end Range) Range {
+	return Range{
+		Filename: start.Filename,
+		Start:    start.Start,
+		End:      end.End,
+	}
+}
+
+// RangeOver returns a new range that covers both of the given ranges and
+// possibly additional content between them if the two ranges do not overlap.
+//
+// If either range is empty then it is ignored. The result is empty if both
+// given ranges are empty.
+//
+// The result is meaningless if the two ranges to not belong to the same
+// source file.
+func RangeOver(a, b Range) Range {
+	if a.Empty() {
+		return b
+	}
+	if b.Empty() {
+		return a
+	}
+
+	var start, end Pos
+	if a.Start.Byte < b.Start.Byte {
+		start = a.Start
+	} else {
+		start = b.Start
+	}
+	if a.End.Byte > b.End.Byte {
+		end = a.End
+	} else {
+		end = b.End
+	}
+	return Range{
+		Filename: a.Filename,
+		Start:    start,
+		End:      end,
+	}
+}
+
+// ContainsPos returns true if and only if the given position is contained within
+// the receiving range.
+//
+// In the unlikely case that the line/column information disagree with the byte
+// offset information in the given position or receiving range, the byte
+// offsets are given priority.
+func (r Range) ContainsPos(pos Pos) bool {
+	return r.ContainsOffset(pos.Byte)
+}
+
+// ContainsOffset returns true if and only if the given byte offset is within
+// the receiving Range.
+func (r Range) ContainsOffset(offset int) bool {
+	return offset >= r.Start.Byte && offset < r.End.Byte
+}
+
+// Ptr returns a pointer to a copy of the receiver. This is a convenience when
+// ranges in places where pointers are required, such as in Diagnostic, but
+// the range in question is returned from a method. Go would otherwise not
+// allow one to take the address of a function call.
+func (r Range) Ptr() *Range {
+	return &r
+}
+
+// String returns a compact string representation of the receiver.
+// Callers should generally prefer to present a range more visually,
+// e.g. via markers directly on the relevant portion of source code.
+func (r Range) String() string {
+	if r.Start.Line == r.End.Line {
+		return fmt.Sprintf(
+			"%s:%d,%d-%d",
+			r.Filename,
+			r.Start.Line, r.Start.Column,
+			r.End.Column,
+		)
+	} else {
+		return fmt.Sprintf(
+			"%s:%d,%d-%d,%d",
+			r.Filename,
+			r.Start.Line, r.Start.Column,
+			r.End.Line, r.End.Column,
+		)
+	}
+}
+
+func (r Range) Empty() bool {
+	return r.Start.Byte == r.End.Byte
+}
+
+// CanSliceBytes returns true if SliceBytes could return an accurate
+// sub-slice of the given slice.
+//
+// This effectively tests whether the start and end offsets of the range
+// are within the bounds of the slice, and thus whether SliceBytes can be
+// trusted to produce an accurate start and end position within that slice.
+func (r Range) CanSliceBytes(b []byte) bool {
+	switch {
+	case r.Start.Byte < 0 || r.Start.Byte > len(b):
+		return false
+	case r.End.Byte < 0 || r.End.Byte > len(b):
+		return false
+	case r.End.Byte < r.Start.Byte:
+		return false
+	default:
+		return true
+	}
+}
+
+// SliceBytes returns a sub-slice of the given slice that is covered by the
+// receiving range, assuming that the given slice is the source code of the
+// file indicated by r.Filename.
+//
+// If the receiver refers to any byte offsets that are outside of the slice
+// then the result is constrained to the overlapping portion only, to avoid
+// a panic. Use CanSliceBytes to determine if the result is guaranteed to
+// be an accurate span of the requested range.
+func (r Range) SliceBytes(b []byte) []byte {
+	start := r.Start.Byte
+	end := r.End.Byte
+	if start < 0 {
+		start = 0
+	} else if start > len(b) {
+		start = len(b)
+	}
+	if end < 0 {
+		end = 0
+	} else if end > len(b) {
+		end = len(b)
+	}
+	if end < start {
+		end = start
+	}
+	return b[start:end]
+}
+
+// Overlaps returns true if the receiver and the other given range share any
+// characters in common.
+func (r Range) Overlaps(other Range) bool {
+	switch {
+	case r.Filename != other.Filename:
+		// If the ranges are in different files then they can't possibly overlap
+		return false
+	case r.Empty() || other.Empty():
+		// Empty ranges can never overlap
+		return false
+	case r.ContainsOffset(other.Start.Byte) || r.ContainsOffset(other.End.Byte):
+		return true
+	case other.ContainsOffset(r.Start.Byte) || other.ContainsOffset(r.End.Byte):
+		return true
+	default:
+		return false
+	}
+}
+
+// Overlap finds a range that is either identical to or a sub-range of both
+// the receiver and the other given range. It returns an empty range
+// within the receiver if there is no overlap between the two ranges.
+//
+// A non-empty result is either identical to or a subset of the receiver.
+func (r Range) Overlap(other Range) Range {
+	if !r.Overlaps(other) {
+		// Start == End indicates an empty range
+		return Range{
+			Filename: r.Filename,
+			Start:    r.Start,
+			End:      r.Start,
+		}
+	}
+
+	var start, end Pos
+	if r.Start.Byte > other.Start.Byte {
+		start = r.Start
+	} else {
+		start = other.Start
+	}
+	if r.End.Byte < other.End.Byte {
+		end = r.End
+	} else {
+		end = other.End
+	}
+
+	return Range{
+		Filename: r.Filename,
+		Start:    start,
+		End:      end,
+	}
+}
+
+// PartitionAround finds the portion of the given range that overlaps with
+// the reciever and returns three ranges: the portion of the reciever that
+// precedes the overlap, the overlap itself, and then the portion of the
+// reciever that comes after the overlap.
+//
+// If the two ranges do not overlap then all three returned ranges are empty.
+//
+// If the given range aligns with or extends beyond either extent of the
+// reciever then the corresponding outer range will be empty.
+func (r Range) PartitionAround(other Range) (before, overlap, after Range) {
+	overlap = r.Overlap(other)
+	if overlap.Empty() {
+		return overlap, overlap, overlap
+	}
+
+	before = Range{
+		Filename: r.Filename,
+		Start:    r.Start,
+		End:      overlap.Start,
+	}
+	after = Range{
+		Filename: r.Filename,
+		Start:    overlap.End,
+		End:      r.End,
+	}
+
+	return before, overlap, after
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/pos_scanner.go b/vendor/github.com/hashicorp/hcl/v2/pos_scanner.go
new file mode 100644
index 000000000..17c0d7c6b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/pos_scanner.go
@@ -0,0 +1,152 @@
+package hcl
+
+import (
+	"bufio"
+	"bytes"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+)
+
+// RangeScanner is a helper that will scan over a buffer using a bufio.SplitFunc
+// and visit a source range for each token matched.
+//
+// For example, this can be used with bufio.ScanLines to find the source range
+// for each line in the file, skipping over the actual newline characters, which
+// may be useful when printing source code snippets as part of diagnostic
+// messages.
+//
+// The line and column information in the returned ranges is produced by
+// counting newline characters and grapheme clusters respectively, which
+// mimics the behavior we expect from a parser when producing ranges.
+type RangeScanner struct {
+	filename string
+	b        []byte
+	cb       bufio.SplitFunc
+
+	pos Pos    // position of next byte to process in b
+	cur Range  // latest range
+	tok []byte // slice of b that is covered by cur
+	err error  // error from last scan, if any
+}
+
+// NewRangeScanner creates a new RangeScanner for the given buffer, producing
+// ranges for the given filename.
+//
+// Since ranges have grapheme-cluster granularity rather than byte granularity,
+// the scanner will produce incorrect results if the given SplitFunc creates
+// tokens between grapheme cluster boundaries. In particular, it is incorrect
+// to use RangeScanner with bufio.ScanRunes because it will produce tokens
+// around individual UTF-8 sequences, which will split any multi-sequence
+// grapheme clusters.
+func NewRangeScanner(b []byte, filename string, cb bufio.SplitFunc) *RangeScanner {
+	return NewRangeScannerFragment(b, filename, InitialPos, cb)
+}
+
+// NewRangeScannerFragment is like NewRangeScanner but the ranges it produces
+// will be offset by the given starting position, which is appropriate for
+// sub-slices of a file, whereas NewRangeScanner assumes it is scanning an
+// entire file.
+func NewRangeScannerFragment(b []byte, filename string, start Pos, cb bufio.SplitFunc) *RangeScanner {
+	return &RangeScanner{
+		filename: filename,
+		b:        b,
+		cb:       cb,
+		pos:      start,
+	}
+}
+
+func (sc *RangeScanner) Scan() bool {
+	if sc.pos.Byte >= len(sc.b) || sc.err != nil {
+		// All done
+		return false
+	}
+
+	// Since we're operating on an in-memory buffer, we always pass the whole
+	// remainder of the buffer to our SplitFunc and set isEOF to let it know
+	// that it has the whole thing.
+	advance, token, err := sc.cb(sc.b[sc.pos.Byte:], true)
+
+	// Since we are setting isEOF to true this should never happen, but
+	// if it does we will just abort and assume the SplitFunc is misbehaving.
+	if advance == 0 && token == nil && err == nil {
+		return false
+	}
+
+	if err != nil {
+		sc.err = err
+		sc.cur = Range{
+			Filename: sc.filename,
+			Start:    sc.pos,
+			End:      sc.pos,
+		}
+		sc.tok = nil
+		return false
+	}
+
+	sc.tok = token
+	start := sc.pos
+	end := sc.pos
+	new := sc.pos
+
+	// adv is similar to token but it also includes any subsequent characters
+	// we're being asked to skip over by the SplitFunc.
+	// adv is a slice covering any additional bytes we are skipping over, based
+	// on what the SplitFunc told us to do with advance.
+	adv := sc.b[sc.pos.Byte : sc.pos.Byte+advance]
+
+	// We now need to scan over our token to count the grapheme clusters
+	// so we can correctly advance Column, and count the newlines so we
+	// can correctly advance Line.
+	advR := bytes.NewReader(adv)
+	gsc := bufio.NewScanner(advR)
+	advanced := 0
+	gsc.Split(textseg.ScanGraphemeClusters)
+	for gsc.Scan() {
+		gr := gsc.Bytes()
+		new.Byte += len(gr)
+		new.Column++
+
+		// We rely here on the fact that \r\n is considered a grapheme cluster
+		// and so we don't need to worry about miscounting additional lines
+		// on files with Windows-style line endings.
+		if len(gr) != 0 && (gr[0] == '\r' || gr[0] == '\n') {
+			new.Column = 1
+			new.Line++
+		}
+
+		if advanced < len(token) {
+			// If we've not yet found the end of our token then we'll
+			// also push our "end" marker along.
+			// (if advance > len(token) then we'll stop moving "end" early
+			// so that the caller only sees the range covered by token.)
+			end = new
+		}
+		advanced += len(gr)
+	}
+
+	sc.cur = Range{
+		Filename: sc.filename,
+		Start:    start,
+		End:      end,
+	}
+	sc.pos = new
+	return true
+}
+
+// Range returns a range that covers the latest token obtained after a call
+// to Scan returns true.
+func (sc *RangeScanner) Range() Range {
+	return sc.cur
+}
+
+// Bytes returns the slice of the input buffer that is covered by the range
+// that would be returned by Range.
+func (sc *RangeScanner) Bytes() []byte {
+	return sc.tok
+}
+
+// Err can be called after Scan returns false to determine if the latest read
+// resulted in an error, and obtain that error if so.
+func (sc *RangeScanner) Err() error {
+	return sc.err
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/schema.go b/vendor/github.com/hashicorp/hcl/v2/schema.go
new file mode 100644
index 000000000..891257acb
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/schema.go
@@ -0,0 +1,21 @@
+package hcl
+
+// BlockHeaderSchema represents the shape of a block header, and is
+// used for matching blocks within bodies.
+type BlockHeaderSchema struct {
+	Type       string
+	LabelNames []string
+}
+
+// AttributeSchema represents the requirements for an attribute, and is used
+// for matching attributes within bodies.
+type AttributeSchema struct {
+	Name     string
+	Required bool
+}
+
+// BodySchema represents the desired shallow structure of a body.
+type BodySchema struct {
+	Attributes []AttributeSchema
+	Blocks     []BlockHeaderSchema
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/spec.md b/vendor/github.com/hashicorp/hcl/v2/spec.md
new file mode 100644
index 000000000..97ef61318
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/spec.md
@@ -0,0 +1,691 @@
+# HCL Syntax-Agnostic Information Model
+
+This is the specification for the general information model (abstract types and
+semantics) for hcl. HCL is a system for defining configuration languages for
+applications. The HCL information model is designed to support multiple
+concrete syntaxes for configuration, each with a mapping to the model defined
+in this specification.
+
+The two primary syntaxes intended for use in conjunction with this model are
+[the HCL native syntax](./hclsyntax/spec.md) and [the JSON syntax](./json/spec.md).
+In principle other syntaxes are possible as long as either their language model
+is sufficiently rich to express the concepts described in this specification
+or the language targets a well-defined subset of the specification.
+
+## Structural Elements
+
+The primary structural element is the _body_, which is a container representing
+a set of zero or more _attributes_ and a set of zero or more _blocks_.
+
+A _configuration file_ is the top-level object, and will usually be produced
+by reading a file from disk and parsing it as a particular syntax. A
+configuration file has its own _body_, representing the top-level attributes
+and blocks.
+
+An _attribute_ is a name and value pair associated with a body. Attribute names
+are unique within a given body. Attribute values are provided as _expressions_,
+which are discussed in detail in a later section.
+
+A _block_ is a nested structure that has a _type name_, zero or more string
+_labels_ (e.g. identifiers), and a nested body.
+
+Together the structural elements create a hierarchical data structure, with
+attributes intended to represent the direct properties of a particular object
+in the calling application, and blocks intended to represent child objects
+of a particular object.
+
+## Body Content
+
+To support the expression of the HCL concepts in languages whose information
+model is a subset of HCL's, such as JSON, a _body_ is an opaque container
+whose content can only be accessed by providing information on the expected
+structure of the content.
+
+The specification for each syntax must describe how its physical constructs
+are mapped on to body content given a schema. For syntaxes that have
+first-class syntax distinguishing attributes and bodies this can be relatively
+straightforward, while more detailed mapping rules may be required in syntaxes
+where the representation of attributes vs. blocks is ambiguous.
+
+### Schema-driven Processing
+
+Schema-driven processing is the primary way to access body content.
+A _body schema_ is a description of what is expected within a particular body,
+which can then be used to extract the _body content_, which then provides
+access to the specific attributes and blocks requested.
+
+A _body schema_ consists of a list of _attribute schemata_ and
+_block header schemata_:
+
+- An _attribute schema_ provides the name of an attribute and whether its
+  presence is required.
+
+- A _block header schema_ provides a block type name and the semantic names
+  assigned to each of the labels of that block type, if any.
+
+Within a schema, it is an error to request the same attribute name twice or
+to request a block type whose name is also an attribute name. While this can
+in principle be supported in some syntaxes, in other syntaxes the attribute
+and block namespaces are combined and so an attribute cannot coexist with
+a block whose type name is identical to the attribute name.
+
+The result of applying a body schema to a body is _body content_, which
+consists of an _attribute map_ and a _block sequence_:
+
+- The _attribute map_ is a map data structure whose keys are attribute names
+  and whose values are _expressions_ that represent the corresponding attribute
+  values.
+
+- The _block sequence_ is an ordered sequence of blocks, with each specifying
+  a block _type name_, the sequence of _labels_ specified for the block,
+  and the body object (not body _content_) representing the block's own body.
+
+After obtaining _body content_, the calling application may continue processing
+by evaluating attribute expressions and/or recursively applying further
+schema-driven processing to the child block bodies.
+
+**Note:** The _body schema_ is intentionally minimal, to reduce the set of
+mapping rules that must be defined for each syntax. Higher-level utility
+libraries may be provided to assist in the construction of a schema and
+perform additional processing, such as automatically evaluating attribute
+expressions and assigning their result values into a data structure, or
+recursively applying a schema to child blocks. Such utilities are not part of
+this core specification and will vary depending on the capabilities and idiom
+of the implementation language.
+
+### _Dynamic Attributes_ Processing
+
+The _schema-driven_ processing model is useful when the expected structure
+of a body is known a priori by the calling application. Some blocks are
+instead more free-form, such as a user-provided set of arbitrary key/value
+pairs.
+
+The alternative _dynamic attributes_ processing mode allows for this more
+ad-hoc approach. Processing in this mode behaves as if a schema had been
+constructed without any _block header schemata_ and with an attribute
+schema for each distinct key provided within the physical representation
+of the body.
+
+The means by which _distinct keys_ are identified is dependent on the
+physical syntax; this processing mode assumes that the syntax has a way
+to enumerate keys provided by the author and identify expressions that
+correspond with those keys, but does not define the means by which this is
+done.
+
+The result of _dynamic attributes_ processing is an _attribute map_ as
+defined in the previous section. No _block sequence_ is produced in this
+processing mode.
+
+### Partial Processing of Body Content
+
+Under _schema-driven processing_, by default the given schema is assumed
+to be exhaustive, such that any attribute or block not matched by schema
+elements is considered an error. This allows feedback about unsupported
+attributes and blocks (such as typos) to be provided.
+
+An alternative is _partial processing_, where any additional elements within
+the body are not considered an error.
+
+Under partial processing, the result is both body content as described
+above _and_ a new body that represents any body elements that remain after
+the schema has been processed.
+
+Specifically:
+
+- Any attribute whose name is specified in the schema is returned in body
+  content and elided from the new body.
+
+- Any block whose type is specified in the schema is returned in body content
+  and elided from the new body.
+
+- Any attribute or block _not_ meeting the above conditions is placed into
+  the new body, unmodified.
+
+The new body can then be recursively processed using any of the body
+processing models. This facility allows different subsets of body content
+to be processed by different parts of the calling application.
+
+Processing a body in two steps — first partial processing of a source body,
+then exhaustive processing of the returned body — is equivalent to single-step
+processing with a schema that is the union of the schemata used
+across the two steps.
+
+## Expressions
+
+Attribute values are represented by _expressions_. Depending on the concrete
+syntax in use, an expression may just be a literal value or it may describe
+a computation in terms of literal values, variables, and functions.
+
+Each syntax defines its own representation of expressions. For syntaxes based
+in languages that do not have any non-literal expression syntax, it is
+recommended to embed the template language from
+[the native syntax](./hclsyntax/spec.md) e.g. as a post-processing step on
+string literals.
+
+### Expression Evaluation
+
+In order to obtain a concrete value, each expression must be _evaluated_.
+Evaluation is performed in terms of an evaluation context, which
+consists of the following:
+
+- An _evaluation mode_, which is defined below.
+- A _variable scope_, which provides a set of named variables for use in
+  expressions.
+- A _function table_, which provides a set of named functions for use in
+  expressions.
+
+The _evaluation mode_ allows for two different interpretations of an
+expression:
+
+- In _literal-only mode_, variables and functions are not available and it
+  is assumed that the calling application's intent is to treat the attribute
+  value as a literal.
+
+- In _full expression mode_, variables and functions are defined and it is
+  assumed that the calling application wishes to provide a full expression
+  language for definition of the attribute value.
+
+The actual behavior of these two modes depends on the syntax in use. For
+languages with first-class expression syntax, these two modes may be considered
+equivalent, with _literal-only mode_ simply not defining any variables or
+functions. For languages that embed arbitrary expressions via string templates,
+_literal-only mode_ may disable such processing, allowing literal strings to
+pass through without interpretation as templates.
+
+Since literal-only mode does not support variables and functions, it is an
+error for the calling application to enable this mode and yet provide a
+variable scope and/or function table.
+
+## Values and Value Types
+
+The result of expression evaluation is a _value_. Each value has a _type_,
+which is dynamically determined during evaluation. The _variable scope_ in
+the evaluation context is a map from variable name to value, using the same
+definition of value.
+
+The type system for HCL values is intended to be of a level abstraction
+suitable for configuration of various applications. A well-defined,
+implementation-language-agnostic type system is defined to allow for
+consistent processing of configuration across many implementation languages.
+Concrete implementations may provide additional functionality to lower
+HCL values and types to corresponding native language types, which may then
+impose additional constraints on the values outside of the scope of this
+specification.
+
+Two values are _equal_ if and only if they have identical types and their
+values are equal according to the rules of their shared type.
+
+### Primitive Types
+
+The primitive types are _string_, _bool_, and _number_.
+
+A _string_ is a sequence of unicode characters. Two strings are equal if
+NFC normalization ([UAX#15](http://unicode.org/reports/tr15/)
+of each string produces two identical sequences of characters.
+NFC normalization ensures that, for example, a precomposed combination of a
+latin letter and a diacritic compares equal with the letter followed by
+a combining diacritic.
+
+The _bool_ type has only two non-null values: _true_ and _false_. Two bool
+values are equal if and only if they are either both true or both false.
+
+A _number_ is an arbitrary-precision floating point value. An implementation
+_must_ make the full-precision values available to the calling application
+for interpretation into any suitable number representation. An implementation
+may in practice implement numbers with limited precision so long as the
+following constraints are met:
+
+- Integers are represented with at least 256 bits.
+- Non-integer numbers are represented as floating point values with a
+  mantissa of at least 256 bits and a signed binary exponent of at least
+  16 bits.
+- An error is produced if an integer value given in source cannot be
+  represented precisely.
+- An error is produced if a non-integer value cannot be represented due to
+  overflow.
+- A non-integer number is rounded to the nearest possible value when a
+  value is of too high a precision to be represented.
+
+The _number_ type also requires representation of both positive and negative
+infinity. A "not a number" (NaN) value is _not_ provided nor used.
+
+Two number values are equal if they are numerically equal to the precision
+associated with the number. Positive infinity and negative infinity are
+equal to themselves but not to each other. Positive infinity is greater than
+any other number value, and negative infinity is less than any other number
+value.
+
+Some syntaxes may be unable to represent numeric literals of arbitrary
+precision. This must be defined in the syntax specification as part of its
+description of mapping numeric literals to HCL values.
+
+### Structural Types
+
+_Structural types_ are types that are constructed by combining other types.
+Each distinct combination of other types is itself a distinct type. There
+are two structural type _kinds_:
+
+- _Object types_ are constructed of a set of named attributes, each of which
+  has a type. Attribute names are always strings. (_Object_ attributes are a
+  distinct idea from _body_ attributes, though calling applications
+  may choose to blur the distinction by use of common naming schemes.)
+- _Tuple types_ are constructed of a sequence of elements, each of which
+  has a type.
+
+Values of structural types are compared for equality in terms of their
+attributes or elements. A structural type value is equal to another if and
+only if all of the corresponding attributes or elements are equal.
+
+Two structural types are identical if they are of the same kind and
+have attributes or elements with identical types.
+
+### Collection Types
+
+_Collection types_ are types that combine together an arbitrary number of
+values of some other single type. There are three collection type _kinds_:
+
+- _List types_ represent ordered sequences of values of their element type.
+- _Map types_ represent values of their element type accessed via string keys.
+- _Set types_ represent unordered sets of distinct values of their element type.
+
+For each of these kinds and each distinct element type there is a distinct
+collection type. For example, "list of string" is a distinct type from
+"set of string", and "list of number" is a distinct type from "list of string".
+
+Values of collection types are compared for equality in terms of their
+elements. A collection type value is equal to another if and only if both
+have the same number of elements and their corresponding elements are equal.
+
+Two collection types are identical if they are of the same kind and have
+the same element type.
+
+### Null values
+
+Each type has a null value. The null value of a type represents the absence
+of a value, but with type information retained to allow for type checking.
+
+Null values are used primarily to represent the conditional absence of a
+body attribute. In a syntax with a conditional operator, one of the result
+values of that conditional may be null to indicate that the attribute should be
+considered not present in that case.
+
+Calling applications _should_ consider an attribute with a null value as
+equivalent to the value not being present at all.
+
+A null value of a particular type is equal to itself.
+
+### Unknown Values and the Dynamic Pseudo-type
+
+An _unknown value_ is a placeholder for a value that is not yet known.
+Operations on unknown values themselves return unknown values that have a
+type appropriate to the operation. For example, adding together two unknown
+numbers yields an unknown number, while comparing two unknown values of any
+type for equality yields an unknown bool.
+
+Each type has a distinct unknown value. For example, an unknown _number_ is
+a distinct value from an unknown _string_.
+
+_The dynamic pseudo-type_ is a placeholder for a type that is not yet known.
+The only values of this type are its null value and its unknown value. It is
+referred to as a _pseudo-type_ because it should not be considered a type in
+its own right, but rather as a placeholder for a type yet to be established.
+The unknown value of the dynamic pseudo-type is referred to as _the dynamic
+value_.
+
+Operations on values of the dynamic pseudo-type behave as if it is a value
+of the expected type, optimistically assuming that once the value and type
+are known they will be valid for the operation. For example, adding together
+a number and the dynamic value produces an unknown number.
+
+Unknown values and the dynamic pseudo-type can be used as a mechanism for
+partial type checking and semantic checking: by evaluating an expression with
+all variables set to an unknown value, the expression can be evaluated to
+produce an unknown value of a given type, or produce an error if any operation
+is provably invalid with only type information.
+
+Unknown values and the dynamic pseudo-type must never be returned from
+operations unless at least one operand is unknown or dynamic. Calling
+applications are guaranteed that unless the global scope includes unknown
+values, or the function table includes functions that return unknown values,
+no expression will evaluate to an unknown value. The calling application is
+thus in total control over the use and meaning of unknown values.
+
+The dynamic pseudo-type is identical only to itself.
+
+### Capsule Types
+
+A _capsule type_ is a custom type defined by the calling application. A value
+of a capsule type is considered opaque to HCL, but may be accepted
+by functions provided by the calling application.
+
+A particular capsule type is identical only to itself. The equality of two
+values of the same capsule type is defined by the calling application. No
+other operations are supported for values of capsule types.
+
+Support for capsule types in a HCL implementation is optional. Capsule types
+are intended to allow calling applications to pass through values that are
+not part of the standard type system. For example, an application that
+deals with raw binary data may define a capsule type representing a byte
+array, and provide functions that produce or operate on byte arrays.
+
+### Type Specifications
+
+In certain situations it is necessary to define expectations about the expected
+type of a value. Whereas two _types_ have a commutative _identity_ relationship,
+a type has a non-commutative _matches_ relationship with a _type specification_.
+A type specification is, in practice, just a different interpretation of a
+type such that:
+
+- Any type _matches_ any type that it is identical to.
+
+- Any type _matches_ the dynamic pseudo-type.
+
+For example, given a type specification "list of dynamic pseudo-type", the
+concrete types "list of string" and "list of map" match, but the
+type "set of string" does not.
+
+## Functions and Function Calls
+
+The evaluation context used to evaluate an expression includes a function
+table, which represents an application-defined set of named functions
+available for use in expressions.
+
+Each syntax defines whether function calls are supported and how they are
+physically represented in source code, but the semantics of function calls are
+defined here to ensure consistent results across syntaxes and to allow
+applications to provide functions that are interoperable with all syntaxes.
+
+A _function_ is defined from the following elements:
+
+- Zero or more _positional parameters_, each with a name used for documentation,
+  a type specification for expected argument values, and a flag for whether
+  each of null values, unknown values, and values of the dynamic pseudo-type
+  are accepted.
+
+- Zero or one _variadic parameters_, with the same structure as the _positional_
+  parameters, which if present collects any additional arguments provided at
+  the function call site.
+
+- A _result type definition_, which specifies the value type returned for each
+  valid sequence of argument values.
+
+- A _result value definition_, which specifies the value returned for each
+  valid sequence of argument values.
+
+A _function call_, regardless of source syntax, consists of a sequence of
+argument values. The argument values are each mapped to a corresponding
+parameter as follows:
+
+- For each of the function's positional parameters in sequence, take the next
+  argument. If there are no more arguments, the call is erroneous.
+
+- If the function has a variadic parameter, take all remaining arguments that
+  where not yet assigned to a positional parameter and collect them into
+  a sequence of variadic arguments that each correspond to the variadic
+  parameter.
+
+- If the function has _no_ variadic parameter, it is an error if any arguments
+  remain after taking one argument for each positional parameter.
+
+After mapping each argument to a parameter, semantic checking proceeds
+for each argument:
+
+- If the argument value corresponding to a parameter does not match the
+  parameter's type specification, the call is erroneous.
+
+- If the argument value corresponding to a parameter is null and the parameter
+  is not specified as accepting nulls, the call is erroneous.
+
+- If the argument value corresponding to a parameter is the dynamic value
+  and the parameter is not specified as accepting values of the dynamic
+  pseudo-type, the call is valid but its _result type_ is forced to be the
+  dynamic pseudo type.
+
+- If neither of the above conditions holds for any argument, the call is
+  valid and the function's value type definition is used to determine the
+  call's _result type_. A function _may_ vary its result type depending on
+  the argument _values_ as well as the argument _types_; for example, a
+  function that decodes a JSON value will return a different result type
+  depending on the data structure described by the given JSON source code.
+
+If semantic checking succeeds without error, the call is _executed_:
+
+- For each argument, if its value is unknown and its corresponding parameter
+  is not specified as accepting unknowns, the _result value_ is forced to be an
+  unknown value of the result type.
+
+- If the previous condition does not apply, the function's result value
+  definition is used to determine the call's _result value_.
+
+The result of a function call expression is either an error, if one of the
+erroneous conditions above applies, or the _result value_.
+
+## Type Conversions and Unification
+
+Values given in configuration may not always match the expectations of the
+operations applied to them or to the calling application. In such situations,
+automatic type conversion is attempted as a convenience to the user.
+
+Along with conversions to a _specified_ type, it is sometimes necessary to
+ensure that a selection of values are all of the _same_ type, without any
+constraint on which type that is. This is the process of _type unification_,
+which attempts to find the most general type that all of the given types can
+be converted to.
+
+Both type conversions and unification are defined in the syntax-agnostic
+model to ensure consistency of behavior between syntaxes.
+
+Type conversions are broadly characterized into two categories: _safe_ and
+_unsafe_. A conversion is "safe" if any distinct value of the source type
+has a corresponding distinct value in the target type. A conversion is
+"unsafe" if either the target type values are _not_ distinct (information
+may be lost in conversion) or if some values of the source type do not have
+any corresponding value in the target type. An unsafe conversion may result
+in an error.
+
+A given type can always be converted to itself, which is a no-op.
+
+### Conversion of Null Values
+
+All null values are safely convertable to a null value of any other type,
+regardless of other type-specific rules specified in the sections below.
+
+### Conversion to and from the Dynamic Pseudo-type
+
+Conversion _from_ the dynamic pseudo-type _to_ any other type always succeeds,
+producing an unknown value of the target type.
+
+Conversion of any value _to_ the dynamic pseudo-type is a no-op. The result
+is the input value, verbatim. This is the only situation where the conversion
+result value is not of the given target type.
+
+### Primitive Type Conversions
+
+Bidirectional conversions are available between the string and number types,
+and between the string and boolean types.
+
+The bool value true corresponds to the string containing the characters "true",
+while the bool value false corresponds to the string containing the characters
+"false". Conversion from bool to string is safe, while the converse is
+unsafe. The strings "1" and "0" are alternative string representations
+of true and false respectively. It is an error to convert a string other than
+the four in this paragraph to type bool.
+
+A number value is converted to string by translating its integer portion
+into a sequence of decimal digits (`0` through `9`), and then if it has a
+non-zero fractional part, a period `.` followed by a sequence of decimal
+digits representing its fractional part. No exponent portion is included.
+The number is converted at its full precision. Conversion from number to
+string is safe.
+
+A string is converted to a number value by reversing the above mapping.
+No exponent portion is allowed. Conversion from string to number is unsafe.
+It is an error to convert a string that does not comply with the expected
+syntax to type number.
+
+No direct conversion is available between the bool and number types.
+
+### Collection and Structural Type Conversions
+
+Conversion from set types to list types is _safe_, as long as their
+element types are safely convertable. If the element types are _unsafely_
+convertable, then the collection conversion is also unsafe. Each set element
+becomes a corresponding list element, in an undefined order. Although no
+particular ordering is required, implementations _should_ produce list
+elements in a consistent order for a given input set, as a convenience
+to calling applications.
+
+Conversion from list types to set types is _unsafe_, as long as their element
+types are convertable. Each distinct list item becomes a distinct set item.
+If two list items are equal, one of the two is lost in the conversion.
+
+Conversion from tuple types to list types permitted if all of the
+tuple element types are convertable to the target list element type.
+The safety of the conversion depends on the safety of each of the element
+conversions. Each element in turn is converted to the list element type,
+producing a list of identical length.
+
+Conversion from tuple types to set types is permitted, behaving as if the
+tuple type was first converted to a list of the same element type and then
+that list converted to the target set type.
+
+Conversion from object types to map types is permitted if all of the object
+attribute types are convertable to the target map element type. The safety
+of the conversion depends on the safety of each of the attribute conversions.
+Each attribute in turn is converted to the map element type, and map element
+keys are set to the name of each corresponding object attribute.
+
+Conversion from list and set types to tuple types is permitted, following
+the opposite steps as the converse conversions. Such conversions are _unsafe_.
+It is an error to convert a list or set to a tuple type whose number of
+elements does not match the list or set length.
+
+Conversion from map types to object types is permitted if each map key
+corresponds to an attribute in the target object type. It is an error to
+convert from a map value whose set of keys does not exactly match the target
+type's attributes. The conversion takes the opposite steps of the converse
+conversion.
+
+Conversion from one object type to another is permitted as long as the
+common attribute names have convertable types. Any attribute present in the
+target type but not in the source type is populated with a null value of
+the appropriate type.
+
+Conversion from one tuple type to another is permitted as long as the
+tuples have the same length and the elements have convertable types.
+
+### Type Unification
+
+Type unification is an operation that takes a list of types and attempts
+to find a single type to which they can all be converted. Since some
+type pairs have bidirectional conversions, preference is given to _safe_
+conversions. In technical terms, all possible types are arranged into
+a lattice, from which a most general supertype is selected where possible.
+
+The type resulting from type unification may be one of the input types, or
+it may be an entirely new type produced by combination of two or more
+input types.
+
+The following rules do not guarantee a valid result. In addition to these
+rules, unification fails if any of the given types are not convertable
+(per the above rules) to the selected result type.
+
+The following unification rules apply transitively. That is, if a rule is
+defined from A to B, and one from B to C, then A can unify to C.
+
+Number and bool types both unify with string by preferring string.
+
+Two collection types of the same kind unify according to the unification
+of their element types.
+
+List and set types unify by preferring the list type.
+
+Map and object types unify by preferring the object type.
+
+List, set and tuple types unify by preferring the tuple type.
+
+The dynamic pseudo-type unifies with any other type by selecting that other
+type. The dynamic pseudo-type is the result type only if _all_ input types
+are the dynamic pseudo-type.
+
+Two object types unify by constructing a new type whose attributes are
+the union of those of the two input types. Any common attributes themselves
+have their types unified.
+
+Two tuple types of the same length unify constructing a new type of the
+same length whose elements are the unification of the corresponding elements
+in the two input types.
+
+## Static Analysis
+
+In most applications, full expression evaluation is sufficient for understanding
+the provided configuration. However, some specialized applications require more
+direct access to the physical structures in the expressions, which can for
+example allow the construction of new language constructs in terms of the
+existing syntax elements.
+
+Since static analysis analyses the physical structure of configuration, the
+details will vary depending on syntax. Each syntax must decide which of its
+physical structures corresponds to the following analyses, producing error
+diagnostics if they are applied to inappropriate expressions.
+
+The following are the required static analysis functions:
+
+- **Static List**: Require list/tuple construction syntax to be used and
+  return a list of expressions for each of the elements given.
+
+- **Static Map**: Require map/object construction syntax to be used and
+  return a list of key/value pairs -- both expressions -- for each of
+  the elements given. The usual constraint that a map key must be a string
+  must not apply to this analysis, thus allowing applications to interpret
+  arbitrary keys as they see fit.
+
+- **Static Call**: Require function call syntax to be used and return an
+  object describing the called function name and a list of expressions
+  representing each of the call arguments.
+
+- **Static Traversal**: Require a reference to a symbol in the variable
+  scope and return a description of the path from the root scope to the
+  accessed attribute or index.
+
+The intent of a calling application using these features is to require a more
+rigid interpretation of the configuration than in expression evaluation.
+Syntax implementations should make use of the extra contextual information
+provided in order to make an intuitive mapping onto the constructs of the
+underlying syntax, possibly interpreting the expression slightly differently
+than it would be interpreted in normal evaluation.
+
+Each syntax must define which of its expression elements each of the analyses
+above applies to, and how those analyses behave given those expression elements.
+
+## Implementation Considerations
+
+Implementations of this specification are free to adopt any strategy that
+produces behavior consistent with the specification. This non-normative
+section describes some possible implementation strategies that are consistent
+with the goals of this specification.
+
+### Language-agnosticism
+
+The language-agnosticism of this specification assumes that certain behaviors
+are implemented separately for each syntax:
+
+- Matching of a body schema with the physical elements of a body in the
+  source language, to determine correspondence between physical constructs
+  and schema elements.
+
+- Implementing the _dynamic attributes_ body processing mode by either
+  interpreting all physical constructs as attributes or producing an error
+  if non-attribute constructs are present.
+
+- Providing an evaluation function for all possible expressions that produces
+  a value given an evaluation context.
+
+- Providing the static analysis functionality described above in a manner that
+  makes sense within the convention of the syntax.
+
+The suggested implementation strategy is to use an implementation language's
+closest concept to an _abstract type_, _virtual type_ or _interface type_
+to represent both Body and Expression. Each language-specific implementation
+can then provide an implementation of each of these types wrapping AST nodes
+or other physical constructs from the language parser.
diff --git a/vendor/github.com/hashicorp/hcl/v2/static_expr.go b/vendor/github.com/hashicorp/hcl/v2/static_expr.go
new file mode 100644
index 000000000..98ada87b6
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/static_expr.go
@@ -0,0 +1,40 @@
+package hcl
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+type staticExpr struct {
+	val cty.Value
+	rng Range
+}
+
+// StaticExpr returns an Expression that always evaluates to the given value.
+//
+// This is useful to substitute default values for expressions that are
+// not explicitly given in configuration and thus would otherwise have no
+// Expression to return.
+//
+// Since expressions are expected to have a source range, the caller must
+// provide one. Ideally this should be a real source range, but it can
+// be a synthetic one (with an empty-string filename) if no suitable range
+// is available.
+func StaticExpr(val cty.Value, rng Range) Expression {
+	return staticExpr{val, rng}
+}
+
+func (e staticExpr) Value(ctx *EvalContext) (cty.Value, Diagnostics) {
+	return e.val, nil
+}
+
+func (e staticExpr) Variables() []Traversal {
+	return nil
+}
+
+func (e staticExpr) Range() Range {
+	return e.rng
+}
+
+func (e staticExpr) StartRange() Range {
+	return e.rng
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/structure.go b/vendor/github.com/hashicorp/hcl/v2/structure.go
new file mode 100644
index 000000000..aab09457d
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/structure.go
@@ -0,0 +1,151 @@
+package hcl
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// File is the top-level node that results from parsing a HCL file.
+type File struct {
+	Body  Body
+	Bytes []byte
+
+	// Nav is used to integrate with the "hcled" editor integration package,
+	// and with diagnostic information formatters. It is not for direct use
+	// by a calling application.
+	Nav interface{}
+}
+
+// Block represents a nested block within a Body.
+type Block struct {
+	Type   string
+	Labels []string
+	Body   Body
+
+	DefRange    Range   // Range that can be considered the "definition" for seeking in an editor
+	TypeRange   Range   // Range for the block type declaration specifically.
+	LabelRanges []Range // Ranges for the label values specifically.
+}
+
+// Blocks is a sequence of Block.
+type Blocks []*Block
+
+// Attributes is a set of attributes keyed by their names.
+type Attributes map[string]*Attribute
+
+// Body is a container for attributes and blocks. It serves as the primary
+// unit of hierarchical structure within configuration.
+//
+// The content of a body cannot be meaningfully interpreted without a schema,
+// so Body represents the raw body content and has methods that allow the
+// content to be extracted in terms of a given schema.
+type Body interface {
+	// Content verifies that the entire body content conforms to the given
+	// schema and then returns it, and/or returns diagnostics. The returned
+	// body content is valid if non-nil, regardless of whether Diagnostics
+	// are provided, but diagnostics should still be eventually shown to
+	// the user.
+	Content(schema *BodySchema) (*BodyContent, Diagnostics)
+
+	// PartialContent is like Content except that it permits the configuration
+	// to contain additional blocks or attributes not specified in the
+	// schema. If any are present, the returned Body is non-nil and contains
+	// the remaining items from the body that were not selected by the schema.
+	PartialContent(schema *BodySchema) (*BodyContent, Body, Diagnostics)
+
+	// JustAttributes attempts to interpret all of the contents of the body
+	// as attributes, allowing for the contents to be accessed without a priori
+	// knowledge of the structure.
+	//
+	// The behavior of this method depends on the body's source language.
+	// Some languages, like JSON, can't distinguish between attributes and
+	// blocks without schema hints, but for languages that _can_ error
+	// diagnostics will be generated if any blocks are present in the body.
+	//
+	// Diagnostics may be produced for other reasons too, such as duplicate
+	// declarations of the same attribute.
+	JustAttributes() (Attributes, Diagnostics)
+
+	// MissingItemRange returns a range that represents where a missing item
+	// might hypothetically be inserted. This is used when producing
+	// diagnostics about missing required attributes or blocks. Not all bodies
+	// will have an obvious single insertion point, so the result here may
+	// be rather arbitrary.
+	MissingItemRange() Range
+}
+
+// BodyContent is the result of applying a BodySchema to a Body.
+type BodyContent struct {
+	Attributes Attributes
+	Blocks     Blocks
+
+	MissingItemRange Range
+}
+
+// Attribute represents an attribute from within a body.
+type Attribute struct {
+	Name string
+	Expr Expression
+
+	Range     Range
+	NameRange Range
+}
+
+// Expression is a literal value or an expression provided in the
+// configuration, which can be evaluated within a scope to produce a value.
+type Expression interface {
+	// Value returns the value resulting from evaluating the expression
+	// in the given evaluation context.
+	//
+	// The context may be nil, in which case the expression may contain
+	// only constants and diagnostics will be produced for any non-constant
+	// sub-expressions. (The exact definition of this depends on the source
+	// language.)
+	//
+	// The context may instead be set but have either its Variables or
+	// Functions maps set to nil, in which case only use of these features
+	// will return diagnostics.
+	//
+	// Different diagnostics are provided depending on whether the given
+	// context maps are nil or empty. In the former case, the message
+	// tells the user that variables/functions are not permitted at all,
+	// while in the latter case usage will produce a "not found" error for
+	// the specific symbol in question.
+	Value(ctx *EvalContext) (cty.Value, Diagnostics)
+
+	// Variables returns a list of variables referenced in the receiving
+	// expression. These are expressed as absolute Traversals, so may include
+	// additional information about how the variable is used, such as
+	// attribute lookups, which the calling application can potentially use
+	// to only selectively populate the scope.
+	Variables() []Traversal
+
+	Range() Range
+	StartRange() Range
+}
+
+// OfType filters the receiving block sequence by block type name,
+// returning a new block sequence including only the blocks of the
+// requested type.
+func (els Blocks) OfType(typeName string) Blocks {
+	ret := make(Blocks, 0)
+	for _, el := range els {
+		if el.Type == typeName {
+			ret = append(ret, el)
+		}
+	}
+	return ret
+}
+
+// ByType transforms the receiving block sequence into a map from type
+// name to block sequences of only that type.
+func (els Blocks) ByType() map[string]Blocks {
+	ret := make(map[string]Blocks)
+	for _, el := range els {
+		ty := el.Type
+		if ret[ty] == nil {
+			ret[ty] = make(Blocks, 0, 1)
+		}
+		ret[ty] = append(ret[ty], el)
+	}
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/structure_at_pos.go b/vendor/github.com/hashicorp/hcl/v2/structure_at_pos.go
new file mode 100644
index 000000000..8521814e5
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/structure_at_pos.go
@@ -0,0 +1,117 @@
+package hcl
+
+// -----------------------------------------------------------------------------
+// The methods in this file all have the general pattern of making a best-effort
+// to find one or more constructs that contain a given source position.
+//
+// These all operate by delegating to an optional method of the same name and
+// signature on the file's root body, allowing each syntax to potentially
+// provide its own implementations of these. For syntaxes that don't implement
+// them, the result is always nil.
+// -----------------------------------------------------------------------------
+
+// BlocksAtPos attempts to find all of the blocks that contain the given
+// position, ordered so that the outermost block is first and the innermost
+// block is last. This is a best-effort method that may not be able to produce
+// a complete result for all positions or for all HCL syntaxes.
+//
+// If the returned slice is non-empty, the first element is guaranteed to
+// represent the same block as would be the result of OutermostBlockAtPos and
+// the last element the result of InnermostBlockAtPos. However, the
+// implementation may return two different objects describing the same block,
+// so comparison by pointer identity is not possible.
+//
+// The result is nil if no blocks at all contain the given position.
+func (f *File) BlocksAtPos(pos Pos) []*Block {
+	// The root body of the file must implement this interface in order
+	// to support BlocksAtPos.
+	type Interface interface {
+		BlocksAtPos(pos Pos) []*Block
+	}
+
+	impl, ok := f.Body.(Interface)
+	if !ok {
+		return nil
+	}
+	return impl.BlocksAtPos(pos)
+}
+
+// OutermostBlockAtPos attempts to find a top-level block in the receiving file
+// that contains the given position. This is a best-effort method that may not
+// be able to produce a result for all positions or for all HCL syntaxes.
+//
+// The result is nil if no single block could be selected for any reason.
+func (f *File) OutermostBlockAtPos(pos Pos) *Block {
+	// The root body of the file must implement this interface in order
+	// to support OutermostBlockAtPos.
+	type Interface interface {
+		OutermostBlockAtPos(pos Pos) *Block
+	}
+
+	impl, ok := f.Body.(Interface)
+	if !ok {
+		return nil
+	}
+	return impl.OutermostBlockAtPos(pos)
+}
+
+// InnermostBlockAtPos attempts to find the most deeply-nested block in the
+// receiving file that contains the given position. This is a best-effort
+// method that may not be able to produce a result for all positions or for
+// all HCL syntaxes.
+//
+// The result is nil if no single block could be selected for any reason.
+func (f *File) InnermostBlockAtPos(pos Pos) *Block {
+	// The root body of the file must implement this interface in order
+	// to support InnermostBlockAtPos.
+	type Interface interface {
+		InnermostBlockAtPos(pos Pos) *Block
+	}
+
+	impl, ok := f.Body.(Interface)
+	if !ok {
+		return nil
+	}
+	return impl.InnermostBlockAtPos(pos)
+}
+
+// OutermostExprAtPos attempts to find an expression in the receiving file
+// that contains the given position. This is a best-effort method that may not
+// be able to produce a result for all positions or for all HCL syntaxes.
+//
+// Since expressions are often nested inside one another, this method returns
+// the outermost "root" expression that is not contained by any other.
+//
+// The result is nil if no single expression could be selected for any reason.
+func (f *File) OutermostExprAtPos(pos Pos) Expression {
+	// The root body of the file must implement this interface in order
+	// to support OutermostExprAtPos.
+	type Interface interface {
+		OutermostExprAtPos(pos Pos) Expression
+	}
+
+	impl, ok := f.Body.(Interface)
+	if !ok {
+		return nil
+	}
+	return impl.OutermostExprAtPos(pos)
+}
+
+// AttributeAtPos attempts to find an attribute definition in the receiving
+// file that contains the given position. This is a best-effort method that may
+// not be able to produce a result for all positions or for all HCL syntaxes.
+//
+// The result is nil if no single attribute could be selected for any reason.
+func (f *File) AttributeAtPos(pos Pos) *Attribute {
+	// The root body of the file must implement this interface in order
+	// to support OutermostExprAtPos.
+	type Interface interface {
+		AttributeAtPos(pos Pos) *Attribute
+	}
+
+	impl, ok := f.Body.(Interface)
+	if !ok {
+		return nil
+	}
+	return impl.AttributeAtPos(pos)
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/traversal.go b/vendor/github.com/hashicorp/hcl/v2/traversal.go
new file mode 100644
index 000000000..d71019700
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/traversal.go
@@ -0,0 +1,293 @@
+package hcl
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// A Traversal is a description of traversing through a value through a
+// series of operations such as attribute lookup, index lookup, etc.
+//
+// It is used to look up values in scopes, for example.
+//
+// The traversal operations are implementations of interface Traverser.
+// This is a closed set of implementations, so the interface cannot be
+// implemented from outside this package.
+//
+// A traversal can be absolute (its first value is a symbol name) or relative
+// (starts from an existing value).
+type Traversal []Traverser
+
+// TraversalJoin appends a relative traversal to an absolute traversal to
+// produce a new absolute traversal.
+func TraversalJoin(abs Traversal, rel Traversal) Traversal {
+	if abs.IsRelative() {
+		panic("first argument to TraversalJoin must be absolute")
+	}
+	if !rel.IsRelative() {
+		panic("second argument to TraversalJoin must be relative")
+	}
+
+	ret := make(Traversal, len(abs)+len(rel))
+	copy(ret, abs)
+	copy(ret[len(abs):], rel)
+	return ret
+}
+
+// TraverseRel applies the receiving traversal to the given value, returning
+// the resulting value. This is supported only for relative traversals,
+// and will panic if applied to an absolute traversal.
+func (t Traversal) TraverseRel(val cty.Value) (cty.Value, Diagnostics) {
+	if !t.IsRelative() {
+		panic("can't use TraverseRel on an absolute traversal")
+	}
+
+	current := val
+	var diags Diagnostics
+	for _, tr := range t {
+		var newDiags Diagnostics
+		current, newDiags = tr.TraversalStep(current)
+		diags = append(diags, newDiags...)
+		if newDiags.HasErrors() {
+			return cty.DynamicVal, diags
+		}
+	}
+	return current, diags
+}
+
+// TraverseAbs applies the receiving traversal to the given eval context,
+// returning the resulting value. This is supported only for absolute
+// traversals, and will panic if applied to a relative traversal.
+func (t Traversal) TraverseAbs(ctx *EvalContext) (cty.Value, Diagnostics) {
+	if t.IsRelative() {
+		panic("can't use TraverseAbs on a relative traversal")
+	}
+
+	split := t.SimpleSplit()
+	root := split.Abs[0].(TraverseRoot)
+	name := root.Name
+
+	thisCtx := ctx
+	hasNonNil := false
+	for thisCtx != nil {
+		if thisCtx.Variables == nil {
+			thisCtx = thisCtx.parent
+			continue
+		}
+		hasNonNil = true
+		val, exists := thisCtx.Variables[name]
+		if exists {
+			return split.Rel.TraverseRel(val)
+		}
+		thisCtx = thisCtx.parent
+	}
+
+	if !hasNonNil {
+		return cty.DynamicVal, Diagnostics{
+			{
+				Severity: DiagError,
+				Summary:  "Variables not allowed",
+				Detail:   "Variables may not be used here.",
+				Subject:  &root.SrcRange,
+			},
+		}
+	}
+
+	suggestions := make([]string, 0, len(ctx.Variables))
+	thisCtx = ctx
+	for thisCtx != nil {
+		for k := range thisCtx.Variables {
+			suggestions = append(suggestions, k)
+		}
+		thisCtx = thisCtx.parent
+	}
+	suggestion := nameSuggestion(name, suggestions)
+	if suggestion != "" {
+		suggestion = fmt.Sprintf(" Did you mean %q?", suggestion)
+	}
+
+	return cty.DynamicVal, Diagnostics{
+		{
+			Severity: DiagError,
+			Summary:  "Unknown variable",
+			Detail:   fmt.Sprintf("There is no variable named %q.%s", name, suggestion),
+			Subject:  &root.SrcRange,
+		},
+	}
+}
+
+// IsRelative returns true if the receiver is a relative traversal, or false
+// otherwise.
+func (t Traversal) IsRelative() bool {
+	if len(t) == 0 {
+		return true
+	}
+	if _, firstIsRoot := t[0].(TraverseRoot); firstIsRoot {
+		return false
+	}
+	return true
+}
+
+// SimpleSplit returns a TraversalSplit where the name lookup is the absolute
+// part and the remainder is the relative part. Supported only for
+// absolute traversals, and will panic if applied to a relative traversal.
+//
+// This can be used by applications that have a relatively-simple variable
+// namespace where only the top-level is directly populated in the scope, with
+// everything else handled by relative lookups from those initial values.
+func (t Traversal) SimpleSplit() TraversalSplit {
+	if t.IsRelative() {
+		panic("can't use SimpleSplit on a relative traversal")
+	}
+	return TraversalSplit{
+		Abs: t[0:1],
+		Rel: t[1:],
+	}
+}
+
+// RootName returns the root name for a absolute traversal. Will panic if
+// called on a relative traversal.
+func (t Traversal) RootName() string {
+	if t.IsRelative() {
+		panic("can't use RootName on a relative traversal")
+
+	}
+	return t[0].(TraverseRoot).Name
+}
+
+// SourceRange returns the source range for the traversal.
+func (t Traversal) SourceRange() Range {
+	if len(t) == 0 {
+		// Nothing useful to return here, but we'll return something
+		// that's correctly-typed at least.
+		return Range{}
+	}
+
+	return RangeBetween(t[0].SourceRange(), t[len(t)-1].SourceRange())
+}
+
+// TraversalSplit represents a pair of traversals, the first of which is
+// an absolute traversal and the second of which is relative to the first.
+//
+// This is used by calling applications that only populate prefixes of the
+// traversals in the scope, with Abs representing the part coming from the
+// scope and Rel representing the remaining steps once that part is
+// retrieved.
+type TraversalSplit struct {
+	Abs Traversal
+	Rel Traversal
+}
+
+// TraverseAbs traverses from a scope to the value resulting from the
+// absolute traversal.
+func (t TraversalSplit) TraverseAbs(ctx *EvalContext) (cty.Value, Diagnostics) {
+	return t.Abs.TraverseAbs(ctx)
+}
+
+// TraverseRel traverses from a given value, assumed to be the result of
+// TraverseAbs on some scope, to a final result for the entire split traversal.
+func (t TraversalSplit) TraverseRel(val cty.Value) (cty.Value, Diagnostics) {
+	return t.Rel.TraverseRel(val)
+}
+
+// Traverse is a convenience function to apply TraverseAbs followed by
+// TraverseRel.
+func (t TraversalSplit) Traverse(ctx *EvalContext) (cty.Value, Diagnostics) {
+	v1, diags := t.TraverseAbs(ctx)
+	if diags.HasErrors() {
+		return cty.DynamicVal, diags
+	}
+	v2, newDiags := t.TraverseRel(v1)
+	diags = append(diags, newDiags...)
+	return v2, diags
+}
+
+// Join concatenates together the Abs and Rel parts to produce a single
+// absolute traversal.
+func (t TraversalSplit) Join() Traversal {
+	return TraversalJoin(t.Abs, t.Rel)
+}
+
+// RootName returns the root name for the absolute part of the split.
+func (t TraversalSplit) RootName() string {
+	return t.Abs.RootName()
+}
+
+// A Traverser is a step within a Traversal.
+type Traverser interface {
+	TraversalStep(cty.Value) (cty.Value, Diagnostics)
+	SourceRange() Range
+	isTraverserSigil() isTraverser
+}
+
+// Embed this in a struct to declare it as a Traverser
+type isTraverser struct {
+}
+
+func (tr isTraverser) isTraverserSigil() isTraverser {
+	return isTraverser{}
+}
+
+// TraverseRoot looks up a root name in a scope. It is used as the first step
+// of an absolute Traversal, and cannot itself be traversed directly.
+type TraverseRoot struct {
+	isTraverser
+	Name     string
+	SrcRange Range
+}
+
+// TraversalStep on a TraverseName immediately panics, because absolute
+// traversals cannot be directly traversed.
+func (tn TraverseRoot) TraversalStep(cty.Value) (cty.Value, Diagnostics) {
+	panic("Cannot traverse an absolute traversal")
+}
+
+func (tn TraverseRoot) SourceRange() Range {
+	return tn.SrcRange
+}
+
+// TraverseAttr looks up an attribute in its initial value.
+type TraverseAttr struct {
+	isTraverser
+	Name     string
+	SrcRange Range
+}
+
+func (tn TraverseAttr) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
+	return GetAttr(val, tn.Name, &tn.SrcRange)
+}
+
+func (tn TraverseAttr) SourceRange() Range {
+	return tn.SrcRange
+}
+
+// TraverseIndex applies the index operation to its initial value.
+type TraverseIndex struct {
+	isTraverser
+	Key      cty.Value
+	SrcRange Range
+}
+
+func (tn TraverseIndex) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
+	return Index(val, tn.Key, &tn.SrcRange)
+}
+
+func (tn TraverseIndex) SourceRange() Range {
+	return tn.SrcRange
+}
+
+// TraverseSplat applies the splat operation to its initial value.
+type TraverseSplat struct {
+	isTraverser
+	Each     Traversal
+	SrcRange Range
+}
+
+func (tn TraverseSplat) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
+	panic("TraverseSplat not yet implemented")
+}
+
+func (tn TraverseSplat) SourceRange() Range {
+	return tn.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl/v2/traversal_for_expr.go b/vendor/github.com/hashicorp/hcl/v2/traversal_for_expr.go
new file mode 100644
index 000000000..f69d5fe9b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl/v2/traversal_for_expr.go
@@ -0,0 +1,124 @@
+package hcl
+
+// AbsTraversalForExpr attempts to interpret the given expression as
+// an absolute traversal, or returns error diagnostic(s) if that is
+// not possible for the given expression.
+//
+// A particular Expression implementation can support this function by
+// offering a method called AsTraversal that takes no arguments and
+// returns either a valid absolute traversal or nil to indicate that
+// no traversal is possible. Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+//
+// In most cases the calling application is interested in the value
+// that results from an expression, but in rarer cases the application
+// needs to see the the name of the variable and subsequent
+// attributes/indexes itself, for example to allow users to give references
+// to the variables themselves rather than to their values. An implementer
+// of this function should at least support attribute and index steps.
+func AbsTraversalForExpr(expr Expression) (Traversal, Diagnostics) {
+	type asTraversal interface {
+		AsTraversal() Traversal
+	}
+
+	physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+		_, supported := expr.(asTraversal)
+		return supported
+	})
+
+	if asT, supported := physExpr.(asTraversal); supported {
+		if traversal := asT.AsTraversal(); traversal != nil {
+			return traversal, nil
+		}
+	}
+	return nil, Diagnostics{
+		&Diagnostic{
+			Severity: DiagError,
+			Summary:  "Invalid expression",
+			Detail:   "A single static variable reference is required: only attribute access and indexing with constant keys. No calculations, function calls, template expressions, etc are allowed here.",
+			Subject:  expr.Range().Ptr(),
+		},
+	}
+}
+
+// RelTraversalForExpr is similar to AbsTraversalForExpr but it returns
+// a relative traversal instead. Due to the nature of HCL expressions, the
+// first element of the returned traversal is always a TraverseAttr, and
+// then it will be followed by zero or more other expressions.
+//
+// Any expression accepted by AbsTraversalForExpr is also accepted by
+// RelTraversalForExpr.
+func RelTraversalForExpr(expr Expression) (Traversal, Diagnostics) {
+	traversal, diags := AbsTraversalForExpr(expr)
+	if len(traversal) > 0 {
+		ret := make(Traversal, len(traversal))
+		copy(ret, traversal)
+		root := traversal[0].(TraverseRoot)
+		ret[0] = TraverseAttr{
+			Name:     root.Name,
+			SrcRange: root.SrcRange,
+		}
+		return ret, diags
+	}
+	return traversal, diags
+}
+
+// ExprAsKeyword attempts to interpret the given expression as a static keyword,
+// returning the keyword string if possible, and the empty string if not.
+//
+// A static keyword, for the sake of this function, is a single identifier.
+// For example, the following attribute has an expression that would produce
+// the keyword "foo":
+//
+//     example = foo
+//
+// This function is a variant of AbsTraversalForExpr, which uses the same
+// interface on the given expression. This helper constrains the result
+// further by requiring only a single root identifier.
+//
+// This function is intended to be used with the following idiom, to recognize
+// situations where one of a fixed set of keywords is required and arbitrary
+// expressions are not allowed:
+//
+//     switch hcl.ExprAsKeyword(expr) {
+//     case "allow":
+//         // (take suitable action for keyword "allow")
+//     case "deny":
+//         // (take suitable action for keyword "deny")
+//     default:
+//         diags = append(diags, &hcl.Diagnostic{
+//             // ... "invalid keyword" diagnostic message ...
+//         })
+//     }
+//
+// The above approach will generate the same message for both the use of an
+// unrecognized keyword and for not using a keyword at all, which is usually
+// reasonable if the message specifies that the given value must be a keyword
+// from that fixed list.
+//
+// Note that in the native syntax the keywords "true", "false", and "null" are
+// recognized as literal values during parsing and so these reserved words
+// cannot not be accepted as keywords by this function.
+//
+// Since interpreting an expression as a keyword bypasses usual expression
+// evaluation, it should be used sparingly for situations where e.g. one of
+// a fixed set of keywords is used in a structural way in a special attribute
+// to affect the further processing of a block.
+func ExprAsKeyword(expr Expression) string {
+	type asTraversal interface {
+		AsTraversal() Traversal
+	}
+
+	physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+		_, supported := expr.(asTraversal)
+		return supported
+	})
+
+	if asT, supported := physExpr.(asTraversal); supported {
+		if traversal := asT.AsTraversal(); len(traversal) == 1 {
+			return traversal.RootName()
+		}
+	}
+	return ""
+}
diff --git a/vendor/github.com/kardianos/osext/go.mod b/vendor/github.com/kardianos/osext/go.mod
new file mode 100644
index 000000000..66c73d7c2
--- /dev/null
+++ b/vendor/github.com/kardianos/osext/go.mod
@@ -0,0 +1 @@
+module github.com/kardianos/osext
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/chunked.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/chunked.go
deleted file mode 100644
index 749f29d32..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/chunked.go
+++ /dev/null
@@ -1,203 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// The wire protocol for HTTP's "chunked" Transfer-Encoding.
-
-// This code is duplicated in net/http and net/http/httputil.
-// Please make any changes in both files.
-
-package http
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-)
-
-const maxLineLength = 4096 // assumed <= bufio.defaultBufSize
-
-var ErrLineTooLong = errors.New("header line too long")
-
-// newChunkedReader returns a new chunkedReader that translates the data read from r
-// out of HTTP "chunked" format before returning it.
-// The chunkedReader returns io.EOF when the final 0-length chunk is read.
-//
-// newChunkedReader is not needed by normal applications. The http package
-// automatically decodes chunking when reading response bodies.
-func newChunkedReader(r io.Reader) io.Reader {
-	br, ok := r.(*bufio.Reader)
-	if !ok {
-		br = bufio.NewReader(r)
-	}
-	return &chunkedReader{r: br}
-}
-
-type chunkedReader struct {
-	r   *bufio.Reader
-	n   uint64 // unread bytes in chunk
-	err error
-	buf [2]byte
-}
-
-func (cr *chunkedReader) beginChunk() {
-	// chunk-size CRLF
-	var line []byte
-	line, cr.err = readLine(cr.r)
-	if cr.err != nil {
-		return
-	}
-	cr.n, cr.err = parseHexUint(line)
-	if cr.err != nil {
-		return
-	}
-	if cr.n == 0 {
-		cr.err = io.EOF
-	}
-}
-
-func (cr *chunkedReader) chunkHeaderAvailable() bool {
-	n := cr.r.Buffered()
-	if n > 0 {
-		peek, _ := cr.r.Peek(n)
-		return bytes.IndexByte(peek, '\n') >= 0
-	}
-	return false
-}
-
-func (cr *chunkedReader) Read(b []uint8) (n int, err error) {
-	for cr.err == nil {
-		if cr.n == 0 {
-			if n > 0 && !cr.chunkHeaderAvailable() {
-				// We've read enough. Don't potentially block
-				// reading a new chunk header.
-				break
-			}
-			cr.beginChunk()
-			continue
-		}
-		if len(b) == 0 {
-			break
-		}
-		rbuf := b
-		if uint64(len(rbuf)) > cr.n {
-			rbuf = rbuf[:cr.n]
-		}
-		var n0 int
-		n0, cr.err = cr.r.Read(rbuf)
-		n += n0
-		b = b[n0:]
-		cr.n -= uint64(n0)
-		// If we're at the end of a chunk, read the next two
-		// bytes to verify they are "\r\n".
-		if cr.n == 0 && cr.err == nil {
-			if _, cr.err = io.ReadFull(cr.r, cr.buf[:2]); cr.err == nil {
-				if cr.buf[0] != '\r' || cr.buf[1] != '\n' {
-					cr.err = errors.New("malformed chunked encoding")
-				}
-			}
-		}
-	}
-	return n, cr.err
-}
-
-// Read a line of bytes (up to \n) from b.
-// Give up if the line exceeds maxLineLength.
-// The returned bytes are a pointer into storage in
-// the bufio, so they are only valid until the next bufio read.
-func readLine(b *bufio.Reader) (p []byte, err error) {
-	if p, err = b.ReadSlice('\n'); err != nil {
-		// We always know when EOF is coming.
-		// If the caller asked for a line, there should be a line.
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		} else if err == bufio.ErrBufferFull {
-			err = ErrLineTooLong
-		}
-		return nil, err
-	}
-	if len(p) >= maxLineLength {
-		return nil, ErrLineTooLong
-	}
-	return trimTrailingWhitespace(p), nil
-}
-
-func trimTrailingWhitespace(b []byte) []byte {
-	for len(b) > 0 && isASCIISpace(b[len(b)-1]) {
-		b = b[:len(b)-1]
-	}
-	return b
-}
-
-func isASCIISpace(b byte) bool {
-	return b == ' ' || b == '\t' || b == '\n' || b == '\r'
-}
-
-// newChunkedWriter returns a new chunkedWriter that translates writes into HTTP
-// "chunked" format before writing them to w. Closing the returned chunkedWriter
-// sends the final 0-length chunk that marks the end of the stream.
-//
-// newChunkedWriter is not needed by normal applications. The http
-// package adds chunking automatically if handlers don't set a
-// Content-Length header. Using newChunkedWriter inside a handler
-// would result in double chunking or chunking with a Content-Length
-// length, both of which are wrong.
-func newChunkedWriter(w io.Writer) io.WriteCloser {
-	return &chunkedWriter{w}
-}
-
-// Writing to chunkedWriter translates to writing in HTTP chunked Transfer
-// Encoding wire format to the underlying Wire chunkedWriter.
-type chunkedWriter struct {
-	Wire io.Writer
-}
-
-// Write the contents of data as one chunk to Wire.
-// NOTE: Note that the corresponding chunk-writing procedure in Conn.Write has
-// a bug since it does not check for success of io.WriteString
-func (cw *chunkedWriter) Write(data []byte) (n int, err error) {
-
-	// Don't send 0-length data. It looks like EOF for chunked encoding.
-	if len(data) == 0 {
-		return 0, nil
-	}
-
-	if _, err = fmt.Fprintf(cw.Wire, "%x\r\n", len(data)); err != nil {
-		return 0, err
-	}
-	if n, err = cw.Wire.Write(data); err != nil {
-		return
-	}
-	if n != len(data) {
-		err = io.ErrShortWrite
-		return
-	}
-	_, err = io.WriteString(cw.Wire, "\r\n")
-
-	return
-}
-
-func (cw *chunkedWriter) Close() error {
-	_, err := io.WriteString(cw.Wire, "0\r\n")
-	return err
-}
-
-func parseHexUint(v []byte) (n uint64, err error) {
-	for _, b := range v {
-		n <<= 4
-		switch {
-		case '0' <= b && b <= '9':
-			b = b - '0'
-		case 'a' <= b && b <= 'f':
-			b = b - 'a' + 10
-		case 'A' <= b && b <= 'F':
-			b = b - 'A' + 10
-		default:
-			return 0, errors.New("invalid byte in chunk length")
-		}
-		n |= uint64(b)
-	}
-	return
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/client.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/client.go
deleted file mode 100644
index a5a3abe61..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/client.go
+++ /dev/null
@@ -1,487 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// HTTP client. See RFC 2616.
-//
-// This is the high-level Client interface.
-// The low-level implementation is in transport.go.
-
-package http
-
-import (
-	"encoding/base64"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net/url"
-	"strings"
-	"sync"
-	"time"
-)
-
-// A Client is an HTTP client. Its zero value (DefaultClient) is a
-// usable client that uses DefaultTransport.
-//
-// The Client's Transport typically has internal state (cached TCP
-// connections), so Clients should be reused instead of created as
-// needed. Clients are safe for concurrent use by multiple goroutines.
-//
-// A Client is higher-level than a RoundTripper (such as Transport)
-// and additionally handles HTTP details such as cookies and
-// redirects.
-type Client struct {
-	// Transport specifies the mechanism by which individual
-	// HTTP requests are made.
-	// If nil, DefaultTransport is used.
-	Transport RoundTripper
-
-	// CheckRedirect specifies the policy for handling redirects.
-	// If CheckRedirect is not nil, the client calls it before
-	// following an HTTP redirect. The arguments req and via are
-	// the upcoming request and the requests made already, oldest
-	// first. If CheckRedirect returns an error, the Client's Get
-	// method returns both the previous Response and
-	// CheckRedirect's error (wrapped in a url.Error) instead of
-	// issuing the Request req.
-	//
-	// If CheckRedirect is nil, the Client uses its default policy,
-	// which is to stop after 10 consecutive requests.
-	CheckRedirect func(req *Request, via []*Request) error
-
-	// Jar specifies the cookie jar.
-	// If Jar is nil, cookies are not sent in requests and ignored
-	// in responses.
-	Jar CookieJar
-
-	// Timeout specifies a time limit for requests made by this
-	// Client. The timeout includes connection time, any
-	// redirects, and reading the response body. The timer remains
-	// running after Get, Head, Post, or Do return and will
-	// interrupt reading of the Response.Body.
-	//
-	// A Timeout of zero means no timeout.
-	//
-	// The Client's Transport must support the CancelRequest
-	// method or Client will return errors when attempting to make
-	// a request with Get, Head, Post, or Do. Client's default
-	// Transport (DefaultTransport) supports CancelRequest.
-	Timeout time.Duration
-}
-
-// DefaultClient is the default Client and is used by Get, Head, and Post.
-var DefaultClient = &Client{}
-
-// RoundTripper is an interface representing the ability to execute a
-// single HTTP transaction, obtaining the Response for a given Request.
-//
-// A RoundTripper must be safe for concurrent use by multiple
-// goroutines.
-type RoundTripper interface {
-	// RoundTrip executes a single HTTP transaction, returning
-	// the Response for the request req.  RoundTrip should not
-	// attempt to interpret the response.  In particular,
-	// RoundTrip must return err == nil if it obtained a response,
-	// regardless of the response's HTTP status code.  A non-nil
-	// err should be reserved for failure to obtain a response.
-	// Similarly, RoundTrip should not attempt to handle
-	// higher-level protocol details such as redirects,
-	// authentication, or cookies.
-	//
-	// RoundTrip should not modify the request, except for
-	// consuming and closing the Body, including on errors. The
-	// request's URL and Header fields are guaranteed to be
-	// initialized.
-	RoundTrip(*Request) (*Response, error)
-}
-
-// Given a string of the form "host", "host:port", or "[ipv6::address]:port",
-// return true if the string includes a port.
-func hasPort(s string) bool { return strings.LastIndex(s, ":") > strings.LastIndex(s, "]") }
-
-// Used in Send to implement io.ReadCloser by bundling together the
-// bufio.Reader through which we read the response, and the underlying
-// network connection.
-type readClose struct {
-	io.Reader
-	io.Closer
-}
-
-func (c *Client) send(req *Request) (*Response, error) {
-	if c.Jar != nil {
-		for _, cookie := range c.Jar.Cookies(req.URL) {
-			req.AddCookie(cookie)
-		}
-	}
-	resp, err := send(req, c.transport())
-	if err != nil {
-		return nil, err
-	}
-	if c.Jar != nil {
-		if rc := resp.Cookies(); len(rc) > 0 {
-			c.Jar.SetCookies(req.URL, rc)
-		}
-	}
-	return resp, err
-}
-
-// Do sends an HTTP request and returns an HTTP response, following
-// policy (e.g. redirects, cookies, auth) as configured on the client.
-//
-// An error is returned if caused by client policy (such as
-// CheckRedirect), or if there was an HTTP protocol error.
-// A non-2xx response doesn't cause an error.
-//
-// When err is nil, resp always contains a non-nil resp.Body.
-//
-// Callers should close resp.Body when done reading from it. If
-// resp.Body is not closed, the Client's underlying RoundTripper
-// (typically Transport) may not be able to re-use a persistent TCP
-// connection to the server for a subsequent "keep-alive" request.
-//
-// The request Body, if non-nil, will be closed by the underlying
-// Transport, even on errors.
-//
-// Generally Get, Post, or PostForm will be used instead of Do.
-func (c *Client) Do(req *Request) (resp *Response, err error) {
-	if req.Method == "GET" || req.Method == "HEAD" {
-		return c.doFollowingRedirects(req, shouldRedirectGet)
-	}
-	if req.Method == "POST" || req.Method == "PUT" {
-		return c.doFollowingRedirects(req, shouldRedirectPost)
-	}
-	return c.send(req)
-}
-
-func (c *Client) transport() RoundTripper {
-	if c.Transport != nil {
-		return c.Transport
-	}
-	return DefaultTransport
-}
-
-// send issues an HTTP request.
-// Caller should close resp.Body when done reading from it.
-func send(req *Request, t RoundTripper) (resp *Response, err error) {
-	if t == nil {
-		req.closeBody()
-		return nil, errors.New("http: no Client.Transport or DefaultTransport")
-	}
-
-	if req.URL == nil {
-		req.closeBody()
-		return nil, errors.New("http: nil Request.URL")
-	}
-
-	if req.RequestURI != "" {
-		req.closeBody()
-		return nil, errors.New("http: Request.RequestURI can't be set in client requests.")
-	}
-
-	// Most the callers of send (Get, Post, et al) don't need
-	// Headers, leaving it uninitialized.  We guarantee to the
-	// Transport that this has been initialized, though.
-	if req.Header == nil {
-		req.Header = make(Header)
-	}
-
-	if u := req.URL.User; u != nil {
-		username := u.Username()
-		password, _ := u.Password()
-		req.Header.Set("Authorization", "Basic "+basicAuth(username, password))
-	}
-	resp, err = t.RoundTrip(req)
-	if err != nil {
-		if resp != nil {
-			log.Printf("RoundTripper returned a response & error; ignoring response")
-		}
-		return nil, err
-	}
-	return resp, nil
-}
-
-// See 2 (end of page 4) http://www.ietf.org/rfc/rfc2617.txt
-// "To receive authorization, the client sends the userid and password,
-// separated by a single colon (":") character, within a base64
-// encoded string in the credentials."
-// It is not meant to be urlencoded.
-func basicAuth(username, password string) string {
-	auth := username + ":" + password
-	return base64.StdEncoding.EncodeToString([]byte(auth))
-}
-
-// True if the specified HTTP status code is one for which the Get utility should
-// automatically redirect.
-func shouldRedirectGet(statusCode int) bool {
-	switch statusCode {
-	case StatusMovedPermanently, StatusFound, StatusSeeOther, StatusTemporaryRedirect:
-		return true
-	}
-	return false
-}
-
-// True if the specified HTTP status code is one for which the Post utility should
-// automatically redirect.
-func shouldRedirectPost(statusCode int) bool {
-	switch statusCode {
-	case StatusFound, StatusSeeOther:
-		return true
-	}
-	return false
-}
-
-// Get issues a GET to the specified URL.  If the response is one of the following
-// redirect codes, Get follows the redirect, up to a maximum of 10 redirects:
-//
-//    301 (Moved Permanently)
-//    302 (Found)
-//    303 (See Other)
-//    307 (Temporary Redirect)
-//
-// An error is returned if there were too many redirects or if there
-// was an HTTP protocol error. A non-2xx response doesn't cause an
-// error.
-//
-// When err is nil, resp always contains a non-nil resp.Body.
-// Caller should close resp.Body when done reading from it.
-//
-// Get is a wrapper around DefaultClient.Get.
-func Get(url string) (resp *Response, err error) {
-	return DefaultClient.Get(url)
-}
-
-// Get issues a GET to the specified URL.  If the response is one of the
-// following redirect codes, Get follows the redirect after calling the
-// Client's CheckRedirect function.
-//
-//    301 (Moved Permanently)
-//    302 (Found)
-//    303 (See Other)
-//    307 (Temporary Redirect)
-//
-// An error is returned if the Client's CheckRedirect function fails
-// or if there was an HTTP protocol error. A non-2xx response doesn't
-// cause an error.
-//
-// When err is nil, resp always contains a non-nil resp.Body.
-// Caller should close resp.Body when done reading from it.
-func (c *Client) Get(url string) (resp *Response, err error) {
-	req, err := NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, err
-	}
-	return c.doFollowingRedirects(req, shouldRedirectGet)
-}
-
-func (c *Client) doFollowingRedirects(ireq *Request, shouldRedirect func(int) bool) (resp *Response, err error) {
-	var base *url.URL
-	redirectChecker := c.CheckRedirect
-	if redirectChecker == nil {
-		redirectChecker = defaultCheckRedirect
-	}
-	var via []*Request
-
-	if ireq.URL == nil {
-		ireq.closeBody()
-		return nil, errors.New("http: nil Request.URL")
-	}
-
-	var reqmu sync.Mutex // guards req
-	req := ireq
-
-	var timer *time.Timer
-	if c.Timeout > 0 {
-		type canceler interface {
-			CancelRequest(*Request)
-		}
-		tr, ok := c.transport().(canceler)
-		if !ok {
-			return nil, fmt.Errorf("net/http: Client Transport of type %T doesn't support CancelRequest; Timeout not supported", c.transport())
-		}
-		timer = time.AfterFunc(c.Timeout, func() {
-			reqmu.Lock()
-			defer reqmu.Unlock()
-			tr.CancelRequest(req)
-		})
-	}
-
-	urlStr := "" // next relative or absolute URL to fetch (after first request)
-	redirectFailed := false
-	for redirect := 0; ; redirect++ {
-		if redirect != 0 {
-			nreq := new(Request)
-			nreq.Method = ireq.Method
-			if ireq.Method == "POST" || ireq.Method == "PUT" {
-				nreq.Method = "GET"
-			}
-			nreq.Header = make(Header)
-			nreq.URL, err = base.Parse(urlStr)
-			if err != nil {
-				break
-			}
-			if len(via) > 0 {
-				// Add the Referer header.
-				lastReq := via[len(via)-1]
-				if lastReq.URL.Scheme != "https" {
-					nreq.Header.Set("Referer", lastReq.URL.String())
-				}
-
-				err = redirectChecker(nreq, via)
-				if err != nil {
-					redirectFailed = true
-					break
-				}
-			}
-			reqmu.Lock()
-			req = nreq
-			reqmu.Unlock()
-		}
-
-		urlStr = req.URL.String()
-		if resp, err = c.send(req); err != nil {
-			break
-		}
-
-		if shouldRedirect(resp.StatusCode) {
-			// Read the body if small so underlying TCP connection will be re-used.
-			// No need to check for errors: if it fails, Transport won't reuse it anyway.
-			const maxBodySlurpSize = 2 << 10
-			if resp.ContentLength == -1 || resp.ContentLength <= maxBodySlurpSize {
-				io.CopyN(ioutil.Discard, resp.Body, maxBodySlurpSize)
-			}
-			resp.Body.Close()
-			if urlStr = resp.Header.Get("Location"); urlStr == "" {
-				err = errors.New(fmt.Sprintf("%d response missing Location header", resp.StatusCode))
-				break
-			}
-			base = req.URL
-			via = append(via, req)
-			continue
-		}
-		if timer != nil {
-			resp.Body = &cancelTimerBody{timer, resp.Body}
-		}
-		return resp, nil
-	}
-
-	method := ireq.Method
-	urlErr := &url.Error{
-		Op:  method[0:1] + strings.ToLower(method[1:]),
-		URL: urlStr,
-		Err: err,
-	}
-
-	if redirectFailed {
-		// Special case for Go 1 compatibility: return both the response
-		// and an error if the CheckRedirect function failed.
-		// See http://golang.org/issue/3795
-		return resp, urlErr
-	}
-
-	if resp != nil {
-		resp.Body.Close()
-	}
-	return nil, urlErr
-}
-
-func defaultCheckRedirect(req *Request, via []*Request) error {
-	if len(via) >= 10 {
-		return errors.New("stopped after 10 redirects")
-	}
-	return nil
-}
-
-// Post issues a POST to the specified URL.
-//
-// Caller should close resp.Body when done reading from it.
-//
-// Post is a wrapper around DefaultClient.Post
-func Post(url string, bodyType string, body io.Reader) (resp *Response, err error) {
-	return DefaultClient.Post(url, bodyType, body)
-}
-
-// Post issues a POST to the specified URL.
-//
-// Caller should close resp.Body when done reading from it.
-//
-// If the provided body is also an io.Closer, it is closed after the
-// request.
-func (c *Client) Post(url string, bodyType string, body io.Reader) (resp *Response, err error) {
-	req, err := NewRequest("POST", url, body)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Content-Type", bodyType)
-	return c.doFollowingRedirects(req, shouldRedirectPost)
-}
-
-// PostForm issues a POST to the specified URL, with data's keys and
-// values URL-encoded as the request body.
-//
-// When err is nil, resp always contains a non-nil resp.Body.
-// Caller should close resp.Body when done reading from it.
-//
-// PostForm is a wrapper around DefaultClient.PostForm
-func PostForm(url string, data url.Values) (resp *Response, err error) {
-	return DefaultClient.PostForm(url, data)
-}
-
-// PostForm issues a POST to the specified URL,
-// with data's keys and values urlencoded as the request body.
-//
-// When err is nil, resp always contains a non-nil resp.Body.
-// Caller should close resp.Body when done reading from it.
-func (c *Client) PostForm(url string, data url.Values) (resp *Response, err error) {
-	return c.Post(url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
-}
-
-// Head issues a HEAD to the specified URL.  If the response is one of the
-// following redirect codes, Head follows the redirect after calling the
-// Client's CheckRedirect function.
-//
-//    301 (Moved Permanently)
-//    302 (Found)
-//    303 (See Other)
-//    307 (Temporary Redirect)
-//
-// Head is a wrapper around DefaultClient.Head
-func Head(url string) (resp *Response, err error) {
-	return DefaultClient.Head(url)
-}
-
-// Head issues a HEAD to the specified URL.  If the response is one of the
-// following redirect codes, Head follows the redirect after calling the
-// Client's CheckRedirect function.
-//
-//    301 (Moved Permanently)
-//    302 (Found)
-//    303 (See Other)
-//    307 (Temporary Redirect)
-func (c *Client) Head(url string) (resp *Response, err error) {
-	req, err := NewRequest("HEAD", url, nil)
-	if err != nil {
-		return nil, err
-	}
-	return c.doFollowingRedirects(req, shouldRedirectGet)
-}
-
-type cancelTimerBody struct {
-	t  *time.Timer
-	rc io.ReadCloser
-}
-
-func (b *cancelTimerBody) Read(p []byte) (n int, err error) {
-	n, err = b.rc.Read(p)
-	if err == io.EOF {
-		b.t.Stop()
-	}
-	return
-}
-
-func (b *cancelTimerBody) Close() error {
-	err := b.rc.Close()
-	b.t.Stop()
-	return err
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/cookie.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/cookie.go
deleted file mode 100644
index dc60ba87f..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/cookie.go
+++ /dev/null
@@ -1,363 +0,0 @@
-// Copyright 2009 The Go 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 http
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// This implementation is done according to RFC 6265:
-//
-//    http://tools.ietf.org/html/rfc6265
-
-// A Cookie represents an HTTP cookie as sent in the Set-Cookie header of an
-// HTTP response or the Cookie header of an HTTP request.
-type Cookie struct {
-	Name       string
-	Value      string
-	Path       string
-	Domain     string
-	Expires    time.Time
-	RawExpires string
-
-	// MaxAge=0 means no 'Max-Age' attribute specified.
-	// MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
-	// MaxAge>0 means Max-Age attribute present and given in seconds
-	MaxAge   int
-	Secure   bool
-	HttpOnly bool
-	Raw      string
-	Unparsed []string // Raw text of unparsed attribute-value pairs
-}
-
-// readSetCookies parses all "Set-Cookie" values from
-// the header h and returns the successfully parsed Cookies.
-func readSetCookies(h Header) []*Cookie {
-	cookies := []*Cookie{}
-	for _, line := range h["Set-Cookie"] {
-		parts := strings.Split(strings.TrimSpace(line), ";")
-		if len(parts) == 1 && parts[0] == "" {
-			continue
-		}
-		parts[0] = strings.TrimSpace(parts[0])
-		j := strings.Index(parts[0], "=")
-		if j < 0 {
-			continue
-		}
-		name, value := parts[0][:j], parts[0][j+1:]
-		if !isCookieNameValid(name) {
-			continue
-		}
-		value, success := parseCookieValue(value)
-		if !success {
-			continue
-		}
-		c := &Cookie{
-			Name:  name,
-			Value: value,
-			Raw:   line,
-		}
-		for i := 1; i < len(parts); i++ {
-			parts[i] = strings.TrimSpace(parts[i])
-			if len(parts[i]) == 0 {
-				continue
-			}
-
-			attr, val := parts[i], ""
-			if j := strings.Index(attr, "="); j >= 0 {
-				attr, val = attr[:j], attr[j+1:]
-			}
-			lowerAttr := strings.ToLower(attr)
-			val, success = parseCookieValue(val)
-			if !success {
-				c.Unparsed = append(c.Unparsed, parts[i])
-				continue
-			}
-			switch lowerAttr {
-			case "secure":
-				c.Secure = true
-				continue
-			case "httponly":
-				c.HttpOnly = true
-				continue
-			case "domain":
-				c.Domain = val
-				continue
-			case "max-age":
-				secs, err := strconv.Atoi(val)
-				if err != nil || secs != 0 && val[0] == '0' {
-					break
-				}
-				if secs <= 0 {
-					c.MaxAge = -1
-				} else {
-					c.MaxAge = secs
-				}
-				continue
-			case "expires":
-				c.RawExpires = val
-				exptime, err := time.Parse(time.RFC1123, val)
-				if err != nil {
-					exptime, err = time.Parse("Mon, 02-Jan-2006 15:04:05 MST", val)
-					if err != nil {
-						c.Expires = time.Time{}
-						break
-					}
-				}
-				c.Expires = exptime.UTC()
-				continue
-			case "path":
-				c.Path = val
-				continue
-			}
-			c.Unparsed = append(c.Unparsed, parts[i])
-		}
-		cookies = append(cookies, c)
-	}
-	return cookies
-}
-
-// SetCookie adds a Set-Cookie header to the provided ResponseWriter's headers.
-func SetCookie(w ResponseWriter, cookie *Cookie) {
-	w.Header().Add("Set-Cookie", cookie.String())
-}
-
-// String returns the serialization of the cookie for use in a Cookie
-// header (if only Name and Value are set) or a Set-Cookie response
-// header (if other fields are set).
-func (c *Cookie) String() string {
-	var b bytes.Buffer
-	fmt.Fprintf(&b, "%s=%s", sanitizeCookieName(c.Name), sanitizeCookieValue(c.Value))
-	if len(c.Path) > 0 {
-		fmt.Fprintf(&b, "; Path=%s", sanitizeCookiePath(c.Path))
-	}
-	if len(c.Domain) > 0 {
-		if validCookieDomain(c.Domain) {
-			// A c.Domain containing illegal characters is not
-			// sanitized but simply dropped which turns the cookie
-			// into a host-only cookie. A leading dot is okay
-			// but won't be sent.
-			d := c.Domain
-			if d[0] == '.' {
-				d = d[1:]
-			}
-			fmt.Fprintf(&b, "; Domain=%s", d)
-		} else {
-			log.Printf("net/http: invalid Cookie.Domain %q; dropping domain attribute",
-				c.Domain)
-		}
-	}
-	if c.Expires.Unix() > 0 {
-		fmt.Fprintf(&b, "; Expires=%s", c.Expires.UTC().Format(time.RFC1123))
-	}
-	if c.MaxAge > 0 {
-		fmt.Fprintf(&b, "; Max-Age=%d", c.MaxAge)
-	} else if c.MaxAge < 0 {
-		fmt.Fprintf(&b, "; Max-Age=0")
-	}
-	if c.HttpOnly {
-		fmt.Fprintf(&b, "; HttpOnly")
-	}
-	if c.Secure {
-		fmt.Fprintf(&b, "; Secure")
-	}
-	return b.String()
-}
-
-// readCookies parses all "Cookie" values from the header h and
-// returns the successfully parsed Cookies.
-//
-// if filter isn't empty, only cookies of that name are returned
-func readCookies(h Header, filter string) []*Cookie {
-	cookies := []*Cookie{}
-	lines, ok := h["Cookie"]
-	if !ok {
-		return cookies
-	}
-
-	for _, line := range lines {
-		parts := strings.Split(strings.TrimSpace(line), ";")
-		if len(parts) == 1 && parts[0] == "" {
-			continue
-		}
-		// Per-line attributes
-		parsedPairs := 0
-		for i := 0; i < len(parts); i++ {
-			parts[i] = strings.TrimSpace(parts[i])
-			if len(parts[i]) == 0 {
-				continue
-			}
-			name, val := parts[i], ""
-			if j := strings.Index(name, "="); j >= 0 {
-				name, val = name[:j], name[j+1:]
-			}
-			if !isCookieNameValid(name) {
-				continue
-			}
-			if filter != "" && filter != name {
-				continue
-			}
-			val, success := parseCookieValue(val)
-			if !success {
-				continue
-			}
-			cookies = append(cookies, &Cookie{Name: name, Value: val})
-			parsedPairs++
-		}
-	}
-	return cookies
-}
-
-// validCookieDomain returns wheter v is a valid cookie domain-value.
-func validCookieDomain(v string) bool {
-	if isCookieDomainName(v) {
-		return true
-	}
-	if net.ParseIP(v) != nil && !strings.Contains(v, ":") {
-		return true
-	}
-	return false
-}
-
-// isCookieDomainName returns whether s is a valid domain name or a valid
-// domain name with a leading dot '.'.  It is almost a direct copy of
-// package net's isDomainName.
-func isCookieDomainName(s string) bool {
-	if len(s) == 0 {
-		return false
-	}
-	if len(s) > 255 {
-		return false
-	}
-
-	if s[0] == '.' {
-		// A cookie a domain attribute may start with a leading dot.
-		s = s[1:]
-	}
-	last := byte('.')
-	ok := false // Ok once we've seen a letter.
-	partlen := 0
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		switch {
-		default:
-			return false
-		case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
-			// No '_' allowed here (in contrast to package net).
-			ok = true
-			partlen++
-		case '0' <= c && c <= '9':
-			// fine
-			partlen++
-		case c == '-':
-			// Byte before dash cannot be dot.
-			if last == '.' {
-				return false
-			}
-			partlen++
-		case c == '.':
-			// Byte before dot cannot be dot, dash.
-			if last == '.' || last == '-' {
-				return false
-			}
-			if partlen > 63 || partlen == 0 {
-				return false
-			}
-			partlen = 0
-		}
-		last = c
-	}
-	if last == '-' || partlen > 63 {
-		return false
-	}
-
-	return ok
-}
-
-var cookieNameSanitizer = strings.NewReplacer("\n", "-", "\r", "-")
-
-func sanitizeCookieName(n string) string {
-	return cookieNameSanitizer.Replace(n)
-}
-
-// http://tools.ietf.org/html/rfc6265#section-4.1.1
-// cookie-value      = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
-// cookie-octet      = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
-//           ; US-ASCII characters excluding CTLs,
-//           ; whitespace DQUOTE, comma, semicolon,
-//           ; and backslash
-// We loosen this as spaces and commas are common in cookie values
-// but we produce a quoted cookie-value in when value starts or ends
-// with a comma or space.
-// See http://golang.org/issue/7243 for the discussion.
-func sanitizeCookieValue(v string) string {
-	v = sanitizeOrWarn("Cookie.Value", validCookieValueByte, v)
-	if len(v) == 0 {
-		return v
-	}
-	if v[0] == ' ' || v[0] == ',' || v[len(v)-1] == ' ' || v[len(v)-1] == ',' {
-		return `"` + v + `"`
-	}
-	return v
-}
-
-func validCookieValueByte(b byte) bool {
-	return 0x20 <= b && b < 0x7f && b != '"' && b != ';' && b != '\\'
-}
-
-// path-av           = "Path=" path-value
-// path-value        = <any CHAR except CTLs or ";">
-func sanitizeCookiePath(v string) string {
-	return sanitizeOrWarn("Cookie.Path", validCookiePathByte, v)
-}
-
-func validCookiePathByte(b byte) bool {
-	return 0x20 <= b && b < 0x7f && b != ';'
-}
-
-func sanitizeOrWarn(fieldName string, valid func(byte) bool, v string) string {
-	ok := true
-	for i := 0; i < len(v); i++ {
-		if valid(v[i]) {
-			continue
-		}
-		log.Printf("net/http: invalid byte %q in %s; dropping invalid bytes", v[i], fieldName)
-		ok = false
-		break
-	}
-	if ok {
-		return v
-	}
-	buf := make([]byte, 0, len(v))
-	for i := 0; i < len(v); i++ {
-		if b := v[i]; valid(b) {
-			buf = append(buf, b)
-		}
-	}
-	return string(buf)
-}
-
-func parseCookieValue(raw string) (string, bool) {
-	// Strip the quotes, if present.
-	if len(raw) > 1 && raw[0] == '"' && raw[len(raw)-1] == '"' {
-		raw = raw[1 : len(raw)-1]
-	}
-	for i := 0; i < len(raw); i++ {
-		if !validCookieValueByte(raw[i]) {
-			return "", false
-		}
-	}
-	return raw, true
-}
-
-func isCookieNameValid(raw string) bool {
-	return strings.IndexFunc(raw, isNotToken) < 0
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/doc.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/doc.go
deleted file mode 100644
index b1216e8da..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/doc.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2011 The Go 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 http provides HTTP client and server implementations.
-
-Get, Head, Post, and PostForm make HTTP (or HTTPS) requests:
-
-	resp, err := http.Get("http://example.com/")
-	...
-	resp, err := http.Post("http://example.com/upload", "image/jpeg", &buf)
-	...
-	resp, err := http.PostForm("http://example.com/form",
-		url.Values{"key": {"Value"}, "id": {"123"}})
-
-The client must close the response body when finished with it:
-
-	resp, err := http.Get("http://example.com/")
-	if err != nil {
-		// handle error
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	// ...
-
-For control over HTTP client headers, redirect policy, and other
-settings, create a Client:
-
-	client := &http.Client{
-		CheckRedirect: redirectPolicyFunc,
-	}
-
-	resp, err := client.Get("http://example.com")
-	// ...
-
-	req, err := http.NewRequest("GET", "http://example.com", nil)
-	// ...
-	req.Header.Add("If-None-Match", `W/"wyzzy"`)
-	resp, err := client.Do(req)
-	// ...
-
-For control over proxies, TLS configuration, keep-alives,
-compression, and other settings, create a Transport:
-
-	tr := &http.Transport{
-		TLSClientConfig:    &tls.Config{RootCAs: pool},
-		DisableCompression: true,
-	}
-	client := &http.Client{Transport: tr}
-	resp, err := client.Get("https://example.com")
-
-Clients and Transports are safe for concurrent use by multiple
-goroutines and for efficiency should only be created once and re-used.
-
-ListenAndServe starts an HTTP server with a given address and handler.
-The handler is usually nil, which means to use DefaultServeMux.
-Handle and HandleFunc add handlers to DefaultServeMux:
-
-	http.Handle("/foo", fooHandler)
-
-	http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
-	})
-
-	log.Fatal(http.ListenAndServe(":8080", nil))
-
-More control over the server's behavior is available by creating a
-custom Server:
-
-	s := &http.Server{
-		Addr:           ":8080",
-		Handler:        myHandler,
-		ReadTimeout:    10 * time.Second,
-		WriteTimeout:   10 * time.Second,
-		MaxHeaderBytes: 1 << 20,
-	}
-	log.Fatal(s.ListenAndServe())
-*/
-package http
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/filetransport.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/filetransport.go
deleted file mode 100644
index 821787e0c..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/filetransport.go
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright 2011 The Go 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 http
-
-import (
-	"fmt"
-	"io"
-)
-
-// fileTransport implements RoundTripper for the 'file' protocol.
-type fileTransport struct {
-	fh fileHandler
-}
-
-// NewFileTransport returns a new RoundTripper, serving the provided
-// FileSystem. The returned RoundTripper ignores the URL host in its
-// incoming requests, as well as most other properties of the
-// request.
-//
-// The typical use case for NewFileTransport is to register the "file"
-// protocol with a Transport, as in:
-//
-//   t := &http.Transport{}
-//   t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
-//   c := &http.Client{Transport: t}
-//   res, err := c.Get("file:///etc/passwd")
-//   ...
-func NewFileTransport(fs FileSystem) RoundTripper {
-	return fileTransport{fileHandler{fs}}
-}
-
-func (t fileTransport) RoundTrip(req *Request) (resp *Response, err error) {
-	// We start ServeHTTP in a goroutine, which may take a long
-	// time if the file is large.  The newPopulateResponseWriter
-	// call returns a channel which either ServeHTTP or finish()
-	// sends our *Response on, once the *Response itself has been
-	// populated (even if the body itself is still being
-	// written to the res.Body, a pipe)
-	rw, resc := newPopulateResponseWriter()
-	go func() {
-		t.fh.ServeHTTP(rw, req)
-		rw.finish()
-	}()
-	return <-resc, nil
-}
-
-func newPopulateResponseWriter() (*populateResponse, <-chan *Response) {
-	pr, pw := io.Pipe()
-	rw := &populateResponse{
-		ch: make(chan *Response),
-		pw: pw,
-		res: &Response{
-			Proto:      "HTTP/1.0",
-			ProtoMajor: 1,
-			Header:     make(Header),
-			Close:      true,
-			Body:       pr,
-		},
-	}
-	return rw, rw.ch
-}
-
-// populateResponse is a ResponseWriter that populates the *Response
-// in res, and writes its body to a pipe connected to the response
-// body. Once writes begin or finish() is called, the response is sent
-// on ch.
-type populateResponse struct {
-	res          *Response
-	ch           chan *Response
-	wroteHeader  bool
-	hasContent   bool
-	sentResponse bool
-	pw           *io.PipeWriter
-}
-
-func (pr *populateResponse) finish() {
-	if !pr.wroteHeader {
-		pr.WriteHeader(500)
-	}
-	if !pr.sentResponse {
-		pr.sendResponse()
-	}
-	pr.pw.Close()
-}
-
-func (pr *populateResponse) sendResponse() {
-	if pr.sentResponse {
-		return
-	}
-	pr.sentResponse = true
-
-	if pr.hasContent {
-		pr.res.ContentLength = -1
-	}
-	pr.ch <- pr.res
-}
-
-func (pr *populateResponse) Header() Header {
-	return pr.res.Header
-}
-
-func (pr *populateResponse) WriteHeader(code int) {
-	if pr.wroteHeader {
-		return
-	}
-	pr.wroteHeader = true
-
-	pr.res.StatusCode = code
-	pr.res.Status = fmt.Sprintf("%d %s", code, StatusText(code))
-}
-
-func (pr *populateResponse) Write(p []byte) (n int, err error) {
-	if !pr.wroteHeader {
-		pr.WriteHeader(StatusOK)
-	}
-	pr.hasContent = true
-	if !pr.sentResponse {
-		pr.sendResponse()
-	}
-	return pr.pw.Write(p)
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/fs.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/fs.go
deleted file mode 100644
index 8576cf844..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/fs.go
+++ /dev/null
@@ -1,549 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// HTTP file system request handler
-
-package http
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"mime"
-	"mime/multipart"
-	"net/textproto"
-	"net/url"
-	"os"
-	"path"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// A Dir implements http.FileSystem using the native file
-// system restricted to a specific directory tree.
-//
-// An empty Dir is treated as ".".
-type Dir string
-
-func (d Dir) Open(name string) (File, error) {
-	if filepath.Separator != '/' && strings.IndexRune(name, filepath.Separator) >= 0 ||
-		strings.Contains(name, "\x00") {
-		return nil, errors.New("http: invalid character in file path")
-	}
-	dir := string(d)
-	if dir == "" {
-		dir = "."
-	}
-	f, err := os.Open(filepath.Join(dir, filepath.FromSlash(path.Clean("/"+name))))
-	if err != nil {
-		return nil, err
-	}
-	return f, nil
-}
-
-// A FileSystem implements access to a collection of named files.
-// The elements in a file path are separated by slash ('/', U+002F)
-// characters, regardless of host operating system convention.
-type FileSystem interface {
-	Open(name string) (File, error)
-}
-
-// A File is returned by a FileSystem's Open method and can be
-// served by the FileServer implementation.
-//
-// The methods should behave the same as those on an *os.File.
-type File interface {
-	io.Closer
-	io.Reader
-	Readdir(count int) ([]os.FileInfo, error)
-	Seek(offset int64, whence int) (int64, error)
-	Stat() (os.FileInfo, error)
-}
-
-func dirList(w ResponseWriter, f File) {
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	fmt.Fprintf(w, "<pre>\n")
-	for {
-		dirs, err := f.Readdir(100)
-		if err != nil || len(dirs) == 0 {
-			break
-		}
-		for _, d := range dirs {
-			name := d.Name()
-			if d.IsDir() {
-				name += "/"
-			}
-			// name may contain '?' or '#', which must be escaped to remain
-			// part of the URL path, and not indicate the start of a query
-			// string or fragment.
-			url := url.URL{Path: name}
-			fmt.Fprintf(w, "<a href=\"%s\">%s</a>\n", url.String(), htmlReplacer.Replace(name))
-		}
-	}
-	fmt.Fprintf(w, "</pre>\n")
-}
-
-// ServeContent replies to the request using the content in the
-// provided ReadSeeker.  The main benefit of ServeContent over io.Copy
-// is that it handles Range requests properly, sets the MIME type, and
-// handles If-Modified-Since requests.
-//
-// If the response's Content-Type header is not set, ServeContent
-// first tries to deduce the type from name's file extension and,
-// if that fails, falls back to reading the first block of the content
-// and passing it to DetectContentType.
-// The name is otherwise unused; in particular it can be empty and is
-// never sent in the response.
-//
-// If modtime is not the zero time, ServeContent includes it in a
-// Last-Modified header in the response.  If the request includes an
-// If-Modified-Since header, ServeContent uses modtime to decide
-// whether the content needs to be sent at all.
-//
-// The content's Seek method must work: ServeContent uses
-// a seek to the end of the content to determine its size.
-//
-// If the caller has set w's ETag header, ServeContent uses it to
-// handle requests using If-Range and If-None-Match.
-//
-// Note that *os.File implements the io.ReadSeeker interface.
-func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker) {
-	sizeFunc := func() (int64, error) {
-		size, err := content.Seek(0, os.SEEK_END)
-		if err != nil {
-			return 0, errSeeker
-		}
-		_, err = content.Seek(0, os.SEEK_SET)
-		if err != nil {
-			return 0, errSeeker
-		}
-		return size, nil
-	}
-	serveContent(w, req, name, modtime, sizeFunc, content)
-}
-
-// errSeeker is returned by ServeContent's sizeFunc when the content
-// doesn't seek properly. The underlying Seeker's error text isn't
-// included in the sizeFunc reply so it's not sent over HTTP to end
-// users.
-var errSeeker = errors.New("seeker can't seek")
-
-// if name is empty, filename is unknown. (used for mime type, before sniffing)
-// if modtime.IsZero(), modtime is unknown.
-// content must be seeked to the beginning of the file.
-// The sizeFunc is called at most once. Its error, if any, is sent in the HTTP response.
-func serveContent(w ResponseWriter, r *Request, name string, modtime time.Time, sizeFunc func() (int64, error), content io.ReadSeeker) {
-	if checkLastModified(w, r, modtime) {
-		return
-	}
-	rangeReq, done := checkETag(w, r)
-	if done {
-		return
-	}
-
-	code := StatusOK
-
-	// If Content-Type isn't set, use the file's extension to find it, but
-	// if the Content-Type is unset explicitly, do not sniff the type.
-	ctypes, haveType := w.Header()["Content-Type"]
-	var ctype string
-	if !haveType {
-		ctype = mime.TypeByExtension(filepath.Ext(name))
-		if ctype == "" {
-			// read a chunk to decide between utf-8 text and binary
-			var buf [sniffLen]byte
-			n, _ := io.ReadFull(content, buf[:])
-			ctype = DetectContentType(buf[:n])
-			_, err := content.Seek(0, os.SEEK_SET) // rewind to output whole file
-			if err != nil {
-				Error(w, "seeker can't seek", StatusInternalServerError)
-				return
-			}
-		}
-		w.Header().Set("Content-Type", ctype)
-	} else if len(ctypes) > 0 {
-		ctype = ctypes[0]
-	}
-
-	size, err := sizeFunc()
-	if err != nil {
-		Error(w, err.Error(), StatusInternalServerError)
-		return
-	}
-
-	// handle Content-Range header.
-	sendSize := size
-	var sendContent io.Reader = content
-	if size >= 0 {
-		ranges, err := parseRange(rangeReq, size)
-		if err != nil {
-			Error(w, err.Error(), StatusRequestedRangeNotSatisfiable)
-			return
-		}
-		if sumRangesSize(ranges) > size {
-			// The total number of bytes in all the ranges
-			// is larger than the size of the file by
-			// itself, so this is probably an attack, or a
-			// dumb client.  Ignore the range request.
-			ranges = nil
-		}
-		switch {
-		case len(ranges) == 1:
-			// RFC 2616, Section 14.16:
-			// "When an HTTP message includes the content of a single
-			// range (for example, a response to a request for a
-			// single range, or to a request for a set of ranges
-			// that overlap without any holes), this content is
-			// transmitted with a Content-Range header, and a
-			// Content-Length header showing the number of bytes
-			// actually transferred.
-			// ...
-			// A response to a request for a single range MUST NOT
-			// be sent using the multipart/byteranges media type."
-			ra := ranges[0]
-			if _, err := content.Seek(ra.start, os.SEEK_SET); err != nil {
-				Error(w, err.Error(), StatusRequestedRangeNotSatisfiable)
-				return
-			}
-			sendSize = ra.length
-			code = StatusPartialContent
-			w.Header().Set("Content-Range", ra.contentRange(size))
-		case len(ranges) > 1:
-			for _, ra := range ranges {
-				if ra.start > size {
-					Error(w, err.Error(), StatusRequestedRangeNotSatisfiable)
-					return
-				}
-			}
-			sendSize = rangesMIMESize(ranges, ctype, size)
-			code = StatusPartialContent
-
-			pr, pw := io.Pipe()
-			mw := multipart.NewWriter(pw)
-			w.Header().Set("Content-Type", "multipart/byteranges; boundary="+mw.Boundary())
-			sendContent = pr
-			defer pr.Close() // cause writing goroutine to fail and exit if CopyN doesn't finish.
-			go func() {
-				for _, ra := range ranges {
-					part, err := mw.CreatePart(ra.mimeHeader(ctype, size))
-					if err != nil {
-						pw.CloseWithError(err)
-						return
-					}
-					if _, err := content.Seek(ra.start, os.SEEK_SET); err != nil {
-						pw.CloseWithError(err)
-						return
-					}
-					if _, err := io.CopyN(part, content, ra.length); err != nil {
-						pw.CloseWithError(err)
-						return
-					}
-				}
-				mw.Close()
-				pw.Close()
-			}()
-		}
-
-		w.Header().Set("Accept-Ranges", "bytes")
-		if w.Header().Get("Content-Encoding") == "" {
-			w.Header().Set("Content-Length", strconv.FormatInt(sendSize, 10))
-		}
-	}
-
-	w.WriteHeader(code)
-
-	if r.Method != "HEAD" {
-		io.CopyN(w, sendContent, sendSize)
-	}
-}
-
-// modtime is the modification time of the resource to be served, or IsZero().
-// return value is whether this request is now complete.
-func checkLastModified(w ResponseWriter, r *Request, modtime time.Time) bool {
-	if modtime.IsZero() {
-		return false
-	}
-
-	// The Date-Modified header truncates sub-second precision, so
-	// use mtime < t+1s instead of mtime <= t to check for unmodified.
-	if t, err := time.Parse(TimeFormat, r.Header.Get("If-Modified-Since")); err == nil && modtime.Before(t.Add(1*time.Second)) {
-		h := w.Header()
-		delete(h, "Content-Type")
-		delete(h, "Content-Length")
-		w.WriteHeader(StatusNotModified)
-		return true
-	}
-	w.Header().Set("Last-Modified", modtime.UTC().Format(TimeFormat))
-	return false
-}
-
-// checkETag implements If-None-Match and If-Range checks.
-// The ETag must have been previously set in the ResponseWriter's headers.
-//
-// The return value is the effective request "Range" header to use and
-// whether this request is now considered done.
-func checkETag(w ResponseWriter, r *Request) (rangeReq string, done bool) {
-	etag := w.Header().get("Etag")
-	rangeReq = r.Header.get("Range")
-
-	// Invalidate the range request if the entity doesn't match the one
-	// the client was expecting.
-	// "If-Range: version" means "ignore the Range: header unless version matches the
-	// current file."
-	// We only support ETag versions.
-	// The caller must have set the ETag on the response already.
-	if ir := r.Header.get("If-Range"); ir != "" && ir != etag {
-		// TODO(bradfitz): handle If-Range requests with Last-Modified
-		// times instead of ETags? I'd rather not, at least for
-		// now. That seems like a bug/compromise in the RFC 2616, and
-		// I've never heard of anybody caring about that (yet).
-		rangeReq = ""
-	}
-
-	if inm := r.Header.get("If-None-Match"); inm != "" {
-		// Must know ETag.
-		if etag == "" {
-			return rangeReq, false
-		}
-
-		// TODO(bradfitz): non-GET/HEAD requests require more work:
-		// sending a different status code on matches, and
-		// also can't use weak cache validators (those with a "W/
-		// prefix).  But most users of ServeContent will be using
-		// it on GET or HEAD, so only support those for now.
-		if r.Method != "GET" && r.Method != "HEAD" {
-			return rangeReq, false
-		}
-
-		// TODO(bradfitz): deal with comma-separated or multiple-valued
-		// list of If-None-match values.  For now just handle the common
-		// case of a single item.
-		if inm == etag || inm == "*" {
-			h := w.Header()
-			delete(h, "Content-Type")
-			delete(h, "Content-Length")
-			w.WriteHeader(StatusNotModified)
-			return "", true
-		}
-	}
-	return rangeReq, false
-}
-
-// name is '/'-separated, not filepath.Separator.
-func serveFile(w ResponseWriter, r *Request, fs FileSystem, name string, redirect bool) {
-	const indexPage = "/index.html"
-
-	// redirect .../index.html to .../
-	// can't use Redirect() because that would make the path absolute,
-	// which would be a problem running under StripPrefix
-	if strings.HasSuffix(r.URL.Path, indexPage) {
-		localRedirect(w, r, "./")
-		return
-	}
-
-	f, err := fs.Open(name)
-	if err != nil {
-		// TODO expose actual error?
-		NotFound(w, r)
-		return
-	}
-	defer f.Close()
-
-	d, err1 := f.Stat()
-	if err1 != nil {
-		// TODO expose actual error?
-		NotFound(w, r)
-		return
-	}
-
-	if redirect {
-		// redirect to canonical path: / at end of directory url
-		// r.URL.Path always begins with /
-		url := r.URL.Path
-		if d.IsDir() {
-			if url[len(url)-1] != '/' {
-				localRedirect(w, r, path.Base(url)+"/")
-				return
-			}
-		} else {
-			if url[len(url)-1] == '/' {
-				localRedirect(w, r, "../"+path.Base(url))
-				return
-			}
-		}
-	}
-
-	// use contents of index.html for directory, if present
-	if d.IsDir() {
-		index := name + indexPage
-		ff, err := fs.Open(index)
-		if err == nil {
-			defer ff.Close()
-			dd, err := ff.Stat()
-			if err == nil {
-				name = index
-				d = dd
-				f = ff
-			}
-		}
-	}
-
-	// Still a directory? (we didn't find an index.html file)
-	if d.IsDir() {
-		if checkLastModified(w, r, d.ModTime()) {
-			return
-		}
-		dirList(w, f)
-		return
-	}
-
-	// serverContent will check modification time
-	sizeFunc := func() (int64, error) { return d.Size(), nil }
-	serveContent(w, r, d.Name(), d.ModTime(), sizeFunc, f)
-}
-
-// localRedirect gives a Moved Permanently response.
-// It does not convert relative paths to absolute paths like Redirect does.
-func localRedirect(w ResponseWriter, r *Request, newPath string) {
-	if q := r.URL.RawQuery; q != "" {
-		newPath += "?" + q
-	}
-	w.Header().Set("Location", newPath)
-	w.WriteHeader(StatusMovedPermanently)
-}
-
-// ServeFile replies to the request with the contents of the named file or directory.
-func ServeFile(w ResponseWriter, r *Request, name string) {
-	dir, file := filepath.Split(name)
-	serveFile(w, r, Dir(dir), file, false)
-}
-
-type fileHandler struct {
-	root FileSystem
-}
-
-// FileServer returns a handler that serves HTTP requests
-// with the contents of the file system rooted at root.
-//
-// To use the operating system's file system implementation,
-// use http.Dir:
-//
-//     http.Handle("/", http.FileServer(http.Dir("/tmp")))
-func FileServer(root FileSystem) Handler {
-	return &fileHandler{root}
-}
-
-func (f *fileHandler) ServeHTTP(w ResponseWriter, r *Request) {
-	upath := r.URL.Path
-	if !strings.HasPrefix(upath, "/") {
-		upath = "/" + upath
-		r.URL.Path = upath
-	}
-	serveFile(w, r, f.root, path.Clean(upath), true)
-}
-
-// httpRange specifies the byte range to be sent to the client.
-type httpRange struct {
-	start, length int64
-}
-
-func (r httpRange) contentRange(size int64) string {
-	return fmt.Sprintf("bytes %d-%d/%d", r.start, r.start+r.length-1, size)
-}
-
-func (r httpRange) mimeHeader(contentType string, size int64) textproto.MIMEHeader {
-	return textproto.MIMEHeader{
-		"Content-Range": {r.contentRange(size)},
-		"Content-Type":  {contentType},
-	}
-}
-
-// parseRange parses a Range header string as per RFC 2616.
-func parseRange(s string, size int64) ([]httpRange, error) {
-	if s == "" {
-		return nil, nil // header not present
-	}
-	const b = "bytes="
-	if !strings.HasPrefix(s, b) {
-		return nil, errors.New("invalid range")
-	}
-	var ranges []httpRange
-	for _, ra := range strings.Split(s[len(b):], ",") {
-		ra = strings.TrimSpace(ra)
-		if ra == "" {
-			continue
-		}
-		i := strings.Index(ra, "-")
-		if i < 0 {
-			return nil, errors.New("invalid range")
-		}
-		start, end := strings.TrimSpace(ra[:i]), strings.TrimSpace(ra[i+1:])
-		var r httpRange
-		if start == "" {
-			// If no start is specified, end specifies the
-			// range start relative to the end of the file.
-			i, err := strconv.ParseInt(end, 10, 64)
-			if err != nil {
-				return nil, errors.New("invalid range")
-			}
-			if i > size {
-				i = size
-			}
-			r.start = size - i
-			r.length = size - r.start
-		} else {
-			i, err := strconv.ParseInt(start, 10, 64)
-			if err != nil || i > size || i < 0 {
-				return nil, errors.New("invalid range")
-			}
-			r.start = i
-			if end == "" {
-				// If no end is specified, range extends to end of the file.
-				r.length = size - r.start
-			} else {
-				i, err := strconv.ParseInt(end, 10, 64)
-				if err != nil || r.start > i {
-					return nil, errors.New("invalid range")
-				}
-				if i >= size {
-					i = size - 1
-				}
-				r.length = i - r.start + 1
-			}
-		}
-		ranges = append(ranges, r)
-	}
-	return ranges, nil
-}
-
-// countingWriter counts how many bytes have been written to it.
-type countingWriter int64
-
-func (w *countingWriter) Write(p []byte) (n int, err error) {
-	*w += countingWriter(len(p))
-	return len(p), nil
-}
-
-// rangesMIMESize returns the number of bytes it takes to encode the
-// provided ranges as a multipart response.
-func rangesMIMESize(ranges []httpRange, contentType string, contentSize int64) (encSize int64) {
-	var w countingWriter
-	mw := multipart.NewWriter(&w)
-	for _, ra := range ranges {
-		mw.CreatePart(ra.mimeHeader(contentType, contentSize))
-		encSize += ra.length
-	}
-	mw.Close()
-	encSize += int64(w)
-	return
-}
-
-func sumRangesSize(ranges []httpRange) (size int64) {
-	for _, ra := range ranges {
-		size += ra.length
-	}
-	return
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/header.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/header.go
deleted file mode 100644
index 153b94370..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/header.go
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2010 The Go 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 http
-
-import (
-	"io"
-	"net/textproto"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-)
-
-var raceEnabled = false // set by race.go
-
-// A Header represents the key-value pairs in an HTTP header.
-type Header map[string][]string
-
-// Add adds the key, value pair to the header.
-// It appends to any existing values associated with key.
-func (h Header) Add(key, value string) {
-	textproto.MIMEHeader(h).Add(key, value)
-}
-
-// Set sets the header entries associated with key to
-// the single element value.  It replaces any existing
-// values associated with key.
-func (h Header) Set(key, value string) {
-	textproto.MIMEHeader(h).Set(key, value)
-}
-
-// Get gets the first value associated with the given key.
-// If there are no values associated with the key, Get returns "".
-// To access multiple values of a key, access the map directly
-// with CanonicalHeaderKey.
-func (h Header) Get(key string) string {
-	return textproto.MIMEHeader(h).Get(key)
-}
-
-// get is like Get, but key must already be in CanonicalHeaderKey form.
-func (h Header) get(key string) string {
-	if v := h[key]; len(v) > 0 {
-		return v[0]
-	}
-	return ""
-}
-
-// Del deletes the values associated with key.
-func (h Header) Del(key string) {
-	textproto.MIMEHeader(h).Del(key)
-}
-
-// Write writes a header in wire format.
-func (h Header) Write(w io.Writer) error {
-	return h.WriteSubset(w, nil)
-}
-
-func (h Header) clone() Header {
-	h2 := make(Header, len(h))
-	for k, vv := range h {
-		vv2 := make([]string, len(vv))
-		copy(vv2, vv)
-		h2[k] = vv2
-	}
-	return h2
-}
-
-var timeFormats = []string{
-	TimeFormat,
-	time.RFC850,
-	time.ANSIC,
-}
-
-// ParseTime parses a time header (such as the Date: header),
-// trying each of the three formats allowed by HTTP/1.1:
-// TimeFormat, time.RFC850, and time.ANSIC.
-func ParseTime(text string) (t time.Time, err error) {
-	for _, layout := range timeFormats {
-		t, err = time.Parse(layout, text)
-		if err == nil {
-			return
-		}
-	}
-	return
-}
-
-var headerNewlineToSpace = strings.NewReplacer("\n", " ", "\r", " ")
-
-type writeStringer interface {
-	WriteString(string) (int, error)
-}
-
-// stringWriter implements WriteString on a Writer.
-type stringWriter struct {
-	w io.Writer
-}
-
-func (w stringWriter) WriteString(s string) (n int, err error) {
-	return w.w.Write([]byte(s))
-}
-
-type keyValues struct {
-	key    string
-	values []string
-}
-
-// A headerSorter implements sort.Interface by sorting a []keyValues
-// by key. It's used as a pointer, so it can fit in a sort.Interface
-// interface value without allocation.
-type headerSorter struct {
-	kvs []keyValues
-}
-
-func (s *headerSorter) Len() int           { return len(s.kvs) }
-func (s *headerSorter) Swap(i, j int)      { s.kvs[i], s.kvs[j] = s.kvs[j], s.kvs[i] }
-func (s *headerSorter) Less(i, j int) bool { return s.kvs[i].key < s.kvs[j].key }
-
-var headerSorterPool = sync.Pool{
-	New: func() interface{} { return new(headerSorter) },
-}
-
-// sortedKeyValues returns h's keys sorted in the returned kvs
-// slice. The headerSorter used to sort is also returned, for possible
-// return to headerSorterCache.
-func (h Header) sortedKeyValues(exclude map[string]bool) (kvs []keyValues, hs *headerSorter) {
-	hs = headerSorterPool.Get().(*headerSorter)
-	if cap(hs.kvs) < len(h) {
-		hs.kvs = make([]keyValues, 0, len(h))
-	}
-	kvs = hs.kvs[:0]
-	for k, vv := range h {
-		if !exclude[k] {
-			kvs = append(kvs, keyValues{k, vv})
-		}
-	}
-	hs.kvs = kvs
-	sort.Sort(hs)
-	return kvs, hs
-}
-
-// WriteSubset writes a header in wire format.
-// If exclude is not nil, keys where exclude[key] == true are not written.
-func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error {
-	ws, ok := w.(writeStringer)
-	if !ok {
-		ws = stringWriter{w}
-	}
-	kvs, sorter := h.sortedKeyValues(exclude)
-	for _, kv := range kvs {
-		for _, v := range kv.values {
-			v = headerNewlineToSpace.Replace(v)
-			v = textproto.TrimString(v)
-			for _, s := range []string{kv.key, ": ", v, "\r\n"} {
-				if _, err := ws.WriteString(s); err != nil {
-					return err
-				}
-			}
-		}
-	}
-	headerSorterPool.Put(sorter)
-	return nil
-}
-
-// CanonicalHeaderKey returns the canonical format of the
-// header key s.  The canonicalization converts the first
-// letter and any letter following a hyphen to upper case;
-// the rest are converted to lowercase.  For example, the
-// canonical key for "accept-encoding" is "Accept-Encoding".
-func CanonicalHeaderKey(s string) string { return textproto.CanonicalMIMEHeaderKey(s) }
-
-// hasToken reports whether token appears with v, ASCII
-// case-insensitive, with space or comma boundaries.
-// token must be all lowercase.
-// v may contain mixed cased.
-func hasToken(v, token string) bool {
-	if len(token) > len(v) || token == "" {
-		return false
-	}
-	if v == token {
-		return true
-	}
-	for sp := 0; sp <= len(v)-len(token); sp++ {
-		// Check that first character is good.
-		// The token is ASCII, so checking only a single byte
-		// is sufficient.  We skip this potential starting
-		// position if both the first byte and its potential
-		// ASCII uppercase equivalent (b|0x20) don't match.
-		// False positives ('^' => '~') are caught by EqualFold.
-		if b := v[sp]; b != token[0] && b|0x20 != token[0] {
-			continue
-		}
-		// Check that start pos is on a valid token boundary.
-		if sp > 0 && !isTokenBoundary(v[sp-1]) {
-			continue
-		}
-		// Check that end pos is on a valid token boundary.
-		if endPos := sp + len(token); endPos != len(v) && !isTokenBoundary(v[endPos]) {
-			continue
-		}
-		if strings.EqualFold(v[sp:sp+len(token)], token) {
-			return true
-		}
-	}
-	return false
-}
-
-func isTokenBoundary(b byte) bool {
-	return b == ' ' || b == ',' || b == '\t'
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/jar.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/jar.go
deleted file mode 100644
index 5c3de0dad..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/jar.go
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2011 The Go 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 http
-
-import (
-	"net/url"
-)
-
-// A CookieJar manages storage and use of cookies in HTTP requests.
-//
-// Implementations of CookieJar must be safe for concurrent use by multiple
-// goroutines.
-//
-// The net/http/cookiejar package provides a CookieJar implementation.
-type CookieJar interface {
-	// SetCookies handles the receipt of the cookies in a reply for the
-	// given URL.  It may or may not choose to save the cookies, depending
-	// on the jar's policy and implementation.
-	SetCookies(u *url.URL, cookies []*Cookie)
-
-	// Cookies returns the cookies to send in a request for the given URL.
-	// It is up to the implementation to honor the standard cookie use
-	// restrictions such as in RFC 6265.
-	Cookies(u *url.URL) []*Cookie
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/lex.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/lex.go
deleted file mode 100644
index cb33318f4..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/lex.go
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2009 The Go 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 http
-
-// This file deals with lexical matters of HTTP
-
-var isTokenTable = [127]bool{
-	'!':  true,
-	'#':  true,
-	'$':  true,
-	'%':  true,
-	'&':  true,
-	'\'': true,
-	'*':  true,
-	'+':  true,
-	'-':  true,
-	'.':  true,
-	'0':  true,
-	'1':  true,
-	'2':  true,
-	'3':  true,
-	'4':  true,
-	'5':  true,
-	'6':  true,
-	'7':  true,
-	'8':  true,
-	'9':  true,
-	'A':  true,
-	'B':  true,
-	'C':  true,
-	'D':  true,
-	'E':  true,
-	'F':  true,
-	'G':  true,
-	'H':  true,
-	'I':  true,
-	'J':  true,
-	'K':  true,
-	'L':  true,
-	'M':  true,
-	'N':  true,
-	'O':  true,
-	'P':  true,
-	'Q':  true,
-	'R':  true,
-	'S':  true,
-	'T':  true,
-	'U':  true,
-	'W':  true,
-	'V':  true,
-	'X':  true,
-	'Y':  true,
-	'Z':  true,
-	'^':  true,
-	'_':  true,
-	'`':  true,
-	'a':  true,
-	'b':  true,
-	'c':  true,
-	'd':  true,
-	'e':  true,
-	'f':  true,
-	'g':  true,
-	'h':  true,
-	'i':  true,
-	'j':  true,
-	'k':  true,
-	'l':  true,
-	'm':  true,
-	'n':  true,
-	'o':  true,
-	'p':  true,
-	'q':  true,
-	'r':  true,
-	's':  true,
-	't':  true,
-	'u':  true,
-	'v':  true,
-	'w':  true,
-	'x':  true,
-	'y':  true,
-	'z':  true,
-	'|':  true,
-	'~':  true,
-}
-
-func isToken(r rune) bool {
-	i := int(r)
-	return i < len(isTokenTable) && isTokenTable[i]
-}
-
-func isNotToken(r rune) bool {
-	return !isToken(r)
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/race.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/race.go
deleted file mode 100644
index 766503967..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/race.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2014 The Go 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 race
-
-package http
-
-func init() {
-	raceEnabled = true
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/request.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/request.go
deleted file mode 100644
index a67092066..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/request.go
+++ /dev/null
@@ -1,875 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// HTTP Request reading and parsing.
-
-package http
-
-import (
-	"bufio"
-	"bytes"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"mime"
-	"mime/multipart"
-	"net/textproto"
-	"net/url"
-	"strconv"
-	"strings"
-	"sync"
-)
-
-const (
-	maxValueLength   = 4096
-	maxHeaderLines   = 1024
-	chunkSize        = 4 << 10  // 4 KB chunks
-	defaultMaxMemory = 32 << 20 // 32 MB
-)
-
-// ErrMissingFile is returned by FormFile when the provided file field name
-// is either not present in the request or not a file field.
-var ErrMissingFile = errors.New("http: no such file")
-
-// HTTP request parsing errors.
-type ProtocolError struct {
-	ErrorString string
-}
-
-func (err *ProtocolError) Error() string { return err.ErrorString }
-
-var (
-	ErrHeaderTooLong        = &ProtocolError{"header too long"}
-	ErrShortBody            = &ProtocolError{"entity body too short"}
-	ErrNotSupported         = &ProtocolError{"feature not supported"}
-	ErrUnexpectedTrailer    = &ProtocolError{"trailer header without chunked transfer encoding"}
-	ErrMissingContentLength = &ProtocolError{"missing ContentLength in HEAD response"}
-	ErrNotMultipart         = &ProtocolError{"request Content-Type isn't multipart/form-data"}
-	ErrMissingBoundary      = &ProtocolError{"no multipart boundary param in Content-Type"}
-)
-
-type badStringError struct {
-	what string
-	str  string
-}
-
-func (e *badStringError) Error() string { return fmt.Sprintf("%s %q", e.what, e.str) }
-
-// Headers that Request.Write handles itself and should be skipped.
-var reqWriteExcludeHeader = map[string]bool{
-	"Host":              true, // not in Header map anyway
-	"User-Agent":        true,
-	"Content-Length":    true,
-	"Transfer-Encoding": true,
-	"Trailer":           true,
-}
-
-// A Request represents an HTTP request received by a server
-// or to be sent by a client.
-//
-// The field semantics differ slightly between client and server
-// usage. In addition to the notes on the fields below, see the
-// documentation for Request.Write and RoundTripper.
-type Request struct {
-	// Method specifies the HTTP method (GET, POST, PUT, etc.).
-	// For client requests an empty string means GET.
-	Method string
-
-	// URL specifies either the URI being requested (for server
-	// requests) or the URL to access (for client requests).
-	//
-	// For server requests the URL is parsed from the URI
-	// supplied on the Request-Line as stored in RequestURI.  For
-	// most requests, fields other than Path and RawQuery will be
-	// empty. (See RFC 2616, Section 5.1.2)
-	//
-	// For client requests, the URL's Host specifies the server to
-	// connect to, while the Request's Host field optionally
-	// specifies the Host header value to send in the HTTP
-	// request.
-	URL *url.URL
-
-	// The protocol version for incoming requests.
-	// Client requests always use HTTP/1.1.
-	Proto      string // "HTTP/1.0"
-	ProtoMajor int    // 1
-	ProtoMinor int    // 0
-
-	// A header maps request lines to their values.
-	// If the header says
-	//
-	//	accept-encoding: gzip, deflate
-	//	Accept-Language: en-us
-	//	Connection: keep-alive
-	//
-	// then
-	//
-	//	Header = map[string][]string{
-	//		"Accept-Encoding": {"gzip, deflate"},
-	//		"Accept-Language": {"en-us"},
-	//		"Connection": {"keep-alive"},
-	//	}
-	//
-	// HTTP defines that header names are case-insensitive.
-	// The request parser implements this by canonicalizing the
-	// name, making the first character and any characters
-	// following a hyphen uppercase and the rest lowercase.
-	//
-	// For client requests certain headers are automatically
-	// added and may override values in Header.
-	//
-	// See the documentation for the Request.Write method.
-	Header Header
-
-	// Body is the request's body.
-	//
-	// For client requests a nil body means the request has no
-	// body, such as a GET request. The HTTP Client's Transport
-	// is responsible for calling the Close method.
-	//
-	// For server requests the Request Body is always non-nil
-	// but will return EOF immediately when no body is present.
-	// The Server will close the request body. The ServeHTTP
-	// Handler does not need to.
-	Body io.ReadCloser
-
-	// ContentLength records the length of the associated content.
-	// The value -1 indicates that the length is unknown.
-	// Values >= 0 indicate that the given number of bytes may
-	// be read from Body.
-	// For client requests, a value of 0 means unknown if Body is not nil.
-	ContentLength int64
-
-	// TransferEncoding lists the transfer encodings from outermost to
-	// innermost. An empty list denotes the "identity" encoding.
-	// TransferEncoding can usually be ignored; chunked encoding is
-	// automatically added and removed as necessary when sending and
-	// receiving requests.
-	TransferEncoding []string
-
-	// Close indicates whether to close the connection after
-	// replying to this request (for servers) or after sending
-	// the request (for clients).
-	Close bool
-
-	// For server requests Host specifies the host on which the
-	// URL is sought. Per RFC 2616, this is either the value of
-	// the "Host" header or the host name given in the URL itself.
-	// It may be of the form "host:port".
-	//
-	// For client requests Host optionally overrides the Host
-	// header to send. If empty, the Request.Write method uses
-	// the value of URL.Host.
-	Host string
-
-	// Form contains the parsed form data, including both the URL
-	// field's query parameters and the POST or PUT form data.
-	// This field is only available after ParseForm is called.
-	// The HTTP client ignores Form and uses Body instead.
-	Form url.Values
-
-	// PostForm contains the parsed form data from POST or PUT
-	// body parameters.
-	// This field is only available after ParseForm is called.
-	// The HTTP client ignores PostForm and uses Body instead.
-	PostForm url.Values
-
-	// MultipartForm is the parsed multipart form, including file uploads.
-	// This field is only available after ParseMultipartForm is called.
-	// The HTTP client ignores MultipartForm and uses Body instead.
-	MultipartForm *multipart.Form
-
-	// Trailer specifies additional headers that are sent after the request
-	// body.
-	//
-	// For server requests the Trailer map initially contains only the
-	// trailer keys, with nil values. (The client declares which trailers it
-	// will later send.)  While the handler is reading from Body, it must
-	// not reference Trailer. After reading from Body returns EOF, Trailer
-	// can be read again and will contain non-nil values, if they were sent
-	// by the client.
-	//
-	// For client requests Trailer must be initialized to a map containing
-	// the trailer keys to later send. The values may be nil or their final
-	// values. The ContentLength must be 0 or -1, to send a chunked request.
-	// After the HTTP request is sent the map values can be updated while
-	// the request body is read. Once the body returns EOF, the caller must
-	// not mutate Trailer.
-	//
-	// Few HTTP clients, servers, or proxies support HTTP trailers.
-	Trailer Header
-
-	// RemoteAddr allows HTTP servers and other software to record
-	// the network address that sent the request, usually for
-	// logging. This field is not filled in by ReadRequest and
-	// has no defined format. The HTTP server in this package
-	// sets RemoteAddr to an "IP:port" address before invoking a
-	// handler.
-	// This field is ignored by the HTTP client.
-	RemoteAddr string
-
-	// RequestURI is the unmodified Request-URI of the
-	// Request-Line (RFC 2616, Section 5.1) as sent by the client
-	// to a server. Usually the URL field should be used instead.
-	// It is an error to set this field in an HTTP client request.
-	RequestURI string
-
-	// TLS allows HTTP servers and other software to record
-	// information about the TLS connection on which the request
-	// was received. This field is not filled in by ReadRequest.
-	// The HTTP server in this package sets the field for
-	// TLS-enabled connections before invoking a handler;
-	// otherwise it leaves the field nil.
-	// This field is ignored by the HTTP client.
-	TLS *tls.ConnectionState
-}
-
-// ProtoAtLeast reports whether the HTTP protocol used
-// in the request is at least major.minor.
-func (r *Request) ProtoAtLeast(major, minor int) bool {
-	return r.ProtoMajor > major ||
-		r.ProtoMajor == major && r.ProtoMinor >= minor
-}
-
-// UserAgent returns the client's User-Agent, if sent in the request.
-func (r *Request) UserAgent() string {
-	return r.Header.Get("User-Agent")
-}
-
-// Cookies parses and returns the HTTP cookies sent with the request.
-func (r *Request) Cookies() []*Cookie {
-	return readCookies(r.Header, "")
-}
-
-var ErrNoCookie = errors.New("http: named cookie not present")
-
-// Cookie returns the named cookie provided in the request or
-// ErrNoCookie if not found.
-func (r *Request) Cookie(name string) (*Cookie, error) {
-	for _, c := range readCookies(r.Header, name) {
-		return c, nil
-	}
-	return nil, ErrNoCookie
-}
-
-// AddCookie adds a cookie to the request.  Per RFC 6265 section 5.4,
-// AddCookie does not attach more than one Cookie header field.  That
-// means all cookies, if any, are written into the same line,
-// separated by semicolon.
-func (r *Request) AddCookie(c *Cookie) {
-	s := fmt.Sprintf("%s=%s", sanitizeCookieName(c.Name), sanitizeCookieValue(c.Value))
-	if c := r.Header.Get("Cookie"); c != "" {
-		r.Header.Set("Cookie", c+"; "+s)
-	} else {
-		r.Header.Set("Cookie", s)
-	}
-}
-
-// Referer returns the referring URL, if sent in the request.
-//
-// Referer is misspelled as in the request itself, a mistake from the
-// earliest days of HTTP.  This value can also be fetched from the
-// Header map as Header["Referer"]; the benefit of making it available
-// as a method is that the compiler can diagnose programs that use the
-// alternate (correct English) spelling req.Referrer() but cannot
-// diagnose programs that use Header["Referrer"].
-func (r *Request) Referer() string {
-	return r.Header.Get("Referer")
-}
-
-// multipartByReader is a sentinel value.
-// Its presence in Request.MultipartForm indicates that parsing of the request
-// body has been handed off to a MultipartReader instead of ParseMultipartFrom.
-var multipartByReader = &multipart.Form{
-	Value: make(map[string][]string),
-	File:  make(map[string][]*multipart.FileHeader),
-}
-
-// MultipartReader returns a MIME multipart reader if this is a
-// multipart/form-data POST request, else returns nil and an error.
-// Use this function instead of ParseMultipartForm to
-// process the request body as a stream.
-func (r *Request) MultipartReader() (*multipart.Reader, error) {
-	if r.MultipartForm == multipartByReader {
-		return nil, errors.New("http: MultipartReader called twice")
-	}
-	if r.MultipartForm != nil {
-		return nil, errors.New("http: multipart handled by ParseMultipartForm")
-	}
-	r.MultipartForm = multipartByReader
-	return r.multipartReader()
-}
-
-func (r *Request) multipartReader() (*multipart.Reader, error) {
-	v := r.Header.Get("Content-Type")
-	if v == "" {
-		return nil, ErrNotMultipart
-	}
-	d, params, err := mime.ParseMediaType(v)
-	if err != nil || d != "multipart/form-data" {
-		return nil, ErrNotMultipart
-	}
-	boundary, ok := params["boundary"]
-	if !ok {
-		return nil, ErrMissingBoundary
-	}
-	return multipart.NewReader(r.Body, boundary), nil
-}
-
-// Return value if nonempty, def otherwise.
-func valueOrDefault(value, def string) string {
-	if value != "" {
-		return value
-	}
-	return def
-}
-
-// NOTE: This is not intended to reflect the actual Go version being used.
-// It was changed from "Go http package" to "Go 1.1 package http" at the
-// time of the Go 1.1 release because the former User-Agent had ended up
-// on a blacklist for some intrusion detection systems.
-// See https://codereview.appspot.com/7532043.
-const defaultUserAgent = "Go 1.1 package http"
-
-// Write writes an HTTP/1.1 request -- header and body -- in wire format.
-// This method consults the following fields of the request:
-//	Host
-//	URL
-//	Method (defaults to "GET")
-//	Header
-//	ContentLength
-//	TransferEncoding
-//	Body
-//
-// If Body is present, Content-Length is <= 0 and TransferEncoding
-// hasn't been set to "identity", Write adds "Transfer-Encoding:
-// chunked" to the header. Body is closed after it is sent.
-func (r *Request) Write(w io.Writer) error {
-	return r.write(w, false, nil)
-}
-
-// WriteProxy is like Write but writes the request in the form
-// expected by an HTTP proxy.  In particular, WriteProxy writes the
-// initial Request-URI line of the request with an absolute URI, per
-// section 5.1.2 of RFC 2616, including the scheme and host.
-// In either case, WriteProxy also writes a Host header, using
-// either r.Host or r.URL.Host.
-func (r *Request) WriteProxy(w io.Writer) error {
-	return r.write(w, true, nil)
-}
-
-// extraHeaders may be nil
-func (req *Request) write(w io.Writer, usingProxy bool, extraHeaders Header) error {
-	host := req.Host
-	if host == "" {
-		if req.URL == nil {
-			return errors.New("http: Request.Write on Request with no Host or URL set")
-		}
-		host = req.URL.Host
-	}
-
-	ruri := req.URL.RequestURI()
-	if usingProxy && req.URL.Scheme != "" && req.URL.Opaque == "" {
-		ruri = req.URL.Scheme + "://" + host + ruri
-	} else if req.Method == "CONNECT" && req.URL.Path == "" {
-		// CONNECT requests normally give just the host and port, not a full URL.
-		ruri = host
-	}
-	// TODO(bradfitz): escape at least newlines in ruri?
-
-	// Wrap the writer in a bufio Writer if it's not already buffered.
-	// Don't always call NewWriter, as that forces a bytes.Buffer
-	// and other small bufio Writers to have a minimum 4k buffer
-	// size.
-	var bw *bufio.Writer
-	if _, ok := w.(io.ByteWriter); !ok {
-		bw = bufio.NewWriter(w)
-		w = bw
-	}
-
-	fmt.Fprintf(w, "%s %s HTTP/1.1\r\n", valueOrDefault(req.Method, "GET"), ruri)
-
-	// Header lines
-	fmt.Fprintf(w, "Host: %s\r\n", host)
-
-	// Use the defaultUserAgent unless the Header contains one, which
-	// may be blank to not send the header.
-	userAgent := defaultUserAgent
-	if req.Header != nil {
-		if ua := req.Header["User-Agent"]; len(ua) > 0 {
-			userAgent = ua[0]
-		}
-	}
-	if userAgent != "" {
-		fmt.Fprintf(w, "User-Agent: %s\r\n", userAgent)
-	}
-
-	// Process Body,ContentLength,Close,Trailer
-	tw, err := newTransferWriter(req)
-	if err != nil {
-		return err
-	}
-	err = tw.WriteHeader(w)
-	if err != nil {
-		return err
-	}
-
-	err = req.Header.WriteSubset(w, reqWriteExcludeHeader)
-	if err != nil {
-		return err
-	}
-
-	if extraHeaders != nil {
-		err = extraHeaders.Write(w)
-		if err != nil {
-			return err
-		}
-	}
-
-	io.WriteString(w, "\r\n")
-
-	// Write body and trailer
-	err = tw.WriteBody(w)
-	if err != nil {
-		return err
-	}
-
-	if bw != nil {
-		return bw.Flush()
-	}
-	return nil
-}
-
-// ParseHTTPVersion parses a HTTP version string.
-// "HTTP/1.0" returns (1, 0, true).
-func ParseHTTPVersion(vers string) (major, minor int, ok bool) {
-	const Big = 1000000 // arbitrary upper bound
-	switch vers {
-	case "HTTP/1.1":
-		return 1, 1, true
-	case "HTTP/1.0":
-		return 1, 0, true
-	}
-	if !strings.HasPrefix(vers, "HTTP/") {
-		return 0, 0, false
-	}
-	dot := strings.Index(vers, ".")
-	if dot < 0 {
-		return 0, 0, false
-	}
-	major, err := strconv.Atoi(vers[5:dot])
-	if err != nil || major < 0 || major > Big {
-		return 0, 0, false
-	}
-	minor, err = strconv.Atoi(vers[dot+1:])
-	if err != nil || minor < 0 || minor > Big {
-		return 0, 0, false
-	}
-	return major, minor, true
-}
-
-// NewRequest returns a new Request given a method, URL, and optional body.
-//
-// If the provided body is also an io.Closer, the returned
-// Request.Body is set to body and will be closed by the Client
-// methods Do, Post, and PostForm, and Transport.RoundTrip.
-func NewRequest(method, urlStr string, body io.Reader) (*Request, error) {
-	u, err := url.Parse(urlStr)
-	if err != nil {
-		return nil, err
-	}
-	rc, ok := body.(io.ReadCloser)
-	if !ok && body != nil {
-		rc = ioutil.NopCloser(body)
-	}
-	req := &Request{
-		Method:     method,
-		URL:        u,
-		Proto:      "HTTP/1.1",
-		ProtoMajor: 1,
-		ProtoMinor: 1,
-		Header:     make(Header),
-		Body:       rc,
-		Host:       u.Host,
-	}
-	if body != nil {
-		switch v := body.(type) {
-		case *bytes.Buffer:
-			req.ContentLength = int64(v.Len())
-		case *bytes.Reader:
-			req.ContentLength = int64(v.Len())
-		case *strings.Reader:
-			req.ContentLength = int64(v.Len())
-		}
-	}
-
-	return req, nil
-}
-
-// SetBasicAuth sets the request's Authorization header to use HTTP
-// Basic Authentication with the provided username and password.
-//
-// With HTTP Basic Authentication the provided username and password
-// are not encrypted.
-func (r *Request) SetBasicAuth(username, password string) {
-	r.Header.Set("Authorization", "Basic "+basicAuth(username, password))
-}
-
-// parseRequestLine parses "GET /foo HTTP/1.1" into its three parts.
-func parseRequestLine(line string) (method, requestURI, 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
-}
-
-var textprotoReaderPool sync.Pool
-
-func newTextprotoReader(br *bufio.Reader) *textproto.Reader {
-	if v := textprotoReaderPool.Get(); v != nil {
-		tr := v.(*textproto.Reader)
-		tr.R = br
-		return tr
-	}
-	return textproto.NewReader(br)
-}
-
-func putTextprotoReader(r *textproto.Reader) {
-	r.R = nil
-	textprotoReaderPool.Put(r)
-}
-
-// ReadRequest reads and parses a request from b.
-func ReadRequest(b *bufio.Reader) (req *Request, err error) {
-
-	tp := newTextprotoReader(b)
-	req = new(Request)
-
-	// First line: GET /index.html HTTP/1.0
-	var s string
-	if s, err = tp.ReadLine(); err != nil {
-		return nil, err
-	}
-	defer func() {
-		putTextprotoReader(tp)
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-	}()
-
-	var ok bool
-	req.Method, req.RequestURI, req.Proto, ok = parseRequestLine(s)
-	if !ok {
-		return nil, &badStringError{"malformed HTTP request", s}
-	}
-	rawurl := req.RequestURI
-	if req.ProtoMajor, req.ProtoMinor, ok = ParseHTTPVersion(req.Proto); !ok {
-		return nil, &badStringError{"malformed HTTP version", req.Proto}
-	}
-
-	// CONNECT requests are used two different ways, and neither uses a full URL:
-	// The standard use is to tunnel HTTPS through an HTTP proxy.
-	// It looks like "CONNECT www.google.com:443 HTTP/1.1", and the parameter is
-	// just the authority section of a URL. This information should go in req.URL.Host.
-	//
-	// The net/rpc package also uses CONNECT, but there the parameter is a path
-	// that starts with a slash. It can be parsed with the regular URL parser,
-	// and the path will end up in req.URL.Path, where it needs to be in order for
-	// RPC to work.
-	justAuthority := req.Method == "CONNECT" && !strings.HasPrefix(rawurl, "/")
-	if justAuthority {
-		rawurl = "http://" + rawurl
-	}
-
-	if req.URL, err = url.ParseRequestURI(rawurl); err != nil {
-		return nil, err
-	}
-
-	if justAuthority {
-		// Strip the bogus "http://" back off.
-		req.URL.Scheme = ""
-	}
-
-	// Subsequent lines: Key: value.
-	mimeHeader, err := tp.ReadMIMEHeader()
-	if err != nil {
-		return nil, err
-	}
-	req.Header = Header(mimeHeader)
-
-	// RFC2616: Must treat
-	//	GET /index.html HTTP/1.1
-	//	Host: www.google.com
-	// and
-	//	GET http://www.google.com/index.html HTTP/1.1
-	//	Host: doesntmatter
-	// the same.  In the second case, any Host line is ignored.
-	req.Host = req.URL.Host
-	if req.Host == "" {
-		req.Host = req.Header.get("Host")
-	}
-	delete(req.Header, "Host")
-
-	fixPragmaCacheControl(req.Header)
-
-	err = readTransfer(req, b)
-	if err != nil {
-		return nil, err
-	}
-
-	return req, nil
-}
-
-// MaxBytesReader is similar to io.LimitReader but is intended for
-// limiting the size of incoming request bodies. In contrast to
-// io.LimitReader, MaxBytesReader's result is a ReadCloser, returns a
-// non-EOF error for a Read beyond the limit, and Closes the
-// underlying reader when its Close method is called.
-//
-// MaxBytesReader prevents clients from accidentally or maliciously
-// sending a large request and wasting server resources.
-func MaxBytesReader(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser {
-	return &maxBytesReader{w: w, r: r, n: n}
-}
-
-type maxBytesReader struct {
-	w       ResponseWriter
-	r       io.ReadCloser // underlying reader
-	n       int64         // max bytes remaining
-	stopped bool
-}
-
-func (l *maxBytesReader) Read(p []byte) (n int, err error) {
-	if l.n <= 0 {
-		if !l.stopped {
-			l.stopped = true
-			if res, ok := l.w.(*response); ok {
-				res.requestTooLarge()
-			}
-		}
-		return 0, errors.New("http: request body too large")
-	}
-	if int64(len(p)) > l.n {
-		p = p[:l.n]
-	}
-	n, err = l.r.Read(p)
-	l.n -= int64(n)
-	return
-}
-
-func (l *maxBytesReader) Close() error {
-	return l.r.Close()
-}
-
-func copyValues(dst, src url.Values) {
-	for k, vs := range src {
-		for _, value := range vs {
-			dst.Add(k, value)
-		}
-	}
-}
-
-func parsePostForm(r *Request) (vs url.Values, err error) {
-	if r.Body == nil {
-		err = errors.New("missing form body")
-		return
-	}
-	ct := r.Header.Get("Content-Type")
-	// RFC 2616, section 7.2.1 - empty type
-	//   SHOULD be treated as application/octet-stream
-	if ct == "" {
-		ct = "application/octet-stream"
-	}
-	ct, _, err = mime.ParseMediaType(ct)
-	switch {
-	case ct == "application/x-www-form-urlencoded":
-		var reader io.Reader = r.Body
-		maxFormSize := int64(1<<63 - 1)
-		if _, ok := r.Body.(*maxBytesReader); !ok {
-			maxFormSize = int64(10 << 20) // 10 MB is a lot of text.
-			reader = io.LimitReader(r.Body, maxFormSize+1)
-		}
-		b, e := ioutil.ReadAll(reader)
-		if e != nil {
-			if err == nil {
-				err = e
-			}
-			break
-		}
-		if int64(len(b)) > maxFormSize {
-			err = errors.New("http: POST too large")
-			return
-		}
-		vs, e = url.ParseQuery(string(b))
-		if err == nil {
-			err = e
-		}
-	case ct == "multipart/form-data":
-		// handled by ParseMultipartForm (which is calling us, or should be)
-		// TODO(bradfitz): there are too many possible
-		// orders to call too many functions here.
-		// Clean this up and write more tests.
-		// request_test.go contains the start of this,
-		// in TestParseMultipartFormOrder and others.
-	}
-	return
-}
-
-// ParseForm parses the raw query from the URL and updates r.Form.
-//
-// For POST or PUT requests, it also parses the request body as a form and
-// put the results into both r.PostForm and r.Form.
-// POST and PUT body parameters take precedence over URL query string values
-// in r.Form.
-//
-// If the request Body's size has not already been limited by MaxBytesReader,
-// the size is capped at 10MB.
-//
-// ParseMultipartForm calls ParseForm automatically.
-// It is idempotent.
-func (r *Request) ParseForm() error {
-	var err error
-	if r.PostForm == nil {
-		if r.Method == "POST" || r.Method == "PUT" || r.Method == "PATCH" {
-			r.PostForm, err = parsePostForm(r)
-		}
-		if r.PostForm == nil {
-			r.PostForm = make(url.Values)
-		}
-	}
-	if r.Form == nil {
-		if len(r.PostForm) > 0 {
-			r.Form = make(url.Values)
-			copyValues(r.Form, r.PostForm)
-		}
-		var newValues url.Values
-		if r.URL != nil {
-			var e error
-			newValues, e = url.ParseQuery(r.URL.RawQuery)
-			if err == nil {
-				err = e
-			}
-		}
-		if newValues == nil {
-			newValues = make(url.Values)
-		}
-		if r.Form == nil {
-			r.Form = newValues
-		} else {
-			copyValues(r.Form, newValues)
-		}
-	}
-	return err
-}
-
-// ParseMultipartForm parses a request body as multipart/form-data.
-// The whole request body is parsed and up to a total of maxMemory bytes of
-// its file parts are stored in memory, with the remainder stored on
-// disk in temporary files.
-// ParseMultipartForm calls ParseForm if necessary.
-// After one call to ParseMultipartForm, subsequent calls have no effect.
-func (r *Request) ParseMultipartForm(maxMemory int64) error {
-	if r.MultipartForm == multipartByReader {
-		return errors.New("http: multipart handled by MultipartReader")
-	}
-	if r.Form == nil {
-		err := r.ParseForm()
-		if err != nil {
-			return err
-		}
-	}
-	if r.MultipartForm != nil {
-		return nil
-	}
-
-	mr, err := r.multipartReader()
-	if err != nil {
-		return err
-	}
-
-	f, err := mr.ReadForm(maxMemory)
-	if err != nil {
-		return err
-	}
-	for k, v := range f.Value {
-		r.Form[k] = append(r.Form[k], v...)
-	}
-	r.MultipartForm = f
-
-	return nil
-}
-
-// FormValue returns the first value for the named component of the query.
-// POST and PUT body parameters take precedence over URL query string values.
-// FormValue calls ParseMultipartForm and ParseForm if necessary.
-// To access multiple values of the same key use ParseForm.
-func (r *Request) FormValue(key string) string {
-	if r.Form == nil {
-		r.ParseMultipartForm(defaultMaxMemory)
-	}
-	if vs := r.Form[key]; len(vs) > 0 {
-		return vs[0]
-	}
-	return ""
-}
-
-// PostFormValue returns the first value for the named component of the POST
-// or PUT request body. URL query parameters are ignored.
-// PostFormValue calls ParseMultipartForm and ParseForm if necessary.
-func (r *Request) PostFormValue(key string) string {
-	if r.PostForm == nil {
-		r.ParseMultipartForm(defaultMaxMemory)
-	}
-	if vs := r.PostForm[key]; len(vs) > 0 {
-		return vs[0]
-	}
-	return ""
-}
-
-// FormFile returns the first file for the provided form key.
-// FormFile calls ParseMultipartForm and ParseForm if necessary.
-func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error) {
-	if r.MultipartForm == multipartByReader {
-		return nil, nil, errors.New("http: multipart handled by MultipartReader")
-	}
-	if r.MultipartForm == nil {
-		err := r.ParseMultipartForm(defaultMaxMemory)
-		if err != nil {
-			return nil, nil, err
-		}
-	}
-	if r.MultipartForm != nil && r.MultipartForm.File != nil {
-		if fhs := r.MultipartForm.File[key]; len(fhs) > 0 {
-			f, err := fhs[0].Open()
-			return f, fhs[0], err
-		}
-	}
-	return nil, nil, ErrMissingFile
-}
-
-func (r *Request) expectsContinue() bool {
-	return hasToken(r.Header.get("Expect"), "100-continue")
-}
-
-func (r *Request) wantsHttp10KeepAlive() bool {
-	if r.ProtoMajor != 1 || r.ProtoMinor != 0 {
-		return false
-	}
-	return hasToken(r.Header.get("Connection"), "keep-alive")
-}
-
-func (r *Request) wantsClose() bool {
-	return hasToken(r.Header.get("Connection"), "close")
-}
-
-func (r *Request) closeBody() {
-	if r.Body != nil {
-		r.Body.Close()
-	}
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/response.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/response.go
deleted file mode 100644
index e1209a237..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/response.go
+++ /dev/null
@@ -1,291 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// HTTP Response reading and parsing.
-
-package http
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"github.com/masterzen/azure-sdk-for-go/core/tls"
-	"io"
-	"net/textproto"
-	"net/url"
-	"strconv"
-	"strings"
-)
-
-var respExcludeHeader = map[string]bool{
-	"Content-Length":    true,
-	"Transfer-Encoding": true,
-	"Trailer":           true,
-}
-
-// Response represents the response from an HTTP request.
-//
-type Response struct {
-	Status     string // e.g. "200 OK"
-	StatusCode int    // e.g. 200
-	Proto      string // e.g. "HTTP/1.0"
-	ProtoMajor int    // e.g. 1
-	ProtoMinor int    // e.g. 0
-
-	// Header maps header keys to values.  If the response had multiple
-	// headers with the same key, they may be concatenated, with comma
-	// delimiters.  (Section 4.2 of RFC 2616 requires that multiple headers
-	// be semantically equivalent to a comma-delimited sequence.) Values
-	// duplicated by other fields in this struct (e.g., ContentLength) are
-	// omitted from Header.
-	//
-	// Keys in the map are canonicalized (see CanonicalHeaderKey).
-	Header Header
-
-	// Body represents the response body.
-	//
-	// The http Client and Transport guarantee that Body is always
-	// non-nil, even on responses without a body or responses with
-	// a zero-length body. It is the caller's responsibility to
-	// close Body.
-	//
-	// The Body is automatically dechunked if the server replied
-	// with a "chunked" Transfer-Encoding.
-	Body io.ReadCloser
-
-	// ContentLength records the length of the associated content.  The
-	// value -1 indicates that the length is unknown.  Unless Request.Method
-	// is "HEAD", values >= 0 indicate that the given number of bytes may
-	// be read from Body.
-	ContentLength int64
-
-	// Contains transfer encodings from outer-most to inner-most. Value is
-	// nil, means that "identity" encoding is used.
-	TransferEncoding []string
-
-	// Close records whether the header directed that the connection be
-	// closed after reading Body.  The value is advice for clients: neither
-	// ReadResponse nor Response.Write ever closes a connection.
-	Close bool
-
-	// Trailer maps trailer keys to values, in the same
-	// format as the header.
-	Trailer Header
-
-	// The Request that was sent to obtain this Response.
-	// Request's Body is nil (having already been consumed).
-	// This is only populated for Client requests.
-	Request *Request
-
-	// TLS contains information about the TLS connection on which the
-	// response was received. It is nil for unencrypted responses.
-	// The pointer is shared between responses and should not be
-	// modified.
-	TLS *tls.ConnectionState
-}
-
-// Cookies parses and returns the cookies set in the Set-Cookie headers.
-func (r *Response) Cookies() []*Cookie {
-	return readSetCookies(r.Header)
-}
-
-var ErrNoLocation = errors.New("http: no Location header in response")
-
-// Location returns the URL of the response's "Location" header,
-// if present.  Relative redirects are resolved relative to
-// the Response's Request.  ErrNoLocation is returned if no
-// Location header is present.
-func (r *Response) Location() (*url.URL, error) {
-	lv := r.Header.Get("Location")
-	if lv == "" {
-		return nil, ErrNoLocation
-	}
-	if r.Request != nil && r.Request.URL != nil {
-		return r.Request.URL.Parse(lv)
-	}
-	return url.Parse(lv)
-}
-
-// ReadResponse reads and returns an HTTP response from r.
-// The req parameter optionally specifies the Request that corresponds
-// to this Response. If nil, a GET request is assumed.
-// Clients must call resp.Body.Close when finished reading resp.Body.
-// After that call, clients can inspect resp.Trailer to find key/value
-// pairs included in the response trailer.
-func ReadResponse(r *bufio.Reader, req *Request) (*Response, error) {
-	tp := textproto.NewReader(r)
-	resp := &Response{
-		Request: req,
-	}
-
-	// Parse the first line of the response.
-	line, err := tp.ReadLine()
-	if err != nil {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-		return nil, err
-	}
-	f := strings.SplitN(line, " ", 3)
-	if len(f) < 2 {
-		return nil, &badStringError{"malformed HTTP response", line}
-	}
-	reasonPhrase := ""
-	if len(f) > 2 {
-		reasonPhrase = f[2]
-	}
-	resp.Status = f[1] + " " + reasonPhrase
-	resp.StatusCode, err = strconv.Atoi(f[1])
-	if err != nil {
-		return nil, &badStringError{"malformed HTTP status code", f[1]}
-	}
-
-	resp.Proto = f[0]
-	var ok bool
-	if resp.ProtoMajor, resp.ProtoMinor, ok = ParseHTTPVersion(resp.Proto); !ok {
-		return nil, &badStringError{"malformed HTTP version", resp.Proto}
-	}
-
-	// Parse the response headers.
-	mimeHeader, err := tp.ReadMIMEHeader()
-	if err != nil {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-		return nil, err
-	}
-	resp.Header = Header(mimeHeader)
-
-	fixPragmaCacheControl(resp.Header)
-
-	err = readTransfer(resp, r)
-	if err != nil {
-		return nil, err
-	}
-
-	return resp, nil
-}
-
-// RFC2616: Should treat
-//	Pragma: no-cache
-// like
-//	Cache-Control: no-cache
-func fixPragmaCacheControl(header Header) {
-	if hp, ok := header["Pragma"]; ok && len(hp) > 0 && hp[0] == "no-cache" {
-		if _, presentcc := header["Cache-Control"]; !presentcc {
-			header["Cache-Control"] = []string{"no-cache"}
-		}
-	}
-}
-
-// ProtoAtLeast reports whether the HTTP protocol used
-// in the response is at least major.minor.
-func (r *Response) ProtoAtLeast(major, minor int) bool {
-	return r.ProtoMajor > major ||
-		r.ProtoMajor == major && r.ProtoMinor >= minor
-}
-
-// Writes the response (header, body and trailer) in wire format. This method
-// consults the following fields of the response:
-//
-//  StatusCode
-//  ProtoMajor
-//  ProtoMinor
-//  Request.Method
-//  TransferEncoding
-//  Trailer
-//  Body
-//  ContentLength
-//  Header, values for non-canonical keys will have unpredictable behavior
-//
-// Body is closed after it is sent.
-func (r *Response) Write(w io.Writer) error {
-	// Status line
-	text := r.Status
-	if text == "" {
-		var ok bool
-		text, ok = statusText[r.StatusCode]
-		if !ok {
-			text = "status code " + strconv.Itoa(r.StatusCode)
-		}
-	}
-	protoMajor, protoMinor := strconv.Itoa(r.ProtoMajor), strconv.Itoa(r.ProtoMinor)
-	statusCode := strconv.Itoa(r.StatusCode) + " "
-	text = strings.TrimPrefix(text, statusCode)
-	if _, err := io.WriteString(w, "HTTP/"+protoMajor+"."+protoMinor+" "+statusCode+text+"\r\n"); err != nil {
-		return err
-	}
-
-	// Clone it, so we can modify r1 as needed.
-	r1 := new(Response)
-	*r1 = *r
-	if r1.ContentLength == 0 && r1.Body != nil {
-		// Is it actually 0 length? Or just unknown?
-		var buf [1]byte
-		n, err := r1.Body.Read(buf[:])
-		if err != nil && err != io.EOF {
-			return err
-		}
-		if n == 0 {
-			// Reset it to a known zero reader, in case underlying one
-			// is unhappy being read repeatedly.
-			r1.Body = eofReader
-		} else {
-			r1.ContentLength = -1
-			r1.Body = struct {
-				io.Reader
-				io.Closer
-			}{
-				io.MultiReader(bytes.NewReader(buf[:1]), r.Body),
-				r.Body,
-			}
-		}
-	}
-	// If we're sending a non-chunked HTTP/1.1 response without a
-	// content-length, the only way to do that is the old HTTP/1.0
-	// way, by noting the EOF with a connection close, so we need
-	// to set Close.
-	if r1.ContentLength == -1 && !r1.Close && r1.ProtoAtLeast(1, 1) && !chunked(r1.TransferEncoding) {
-		r1.Close = true
-	}
-
-	// Process Body,ContentLength,Close,Trailer
-	tw, err := newTransferWriter(r1)
-	if err != nil {
-		return err
-	}
-	err = tw.WriteHeader(w)
-	if err != nil {
-		return err
-	}
-
-	// Rest of header
-	err = r.Header.WriteSubset(w, respExcludeHeader)
-	if err != nil {
-		return err
-	}
-
-	// contentLengthAlreadySent may have been already sent for
-	// POST/PUT requests, even if zero length. See Issue 8180.
-	contentLengthAlreadySent := tw.shouldSendContentLength()
-	if r1.ContentLength == 0 && !chunked(r1.TransferEncoding) && !contentLengthAlreadySent {
-		if _, err := io.WriteString(w, "Content-Length: 0\r\n"); err != nil {
-			return err
-		}
-	}
-
-	// End-of-header
-	if _, err := io.WriteString(w, "\r\n"); err != nil {
-		return err
-	}
-
-	// Write body and trailer
-	err = tw.WriteBody(w)
-	if err != nil {
-		return err
-	}
-
-	// Success
-	return nil
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/server.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/server.go
deleted file mode 100644
index eae097eb8..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/server.go
+++ /dev/null
@@ -1,2052 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// HTTP server.  See RFC 2616.
-
-package http
-
-import (
-	"bufio"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net"
-	"net/url"
-	"os"
-	"path"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-// Errors introduced by the HTTP server.
-var (
-	ErrWriteAfterFlush = errors.New("Conn.Write called after Flush")
-	ErrBodyNotAllowed  = errors.New("http: request method or response status code does not allow body")
-	ErrHijacked        = errors.New("Conn has been hijacked")
-	ErrContentLength   = errors.New("Conn.Write wrote more than the declared Content-Length")
-)
-
-// Objects implementing the Handler interface can be
-// registered to serve a particular path or subtree
-// in the HTTP server.
-//
-// ServeHTTP should write reply headers and data to the ResponseWriter
-// and then return.  Returning signals that the request is finished
-// and that the HTTP server can move on to the next request on
-// the connection.
-type Handler interface {
-	ServeHTTP(ResponseWriter, *Request)
-}
-
-// A ResponseWriter interface is used by an HTTP handler to
-// construct an HTTP response.
-type ResponseWriter interface {
-	// Header returns the header map that will be sent by WriteHeader.
-	// Changing the header after a call to WriteHeader (or Write) has
-	// no effect.
-	Header() Header
-
-	// Write writes the data to the connection as part of an HTTP reply.
-	// If WriteHeader has not yet been called, Write calls WriteHeader(http.StatusOK)
-	// before writing the data.  If the Header does not contain a
-	// Content-Type line, Write adds a Content-Type set to the result of passing
-	// the initial 512 bytes of written data to DetectContentType.
-	Write([]byte) (int, error)
-
-	// WriteHeader sends an HTTP response header with status code.
-	// If WriteHeader is not called explicitly, the first call to Write
-	// will trigger an implicit WriteHeader(http.StatusOK).
-	// Thus explicit calls to WriteHeader are mainly used to
-	// send error codes.
-	WriteHeader(int)
-}
-
-// The Flusher interface is implemented by ResponseWriters that allow
-// an HTTP handler to flush buffered data to the client.
-//
-// Note that even for ResponseWriters that support Flush,
-// if the client is connected through an HTTP proxy,
-// the buffered data may not reach the client until the response
-// completes.
-type Flusher interface {
-	// Flush sends any buffered data to the client.
-	Flush()
-}
-
-// The Hijacker interface is implemented by ResponseWriters that allow
-// an HTTP handler to take over the connection.
-type Hijacker interface {
-	// Hijack lets the caller take over the connection.
-	// After a call to Hijack(), the HTTP server library
-	// will not do anything else with the connection.
-	// It becomes the caller's responsibility to manage
-	// and close the connection.
-	Hijack() (net.Conn, *bufio.ReadWriter, error)
-}
-
-// The CloseNotifier interface is implemented by ResponseWriters which
-// allow detecting when the underlying connection has gone away.
-//
-// This mechanism can be used to cancel long operations on the server
-// if the client has disconnected before the response is ready.
-type CloseNotifier interface {
-	// CloseNotify returns a channel that receives a single value
-	// when the client connection has gone away.
-	CloseNotify() <-chan bool
-}
-
-// A conn represents the server side of an HTTP connection.
-type conn struct {
-	remoteAddr string               // network address of remote side
-	server     *Server              // the Server on which the connection arrived
-	rwc        net.Conn             // i/o connection
-	sr         liveSwitchReader     // where the LimitReader reads from; usually the rwc
-	lr         *io.LimitedReader    // io.LimitReader(sr)
-	buf        *bufio.ReadWriter    // buffered(lr,rwc), reading from bufio->limitReader->sr->rwc
-	tlsState   *tls.ConnectionState // or nil when not using TLS
-
-	mu           sync.Mutex // guards the following
-	clientGone   bool       // if client has disconnected mid-request
-	closeNotifyc chan bool  // made lazily
-	hijackedv    bool       // connection has been hijacked by handler
-}
-
-func (c *conn) hijacked() bool {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.hijackedv
-}
-
-func (c *conn) hijack() (rwc net.Conn, buf *bufio.ReadWriter, err error) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if c.hijackedv {
-		return nil, nil, ErrHijacked
-	}
-	if c.closeNotifyc != nil {
-		return nil, nil, errors.New("http: Hijack is incompatible with use of CloseNotifier")
-	}
-	c.hijackedv = true
-	rwc = c.rwc
-	buf = c.buf
-	c.rwc = nil
-	c.buf = nil
-	c.setState(rwc, StateHijacked)
-	return
-}
-
-func (c *conn) closeNotify() <-chan bool {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if c.closeNotifyc == nil {
-		c.closeNotifyc = make(chan bool, 1)
-		if c.hijackedv {
-			// to obey the function signature, even though
-			// it'll never receive a value.
-			return c.closeNotifyc
-		}
-		pr, pw := io.Pipe()
-
-		readSource := c.sr.r
-		c.sr.Lock()
-		c.sr.r = pr
-		c.sr.Unlock()
-		go func() {
-			_, err := io.Copy(pw, readSource)
-			if err == nil {
-				err = io.EOF
-			}
-			pw.CloseWithError(err)
-			c.noteClientGone()
-		}()
-	}
-	return c.closeNotifyc
-}
-
-func (c *conn) noteClientGone() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if c.closeNotifyc != nil && !c.clientGone {
-		c.closeNotifyc <- true
-	}
-	c.clientGone = true
-}
-
-// A switchReader can have its Reader changed at runtime.
-// It's not safe for concurrent Reads and switches.
-type switchReader struct {
-	io.Reader
-}
-
-// A switchWriter can have its Writer changed at runtime.
-// It's not safe for concurrent Writes and switches.
-type switchWriter struct {
-	io.Writer
-}
-
-// A liveSwitchReader is a switchReader that's safe for concurrent
-// reads and switches, if its mutex is held.
-type liveSwitchReader struct {
-	sync.Mutex
-	r io.Reader
-}
-
-func (sr *liveSwitchReader) Read(p []byte) (n int, err error) {
-	sr.Lock()
-	r := sr.r
-	sr.Unlock()
-	return r.Read(p)
-}
-
-// This should be >= 512 bytes for DetectContentType,
-// but otherwise it's somewhat arbitrary.
-const bufferBeforeChunkingSize = 2048
-
-// chunkWriter writes to a response's conn buffer, and is the writer
-// wrapped by the response.bufw buffered writer.
-//
-// chunkWriter also is responsible for finalizing the Header, including
-// conditionally setting the Content-Type and setting a Content-Length
-// in cases where the handler's final output is smaller than the buffer
-// size. It also conditionally adds chunk headers, when in chunking mode.
-//
-// See the comment above (*response).Write for the entire write flow.
-type chunkWriter struct {
-	res *response
-
-	// header is either nil or a deep clone of res.handlerHeader
-	// at the time of res.WriteHeader, if res.WriteHeader is
-	// called and extra buffering is being done to calculate
-	// Content-Type and/or Content-Length.
-	header Header
-
-	// wroteHeader tells whether the header's been written to "the
-	// wire" (or rather: w.conn.buf). this is unlike
-	// (*response).wroteHeader, which tells only whether it was
-	// logically written.
-	wroteHeader bool
-
-	// set by the writeHeader method:
-	chunking bool // using chunked transfer encoding for reply body
-}
-
-var (
-	crlf       = []byte("\r\n")
-	colonSpace = []byte(": ")
-)
-
-func (cw *chunkWriter) Write(p []byte) (n int, err error) {
-	if !cw.wroteHeader {
-		cw.writeHeader(p)
-	}
-	if cw.res.req.Method == "HEAD" {
-		// Eat writes.
-		return len(p), nil
-	}
-	if cw.chunking {
-		_, err = fmt.Fprintf(cw.res.conn.buf, "%x\r\n", len(p))
-		if err != nil {
-			cw.res.conn.rwc.Close()
-			return
-		}
-	}
-	n, err = cw.res.conn.buf.Write(p)
-	if cw.chunking && err == nil {
-		_, err = cw.res.conn.buf.Write(crlf)
-	}
-	if err != nil {
-		cw.res.conn.rwc.Close()
-	}
-	return
-}
-
-func (cw *chunkWriter) flush() {
-	if !cw.wroteHeader {
-		cw.writeHeader(nil)
-	}
-	cw.res.conn.buf.Flush()
-}
-
-func (cw *chunkWriter) close() {
-	if !cw.wroteHeader {
-		cw.writeHeader(nil)
-	}
-	if cw.chunking {
-		// zero EOF chunk, trailer key/value pairs (currently
-		// unsupported in Go's server), followed by a blank
-		// line.
-		cw.res.conn.buf.WriteString("0\r\n\r\n")
-	}
-}
-
-// A response represents the server side of an HTTP response.
-type response struct {
-	conn          *conn
-	req           *Request // request for this response
-	wroteHeader   bool     // reply header has been (logically) written
-	wroteContinue bool     // 100 Continue response was written
-
-	w  *bufio.Writer // buffers output in chunks to chunkWriter
-	cw chunkWriter
-	sw *switchWriter // of the bufio.Writer, for return to putBufioWriter
-
-	// handlerHeader is the Header that Handlers get access to,
-	// which may be retained and mutated even after WriteHeader.
-	// handlerHeader is copied into cw.header at WriteHeader
-	// time, and privately mutated thereafter.
-	handlerHeader Header
-	calledHeader  bool // handler accessed handlerHeader via Header
-
-	written       int64 // number of bytes written in body
-	contentLength int64 // explicitly-declared Content-Length; or -1
-	status        int   // status code passed to WriteHeader
-
-	// close connection after this reply.  set on request and
-	// updated after response from handler if there's a
-	// "Connection: keep-alive" response header and a
-	// Content-Length.
-	closeAfterReply bool
-
-	// requestBodyLimitHit is set by requestTooLarge when
-	// maxBytesReader hits its max size. It is checked in
-	// WriteHeader, to make sure we don't consume the
-	// remaining request body to try to advance to the next HTTP
-	// request. Instead, when this is set, we stop reading
-	// subsequent requests on this connection and stop reading
-	// input from it.
-	requestBodyLimitHit bool
-
-	handlerDone bool // set true when the handler exits
-
-	// Buffers for Date and Content-Length
-	dateBuf [len(TimeFormat)]byte
-	clenBuf [10]byte
-}
-
-// requestTooLarge is called by maxBytesReader when too much input has
-// been read from the client.
-func (w *response) requestTooLarge() {
-	w.closeAfterReply = true
-	w.requestBodyLimitHit = true
-	if !w.wroteHeader {
-		w.Header().Set("Connection", "close")
-	}
-}
-
-// needsSniff reports whether a Content-Type still needs to be sniffed.
-func (w *response) needsSniff() bool {
-	_, haveType := w.handlerHeader["Content-Type"]
-	return !w.cw.wroteHeader && !haveType && w.written < sniffLen
-}
-
-// writerOnly hides an io.Writer value's optional ReadFrom method
-// from io.Copy.
-type writerOnly struct {
-	io.Writer
-}
-
-func srcIsRegularFile(src io.Reader) (isRegular bool, err error) {
-	switch v := src.(type) {
-	case *os.File:
-		fi, err := v.Stat()
-		if err != nil {
-			return false, err
-		}
-		return fi.Mode().IsRegular(), nil
-	case *io.LimitedReader:
-		return srcIsRegularFile(v.R)
-	default:
-		return
-	}
-}
-
-// ReadFrom is here to optimize copying from an *os.File regular file
-// to a *net.TCPConn with sendfile.
-func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
-	// Our underlying w.conn.rwc is usually a *TCPConn (with its
-	// own ReadFrom method). If not, or if our src isn't a regular
-	// file, just fall back to the normal copy method.
-	rf, ok := w.conn.rwc.(io.ReaderFrom)
-	regFile, err := srcIsRegularFile(src)
-	if err != nil {
-		return 0, err
-	}
-	if !ok || !regFile {
-		return io.Copy(writerOnly{w}, src)
-	}
-
-	// sendfile path:
-
-	if !w.wroteHeader {
-		w.WriteHeader(StatusOK)
-	}
-
-	if w.needsSniff() {
-		n0, err := io.Copy(writerOnly{w}, io.LimitReader(src, sniffLen))
-		n += n0
-		if err != nil {
-			return n, err
-		}
-	}
-
-	w.w.Flush()  // get rid of any previous writes
-	w.cw.flush() // make sure Header is written; flush data to rwc
-
-	// Now that cw has been flushed, its chunking field is guaranteed initialized.
-	if !w.cw.chunking && w.bodyAllowed() {
-		n0, err := rf.ReadFrom(src)
-		n += n0
-		w.written += n0
-		return n, err
-	}
-
-	n0, err := io.Copy(writerOnly{w}, src)
-	n += n0
-	return n, err
-}
-
-// noLimit is an effective infinite upper bound for io.LimitedReader
-const noLimit int64 = (1 << 63) - 1
-
-// debugServerConnections controls whether all server connections are wrapped
-// with a verbose logging wrapper.
-const debugServerConnections = false
-
-// Create new connection from rwc.
-func (srv *Server) newConn(rwc net.Conn) (c *conn, err error) {
-	c = new(conn)
-	c.remoteAddr = rwc.RemoteAddr().String()
-	c.server = srv
-	c.rwc = rwc
-	if debugServerConnections {
-		c.rwc = newLoggingConn("server", c.rwc)
-	}
-	c.sr = liveSwitchReader{r: c.rwc}
-	c.lr = io.LimitReader(&c.sr, noLimit).(*io.LimitedReader)
-	br := newBufioReader(c.lr)
-	bw := newBufioWriterSize(c.rwc, 4<<10)
-	c.buf = bufio.NewReadWriter(br, bw)
-	return c, nil
-}
-
-var (
-	bufioReaderPool   sync.Pool
-	bufioWriter2kPool sync.Pool
-	bufioWriter4kPool sync.Pool
-)
-
-func bufioWriterPool(size int) *sync.Pool {
-	switch size {
-	case 2 << 10:
-		return &bufioWriter2kPool
-	case 4 << 10:
-		return &bufioWriter4kPool
-	}
-	return nil
-}
-
-func newBufioReader(r io.Reader) *bufio.Reader {
-	if v := bufioReaderPool.Get(); v != nil {
-		br := v.(*bufio.Reader)
-		br.Reset(r)
-		return br
-	}
-	return bufio.NewReader(r)
-}
-
-func putBufioReader(br *bufio.Reader) {
-	br.Reset(nil)
-	bufioReaderPool.Put(br)
-}
-
-func newBufioWriterSize(w io.Writer, size int) *bufio.Writer {
-	pool := bufioWriterPool(size)
-	if pool != nil {
-		if v := pool.Get(); v != nil {
-			bw := v.(*bufio.Writer)
-			bw.Reset(w)
-			return bw
-		}
-	}
-	return bufio.NewWriterSize(w, size)
-}
-
-func putBufioWriter(bw *bufio.Writer) {
-	bw.Reset(nil)
-	if pool := bufioWriterPool(bw.Available()); pool != nil {
-		pool.Put(bw)
-	}
-}
-
-// DefaultMaxHeaderBytes is the maximum permitted size of the headers
-// in an HTTP request.
-// This can be overridden by setting Server.MaxHeaderBytes.
-const DefaultMaxHeaderBytes = 1 << 20 // 1 MB
-
-func (srv *Server) maxHeaderBytes() int {
-	if srv.MaxHeaderBytes > 0 {
-		return srv.MaxHeaderBytes
-	}
-	return DefaultMaxHeaderBytes
-}
-
-func (srv *Server) initialLimitedReaderSize() int64 {
-	return int64(srv.maxHeaderBytes()) + 4096 // bufio slop
-}
-
-// wrapper around io.ReaderCloser which on first read, sends an
-// HTTP/1.1 100 Continue header
-type expectContinueReader struct {
-	resp       *response
-	readCloser io.ReadCloser
-	closed     bool
-}
-
-func (ecr *expectContinueReader) Read(p []byte) (n int, err error) {
-	if ecr.closed {
-		return 0, ErrBodyReadAfterClose
-	}
-	if !ecr.resp.wroteContinue && !ecr.resp.conn.hijacked() {
-		ecr.resp.wroteContinue = true
-		ecr.resp.conn.buf.WriteString("HTTP/1.1 100 Continue\r\n\r\n")
-		ecr.resp.conn.buf.Flush()
-	}
-	return ecr.readCloser.Read(p)
-}
-
-func (ecr *expectContinueReader) Close() error {
-	ecr.closed = true
-	return ecr.readCloser.Close()
-}
-
-// TimeFormat is the time format to use with
-// time.Parse and time.Time.Format when parsing
-// or generating times in HTTP headers.
-// It is like time.RFC1123 but hard codes GMT as the time zone.
-const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"
-
-// appendTime is a non-allocating version of []byte(t.UTC().Format(TimeFormat))
-func appendTime(b []byte, t time.Time) []byte {
-	const days = "SunMonTueWedThuFriSat"
-	const months = "JanFebMarAprMayJunJulAugSepOctNovDec"
-
-	t = t.UTC()
-	yy, mm, dd := t.Date()
-	hh, mn, ss := t.Clock()
-	day := days[3*t.Weekday():]
-	mon := months[3*(mm-1):]
-
-	return append(b,
-		day[0], day[1], day[2], ',', ' ',
-		byte('0'+dd/10), byte('0'+dd%10), ' ',
-		mon[0], mon[1], mon[2], ' ',
-		byte('0'+yy/1000), byte('0'+(yy/100)%10), byte('0'+(yy/10)%10), byte('0'+yy%10), ' ',
-		byte('0'+hh/10), byte('0'+hh%10), ':',
-		byte('0'+mn/10), byte('0'+mn%10), ':',
-		byte('0'+ss/10), byte('0'+ss%10), ' ',
-		'G', 'M', 'T')
-}
-
-var errTooLarge = errors.New("http: request too large")
-
-// Read next request from connection.
-func (c *conn) readRequest() (w *response, err error) {
-	if c.hijacked() {
-		return nil, ErrHijacked
-	}
-
-	if d := c.server.ReadTimeout; d != 0 {
-		c.rwc.SetReadDeadline(time.Now().Add(d))
-	}
-	if d := c.server.WriteTimeout; d != 0 {
-		defer func() {
-			c.rwc.SetWriteDeadline(time.Now().Add(d))
-		}()
-	}
-
-	c.lr.N = c.server.initialLimitedReaderSize()
-	var req *Request
-	if req, err = ReadRequest(c.buf.Reader); err != nil {
-		if c.lr.N == 0 {
-			return nil, errTooLarge
-		}
-		return nil, err
-	}
-	c.lr.N = noLimit
-
-	req.RemoteAddr = c.remoteAddr
-	req.TLS = c.tlsState
-
-	w = &response{
-		conn:          c,
-		req:           req,
-		handlerHeader: make(Header),
-		contentLength: -1,
-	}
-	w.cw.res = w
-	w.w = newBufioWriterSize(&w.cw, bufferBeforeChunkingSize)
-	return w, nil
-}
-
-func (w *response) Header() Header {
-	if w.cw.header == nil && w.wroteHeader && !w.cw.wroteHeader {
-		// Accessing the header between logically writing it
-		// and physically writing it means we need to allocate
-		// a clone to snapshot the logically written state.
-		w.cw.header = w.handlerHeader.clone()
-	}
-	w.calledHeader = true
-	return w.handlerHeader
-}
-
-// maxPostHandlerReadBytes is the max number of Request.Body bytes not
-// consumed by a handler that the server will read from the client
-// in order to keep a connection alive.  If there are more bytes than
-// this then the server to be paranoid instead sends a "Connection:
-// close" response.
-//
-// This number is approximately what a typical machine's TCP buffer
-// size is anyway.  (if we have the bytes on the machine, we might as
-// well read them)
-const maxPostHandlerReadBytes = 256 << 10
-
-func (w *response) WriteHeader(code int) {
-	if w.conn.hijacked() {
-		w.conn.server.logf("http: response.WriteHeader on hijacked connection")
-		return
-	}
-	if w.wroteHeader {
-		w.conn.server.logf("http: multiple response.WriteHeader calls")
-		return
-	}
-	w.wroteHeader = true
-	w.status = code
-
-	if w.calledHeader && w.cw.header == nil {
-		w.cw.header = w.handlerHeader.clone()
-	}
-
-	if cl := w.handlerHeader.get("Content-Length"); cl != "" {
-		v, err := strconv.ParseInt(cl, 10, 64)
-		if err == nil && v >= 0 {
-			w.contentLength = v
-		} else {
-			w.conn.server.logf("http: invalid Content-Length of %q", cl)
-			w.handlerHeader.Del("Content-Length")
-		}
-	}
-}
-
-// extraHeader is the set of headers sometimes added by chunkWriter.writeHeader.
-// This type is used to avoid extra allocations from cloning and/or populating
-// the response Header map and all its 1-element slices.
-type extraHeader struct {
-	contentType      string
-	connection       string
-	transferEncoding string
-	date             []byte // written if not nil
-	contentLength    []byte // written if not nil
-}
-
-// Sorted the same as extraHeader.Write's loop.
-var extraHeaderKeys = [][]byte{
-	[]byte("Content-Type"),
-	[]byte("Connection"),
-	[]byte("Transfer-Encoding"),
-}
-
-var (
-	headerContentLength = []byte("Content-Length: ")
-	headerDate          = []byte("Date: ")
-)
-
-// Write writes the headers described in h to w.
-//
-// This method has a value receiver, despite the somewhat large size
-// of h, because it prevents an allocation. The escape analysis isn't
-// smart enough to realize this function doesn't mutate h.
-func (h extraHeader) Write(w *bufio.Writer) {
-	if h.date != nil {
-		w.Write(headerDate)
-		w.Write(h.date)
-		w.Write(crlf)
-	}
-	if h.contentLength != nil {
-		w.Write(headerContentLength)
-		w.Write(h.contentLength)
-		w.Write(crlf)
-	}
-	for i, v := range []string{h.contentType, h.connection, h.transferEncoding} {
-		if v != "" {
-			w.Write(extraHeaderKeys[i])
-			w.Write(colonSpace)
-			w.WriteString(v)
-			w.Write(crlf)
-		}
-	}
-}
-
-// writeHeader finalizes the header sent to the client and writes it
-// to cw.res.conn.buf.
-//
-// p is not written by writeHeader, but is the first chunk of the body
-// that will be written.  It is sniffed for a Content-Type if none is
-// set explicitly.  It's also used to set the Content-Length, if the
-// total body size was small and the handler has already finished
-// running.
-func (cw *chunkWriter) writeHeader(p []byte) {
-	if cw.wroteHeader {
-		return
-	}
-	cw.wroteHeader = true
-
-	w := cw.res
-	keepAlivesEnabled := w.conn.server.doKeepAlives()
-	isHEAD := w.req.Method == "HEAD"
-
-	// header is written out to w.conn.buf below. Depending on the
-	// state of the handler, we either own the map or not. If we
-	// don't own it, the exclude map is created lazily for
-	// WriteSubset to remove headers. The setHeader struct holds
-	// headers we need to add.
-	header := cw.header
-	owned := header != nil
-	if !owned {
-		header = w.handlerHeader
-	}
-	var excludeHeader map[string]bool
-	delHeader := func(key string) {
-		if owned {
-			header.Del(key)
-			return
-		}
-		if _, ok := header[key]; !ok {
-			return
-		}
-		if excludeHeader == nil {
-			excludeHeader = make(map[string]bool)
-		}
-		excludeHeader[key] = true
-	}
-	var setHeader extraHeader
-
-	// If the handler is done but never sent a Content-Length
-	// response header and this is our first (and last) write, set
-	// it, even to zero. This helps HTTP/1.0 clients keep their
-	// "keep-alive" connections alive.
-	// Exceptions: 304/204/1xx responses never get Content-Length, and if
-	// it was a HEAD request, we don't know the difference between
-	// 0 actual bytes and 0 bytes because the handler noticed it
-	// was a HEAD request and chose not to write anything.  So for
-	// HEAD, the handler should either write the Content-Length or
-	// write non-zero bytes.  If it's actually 0 bytes and the
-	// handler never looked at the Request.Method, we just don't
-	// send a Content-Length header.
-	if w.handlerDone && bodyAllowedForStatus(w.status) && header.get("Content-Length") == "" && (!isHEAD || len(p) > 0) {
-		w.contentLength = int64(len(p))
-		setHeader.contentLength = strconv.AppendInt(cw.res.clenBuf[:0], int64(len(p)), 10)
-	}
-
-	// If this was an HTTP/1.0 request with keep-alive and we sent a
-	// Content-Length back, we can make this a keep-alive response ...
-	if w.req.wantsHttp10KeepAlive() && keepAlivesEnabled {
-		sentLength := header.get("Content-Length") != ""
-		if sentLength && header.get("Connection") == "keep-alive" {
-			w.closeAfterReply = false
-		}
-	}
-
-	// Check for a explicit (and valid) Content-Length header.
-	hasCL := w.contentLength != -1
-
-	if w.req.wantsHttp10KeepAlive() && (isHEAD || hasCL) {
-		_, connectionHeaderSet := header["Connection"]
-		if !connectionHeaderSet {
-			setHeader.connection = "keep-alive"
-		}
-	} else if !w.req.ProtoAtLeast(1, 1) || w.req.wantsClose() {
-		w.closeAfterReply = true
-	}
-
-	if header.get("Connection") == "close" || !keepAlivesEnabled {
-		w.closeAfterReply = true
-	}
-
-	// Per RFC 2616, we should consume the request body before
-	// replying, if the handler hasn't already done so.  But we
-	// don't want to do an unbounded amount of reading here for
-	// DoS reasons, so we only try up to a threshold.
-	if w.req.ContentLength != 0 && !w.closeAfterReply {
-		ecr, isExpecter := w.req.Body.(*expectContinueReader)
-		if !isExpecter || ecr.resp.wroteContinue {
-			n, _ := io.CopyN(ioutil.Discard, w.req.Body, maxPostHandlerReadBytes+1)
-			if n >= maxPostHandlerReadBytes {
-				w.requestTooLarge()
-				delHeader("Connection")
-				setHeader.connection = "close"
-			} else {
-				w.req.Body.Close()
-			}
-		}
-	}
-
-	code := w.status
-	if bodyAllowedForStatus(code) {
-		// If no content type, apply sniffing algorithm to body.
-		_, haveType := header["Content-Type"]
-		if !haveType {
-			setHeader.contentType = DetectContentType(p)
-		}
-	} else {
-		for _, k := range suppressedHeaders(code) {
-			delHeader(k)
-		}
-	}
-
-	if _, ok := header["Date"]; !ok {
-		setHeader.date = appendTime(cw.res.dateBuf[:0], time.Now())
-	}
-
-	te := header.get("Transfer-Encoding")
-	hasTE := te != ""
-	if hasCL && hasTE && te != "identity" {
-		// TODO: return an error if WriteHeader gets a return parameter
-		// For now just ignore the Content-Length.
-		w.conn.server.logf("http: WriteHeader called with both Transfer-Encoding of %q and a Content-Length of %d",
-			te, w.contentLength)
-		delHeader("Content-Length")
-		hasCL = false
-	}
-
-	if w.req.Method == "HEAD" || !bodyAllowedForStatus(code) {
-		// do nothing
-	} else if code == StatusNoContent {
-		delHeader("Transfer-Encoding")
-	} else if hasCL {
-		delHeader("Transfer-Encoding")
-	} else if w.req.ProtoAtLeast(1, 1) {
-		// HTTP/1.1 or greater: use chunked transfer encoding
-		// to avoid closing the connection at EOF.
-		// TODO: this blows away any custom or stacked Transfer-Encoding they
-		// might have set.  Deal with that as need arises once we have a valid
-		// use case.
-		cw.chunking = true
-		setHeader.transferEncoding = "chunked"
-	} else {
-		// HTTP version < 1.1: cannot do chunked transfer
-		// encoding and we don't know the Content-Length so
-		// signal EOF by closing connection.
-		w.closeAfterReply = true
-		delHeader("Transfer-Encoding") // in case already set
-	}
-
-	// Cannot use Content-Length with non-identity Transfer-Encoding.
-	if cw.chunking {
-		delHeader("Content-Length")
-	}
-	if !w.req.ProtoAtLeast(1, 0) {
-		return
-	}
-
-	if w.closeAfterReply && (!keepAlivesEnabled || !hasToken(cw.header.get("Connection"), "close")) {
-		delHeader("Connection")
-		if w.req.ProtoAtLeast(1, 1) {
-			setHeader.connection = "close"
-		}
-	}
-
-	w.conn.buf.WriteString(statusLine(w.req, code))
-	cw.header.WriteSubset(w.conn.buf, excludeHeader)
-	setHeader.Write(w.conn.buf.Writer)
-	w.conn.buf.Write(crlf)
-}
-
-// statusLines is a cache of Status-Line strings, keyed by code (for
-// HTTP/1.1) or negative code (for HTTP/1.0). This is faster than a
-// map keyed by struct of two fields. This map's max size is bounded
-// by 2*len(statusText), two protocol types for each known official
-// status code in the statusText map.
-var (
-	statusMu    sync.RWMutex
-	statusLines = make(map[int]string)
-)
-
-// statusLine returns a response Status-Line (RFC 2616 Section 6.1)
-// for the given request and response status code.
-func statusLine(req *Request, code int) string {
-	// Fast path:
-	key := code
-	proto11 := req.ProtoAtLeast(1, 1)
-	if !proto11 {
-		key = -key
-	}
-	statusMu.RLock()
-	line, ok := statusLines[key]
-	statusMu.RUnlock()
-	if ok {
-		return line
-	}
-
-	// Slow path:
-	proto := "HTTP/1.0"
-	if proto11 {
-		proto = "HTTP/1.1"
-	}
-	codestring := strconv.Itoa(code)
-	text, ok := statusText[code]
-	if !ok {
-		text = "status code " + codestring
-	}
-	line = proto + " " + codestring + " " + text + "\r\n"
-	if ok {
-		statusMu.Lock()
-		defer statusMu.Unlock()
-		statusLines[key] = line
-	}
-	return line
-}
-
-// bodyAllowed returns true if a Write is allowed for this response type.
-// It's illegal to call this before the header has been flushed.
-func (w *response) bodyAllowed() bool {
-	if !w.wroteHeader {
-		panic("")
-	}
-	return bodyAllowedForStatus(w.status)
-}
-
-// The Life Of A Write is like this:
-//
-// Handler starts. No header has been sent. The handler can either
-// write a header, or just start writing.  Writing before sending a header
-// sends an implicitly empty 200 OK header.
-//
-// If the handler didn't declare a Content-Length up front, we either
-// go into chunking mode or, if the handler finishes running before
-// the chunking buffer size, we compute a Content-Length and send that
-// in the header instead.
-//
-// Likewise, if the handler didn't set a Content-Type, we sniff that
-// from the initial chunk of output.
-//
-// The Writers are wired together like:
-//
-// 1. *response (the ResponseWriter) ->
-// 2. (*response).w, a *bufio.Writer of bufferBeforeChunkingSize bytes
-// 3. chunkWriter.Writer (whose writeHeader finalizes Content-Length/Type)
-//    and which writes the chunk headers, if needed.
-// 4. conn.buf, a bufio.Writer of default (4kB) bytes
-// 5. the rwc, the net.Conn.
-//
-// TODO(bradfitz): short-circuit some of the buffering when the
-// initial header contains both a Content-Type and Content-Length.
-// Also short-circuit in (1) when the header's been sent and not in
-// chunking mode, writing directly to (4) instead, if (2) has no
-// buffered data.  More generally, we could short-circuit from (1) to
-// (3) even in chunking mode if the write size from (1) is over some
-// threshold and nothing is in (2).  The answer might be mostly making
-// bufferBeforeChunkingSize smaller and having bufio's fast-paths deal
-// with this instead.
-func (w *response) Write(data []byte) (n int, err error) {
-	return w.write(len(data), data, "")
-}
-
-func (w *response) WriteString(data string) (n int, err error) {
-	return w.write(len(data), nil, data)
-}
-
-// either dataB or dataS is non-zero.
-func (w *response) write(lenData int, dataB []byte, dataS string) (n int, err error) {
-	if w.conn.hijacked() {
-		w.conn.server.logf("http: response.Write on hijacked connection")
-		return 0, ErrHijacked
-	}
-	if !w.wroteHeader {
-		w.WriteHeader(StatusOK)
-	}
-	if lenData == 0 {
-		return 0, nil
-	}
-	if !w.bodyAllowed() {
-		return 0, ErrBodyNotAllowed
-	}
-
-	w.written += int64(lenData) // ignoring errors, for errorKludge
-	if w.contentLength != -1 && w.written > w.contentLength {
-		return 0, ErrContentLength
-	}
-	if dataB != nil {
-		return w.w.Write(dataB)
-	} else {
-		return w.w.WriteString(dataS)
-	}
-}
-
-func (w *response) finishRequest() {
-	w.handlerDone = true
-
-	if !w.wroteHeader {
-		w.WriteHeader(StatusOK)
-	}
-
-	w.w.Flush()
-	putBufioWriter(w.w)
-	w.cw.close()
-	w.conn.buf.Flush()
-
-	// Close the body (regardless of w.closeAfterReply) so we can
-	// re-use its bufio.Reader later safely.
-	w.req.Body.Close()
-
-	if w.req.MultipartForm != nil {
-		w.req.MultipartForm.RemoveAll()
-	}
-
-	if w.req.Method != "HEAD" && w.contentLength != -1 && w.bodyAllowed() && w.contentLength != w.written {
-		// Did not write enough. Avoid getting out of sync.
-		w.closeAfterReply = true
-	}
-}
-
-func (w *response) Flush() {
-	if !w.wroteHeader {
-		w.WriteHeader(StatusOK)
-	}
-	w.w.Flush()
-	w.cw.flush()
-}
-
-func (c *conn) finalFlush() {
-	if c.buf != nil {
-		c.buf.Flush()
-
-		// Steal the bufio.Reader (~4KB worth of memory) and its associated
-		// reader for a future connection.
-		putBufioReader(c.buf.Reader)
-
-		// Steal the bufio.Writer (~4KB worth of memory) and its associated
-		// writer for a future connection.
-		putBufioWriter(c.buf.Writer)
-
-		c.buf = nil
-	}
-}
-
-// Close the connection.
-func (c *conn) close() {
-	c.finalFlush()
-	if c.rwc != nil {
-		c.rwc.Close()
-		c.rwc = nil
-	}
-}
-
-// rstAvoidanceDelay is the amount of time we sleep after closing the
-// write side of a TCP connection before closing the entire socket.
-// By sleeping, we increase the chances that the client sees our FIN
-// and processes its final data before they process the subsequent RST
-// from closing a connection with known unread data.
-// This RST seems to occur mostly on BSD systems. (And Windows?)
-// This timeout is somewhat arbitrary (~latency around the planet).
-const rstAvoidanceDelay = 500 * time.Millisecond
-
-// closeWrite flushes any outstanding data and sends a FIN packet (if
-// client is connected via TCP), signalling that we're done.  We then
-// pause for a bit, hoping the client processes it before `any
-// subsequent RST.
-//
-// See http://golang.org/issue/3595
-func (c *conn) closeWriteAndWait() {
-	c.finalFlush()
-	if tcp, ok := c.rwc.(*net.TCPConn); ok {
-		tcp.CloseWrite()
-	}
-	time.Sleep(rstAvoidanceDelay)
-}
-
-// validNPN reports whether the proto is not a blacklisted Next
-// Protocol Negotiation protocol.  Empty and built-in protocol types
-// are blacklisted and can't be overridden with alternate
-// implementations.
-func validNPN(proto string) bool {
-	switch proto {
-	case "", "http/1.1", "http/1.0":
-		return false
-	}
-	return true
-}
-
-func (c *conn) setState(nc net.Conn, state ConnState) {
-	if hook := c.server.ConnState; hook != nil {
-		hook(nc, state)
-	}
-}
-
-// Serve a new connection.
-func (c *conn) serve() {
-	origConn := c.rwc // copy it before it's set nil on Close or Hijack
-	defer func() {
-		if err := recover(); err != nil {
-			const size = 64 << 10
-			buf := make([]byte, size)
-			buf = buf[:runtime.Stack(buf, false)]
-			c.server.logf("http: panic serving %v: %v\n%s", c.remoteAddr, err, buf)
-		}
-		if !c.hijacked() {
-			c.close()
-			c.setState(origConn, StateClosed)
-		}
-	}()
-
-	if tlsConn, ok := c.rwc.(*tls.Conn); ok {
-		if d := c.server.ReadTimeout; d != 0 {
-			c.rwc.SetReadDeadline(time.Now().Add(d))
-		}
-		if d := c.server.WriteTimeout; d != 0 {
-			c.rwc.SetWriteDeadline(time.Now().Add(d))
-		}
-		if err := tlsConn.Handshake(); err != nil {
-			c.server.logf("http: TLS handshake error from %s: %v", c.rwc.RemoteAddr(), err)
-			return
-		}
-		c.tlsState = new(tls.ConnectionState)
-		*c.tlsState = tlsConn.ConnectionState()
-		if proto := c.tlsState.NegotiatedProtocol; validNPN(proto) {
-			if fn := c.server.TLSNextProto[proto]; fn != nil {
-				h := initNPNRequest{tlsConn, serverHandler{c.server}}
-				fn(c.server, tlsConn, h)
-			}
-			return
-		}
-	}
-
-	for {
-		w, err := c.readRequest()
-		if c.lr.N != c.server.initialLimitedReaderSize() {
-			// If we read any bytes off the wire, we're active.
-			c.setState(c.rwc, StateActive)
-		}
-		if err != nil {
-			if err == errTooLarge {
-				// Their HTTP client may or may not be
-				// able to read this if we're
-				// responding to them and hanging up
-				// while they're still writing their
-				// request.  Undefined behavior.
-				io.WriteString(c.rwc, "HTTP/1.1 413 Request Entity Too Large\r\n\r\n")
-				c.closeWriteAndWait()
-				break
-			} else if err == io.EOF {
-				break // Don't reply
-			} else if neterr, ok := err.(net.Error); ok && neterr.Timeout() {
-				break // Don't reply
-			}
-			io.WriteString(c.rwc, "HTTP/1.1 400 Bad Request\r\n\r\n")
-			break
-		}
-
-		// Expect 100 Continue support
-		req := w.req
-		if req.expectsContinue() {
-			if req.ProtoAtLeast(1, 1) && req.ContentLength != 0 {
-				// Wrap the Body reader with one that replies on the connection
-				req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
-			}
-			req.Header.Del("Expect")
-		} else if req.Header.get("Expect") != "" {
-			w.sendExpectationFailed()
-			break
-		}
-
-		// HTTP cannot have multiple simultaneous active requests.[*]
-		// Until the server replies to this request, it can't read another,
-		// so we might as well run the handler in this goroutine.
-		// [*] Not strictly true: HTTP pipelining.  We could let them all process
-		// in parallel even if their responses need to be serialized.
-		serverHandler{c.server}.ServeHTTP(w, w.req)
-		if c.hijacked() {
-			return
-		}
-		w.finishRequest()
-		if w.closeAfterReply {
-			if w.requestBodyLimitHit {
-				c.closeWriteAndWait()
-			}
-			break
-		}
-		c.setState(c.rwc, StateIdle)
-	}
-}
-
-func (w *response) sendExpectationFailed() {
-	// TODO(bradfitz): let ServeHTTP handlers handle
-	// requests with non-standard expectation[s]? Seems
-	// theoretical at best, and doesn't fit into the
-	// current ServeHTTP model anyway.  We'd need to
-	// make the ResponseWriter an optional
-	// "ExpectReplier" interface or something.
-	//
-	// For now we'll just obey RFC 2616 14.20 which says
-	// "If a server receives a request containing an
-	// Expect field that includes an expectation-
-	// extension that it does not support, it MUST
-	// respond with a 417 (Expectation Failed) status."
-	w.Header().Set("Connection", "close")
-	w.WriteHeader(StatusExpectationFailed)
-	w.finishRequest()
-}
-
-// Hijack implements the Hijacker.Hijack method. Our response is both a ResponseWriter
-// and a Hijacker.
-func (w *response) Hijack() (rwc net.Conn, buf *bufio.ReadWriter, err error) {
-	if w.wroteHeader {
-		w.cw.flush()
-	}
-	// Release the bufioWriter that writes to the chunk writer, it is not
-	// used after a connection has been hijacked.
-	rwc, buf, err = w.conn.hijack()
-	if err == nil {
-		putBufioWriter(w.w)
-		w.w = nil
-	}
-	return rwc, buf, err
-}
-
-func (w *response) CloseNotify() <-chan bool {
-	return w.conn.closeNotify()
-}
-
-// The HandlerFunc type is an adapter to allow the use of
-// ordinary functions as HTTP handlers.  If f is a function
-// with the appropriate signature, HandlerFunc(f) is a
-// Handler object that calls f.
-type HandlerFunc func(ResponseWriter, *Request)
-
-// ServeHTTP calls f(w, r).
-func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
-	f(w, r)
-}
-
-// Helper handlers
-
-// Error replies to the request with the specified error message and HTTP code.
-// The error message should be plain text.
-func Error(w ResponseWriter, error string, code int) {
-	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
-	w.WriteHeader(code)
-	fmt.Fprintln(w, error)
-}
-
-// NotFound replies to the request with an HTTP 404 not found error.
-func NotFound(w ResponseWriter, r *Request) { Error(w, "404 page not found", StatusNotFound) }
-
-// NotFoundHandler returns a simple request handler
-// that replies to each request with a ``404 page not found'' reply.
-func NotFoundHandler() Handler { return HandlerFunc(NotFound) }
-
-// StripPrefix returns a handler that serves HTTP requests
-// by removing the given prefix from the request URL's Path
-// and invoking the handler h. StripPrefix handles a
-// request for a path that doesn't begin with prefix by
-// replying with an HTTP 404 not found error.
-func StripPrefix(prefix string, h Handler) Handler {
-	if prefix == "" {
-		return h
-	}
-	return HandlerFunc(func(w ResponseWriter, r *Request) {
-		if p := strings.TrimPrefix(r.URL.Path, prefix); len(p) < len(r.URL.Path) {
-			r.URL.Path = p
-			h.ServeHTTP(w, r)
-		} else {
-			NotFound(w, r)
-		}
-	})
-}
-
-// Redirect replies to the request with a redirect to url,
-// which may be a path relative to the request path.
-func Redirect(w ResponseWriter, r *Request, urlStr string, code int) {
-	if u, err := url.Parse(urlStr); err == nil {
-		// If url was relative, make absolute by
-		// combining with request path.
-		// The browser would probably do this for us,
-		// but doing it ourselves is more reliable.
-
-		// NOTE(rsc): RFC 2616 says that the Location
-		// line must be an absolute URI, like
-		// "http://www.google.com/redirect/",
-		// not a path like "/redirect/".
-		// Unfortunately, we don't know what to
-		// put in the host name section to get the
-		// client to connect to us again, so we can't
-		// know the right absolute URI to send back.
-		// Because of this problem, no one pays attention
-		// to the RFC; they all send back just a new path.
-		// So do we.
-		oldpath := r.URL.Path
-		if oldpath == "" { // should not happen, but avoid a crash if it does
-			oldpath = "/"
-		}
-		if u.Scheme == "" {
-			// no leading http://server
-			if urlStr == "" || urlStr[0] != '/' {
-				// make relative path absolute
-				olddir, _ := path.Split(oldpath)
-				urlStr = olddir + urlStr
-			}
-
-			var query string
-			if i := strings.Index(urlStr, "?"); i != -1 {
-				urlStr, query = urlStr[:i], urlStr[i:]
-			}
-
-			// clean up but preserve trailing slash
-			trailing := strings.HasSuffix(urlStr, "/")
-			urlStr = path.Clean(urlStr)
-			if trailing && !strings.HasSuffix(urlStr, "/") {
-				urlStr += "/"
-			}
-			urlStr += query
-		}
-	}
-
-	w.Header().Set("Location", urlStr)
-	w.WriteHeader(code)
-
-	// RFC2616 recommends that a short note "SHOULD" be included in the
-	// response because older user agents may not understand 301/307.
-	// Shouldn't send the response for POST or HEAD; that leaves GET.
-	if r.Method == "GET" {
-		note := "<a href=\"" + htmlEscape(urlStr) + "\">" + statusText[code] + "</a>.\n"
-		fmt.Fprintln(w, note)
-	}
-}
-
-var htmlReplacer = strings.NewReplacer(
-	"&", "&amp;",
-	"<", "&lt;",
-	">", "&gt;",
-	// "&#34;" is shorter than "&quot;".
-	`"`, "&#34;",
-	// "&#39;" is shorter than "&apos;" and apos was not in HTML until HTML5.
-	"'", "&#39;",
-)
-
-func htmlEscape(s string) string {
-	return htmlReplacer.Replace(s)
-}
-
-// Redirect to a fixed URL
-type redirectHandler struct {
-	url  string
-	code int
-}
-
-func (rh *redirectHandler) ServeHTTP(w ResponseWriter, r *Request) {
-	Redirect(w, r, rh.url, rh.code)
-}
-
-// RedirectHandler returns a request handler that redirects
-// each request it receives to the given url using the given
-// status code.
-func RedirectHandler(url string, code int) Handler {
-	return &redirectHandler{url, code}
-}
-
-// ServeMux is an HTTP request multiplexer.
-// It matches the URL of each incoming request against a list of registered
-// patterns and calls the handler for the pattern that
-// most closely matches the URL.
-//
-// Patterns name fixed, rooted paths, like "/favicon.ico",
-// or rooted subtrees, like "/images/" (note the trailing slash).
-// Longer patterns take precedence over shorter ones, so that
-// if there are handlers registered for both "/images/"
-// and "/images/thumbnails/", the latter handler will be
-// called for paths beginning "/images/thumbnails/" and the
-// former will receive requests for any other paths in the
-// "/images/" subtree.
-//
-// Note that since a pattern ending in a slash names a rooted subtree,
-// the pattern "/" matches all paths not matched by other registered
-// patterns, not just the URL with Path == "/".
-//
-// Patterns may optionally begin with a host name, restricting matches to
-// URLs on that host only.  Host-specific patterns take precedence over
-// general patterns, so that a handler might register for the two patterns
-// "/codesearch" and "codesearch.google.com/" without also taking over
-// requests for "http://www.google.com/".
-//
-// ServeMux also takes care of sanitizing the URL request path,
-// redirecting any request containing . or .. elements to an
-// equivalent .- and ..-free URL.
-type ServeMux struct {
-	mu    sync.RWMutex
-	m     map[string]muxEntry
-	hosts bool // whether any patterns contain hostnames
-}
-
-type muxEntry struct {
-	explicit bool
-	h        Handler
-	pattern  string
-}
-
-// NewServeMux allocates and returns a new ServeMux.
-func NewServeMux() *ServeMux { return &ServeMux{m: make(map[string]muxEntry)} }
-
-// DefaultServeMux is the default ServeMux used by Serve.
-var DefaultServeMux = NewServeMux()
-
-// Does path match pattern?
-func pathMatch(pattern, path string) bool {
-	if len(pattern) == 0 {
-		// should not happen
-		return false
-	}
-	n := len(pattern)
-	if pattern[n-1] != '/' {
-		return pattern == path
-	}
-	return len(path) >= n && path[0:n] == pattern
-}
-
-// Return the canonical path for p, eliminating . and .. elements.
-func cleanPath(p string) string {
-	if p == "" {
-		return "/"
-	}
-	if p[0] != '/' {
-		p = "/" + p
-	}
-	np := path.Clean(p)
-	// path.Clean removes trailing slash except for root;
-	// put the trailing slash back if necessary.
-	if p[len(p)-1] == '/' && np != "/" {
-		np += "/"
-	}
-	return np
-}
-
-// Find a handler on a handler map given a path string
-// Most-specific (longest) pattern wins
-func (mux *ServeMux) match(path string) (h Handler, pattern string) {
-	var n = 0
-	for k, v := range mux.m {
-		if !pathMatch(k, path) {
-			continue
-		}
-		if h == nil || len(k) > n {
-			n = len(k)
-			h = v.h
-			pattern = v.pattern
-		}
-	}
-	return
-}
-
-// Handler returns the handler to use for the given request,
-// consulting r.Method, r.Host, and r.URL.Path. It always returns
-// a non-nil handler. If the path is not in its canonical form, the
-// handler will be an internally-generated handler that redirects
-// to the canonical path.
-//
-// Handler also returns the registered pattern that matches the
-// request or, in the case of internally-generated redirects,
-// the pattern that will match after following the redirect.
-//
-// If there is no registered handler that applies to the request,
-// Handler returns a ``page not found'' handler and an empty pattern.
-func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
-	if r.Method != "CONNECT" {
-		if p := cleanPath(r.URL.Path); p != r.URL.Path {
-			_, pattern = mux.handler(r.Host, p)
-			url := *r.URL
-			url.Path = p
-			return RedirectHandler(url.String(), StatusMovedPermanently), pattern
-		}
-	}
-
-	return mux.handler(r.Host, r.URL.Path)
-}
-
-// handler is the main implementation of Handler.
-// The path is known to be in canonical form, except for CONNECT methods.
-func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
-	mux.mu.RLock()
-	defer mux.mu.RUnlock()
-
-	// Host-specific pattern takes precedence over generic ones
-	if mux.hosts {
-		h, pattern = mux.match(host + path)
-	}
-	if h == nil {
-		h, pattern = mux.match(path)
-	}
-	if h == nil {
-		h, pattern = NotFoundHandler(), ""
-	}
-	return
-}
-
-// ServeHTTP dispatches the request to the handler whose
-// pattern most closely matches the request URL.
-func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
-	if r.RequestURI == "*" {
-		if r.ProtoAtLeast(1, 1) {
-			w.Header().Set("Connection", "close")
-		}
-		w.WriteHeader(StatusBadRequest)
-		return
-	}
-	h, _ := mux.Handler(r)
-	h.ServeHTTP(w, r)
-}
-
-// Handle registers the handler for the given pattern.
-// If a handler already exists for pattern, Handle panics.
-func (mux *ServeMux) Handle(pattern string, handler Handler) {
-	mux.mu.Lock()
-	defer mux.mu.Unlock()
-
-	if pattern == "" {
-		panic("http: invalid pattern " + pattern)
-	}
-	if handler == nil {
-		panic("http: nil handler")
-	}
-	if mux.m[pattern].explicit {
-		panic("http: multiple registrations for " + pattern)
-	}
-
-	mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}
-
-	if pattern[0] != '/' {
-		mux.hosts = true
-	}
-
-	// Helpful behavior:
-	// If pattern is /tree/, insert an implicit permanent redirect for /tree.
-	// It can be overridden by an explicit registration.
-	n := len(pattern)
-	if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit {
-		// If pattern contains a host name, strip it and use remaining
-		// path for redirect.
-		path := pattern
-		if pattern[0] != '/' {
-			// In pattern, at least the last character is a '/', so
-			// strings.Index can't be -1.
-			path = pattern[strings.Index(pattern, "/"):]
-		}
-		mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(path, StatusMovedPermanently), pattern: pattern}
-	}
-}
-
-// HandleFunc registers the handler function for the given pattern.
-func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
-	mux.Handle(pattern, HandlerFunc(handler))
-}
-
-// Handle registers the handler for the given pattern
-// in the DefaultServeMux.
-// The documentation for ServeMux explains how patterns are matched.
-func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
-
-// HandleFunc registers the handler function for the given pattern
-// in the DefaultServeMux.
-// The documentation for ServeMux explains how patterns are matched.
-func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
-	DefaultServeMux.HandleFunc(pattern, handler)
-}
-
-// Serve accepts incoming HTTP connections on the listener l,
-// creating a new service goroutine for each.  The service goroutines
-// read requests and then call handler to reply to them.
-// Handler is typically nil, in which case the DefaultServeMux is used.
-func Serve(l net.Listener, handler Handler) error {
-	srv := &Server{Handler: handler}
-	return srv.Serve(l)
-}
-
-// A Server defines parameters for running an HTTP server.
-// The zero value for Server is a valid configuration.
-type Server struct {
-	Addr           string        // TCP address to listen on, ":http" if empty
-	Handler        Handler       // handler to invoke, http.DefaultServeMux if nil
-	ReadTimeout    time.Duration // maximum duration before timing out read of the request
-	WriteTimeout   time.Duration // maximum duration before timing out write of the response
-	MaxHeaderBytes int           // maximum size of request headers, DefaultMaxHeaderBytes if 0
-	TLSConfig      *tls.Config   // optional TLS config, used by ListenAndServeTLS
-
-	// TLSNextProto optionally specifies a function to take over
-	// ownership of the provided TLS connection when an NPN
-	// protocol upgrade has occurred.  The map key is the protocol
-	// name negotiated. The Handler argument should be used to
-	// handle HTTP requests and will initialize the Request's TLS
-	// and RemoteAddr if not already set.  The connection is
-	// automatically closed when the function returns.
-	TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
-
-	// ConnState specifies an optional callback function that is
-	// called when a client connection changes state. See the
-	// ConnState type and associated constants for details.
-	ConnState func(net.Conn, ConnState)
-
-	// ErrorLog specifies an optional logger for errors accepting
-	// connections and unexpected behavior from handlers.
-	// If nil, logging goes to os.Stderr via the log package's
-	// standard logger.
-	ErrorLog *log.Logger
-
-	disableKeepAlives int32 // accessed atomically.
-}
-
-// A ConnState represents the state of a client connection to a server.
-// It's used by the optional Server.ConnState hook.
-type ConnState int
-
-const (
-	// StateNew represents a new connection that is expected to
-	// send a request immediately. Connections begin at this
-	// state and then transition to either StateActive or
-	// StateClosed.
-	StateNew ConnState = iota
-
-	// StateActive represents a connection that has read 1 or more
-	// bytes of a request. The Server.ConnState hook for
-	// StateActive fires before the request has entered a handler
-	// and doesn't fire again until the request has been
-	// handled. After the request is handled, the state
-	// transitions to StateClosed, StateHijacked, or StateIdle.
-	StateActive
-
-	// StateIdle represents a connection that has finished
-	// handling a request and is in the keep-alive state, waiting
-	// for a new request. Connections transition from StateIdle
-	// to either StateActive or StateClosed.
-	StateIdle
-
-	// StateHijacked represents a hijacked connection.
-	// This is a terminal state. It does not transition to StateClosed.
-	StateHijacked
-
-	// StateClosed represents a closed connection.
-	// This is a terminal state. Hijacked connections do not
-	// transition to StateClosed.
-	StateClosed
-)
-
-var stateName = map[ConnState]string{
-	StateNew:      "new",
-	StateActive:   "active",
-	StateIdle:     "idle",
-	StateHijacked: "hijacked",
-	StateClosed:   "closed",
-}
-
-func (c ConnState) String() string {
-	return stateName[c]
-}
-
-// serverHandler delegates to either the server's Handler or
-// DefaultServeMux and also handles "OPTIONS *" requests.
-type serverHandler struct {
-	srv *Server
-}
-
-func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
-	handler := sh.srv.Handler
-	if handler == nil {
-		handler = DefaultServeMux
-	}
-	if req.RequestURI == "*" && req.Method == "OPTIONS" {
-		handler = globalOptionsHandler{}
-	}
-	handler.ServeHTTP(rw, req)
-}
-
-// ListenAndServe listens on the TCP network address srv.Addr and then
-// calls Serve to handle requests on incoming connections.  If
-// srv.Addr is blank, ":http" is used.
-func (srv *Server) ListenAndServe() error {
-	addr := srv.Addr
-	if addr == "" {
-		addr = ":http"
-	}
-	ln, err := net.Listen("tcp", addr)
-	if err != nil {
-		return err
-	}
-	return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
-}
-
-// Serve accepts incoming connections on the Listener l, creating a
-// new service goroutine for each.  The service goroutines read requests and
-// then call srv.Handler to reply to them.
-func (srv *Server) Serve(l net.Listener) error {
-	defer l.Close()
-	var tempDelay time.Duration // how long to sleep on accept failure
-	for {
-		rw, e := l.Accept()
-		if e != nil {
-			if ne, ok := e.(net.Error); ok && ne.Temporary() {
-				if tempDelay == 0 {
-					tempDelay = 5 * time.Millisecond
-				} else {
-					tempDelay *= 2
-				}
-				if max := 1 * time.Second; tempDelay > max {
-					tempDelay = max
-				}
-				srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
-				time.Sleep(tempDelay)
-				continue
-			}
-			return e
-		}
-		tempDelay = 0
-		c, err := srv.newConn(rw)
-		if err != nil {
-			continue
-		}
-		c.setState(c.rwc, StateNew) // before Serve can return
-		go c.serve()
-	}
-}
-
-func (s *Server) doKeepAlives() bool {
-	return atomic.LoadInt32(&s.disableKeepAlives) == 0
-}
-
-// SetKeepAlivesEnabled controls whether HTTP keep-alives are enabled.
-// By default, keep-alives are always enabled. Only very
-// resource-constrained environments or servers in the process of
-// shutting down should disable them.
-func (s *Server) SetKeepAlivesEnabled(v bool) {
-	if v {
-		atomic.StoreInt32(&s.disableKeepAlives, 0)
-	} else {
-		atomic.StoreInt32(&s.disableKeepAlives, 1)
-	}
-}
-
-func (s *Server) logf(format string, args ...interface{}) {
-	if s.ErrorLog != nil {
-		s.ErrorLog.Printf(format, args...)
-	} else {
-		log.Printf(format, args...)
-	}
-}
-
-// ListenAndServe listens on the TCP network address addr
-// and then calls Serve with handler to handle requests
-// on incoming connections.  Handler is typically nil,
-// in which case the DefaultServeMux is used.
-//
-// A trivial example server is:
-//
-//	package main
-//
-//	import (
-//		"io"
-//		"net/http"
-//		"log"
-//	)
-//
-//	// hello world, the web server
-//	func HelloServer(w http.ResponseWriter, req *http.Request) {
-//		io.WriteString(w, "hello, world!\n")
-//	}
-//
-//	func main() {
-//		http.HandleFunc("/hello", HelloServer)
-//		err := http.ListenAndServe(":12345", nil)
-//		if err != nil {
-//			log.Fatal("ListenAndServe: ", err)
-//		}
-//	}
-func ListenAndServe(addr string, handler Handler) error {
-	server := &Server{Addr: addr, Handler: handler}
-	return server.ListenAndServe()
-}
-
-// ListenAndServeTLS acts identically to ListenAndServe, except that it
-// expects HTTPS connections. Additionally, files containing a certificate and
-// matching private key for the server must be provided. If the certificate
-// is signed by a certificate authority, the certFile should be the concatenation
-// of the server's certificate followed by the CA's certificate.
-//
-// A trivial example server is:
-//
-//	import (
-//		"log"
-//		"net/http"
-//	)
-//
-//	func handler(w http.ResponseWriter, req *http.Request) {
-//		w.Header().Set("Content-Type", "text/plain")
-//		w.Write([]byte("This is an example server.\n"))
-//	}
-//
-//	func main() {
-//		http.HandleFunc("/", handler)
-//		log.Printf("About to listen on 10443. Go to https://127.0.0.1:10443/")
-//		err := http.ListenAndServeTLS(":10443", "cert.pem", "key.pem", nil)
-//		if err != nil {
-//			log.Fatal(err)
-//		}
-//	}
-//
-// One can use generate_cert.go in crypto/tls to generate cert.pem and key.pem.
-func ListenAndServeTLS(addr string, certFile string, keyFile string, handler Handler) error {
-	server := &Server{Addr: addr, Handler: handler}
-	return server.ListenAndServeTLS(certFile, keyFile)
-}
-
-// ListenAndServeTLS listens on the TCP network address srv.Addr and
-// then calls Serve to handle requests on incoming TLS connections.
-//
-// Filenames containing a certificate and matching private key for
-// the server must be provided. If the certificate is signed by a
-// certificate authority, the certFile should be the concatenation
-// of the server's certificate followed by the CA's certificate.
-//
-// If srv.Addr is blank, ":https" is used.
-func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error {
-	addr := srv.Addr
-	if addr == "" {
-		addr = ":https"
-	}
-	config := &tls.Config{}
-	if srv.TLSConfig != nil {
-		*config = *srv.TLSConfig
-	}
-	if config.NextProtos == nil {
-		config.NextProtos = []string{"http/1.1"}
-	}
-
-	var err error
-	config.Certificates = make([]tls.Certificate, 1)
-	config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
-	if err != nil {
-		return err
-	}
-
-	ln, err := net.Listen("tcp", addr)
-	if err != nil {
-		return err
-	}
-
-	tlsListener := tls.NewListener(tcpKeepAliveListener{ln.(*net.TCPListener)}, config)
-	return srv.Serve(tlsListener)
-}
-
-// TimeoutHandler returns a Handler that runs h with the given time limit.
-//
-// The new Handler calls h.ServeHTTP to handle each request, but if a
-// call runs for longer than its time limit, the handler responds with
-// a 503 Service Unavailable error and the given message in its body.
-// (If msg is empty, a suitable default message will be sent.)
-// After such a timeout, writes by h to its ResponseWriter will return
-// ErrHandlerTimeout.
-func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler {
-	f := func() <-chan time.Time {
-		return time.After(dt)
-	}
-	return &timeoutHandler{h, f, msg}
-}
-
-// ErrHandlerTimeout is returned on ResponseWriter Write calls
-// in handlers which have timed out.
-var ErrHandlerTimeout = errors.New("http: Handler timeout")
-
-type timeoutHandler struct {
-	handler Handler
-	timeout func() <-chan time.Time // returns channel producing a timeout
-	body    string
-}
-
-func (h *timeoutHandler) errorBody() string {
-	if h.body != "" {
-		return h.body
-	}
-	return "<html><head><title>Timeout</title></head><body><h1>Timeout</h1></body></html>"
-}
-
-func (h *timeoutHandler) ServeHTTP(w ResponseWriter, r *Request) {
-	done := make(chan bool, 1)
-	tw := &timeoutWriter{w: w}
-	go func() {
-		h.handler.ServeHTTP(tw, r)
-		done <- true
-	}()
-	select {
-	case <-done:
-		return
-	case <-h.timeout():
-		tw.mu.Lock()
-		defer tw.mu.Unlock()
-		if !tw.wroteHeader {
-			tw.w.WriteHeader(StatusServiceUnavailable)
-			tw.w.Write([]byte(h.errorBody()))
-		}
-		tw.timedOut = true
-	}
-}
-
-type timeoutWriter struct {
-	w ResponseWriter
-
-	mu          sync.Mutex
-	timedOut    bool
-	wroteHeader bool
-}
-
-func (tw *timeoutWriter) Header() Header {
-	return tw.w.Header()
-}
-
-func (tw *timeoutWriter) Write(p []byte) (int, error) {
-	tw.mu.Lock()
-	timedOut := tw.timedOut
-	tw.mu.Unlock()
-	if timedOut {
-		return 0, ErrHandlerTimeout
-	}
-	return tw.w.Write(p)
-}
-
-func (tw *timeoutWriter) WriteHeader(code int) {
-	tw.mu.Lock()
-	if tw.timedOut || tw.wroteHeader {
-		tw.mu.Unlock()
-		return
-	}
-	tw.wroteHeader = true
-	tw.mu.Unlock()
-	tw.w.WriteHeader(code)
-}
-
-// tcpKeepAliveListener sets TCP keep-alive timeouts on accepted
-// connections. It's used by ListenAndServe and ListenAndServeTLS so
-// dead TCP connections (e.g. closing laptop mid-download) eventually
-// go away.
-type tcpKeepAliveListener struct {
-	*net.TCPListener
-}
-
-func (ln tcpKeepAliveListener) Accept() (c net.Conn, err error) {
-	tc, err := ln.AcceptTCP()
-	if err != nil {
-		return
-	}
-	tc.SetKeepAlive(true)
-	tc.SetKeepAlivePeriod(3 * time.Minute)
-	return tc, nil
-}
-
-// globalOptionsHandler responds to "OPTIONS *" requests.
-type globalOptionsHandler struct{}
-
-func (globalOptionsHandler) ServeHTTP(w ResponseWriter, r *Request) {
-	w.Header().Set("Content-Length", "0")
-	if r.ContentLength != 0 {
-		// Read up to 4KB of OPTIONS body (as mentioned in the
-		// spec as being reserved for future use), but anything
-		// over that is considered a waste of server resources
-		// (or an attack) and we abort and close the connection,
-		// courtesy of MaxBytesReader's EOF behavior.
-		mb := MaxBytesReader(w, r.Body, 4<<10)
-		io.Copy(ioutil.Discard, mb)
-	}
-}
-
-type eofReaderWithWriteTo struct{}
-
-func (eofReaderWithWriteTo) WriteTo(io.Writer) (int64, error) { return 0, nil }
-func (eofReaderWithWriteTo) Read([]byte) (int, error)         { return 0, io.EOF }
-
-// eofReader is a non-nil io.ReadCloser that always returns EOF.
-// It has a WriteTo method so io.Copy won't need a buffer.
-var eofReader = &struct {
-	eofReaderWithWriteTo
-	io.Closer
-}{
-	eofReaderWithWriteTo{},
-	ioutil.NopCloser(nil),
-}
-
-// Verify that an io.Copy from an eofReader won't require a buffer.
-var _ io.WriterTo = eofReader
-
-// initNPNRequest is an HTTP handler that initializes certain
-// uninitialized fields in its *Request. Such partially-initialized
-// Requests come from NPN protocol handlers.
-type initNPNRequest struct {
-	c *tls.Conn
-	h serverHandler
-}
-
-func (h initNPNRequest) ServeHTTP(rw ResponseWriter, req *Request) {
-	if req.TLS == nil {
-		req.TLS = &tls.ConnectionState{}
-		*req.TLS = h.c.ConnectionState()
-	}
-	if req.Body == nil {
-		req.Body = eofReader
-	}
-	if req.RemoteAddr == "" {
-		req.RemoteAddr = h.c.RemoteAddr().String()
-	}
-	h.h.ServeHTTP(rw, req)
-}
-
-// loggingConn is used for debugging.
-type loggingConn struct {
-	name string
-	net.Conn
-}
-
-var (
-	uniqNameMu   sync.Mutex
-	uniqNameNext = make(map[string]int)
-)
-
-func newLoggingConn(baseName string, c net.Conn) net.Conn {
-	uniqNameMu.Lock()
-	defer uniqNameMu.Unlock()
-	uniqNameNext[baseName]++
-	return &loggingConn{
-		name: fmt.Sprintf("%s-%d", baseName, uniqNameNext[baseName]),
-		Conn: c,
-	}
-}
-
-func (c *loggingConn) Write(p []byte) (n int, err error) {
-	log.Printf("%s.Write(%d) = ....", c.name, len(p))
-	n, err = c.Conn.Write(p)
-	log.Printf("%s.Write(%d) = %d, %v", c.name, len(p), n, err)
-	return
-}
-
-func (c *loggingConn) Read(p []byte) (n int, err error) {
-	log.Printf("%s.Read(%d) = ....", c.name, len(p))
-	n, err = c.Conn.Read(p)
-	log.Printf("%s.Read(%d) = %d, %v", c.name, len(p), n, err)
-	return
-}
-
-func (c *loggingConn) Close() (err error) {
-	log.Printf("%s.Close() = ...", c.name)
-	err = c.Conn.Close()
-	log.Printf("%s.Close() = %v", c.name, err)
-	return
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/sniff.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/sniff.go
deleted file mode 100644
index 68f519b05..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/sniff.go
+++ /dev/null
@@ -1,214 +0,0 @@
-// Copyright 2011 The Go 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 http
-
-import (
-	"bytes"
-	"encoding/binary"
-)
-
-// The algorithm uses at most sniffLen bytes to make its decision.
-const sniffLen = 512
-
-// DetectContentType implements the algorithm described
-// at http://mimesniff.spec.whatwg.org/ to determine the
-// Content-Type of the given data.  It considers at most the
-// first 512 bytes of data.  DetectContentType always returns
-// a valid MIME type: if it cannot determine a more specific one, it
-// returns "application/octet-stream".
-func DetectContentType(data []byte) string {
-	if len(data) > sniffLen {
-		data = data[:sniffLen]
-	}
-
-	// Index of the first non-whitespace byte in data.
-	firstNonWS := 0
-	for ; firstNonWS < len(data) && isWS(data[firstNonWS]); firstNonWS++ {
-	}
-
-	for _, sig := range sniffSignatures {
-		if ct := sig.match(data, firstNonWS); ct != "" {
-			return ct
-		}
-	}
-
-	return "application/octet-stream" // fallback
-}
-
-func isWS(b byte) bool {
-	return bytes.IndexByte([]byte("\t\n\x0C\r "), b) != -1
-}
-
-type sniffSig interface {
-	// match returns the MIME type of the data, or "" if unknown.
-	match(data []byte, firstNonWS int) string
-}
-
-// Data matching the table in section 6.
-var sniffSignatures = []sniffSig{
-	htmlSig("<!DOCTYPE HTML"),
-	htmlSig("<HTML"),
-	htmlSig("<HEAD"),
-	htmlSig("<SCRIPT"),
-	htmlSig("<IFRAME"),
-	htmlSig("<H1"),
-	htmlSig("<DIV"),
-	htmlSig("<FONT"),
-	htmlSig("<TABLE"),
-	htmlSig("<A"),
-	htmlSig("<STYLE"),
-	htmlSig("<TITLE"),
-	htmlSig("<B"),
-	htmlSig("<BODY"),
-	htmlSig("<BR"),
-	htmlSig("<P"),
-	htmlSig("<!--"),
-
-	&maskedSig{mask: []byte("\xFF\xFF\xFF\xFF\xFF"), pat: []byte("<?xml"), skipWS: true, ct: "text/xml; charset=utf-8"},
-
-	&exactSig{[]byte("%PDF-"), "application/pdf"},
-	&exactSig{[]byte("%!PS-Adobe-"), "application/postscript"},
-
-	// UTF BOMs.
-	&maskedSig{mask: []byte("\xFF\xFF\x00\x00"), pat: []byte("\xFE\xFF\x00\x00"), ct: "text/plain; charset=utf-16be"},
-	&maskedSig{mask: []byte("\xFF\xFF\x00\x00"), pat: []byte("\xFF\xFE\x00\x00"), ct: "text/plain; charset=utf-16le"},
-	&maskedSig{mask: []byte("\xFF\xFF\xFF\x00"), pat: []byte("\xEF\xBB\xBF\x00"), ct: "text/plain; charset=utf-8"},
-
-	&exactSig{[]byte("GIF87a"), "image/gif"},
-	&exactSig{[]byte("GIF89a"), "image/gif"},
-	&exactSig{[]byte("\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"), "image/png"},
-	&exactSig{[]byte("\xFF\xD8\xFF"), "image/jpeg"},
-	&exactSig{[]byte("BM"), "image/bmp"},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF"),
-		pat:  []byte("RIFF\x00\x00\x00\x00WEBPVP"),
-		ct:   "image/webp",
-	},
-	&exactSig{[]byte("\x00\x00\x01\x00"), "image/vnd.microsoft.icon"},
-	&exactSig{[]byte("\x4F\x67\x67\x53\x00"), "application/ogg"},
-	&maskedSig{
-		mask: []byte("\xFF\xFF\xFF\xFF\x00\x00\x00\x00\xFF\xFF\xFF\xFF"),
-		pat:  []byte("RIFF\x00\x00\x00\x00WAVE"),
-		ct:   "audio/wave",
-	},
-	&exactSig{[]byte("\x1A\x45\xDF\xA3"), "video/webm"},
-	&exactSig{[]byte("\x52\x61\x72\x20\x1A\x07\x00"), "application/x-rar-compressed"},
-	&exactSig{[]byte("\x50\x4B\x03\x04"), "application/zip"},
-	&exactSig{[]byte("\x1F\x8B\x08"), "application/x-gzip"},
-
-	// TODO(dsymonds): Re-enable this when the spec is sorted w.r.t. MP4.
-	//mp4Sig(0),
-
-	textSig(0), // should be last
-}
-
-type exactSig struct {
-	sig []byte
-	ct  string
-}
-
-func (e *exactSig) match(data []byte, firstNonWS int) string {
-	if bytes.HasPrefix(data, e.sig) {
-		return e.ct
-	}
-	return ""
-}
-
-type maskedSig struct {
-	mask, pat []byte
-	skipWS    bool
-	ct        string
-}
-
-func (m *maskedSig) match(data []byte, firstNonWS int) string {
-	if m.skipWS {
-		data = data[firstNonWS:]
-	}
-	if len(data) < len(m.mask) {
-		return ""
-	}
-	for i, mask := range m.mask {
-		db := data[i] & mask
-		if db != m.pat[i] {
-			return ""
-		}
-	}
-	return m.ct
-}
-
-type htmlSig []byte
-
-func (h htmlSig) match(data []byte, firstNonWS int) string {
-	data = data[firstNonWS:]
-	if len(data) < len(h)+1 {
-		return ""
-	}
-	for i, b := range h {
-		db := data[i]
-		if 'A' <= b && b <= 'Z' {
-			db &= 0xDF
-		}
-		if b != db {
-			return ""
-		}
-	}
-	// Next byte must be space or right angle bracket.
-	if db := data[len(h)]; db != ' ' && db != '>' {
-		return ""
-	}
-	return "text/html; charset=utf-8"
-}
-
-type mp4Sig int
-
-func (mp4Sig) match(data []byte, firstNonWS int) string {
-	// c.f. section 6.1.
-	if len(data) < 8 {
-		return ""
-	}
-	boxSize := int(binary.BigEndian.Uint32(data[:4]))
-	if boxSize%4 != 0 || len(data) < boxSize {
-		return ""
-	}
-	if !bytes.Equal(data[4:8], []byte("ftyp")) {
-		return ""
-	}
-	for st := 8; st < boxSize; st += 4 {
-		if st == 12 {
-			// minor version number
-			continue
-		}
-		seg := string(data[st : st+3])
-		switch seg {
-		case "mp4", "iso", "M4V", "M4P", "M4B":
-			return "video/mp4"
-			/* The remainder are not in the spec.
-			case "M4A":
-				return "audio/mp4"
-			case "3gp":
-				return "video/3gpp"
-			case "jp2":
-				return "image/jp2" // JPEG 2000
-			*/
-		}
-	}
-	return ""
-}
-
-type textSig int
-
-func (textSig) match(data []byte, firstNonWS int) string {
-	// c.f. section 5, step 4.
-	for _, b := range data[firstNonWS:] {
-		switch {
-		case 0x00 <= b && b <= 0x08,
-			b == 0x0B,
-			0x0E <= b && b <= 0x1A,
-			0x1C <= b && b <= 0x1F:
-			return ""
-		}
-	}
-	return "text/plain; charset=utf-8"
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/status.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/status.go
deleted file mode 100644
index d253bd5cb..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/status.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright 2009 The Go 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 http
-
-// HTTP status codes, defined in RFC 2616.
-const (
-	StatusContinue           = 100
-	StatusSwitchingProtocols = 101
-
-	StatusOK                   = 200
-	StatusCreated              = 201
-	StatusAccepted             = 202
-	StatusNonAuthoritativeInfo = 203
-	StatusNoContent            = 204
-	StatusResetContent         = 205
-	StatusPartialContent       = 206
-
-	StatusMultipleChoices   = 300
-	StatusMovedPermanently  = 301
-	StatusFound             = 302
-	StatusSeeOther          = 303
-	StatusNotModified       = 304
-	StatusUseProxy          = 305
-	StatusTemporaryRedirect = 307
-
-	StatusBadRequest                   = 400
-	StatusUnauthorized                 = 401
-	StatusPaymentRequired              = 402
-	StatusForbidden                    = 403
-	StatusNotFound                     = 404
-	StatusMethodNotAllowed             = 405
-	StatusNotAcceptable                = 406
-	StatusProxyAuthRequired            = 407
-	StatusRequestTimeout               = 408
-	StatusConflict                     = 409
-	StatusGone                         = 410
-	StatusLengthRequired               = 411
-	StatusPreconditionFailed           = 412
-	StatusRequestEntityTooLarge        = 413
-	StatusRequestURITooLong            = 414
-	StatusUnsupportedMediaType         = 415
-	StatusRequestedRangeNotSatisfiable = 416
-	StatusExpectationFailed            = 417
-	StatusTeapot                       = 418
-
-	StatusInternalServerError     = 500
-	StatusNotImplemented          = 501
-	StatusBadGateway              = 502
-	StatusServiceUnavailable      = 503
-	StatusGatewayTimeout          = 504
-	StatusHTTPVersionNotSupported = 505
-
-	// New HTTP status codes from RFC 6585. Not exported yet in Go 1.1.
-	// See discussion at https://codereview.appspot.com/7678043/
-	statusPreconditionRequired          = 428
-	statusTooManyRequests               = 429
-	statusRequestHeaderFieldsTooLarge   = 431
-	statusNetworkAuthenticationRequired = 511
-)
-
-var statusText = map[int]string{
-	StatusContinue:           "Continue",
-	StatusSwitchingProtocols: "Switching Protocols",
-
-	StatusOK:                   "OK",
-	StatusCreated:              "Created",
-	StatusAccepted:             "Accepted",
-	StatusNonAuthoritativeInfo: "Non-Authoritative Information",
-	StatusNoContent:            "No Content",
-	StatusResetContent:         "Reset Content",
-	StatusPartialContent:       "Partial Content",
-
-	StatusMultipleChoices:   "Multiple Choices",
-	StatusMovedPermanently:  "Moved Permanently",
-	StatusFound:             "Found",
-	StatusSeeOther:          "See Other",
-	StatusNotModified:       "Not Modified",
-	StatusUseProxy:          "Use Proxy",
-	StatusTemporaryRedirect: "Temporary Redirect",
-
-	StatusBadRequest:                   "Bad Request",
-	StatusUnauthorized:                 "Unauthorized",
-	StatusPaymentRequired:              "Payment Required",
-	StatusForbidden:                    "Forbidden",
-	StatusNotFound:                     "Not Found",
-	StatusMethodNotAllowed:             "Method Not Allowed",
-	StatusNotAcceptable:                "Not Acceptable",
-	StatusProxyAuthRequired:            "Proxy Authentication Required",
-	StatusRequestTimeout:               "Request Timeout",
-	StatusConflict:                     "Conflict",
-	StatusGone:                         "Gone",
-	StatusLengthRequired:               "Length Required",
-	StatusPreconditionFailed:           "Precondition Failed",
-	StatusRequestEntityTooLarge:        "Request Entity Too Large",
-	StatusRequestURITooLong:            "Request URI Too Long",
-	StatusUnsupportedMediaType:         "Unsupported Media Type",
-	StatusRequestedRangeNotSatisfiable: "Requested Range Not Satisfiable",
-	StatusExpectationFailed:            "Expectation Failed",
-	StatusTeapot:                       "I'm a teapot",
-
-	StatusInternalServerError:     "Internal Server Error",
-	StatusNotImplemented:          "Not Implemented",
-	StatusBadGateway:              "Bad Gateway",
-	StatusServiceUnavailable:      "Service Unavailable",
-	StatusGatewayTimeout:          "Gateway Timeout",
-	StatusHTTPVersionNotSupported: "HTTP Version Not Supported",
-
-	statusPreconditionRequired:          "Precondition Required",
-	statusTooManyRequests:               "Too Many Requests",
-	statusRequestHeaderFieldsTooLarge:   "Request Header Fields Too Large",
-	statusNetworkAuthenticationRequired: "Network Authentication Required",
-}
-
-// StatusText returns a text for the HTTP status code. It returns the empty
-// string if the code is unknown.
-func StatusText(code int) string {
-	return statusText[code]
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/transfer.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/transfer.go
deleted file mode 100644
index 7f6368652..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/transfer.go
+++ /dev/null
@@ -1,730 +0,0 @@
-// Copyright 2009 The Go 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 http
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/textproto"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-)
-
-type errorReader struct {
-	err error
-}
-
-func (r *errorReader) Read(p []byte) (n int, err error) {
-	return 0, r.err
-}
-
-// transferWriter inspects the fields of a user-supplied Request or Response,
-// sanitizes them without changing the user object and provides methods for
-// writing the respective header, body and trailer in wire format.
-type transferWriter struct {
-	Method           string
-	Body             io.Reader
-	BodyCloser       io.Closer
-	ResponseToHEAD   bool
-	ContentLength    int64 // -1 means unknown, 0 means exactly none
-	Close            bool
-	TransferEncoding []string
-	Trailer          Header
-}
-
-func newTransferWriter(r interface{}) (t *transferWriter, err error) {
-	t = &transferWriter{}
-
-	// Extract relevant fields
-	atLeastHTTP11 := false
-	switch rr := r.(type) {
-	case *Request:
-		if rr.ContentLength != 0 && rr.Body == nil {
-			return nil, fmt.Errorf("http: Request.ContentLength=%d with nil Body", rr.ContentLength)
-		}
-		t.Method = rr.Method
-		t.Body = rr.Body
-		t.BodyCloser = rr.Body
-		t.ContentLength = rr.ContentLength
-		t.Close = rr.Close
-		t.TransferEncoding = rr.TransferEncoding
-		t.Trailer = rr.Trailer
-		atLeastHTTP11 = rr.ProtoAtLeast(1, 1)
-		if t.Body != nil && len(t.TransferEncoding) == 0 && atLeastHTTP11 {
-			if t.ContentLength == 0 {
-				// Test to see if it's actually zero or just unset.
-				var buf [1]byte
-				n, rerr := io.ReadFull(t.Body, buf[:])
-				if rerr != nil && rerr != io.EOF {
-					t.ContentLength = -1
-					t.Body = &errorReader{rerr}
-				} else if n == 1 {
-					// Oh, guess there is data in this Body Reader after all.
-					// The ContentLength field just wasn't set.
-					// Stich the Body back together again, re-attaching our
-					// consumed byte.
-					t.ContentLength = -1
-					t.Body = io.MultiReader(bytes.NewReader(buf[:]), t.Body)
-				} else {
-					// Body is actually empty.
-					t.Body = nil
-					t.BodyCloser = nil
-				}
-			}
-			if t.ContentLength < 0 {
-				t.TransferEncoding = []string{"chunked"}
-			}
-		}
-	case *Response:
-		if rr.Request != nil {
-			t.Method = rr.Request.Method
-		}
-		t.Body = rr.Body
-		t.BodyCloser = rr.Body
-		t.ContentLength = rr.ContentLength
-		t.Close = rr.Close
-		t.TransferEncoding = rr.TransferEncoding
-		t.Trailer = rr.Trailer
-		atLeastHTTP11 = rr.ProtoAtLeast(1, 1)
-		t.ResponseToHEAD = noBodyExpected(t.Method)
-	}
-
-	// Sanitize Body,ContentLength,TransferEncoding
-	if t.ResponseToHEAD {
-		t.Body = nil
-		if chunked(t.TransferEncoding) {
-			t.ContentLength = -1
-		}
-	} else {
-		if !atLeastHTTP11 || t.Body == nil {
-			t.TransferEncoding = nil
-		}
-		if chunked(t.TransferEncoding) {
-			t.ContentLength = -1
-		} else if t.Body == nil { // no chunking, no body
-			t.ContentLength = 0
-		}
-	}
-
-	// Sanitize Trailer
-	if !chunked(t.TransferEncoding) {
-		t.Trailer = nil
-	}
-
-	return t, nil
-}
-
-func noBodyExpected(requestMethod string) bool {
-	return requestMethod == "HEAD"
-}
-
-func (t *transferWriter) shouldSendContentLength() bool {
-	if chunked(t.TransferEncoding) {
-		return false
-	}
-	if t.ContentLength > 0 {
-		return true
-	}
-	// Many servers expect a Content-Length for these methods
-	if t.Method == "POST" || t.Method == "PUT" {
-		return true
-	}
-	if t.ContentLength == 0 && isIdentity(t.TransferEncoding) {
-		return true
-	}
-
-	return false
-}
-
-func (t *transferWriter) WriteHeader(w io.Writer) error {
-	if t.Close {
-		if _, err := io.WriteString(w, "Connection: close\r\n"); err != nil {
-			return err
-		}
-	}
-
-	// Write Content-Length and/or Transfer-Encoding whose values are a
-	// function of the sanitized field triple (Body, ContentLength,
-	// TransferEncoding)
-	if t.shouldSendContentLength() {
-		if _, err := io.WriteString(w, "Content-Length: "); err != nil {
-			return err
-		}
-		if _, err := io.WriteString(w, strconv.FormatInt(t.ContentLength, 10)+"\r\n"); err != nil {
-			return err
-		}
-	} else if chunked(t.TransferEncoding) {
-		if _, err := io.WriteString(w, "Transfer-Encoding: chunked\r\n"); err != nil {
-			return err
-		}
-	}
-
-	// Write Trailer header
-	if t.Trailer != nil {
-		keys := make([]string, 0, len(t.Trailer))
-		for k := range t.Trailer {
-			k = CanonicalHeaderKey(k)
-			switch k {
-			case "Transfer-Encoding", "Trailer", "Content-Length":
-				return &badStringError{"invalid Trailer key", k}
-			}
-			keys = append(keys, k)
-		}
-		if len(keys) > 0 {
-			sort.Strings(keys)
-			// TODO: could do better allocation-wise here, but trailers are rare,
-			// so being lazy for now.
-			if _, err := io.WriteString(w, "Trailer: "+strings.Join(keys, ",")+"\r\n"); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func (t *transferWriter) WriteBody(w io.Writer) error {
-	var err error
-	var ncopy int64
-
-	// Write body
-	if t.Body != nil {
-		if chunked(t.TransferEncoding) {
-			cw := newChunkedWriter(w)
-			_, err = io.Copy(cw, t.Body)
-			if err == nil {
-				err = cw.Close()
-			}
-		} else if t.ContentLength == -1 {
-			ncopy, err = io.Copy(w, t.Body)
-		} else {
-			ncopy, err = io.Copy(w, io.LimitReader(t.Body, t.ContentLength))
-			if err != nil {
-				return err
-			}
-			var nextra int64
-			nextra, err = io.Copy(ioutil.Discard, t.Body)
-			ncopy += nextra
-		}
-		if err != nil {
-			return err
-		}
-		if err = t.BodyCloser.Close(); err != nil {
-			return err
-		}
-	}
-
-	if !t.ResponseToHEAD && t.ContentLength != -1 && t.ContentLength != ncopy {
-		return fmt.Errorf("http: Request.ContentLength=%d with Body length %d",
-			t.ContentLength, ncopy)
-	}
-
-	// TODO(petar): Place trailer writer code here.
-	if chunked(t.TransferEncoding) {
-		// Write Trailer header
-		if t.Trailer != nil {
-			if err := t.Trailer.Write(w); err != nil {
-				return err
-			}
-		}
-		// Last chunk, empty trailer
-		_, err = io.WriteString(w, "\r\n")
-	}
-	return err
-}
-
-type transferReader struct {
-	// Input
-	Header        Header
-	StatusCode    int
-	RequestMethod string
-	ProtoMajor    int
-	ProtoMinor    int
-	// Output
-	Body             io.ReadCloser
-	ContentLength    int64
-	TransferEncoding []string
-	Close            bool
-	Trailer          Header
-}
-
-// bodyAllowedForStatus reports whether a given response status code
-// permits a body.  See RFC2616, section 4.4.
-func bodyAllowedForStatus(status int) bool {
-	switch {
-	case status >= 100 && status <= 199:
-		return false
-	case status == 204:
-		return false
-	case status == 304:
-		return false
-	}
-	return true
-}
-
-var (
-	suppressedHeaders304    = []string{"Content-Type", "Content-Length", "Transfer-Encoding"}
-	suppressedHeadersNoBody = []string{"Content-Length", "Transfer-Encoding"}
-)
-
-func suppressedHeaders(status int) []string {
-	switch {
-	case status == 304:
-		// RFC 2616 section 10.3.5: "the response MUST NOT include other entity-headers"
-		return suppressedHeaders304
-	case !bodyAllowedForStatus(status):
-		return suppressedHeadersNoBody
-	}
-	return nil
-}
-
-// msg is *Request or *Response.
-func readTransfer(msg interface{}, r *bufio.Reader) (err error) {
-	t := &transferReader{RequestMethod: "GET"}
-
-	// Unify input
-	isResponse := false
-	switch rr := msg.(type) {
-	case *Response:
-		t.Header = rr.Header
-		t.StatusCode = rr.StatusCode
-		t.ProtoMajor = rr.ProtoMajor
-		t.ProtoMinor = rr.ProtoMinor
-		t.Close = shouldClose(t.ProtoMajor, t.ProtoMinor, t.Header)
-		isResponse = true
-		if rr.Request != nil {
-			t.RequestMethod = rr.Request.Method
-		}
-	case *Request:
-		t.Header = rr.Header
-		t.ProtoMajor = rr.ProtoMajor
-		t.ProtoMinor = rr.ProtoMinor
-		// Transfer semantics for Requests are exactly like those for
-		// Responses with status code 200, responding to a GET method
-		t.StatusCode = 200
-	default:
-		panic("unexpected type")
-	}
-
-	// Default to HTTP/1.1
-	if t.ProtoMajor == 0 && t.ProtoMinor == 0 {
-		t.ProtoMajor, t.ProtoMinor = 1, 1
-	}
-
-	// Transfer encoding, content length
-	t.TransferEncoding, err = fixTransferEncoding(t.RequestMethod, t.Header)
-	if err != nil {
-		return err
-	}
-
-	realLength, err := fixLength(isResponse, t.StatusCode, t.RequestMethod, t.Header, t.TransferEncoding)
-	if err != nil {
-		return err
-	}
-	if isResponse && t.RequestMethod == "HEAD" {
-		if n, err := parseContentLength(t.Header.get("Content-Length")); err != nil {
-			return err
-		} else {
-			t.ContentLength = n
-		}
-	} else {
-		t.ContentLength = realLength
-	}
-
-	// Trailer
-	t.Trailer, err = fixTrailer(t.Header, t.TransferEncoding)
-	if err != nil {
-		return err
-	}
-
-	// If there is no Content-Length or chunked Transfer-Encoding on a *Response
-	// and the status is not 1xx, 204 or 304, then the body is unbounded.
-	// See RFC2616, section 4.4.
-	switch msg.(type) {
-	case *Response:
-		if realLength == -1 &&
-			!chunked(t.TransferEncoding) &&
-			bodyAllowedForStatus(t.StatusCode) {
-			// Unbounded body.
-			t.Close = true
-		}
-	}
-
-	// Prepare body reader.  ContentLength < 0 means chunked encoding
-	// or close connection when finished, since multipart is not supported yet
-	switch {
-	case chunked(t.TransferEncoding):
-		if noBodyExpected(t.RequestMethod) {
-			t.Body = eofReader
-		} else {
-			t.Body = &body{src: newChunkedReader(r), hdr: msg, r: r, closing: t.Close}
-		}
-	case realLength == 0:
-		t.Body = eofReader
-	case realLength > 0:
-		t.Body = &body{src: io.LimitReader(r, realLength), closing: t.Close}
-	default:
-		// realLength < 0, i.e. "Content-Length" not mentioned in header
-		if t.Close {
-			// Close semantics (i.e. HTTP/1.0)
-			t.Body = &body{src: r, closing: t.Close}
-		} else {
-			// Persistent connection (i.e. HTTP/1.1)
-			t.Body = eofReader
-		}
-	}
-
-	// Unify output
-	switch rr := msg.(type) {
-	case *Request:
-		rr.Body = t.Body
-		rr.ContentLength = t.ContentLength
-		rr.TransferEncoding = t.TransferEncoding
-		rr.Close = t.Close
-		rr.Trailer = t.Trailer
-	case *Response:
-		rr.Body = t.Body
-		rr.ContentLength = t.ContentLength
-		rr.TransferEncoding = t.TransferEncoding
-		rr.Close = t.Close
-		rr.Trailer = t.Trailer
-	}
-
-	return nil
-}
-
-// Checks whether chunked is part of the encodings stack
-func chunked(te []string) bool { return len(te) > 0 && te[0] == "chunked" }
-
-// Checks whether the encoding is explicitly "identity".
-func isIdentity(te []string) bool { return len(te) == 1 && te[0] == "identity" }
-
-// Sanitize transfer encoding
-func fixTransferEncoding(requestMethod string, header Header) ([]string, error) {
-	raw, present := header["Transfer-Encoding"]
-	if !present {
-		return nil, nil
-	}
-
-	delete(header, "Transfer-Encoding")
-
-	encodings := strings.Split(raw[0], ",")
-	te := make([]string, 0, len(encodings))
-	// TODO: Even though we only support "identity" and "chunked"
-	// encodings, the loop below is designed with foresight. One
-	// invariant that must be maintained is that, if present,
-	// chunked encoding must always come first.
-	for _, encoding := range encodings {
-		encoding = strings.ToLower(strings.TrimSpace(encoding))
-		// "identity" encoding is not recorded
-		if encoding == "identity" {
-			break
-		}
-		if encoding != "chunked" {
-			return nil, &badStringError{"unsupported transfer encoding", encoding}
-		}
-		te = te[0 : len(te)+1]
-		te[len(te)-1] = encoding
-	}
-	if len(te) > 1 {
-		return nil, &badStringError{"too many transfer encodings", strings.Join(te, ",")}
-	}
-	if len(te) > 0 {
-		// Chunked encoding trumps Content-Length. See RFC 2616
-		// Section 4.4. Currently len(te) > 0 implies chunked
-		// encoding.
-		delete(header, "Content-Length")
-		return te, nil
-	}
-
-	return nil, nil
-}
-
-// Determine the expected body length, using RFC 2616 Section 4.4. This
-// function is not a method, because ultimately it should be shared by
-// ReadResponse and ReadRequest.
-func fixLength(isResponse bool, status int, requestMethod string, header Header, te []string) (int64, error) {
-
-	// Logic based on response type or status
-	if noBodyExpected(requestMethod) {
-		return 0, nil
-	}
-	if status/100 == 1 {
-		return 0, nil
-	}
-	switch status {
-	case 204, 304:
-		return 0, nil
-	}
-
-	// Logic based on Transfer-Encoding
-	if chunked(te) {
-		return -1, nil
-	}
-
-	// Logic based on Content-Length
-	cl := strings.TrimSpace(header.get("Content-Length"))
-	if cl != "" {
-		n, err := parseContentLength(cl)
-		if err != nil {
-			return -1, err
-		}
-		return n, nil
-	} else {
-		header.Del("Content-Length")
-	}
-
-	if !isResponse && requestMethod == "GET" {
-		// RFC 2616 doesn't explicitly permit nor forbid an
-		// entity-body on a GET request so we permit one if
-		// declared, but we default to 0 here (not -1 below)
-		// if there's no mention of a body.
-		return 0, nil
-	}
-
-	// Body-EOF logic based on other methods (like closing, or chunked coding)
-	return -1, nil
-}
-
-// Determine whether to hang up after sending a request and body, or
-// receiving a response and body
-// 'header' is the request headers
-func shouldClose(major, minor int, header Header) bool {
-	if major < 1 {
-		return true
-	} else if major == 1 && minor == 0 {
-		if !strings.Contains(strings.ToLower(header.get("Connection")), "keep-alive") {
-			return true
-		}
-		return false
-	} else {
-		// TODO: Should split on commas, toss surrounding white space,
-		// and check each field.
-		if strings.ToLower(header.get("Connection")) == "close" {
-			header.Del("Connection")
-			return true
-		}
-	}
-	return false
-}
-
-// Parse the trailer header
-func fixTrailer(header Header, te []string) (Header, error) {
-	raw := header.get("Trailer")
-	if raw == "" {
-		return nil, nil
-	}
-
-	header.Del("Trailer")
-	trailer := make(Header)
-	keys := strings.Split(raw, ",")
-	for _, key := range keys {
-		key = CanonicalHeaderKey(strings.TrimSpace(key))
-		switch key {
-		case "Transfer-Encoding", "Trailer", "Content-Length":
-			return nil, &badStringError{"bad trailer key", key}
-		}
-		trailer[key] = nil
-	}
-	if len(trailer) == 0 {
-		return nil, nil
-	}
-	if !chunked(te) {
-		// Trailer and no chunking
-		return nil, ErrUnexpectedTrailer
-	}
-	return trailer, nil
-}
-
-// body turns a Reader into a ReadCloser.
-// Close ensures that the body has been fully read
-// and then reads the trailer if necessary.
-type body struct {
-	src     io.Reader
-	hdr     interface{}   // non-nil (Response or Request) value means read trailer
-	r       *bufio.Reader // underlying wire-format reader for the trailer
-	closing bool          // is the connection to be closed after reading body?
-
-	mu     sync.Mutex // guards closed, and calls to Read and Close
-	closed bool
-}
-
-// ErrBodyReadAfterClose is returned when reading a Request or Response
-// Body after the body has been closed. This typically happens when the body is
-// read after an HTTP Handler calls WriteHeader or Write on its
-// ResponseWriter.
-var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed Body")
-
-func (b *body) Read(p []byte) (n int, err error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	if b.closed {
-		return 0, ErrBodyReadAfterClose
-	}
-	return b.readLocked(p)
-}
-
-// Must hold b.mu.
-func (b *body) readLocked(p []byte) (n int, err error) {
-	n, err = b.src.Read(p)
-
-	if err == io.EOF {
-		// Chunked case. Read the trailer.
-		if b.hdr != nil {
-			if e := b.readTrailer(); e != nil {
-				err = e
-			}
-			b.hdr = nil
-		} else {
-			// If the server declared the Content-Length, our body is a LimitedReader
-			// and we need to check whether this EOF arrived early.
-			if lr, ok := b.src.(*io.LimitedReader); ok && lr.N > 0 {
-				err = io.ErrUnexpectedEOF
-			}
-		}
-	}
-
-	// If we can return an EOF here along with the read data, do
-	// so. This is optional per the io.Reader contract, but doing
-	// so helps the HTTP transport code recycle its connection
-	// earlier (since it will see this EOF itself), even if the
-	// client doesn't do future reads or Close.
-	if err == nil && n > 0 {
-		if lr, ok := b.src.(*io.LimitedReader); ok && lr.N == 0 {
-			err = io.EOF
-		}
-	}
-
-	return n, err
-}
-
-var (
-	singleCRLF = []byte("\r\n")
-	doubleCRLF = []byte("\r\n\r\n")
-)
-
-func seeUpcomingDoubleCRLF(r *bufio.Reader) bool {
-	for peekSize := 4; ; peekSize++ {
-		// This loop stops when Peek returns an error,
-		// which it does when r's buffer has been filled.
-		buf, err := r.Peek(peekSize)
-		if bytes.HasSuffix(buf, doubleCRLF) {
-			return true
-		}
-		if err != nil {
-			break
-		}
-	}
-	return false
-}
-
-var errTrailerEOF = errors.New("http: unexpected EOF reading trailer")
-
-func (b *body) readTrailer() error {
-	// The common case, since nobody uses trailers.
-	buf, err := b.r.Peek(2)
-	if bytes.Equal(buf, singleCRLF) {
-		b.r.ReadByte()
-		b.r.ReadByte()
-		return nil
-	}
-	if len(buf) < 2 {
-		return errTrailerEOF
-	}
-	if err != nil {
-		return err
-	}
-
-	// Make sure there's a header terminator coming up, to prevent
-	// a DoS with an unbounded size Trailer.  It's not easy to
-	// slip in a LimitReader here, as textproto.NewReader requires
-	// a concrete *bufio.Reader.  Also, we can't get all the way
-	// back up to our conn's LimitedReader that *might* be backing
-	// this bufio.Reader.  Instead, a hack: we iteratively Peek up
-	// to the bufio.Reader's max size, looking for a double CRLF.
-	// This limits the trailer to the underlying buffer size, typically 4kB.
-	if !seeUpcomingDoubleCRLF(b.r) {
-		return errors.New("http: suspiciously long trailer after chunked body")
-	}
-
-	hdr, err := textproto.NewReader(b.r).ReadMIMEHeader()
-	if err != nil {
-		if err == io.EOF {
-			return errTrailerEOF
-		}
-		return err
-	}
-	switch rr := b.hdr.(type) {
-	case *Request:
-		mergeSetHeader(&rr.Trailer, Header(hdr))
-	case *Response:
-		mergeSetHeader(&rr.Trailer, Header(hdr))
-	}
-	return nil
-}
-
-func mergeSetHeader(dst *Header, src Header) {
-	if *dst == nil {
-		*dst = src
-		return
-	}
-	for k, vv := range src {
-		(*dst)[k] = vv
-	}
-}
-
-func (b *body) Close() error {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	if b.closed {
-		return nil
-	}
-	var err error
-	switch {
-	case b.hdr == nil && b.closing:
-		// no trailer and closing the connection next.
-		// no point in reading to EOF.
-	default:
-		// Fully consume the body, which will also lead to us reading
-		// the trailer headers after the body, if present.
-		_, err = io.Copy(ioutil.Discard, bodyLocked{b})
-	}
-	b.closed = true
-	return err
-}
-
-// bodyLocked is a io.Reader reading from a *body when its mutex is
-// already held.
-type bodyLocked struct {
-	b *body
-}
-
-func (bl bodyLocked) Read(p []byte) (n int, err error) {
-	if bl.b.closed {
-		return 0, ErrBodyReadAfterClose
-	}
-	return bl.b.readLocked(p)
-}
-
-// parseContentLength trims whitespace from s and returns -1 if no value
-// is set, or the value if it's >= 0.
-func parseContentLength(cl string) (int64, error) {
-	cl = strings.TrimSpace(cl)
-	if cl == "" {
-		return -1, nil
-	}
-	n, err := strconv.ParseInt(cl, 10, 64)
-	if err != nil || n < 0 {
-		return 0, &badStringError{"bad Content-Length", cl}
-	}
-	return n, nil
-
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/transport.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/http/transport.go
deleted file mode 100644
index c58e2dc35..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/http/transport.go
+++ /dev/null
@@ -1,1208 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// HTTP client implementation. See RFC 2616.
-//
-// This is the low-level Transport implementation of RoundTripper.
-// The high-level interface is in client.go.
-
-package http
-
-import (
-	"bufio"
-	"compress/gzip"
-	"errors"
-	"fmt"
-	"github.com/masterzen/azure-sdk-for-go/core/tls"
-	"io"
-	"log"
-	"net"
-	"net/url"
-	"os"
-	"strings"
-	"sync"
-	"time"
-)
-
-// DefaultTransport is the default implementation of Transport and is
-// used by DefaultClient. It establishes network connections as needed
-// and caches them for reuse by subsequent calls. It uses HTTP proxies
-// as directed by the $HTTP_PROXY and $NO_PROXY (or $http_proxy and
-// $no_proxy) environment variables.
-var DefaultTransport RoundTripper = &Transport{
-	Proxy: ProxyFromEnvironment,
-	Dial: (&net.Dialer{
-		Timeout:   30 * time.Second,
-		KeepAlive: 30 * time.Second,
-	}).Dial,
-	TLSHandshakeTimeout: 10 * time.Second,
-}
-
-// DefaultMaxIdleConnsPerHost is the default value of Transport's
-// MaxIdleConnsPerHost.
-const DefaultMaxIdleConnsPerHost = 2
-
-// Transport is an implementation of RoundTripper that supports http,
-// https, and http proxies (for either http or https with CONNECT).
-// Transport can also cache connections for future re-use.
-type Transport struct {
-	idleMu      sync.Mutex
-	idleConn    map[connectMethodKey][]*persistConn
-	idleConnCh  map[connectMethodKey]chan *persistConn
-	reqMu       sync.Mutex
-	reqCanceler map[*Request]func()
-	altMu       sync.RWMutex
-	altProto    map[string]RoundTripper // nil or map of URI scheme => RoundTripper
-
-	// 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(*Request) (*url.URL, error)
-
-	// Dial specifies the dial function for creating TCP
-	// connections.
-	// If Dial is nil, net.Dial is used.
-	Dial func(network, addr string) (net.Conn, error)
-
-	// TLSClientConfig specifies the TLS configuration to use with
-	// tls.Client. If nil, the default configuration is used.
-	TLSClientConfig *tls.Config
-
-	// TLSHandshakeTimeout specifies the maximum amount of time waiting to
-	// wait for a TLS handshake. Zero means no timeout.
-	TLSHandshakeTimeout time.Duration
-
-	// DisableKeepAlives, if true, prevents re-use of TCP connections
-	// between different HTTP requests.
-	DisableKeepAlives bool
-
-	// DisableCompression, if true, prevents the Transport from
-	// requesting compression with an "Accept-Encoding: gzip"
-	// request header when the Request contains no existing
-	// Accept-Encoding value. If the Transport requests gzip on
-	// its own and gets a gzipped response, it's transparently
-	// decoded in the Response.Body. However, if the user
-	// explicitly requested gzip it is not automatically
-	// uncompressed.
-	DisableCompression bool
-
-	// MaxIdleConnsPerHost, if non-zero, controls the maximum idle
-	// (keep-alive) to keep per-host.  If zero,
-	// DefaultMaxIdleConnsPerHost is used.
-	MaxIdleConnsPerHost int
-
-	// ResponseHeaderTimeout, if non-zero, specifies the amount of
-	// time to wait for a server's response headers after fully
-	// writing the request (including its body, if any). This
-	// time does not include the time to read the response body.
-	ResponseHeaderTimeout time.Duration
-
-	// TODO: tunable on global max cached connections
-	// TODO: tunable on timeout on cached connections
-}
-
-// ProxyFromEnvironment returns the URL of the proxy to use for a
-// given request, as indicated by the environment variables
-// $HTTP_PROXY and $NO_PROXY (or $http_proxy and $no_proxy).
-// An error is returned if the proxy environment is invalid.
-// A nil URL and nil error are returned if no proxy is defined in the
-// environment, or a proxy should not be used for the given request.
-//
-// As a special case, if req.URL.Host is "localhost" (with or without
-// a port number), then a nil URL and nil error will be returned.
-func ProxyFromEnvironment(req *Request) (*url.URL, error) {
-	proxy := httpProxyEnv.Get()
-	if proxy == "" {
-		return nil, nil
-	}
-	if !useProxy(canonicalAddr(req.URL)) {
-		return nil, nil
-	}
-	proxyURL, err := url.Parse(proxy)
-	if err != nil || !strings.HasPrefix(proxyURL.Scheme, "http") {
-		// proxy was bogus. Try prepending "http://" to it and
-		// see if that parses correctly. If not, we fall
-		// through and complain about the original one.
-		if proxyURL, err := url.Parse("http://" + proxy); err == nil {
-			return proxyURL, nil
-		}
-	}
-	if err != nil {
-		return nil, fmt.Errorf("invalid proxy address %q: %v", proxy, err)
-	}
-	return proxyURL, nil
-}
-
-// ProxyURL returns a proxy function (for use in a Transport)
-// that always returns the same URL.
-func ProxyURL(fixedURL *url.URL) func(*Request) (*url.URL, error) {
-	return func(*Request) (*url.URL, error) {
-		return fixedURL, nil
-	}
-}
-
-// transportRequest is a wrapper around a *Request that adds
-// optional extra headers to write.
-type transportRequest struct {
-	*Request        // original request, not to be mutated
-	extra    Header // extra headers to write, or nil
-}
-
-func (tr *transportRequest) extraHeaders() Header {
-	if tr.extra == nil {
-		tr.extra = make(Header)
-	}
-	return tr.extra
-}
-
-// RoundTrip implements the RoundTripper interface.
-//
-// For higher-level HTTP client support (such as handling of cookies
-// and redirects), see Get, Post, and the Client type.
-func (t *Transport) RoundTrip(req *Request) (resp *Response, err error) {
-	if req.URL == nil {
-		req.closeBody()
-		return nil, errors.New("http: nil Request.URL")
-	}
-	if req.Header == nil {
-		req.closeBody()
-		return nil, errors.New("http: nil Request.Header")
-	}
-	if req.URL.Scheme != "http" && req.URL.Scheme != "https" {
-		t.altMu.RLock()
-		var rt RoundTripper
-		if t.altProto != nil {
-			rt = t.altProto[req.URL.Scheme]
-		}
-		t.altMu.RUnlock()
-		if rt == nil {
-			req.closeBody()
-			return nil, &badStringError{"unsupported protocol scheme", req.URL.Scheme}
-		}
-		return rt.RoundTrip(req)
-	}
-	if req.URL.Host == "" {
-		req.closeBody()
-		return nil, errors.New("http: no Host in request URL")
-	}
-	treq := &transportRequest{Request: req}
-	cm, err := t.connectMethodForRequest(treq)
-	if err != nil {
-		req.closeBody()
-		return nil, err
-	}
-
-	// Get the cached or newly-created connection to either the
-	// host (for http or https), the http proxy, or the http proxy
-	// pre-CONNECTed to https server.  In any case, we'll be ready
-	// to send it requests.
-	pconn, err := t.getConn(req, cm)
-	if err != nil {
-		t.setReqCanceler(req, nil)
-		req.closeBody()
-		return nil, err
-	}
-
-	return pconn.roundTrip(treq)
-}
-
-// RegisterProtocol registers a new protocol with scheme.
-// The Transport will pass requests using the given scheme to rt.
-// It is rt's responsibility to simulate HTTP request semantics.
-//
-// RegisterProtocol can be used by other packages to provide
-// implementations of protocol schemes like "ftp" or "file".
-func (t *Transport) RegisterProtocol(scheme string, rt RoundTripper) {
-	if scheme == "http" || scheme == "https" {
-		panic("protocol " + scheme + " already registered")
-	}
-	t.altMu.Lock()
-	defer t.altMu.Unlock()
-	if t.altProto == nil {
-		t.altProto = make(map[string]RoundTripper)
-	}
-	if _, exists := t.altProto[scheme]; exists {
-		panic("protocol " + scheme + " already registered")
-	}
-	t.altProto[scheme] = rt
-}
-
-// CloseIdleConnections closes any connections which were previously
-// connected from previous requests but are now sitting idle in
-// a "keep-alive" state. It does not interrupt any connections currently
-// in use.
-func (t *Transport) CloseIdleConnections() {
-	t.idleMu.Lock()
-	m := t.idleConn
-	t.idleConn = nil
-	t.idleConnCh = nil
-	t.idleMu.Unlock()
-	for _, conns := range m {
-		for _, pconn := range conns {
-			pconn.close()
-		}
-	}
-}
-
-// CancelRequest cancels an in-flight request by closing its
-// connection.
-func (t *Transport) CancelRequest(req *Request) {
-	t.reqMu.Lock()
-	cancel := t.reqCanceler[req]
-	t.reqMu.Unlock()
-	if cancel != nil {
-		cancel()
-	}
-}
-
-//
-// Private implementation past this point.
-//
-
-var (
-	httpProxyEnv = &envOnce{
-		names: []string{"HTTP_PROXY", "http_proxy"},
-	}
-	noProxyEnv = &envOnce{
-		names: []string{"NO_PROXY", "no_proxy"},
-	}
-)
-
-// envOnce looks up an environment variable (optionally by multiple
-// names) once. It mitigates expensive lookups on some platforms
-// (e.g. Windows).
-type envOnce struct {
-	names []string
-	once  sync.Once
-	val   string
-}
-
-func (e *envOnce) Get() string {
-	e.once.Do(e.init)
-	return e.val
-}
-
-func (e *envOnce) init() {
-	for _, n := range e.names {
-		e.val = os.Getenv(n)
-		if e.val != "" {
-			return
-		}
-	}
-}
-
-// reset is used by tests
-func (e *envOnce) reset() {
-	e.once = sync.Once{}
-	e.val = ""
-}
-
-func (t *Transport) connectMethodForRequest(treq *transportRequest) (cm connectMethod, err error) {
-	cm.targetScheme = treq.URL.Scheme
-	cm.targetAddr = canonicalAddr(treq.URL)
-	if t.Proxy != nil {
-		cm.proxyURL, err = t.Proxy(treq.Request)
-	}
-	return cm, nil
-}
-
-// proxyAuth returns the Proxy-Authorization header to set
-// on requests, if applicable.
-func (cm *connectMethod) proxyAuth() string {
-	if cm.proxyURL == nil {
-		return ""
-	}
-	if u := cm.proxyURL.User; u != nil {
-		username := u.Username()
-		password, _ := u.Password()
-		return "Basic " + basicAuth(username, password)
-	}
-	return ""
-}
-
-// putIdleConn adds pconn to the list of idle persistent connections awaiting
-// a new request.
-// If pconn is no longer needed or not in a good state, putIdleConn
-// returns false.
-func (t *Transport) putIdleConn(pconn *persistConn) bool {
-	if t.DisableKeepAlives || t.MaxIdleConnsPerHost < 0 {
-		pconn.close()
-		return false
-	}
-	if pconn.isBroken() {
-		return false
-	}
-	key := pconn.cacheKey
-	max := t.MaxIdleConnsPerHost
-	if max == 0 {
-		max = DefaultMaxIdleConnsPerHost
-	}
-	t.idleMu.Lock()
-
-	waitingDialer := t.idleConnCh[key]
-	select {
-	case waitingDialer <- pconn:
-		// We're done with this pconn and somebody else is
-		// currently waiting for a conn of this type (they're
-		// actively dialing, but this conn is ready
-		// first). Chrome calls this socket late binding.  See
-		// https://insouciant.org/tech/connection-management-in-chromium/
-		t.idleMu.Unlock()
-		return true
-	default:
-		if waitingDialer != nil {
-			// They had populated this, but their dial won
-			// first, so we can clean up this map entry.
-			delete(t.idleConnCh, key)
-		}
-	}
-	if t.idleConn == nil {
-		t.idleConn = make(map[connectMethodKey][]*persistConn)
-	}
-	if len(t.idleConn[key]) >= max {
-		t.idleMu.Unlock()
-		pconn.close()
-		return false
-	}
-	for _, exist := range t.idleConn[key] {
-		if exist == pconn {
-			log.Fatalf("dup idle pconn %p in freelist", pconn)
-		}
-	}
-	t.idleConn[key] = append(t.idleConn[key], pconn)
-	t.idleMu.Unlock()
-	return true
-}
-
-// getIdleConnCh returns a channel to receive and return idle
-// persistent connection for the given connectMethod.
-// It may return nil, if persistent connections are not being used.
-func (t *Transport) getIdleConnCh(cm connectMethod) chan *persistConn {
-	if t.DisableKeepAlives {
-		return nil
-	}
-	key := cm.key()
-	t.idleMu.Lock()
-	defer t.idleMu.Unlock()
-	if t.idleConnCh == nil {
-		t.idleConnCh = make(map[connectMethodKey]chan *persistConn)
-	}
-	ch, ok := t.idleConnCh[key]
-	if !ok {
-		ch = make(chan *persistConn)
-		t.idleConnCh[key] = ch
-	}
-	return ch
-}
-
-func (t *Transport) getIdleConn(cm connectMethod) (pconn *persistConn) {
-	key := cm.key()
-	t.idleMu.Lock()
-	defer t.idleMu.Unlock()
-	if t.idleConn == nil {
-		return nil
-	}
-	for {
-		pconns, ok := t.idleConn[key]
-		if !ok {
-			return nil
-		}
-		if len(pconns) == 1 {
-			pconn = pconns[0]
-			delete(t.idleConn, key)
-		} else {
-			// 2 or more cached connections; pop last
-			// TODO: queue?
-			pconn = pconns[len(pconns)-1]
-			t.idleConn[key] = pconns[:len(pconns)-1]
-		}
-		if !pconn.isBroken() {
-			return
-		}
-	}
-}
-
-func (t *Transport) setReqCanceler(r *Request, fn func()) {
-	t.reqMu.Lock()
-	defer t.reqMu.Unlock()
-	if t.reqCanceler == nil {
-		t.reqCanceler = make(map[*Request]func())
-	}
-	if fn != nil {
-		t.reqCanceler[r] = fn
-	} else {
-		delete(t.reqCanceler, r)
-	}
-}
-
-func (t *Transport) dial(network, addr string) (c net.Conn, err error) {
-	if t.Dial != nil {
-		return t.Dial(network, addr)
-	}
-	return net.Dial(network, addr)
-}
-
-// getConn dials and creates a new persistConn to the target as
-// specified in the connectMethod.  This includes doing a proxy CONNECT
-// and/or setting up TLS.  If this doesn't return an error, the persistConn
-// is ready to write requests to.
-func (t *Transport) getConn(req *Request, cm connectMethod) (*persistConn, error) {
-	if pc := t.getIdleConn(cm); pc != nil {
-		return pc, nil
-	}
-
-	type dialRes struct {
-		pc  *persistConn
-		err error
-	}
-	dialc := make(chan dialRes)
-
-	handlePendingDial := func() {
-		if v := <-dialc; v.err == nil {
-			t.putIdleConn(v.pc)
-		}
-	}
-
-	cancelc := make(chan struct{})
-	t.setReqCanceler(req, func() { close(cancelc) })
-
-	go func() {
-		pc, err := t.dialConn(cm)
-		dialc <- dialRes{pc, err}
-	}()
-
-	idleConnCh := t.getIdleConnCh(cm)
-	select {
-	case v := <-dialc:
-		// Our dial finished.
-		return v.pc, v.err
-	case pc := <-idleConnCh:
-		// Another request finished first and its net.Conn
-		// became available before our dial. Or somebody
-		// else's dial that they didn't use.
-		// But our dial is still going, so give it away
-		// when it finishes:
-		go handlePendingDial()
-		return pc, nil
-	case <-cancelc:
-		go handlePendingDial()
-		return nil, errors.New("net/http: request canceled while waiting for connection")
-	}
-}
-
-func (t *Transport) dialConn(cm connectMethod) (*persistConn, error) {
-	conn, err := t.dial("tcp", cm.addr())
-	if err != nil {
-		if cm.proxyURL != nil {
-			err = fmt.Errorf("http: error connecting to proxy %s: %v", cm.proxyURL, err)
-		}
-		return nil, err
-	}
-
-	pa := cm.proxyAuth()
-
-	pconn := &persistConn{
-		t:          t,
-		cacheKey:   cm.key(),
-		conn:       conn,
-		reqch:      make(chan requestAndChan, 1),
-		writech:    make(chan writeRequest, 1),
-		closech:    make(chan struct{}),
-		writeErrCh: make(chan error, 1),
-	}
-
-	switch {
-	case cm.proxyURL == nil:
-		// Do nothing.
-	case cm.targetScheme == "http":
-		pconn.isProxy = true
-		if pa != "" {
-			pconn.mutateHeaderFunc = func(h Header) {
-				h.Set("Proxy-Authorization", pa)
-			}
-		}
-	case cm.targetScheme == "https":
-		connectReq := &Request{
-			Method: "CONNECT",
-			URL:    &url.URL{Opaque: cm.targetAddr},
-			Host:   cm.targetAddr,
-			Header: make(Header),
-		}
-		if pa != "" {
-			connectReq.Header.Set("Proxy-Authorization", pa)
-		}
-		connectReq.Write(conn)
-
-		// Read response.
-		// Okay to use and discard buffered reader here, because
-		// TLS server will not speak until spoken to.
-		br := bufio.NewReader(conn)
-		resp, err := ReadResponse(br, connectReq)
-		if err != nil {
-			conn.Close()
-			return nil, err
-		}
-		if resp.StatusCode != 200 {
-			f := strings.SplitN(resp.Status, " ", 2)
-			conn.Close()
-			return nil, errors.New(f[1])
-		}
-	}
-
-	if cm.targetScheme == "https" {
-		// Initiate TLS and check remote host name against certificate.
-		cfg := t.TLSClientConfig
-		if cfg == nil || cfg.ServerName == "" {
-			host := cm.tlsHost()
-			if cfg == nil {
-				cfg = &tls.Config{ServerName: host}
-			} else {
-				clone := *cfg // shallow clone
-				clone.ServerName = host
-				cfg = &clone
-			}
-		}
-		plainConn := conn
-		tlsConn := tls.Client(plainConn, cfg)
-		errc := make(chan error, 2)
-		var timer *time.Timer // for canceling TLS handshake
-		if d := t.TLSHandshakeTimeout; d != 0 {
-			timer = time.AfterFunc(d, func() {
-				errc <- tlsHandshakeTimeoutError{}
-			})
-		}
-		go func() {
-			err := tlsConn.Handshake()
-			if timer != nil {
-				timer.Stop()
-			}
-			errc <- err
-		}()
-		if err := <-errc; err != nil {
-			plainConn.Close()
-			return nil, err
-		}
-		if !cfg.InsecureSkipVerify {
-			if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
-				plainConn.Close()
-				return nil, err
-			}
-		}
-		cs := tlsConn.ConnectionState()
-		pconn.tlsState = &cs
-		pconn.conn = tlsConn
-	}
-
-	pconn.br = bufio.NewReader(noteEOFReader{pconn.conn, &pconn.sawEOF})
-	pconn.bw = bufio.NewWriter(pconn.conn)
-	go pconn.readLoop()
-	go pconn.writeLoop()
-	return pconn, nil
-}
-
-// useProxy returns true if requests to addr should use a proxy,
-// according to the NO_PROXY or no_proxy environment variable.
-// addr is always a canonicalAddr with a host and port.
-func useProxy(addr string) bool {
-	if len(addr) == 0 {
-		return true
-	}
-	host, _, err := net.SplitHostPort(addr)
-	if err != nil {
-		return false
-	}
-	if host == "localhost" {
-		return false
-	}
-	if ip := net.ParseIP(host); ip != nil {
-		if ip.IsLoopback() {
-			return false
-		}
-	}
-
-	no_proxy := noProxyEnv.Get()
-	if no_proxy == "*" {
-		return false
-	}
-
-	addr = strings.ToLower(strings.TrimSpace(addr))
-	if hasPort(addr) {
-		addr = addr[:strings.LastIndex(addr, ":")]
-	}
-
-	for _, p := range strings.Split(no_proxy, ",") {
-		p = strings.ToLower(strings.TrimSpace(p))
-		if len(p) == 0 {
-			continue
-		}
-		if hasPort(p) {
-			p = p[:strings.LastIndex(p, ":")]
-		}
-		if addr == p {
-			return false
-		}
-		if p[0] == '.' && (strings.HasSuffix(addr, p) || addr == p[1:]) {
-			// no_proxy ".foo.com" matches "bar.foo.com" or "foo.com"
-			return false
-		}
-		if p[0] != '.' && strings.HasSuffix(addr, p) && addr[len(addr)-len(p)-1] == '.' {
-			// no_proxy "foo.com" matches "bar.foo.com"
-			return false
-		}
-	}
-	return true
-}
-
-// connectMethod is the map key (in its String form) for keeping persistent
-// TCP connections alive for subsequent HTTP requests.
-//
-// A connect method may be of the following types:
-//
-// Cache key form                Description
-// -----------------             -------------------------
-// |http|foo.com                 http directly to server, no proxy
-// |https|foo.com                https directly to server, no proxy
-// http://proxy.com|https|foo.com  http to proxy, then CONNECT to foo.com
-// http://proxy.com|http           http to proxy, http to anywhere after that
-//
-// Note: no support to https to the proxy yet.
-//
-type connectMethod struct {
-	proxyURL     *url.URL // nil for no proxy, else full proxy URL
-	targetScheme string   // "http" or "https"
-	targetAddr   string   // Not used if proxy + http targetScheme (4th example in table)
-}
-
-func (cm *connectMethod) key() connectMethodKey {
-	proxyStr := ""
-	targetAddr := cm.targetAddr
-	if cm.proxyURL != nil {
-		proxyStr = cm.proxyURL.String()
-		if cm.targetScheme == "http" {
-			targetAddr = ""
-		}
-	}
-	return connectMethodKey{
-		proxy:  proxyStr,
-		scheme: cm.targetScheme,
-		addr:   targetAddr,
-	}
-}
-
-// addr returns the first hop "host:port" to which we need to TCP connect.
-func (cm *connectMethod) addr() string {
-	if cm.proxyURL != nil {
-		return canonicalAddr(cm.proxyURL)
-	}
-	return cm.targetAddr
-}
-
-// tlsHost returns the host name to match against the peer's
-// TLS certificate.
-func (cm *connectMethod) tlsHost() string {
-	h := cm.targetAddr
-	if hasPort(h) {
-		h = h[:strings.LastIndex(h, ":")]
-	}
-	return h
-}
-
-// connectMethodKey is the map key version of connectMethod, with a
-// stringified proxy URL (or the empty string) instead of a pointer to
-// a URL.
-type connectMethodKey struct {
-	proxy, scheme, addr string
-}
-
-func (k connectMethodKey) String() string {
-	// Only used by tests.
-	return fmt.Sprintf("%s|%s|%s", k.proxy, k.scheme, k.addr)
-}
-
-// persistConn wraps a connection, usually a persistent one
-// (but may be used for non-keep-alive requests as well)
-type persistConn struct {
-	t        *Transport
-	cacheKey connectMethodKey
-	conn     net.Conn
-	tlsState *tls.ConnectionState
-	br       *bufio.Reader       // from conn
-	sawEOF   bool                // whether we've seen EOF from conn; owned by readLoop
-	bw       *bufio.Writer       // to conn
-	reqch    chan requestAndChan // written by roundTrip; read by readLoop
-	writech  chan writeRequest   // written by roundTrip; read by writeLoop
-	closech  chan struct{}       // closed when conn closed
-	isProxy  bool
-	// writeErrCh passes the request write error (usually nil)
-	// from the writeLoop goroutine to the readLoop which passes
-	// it off to the res.Body reader, which then uses it to decide
-	// whether or not a connection can be reused. Issue 7569.
-	writeErrCh chan error
-
-	lk                   sync.Mutex // guards following fields
-	numExpectedResponses int
-	closed               bool // whether conn has been closed
-	broken               bool // an error has happened on this connection; marked broken so it's not reused.
-	// mutateHeaderFunc is an optional func to modify extra
-	// headers on each outbound request before it's written. (the
-	// original Request given to RoundTrip is not modified)
-	mutateHeaderFunc func(Header)
-}
-
-// isBroken reports whether this connection is in a known broken state.
-func (pc *persistConn) isBroken() bool {
-	pc.lk.Lock()
-	b := pc.broken
-	pc.lk.Unlock()
-	return b
-}
-
-func (pc *persistConn) cancelRequest() {
-	pc.conn.Close()
-}
-
-var remoteSideClosedFunc func(error) bool // or nil to use default
-
-func remoteSideClosed(err error) bool {
-	if err == io.EOF {
-		return true
-	}
-	if remoteSideClosedFunc != nil {
-		return remoteSideClosedFunc(err)
-	}
-	return false
-}
-
-func (pc *persistConn) readLoop() {
-	alive := true
-
-	for alive {
-		pb, err := pc.br.Peek(1)
-
-		pc.lk.Lock()
-		if pc.numExpectedResponses == 0 {
-			if !pc.closed {
-				pc.closeLocked()
-				if len(pb) > 0 {
-					log.Printf("Unsolicited response received on idle HTTP channel starting with %q; err=%v",
-						string(pb), err)
-				}
-			}
-			pc.lk.Unlock()
-			return
-		}
-		pc.lk.Unlock()
-
-		rc := <-pc.reqch
-
-		var resp *Response
-		if err == nil {
-			resp, err = ReadResponse(pc.br, rc.req)
-			if err == nil && resp.StatusCode == 100 {
-				// Skip any 100-continue for now.
-				// TODO(bradfitz): if rc.req had "Expect: 100-continue",
-				// actually block the request body write and signal the
-				// writeLoop now to begin sending it. (Issue 2184) For now we
-				// eat it, since we're never expecting one.
-				resp, err = ReadResponse(pc.br, rc.req)
-			}
-		}
-
-		if resp != nil {
-			resp.TLS = pc.tlsState
-		}
-
-		hasBody := resp != nil && rc.req.Method != "HEAD" && resp.ContentLength != 0
-
-		if err != nil {
-			pc.close()
-		} else {
-			if rc.addedGzip && hasBody && resp.Header.Get("Content-Encoding") == "gzip" {
-				resp.Header.Del("Content-Encoding")
-				resp.Header.Del("Content-Length")
-				resp.ContentLength = -1
-				resp.Body = &gzipReader{body: resp.Body}
-			}
-			resp.Body = &bodyEOFSignal{body: resp.Body}
-		}
-
-		if err != nil || resp.Close || rc.req.Close || resp.StatusCode <= 199 {
-			// Don't do keep-alive on error if either party requested a close
-			// or we get an unexpected informational (1xx) response.
-			// StatusCode 100 is already handled above.
-			alive = false
-		}
-
-		var waitForBodyRead chan bool
-		if hasBody {
-			waitForBodyRead = make(chan bool, 2)
-			resp.Body.(*bodyEOFSignal).earlyCloseFn = func() error {
-				// Sending false here sets alive to
-				// false and closes the connection
-				// below.
-				waitForBodyRead <- false
-				return nil
-			}
-			resp.Body.(*bodyEOFSignal).fn = func(err error) {
-				waitForBodyRead <- alive &&
-					err == nil &&
-					!pc.sawEOF &&
-					pc.wroteRequest() &&
-					pc.t.putIdleConn(pc)
-			}
-		}
-
-		if alive && !hasBody {
-			alive = !pc.sawEOF &&
-				pc.wroteRequest() &&
-				pc.t.putIdleConn(pc)
-		}
-
-		rc.ch <- responseAndError{resp, err}
-
-		// Wait for the just-returned response body to be fully consumed
-		// before we race and peek on the underlying bufio reader.
-		if waitForBodyRead != nil {
-			select {
-			case alive = <-waitForBodyRead:
-			case <-pc.closech:
-				alive = false
-			}
-		}
-
-		pc.t.setReqCanceler(rc.req, nil)
-
-		if !alive {
-			pc.close()
-		}
-	}
-}
-
-func (pc *persistConn) writeLoop() {
-	for {
-		select {
-		case wr := <-pc.writech:
-			if pc.isBroken() {
-				wr.ch <- errors.New("http: can't write HTTP request on broken connection")
-				continue
-			}
-			err := wr.req.Request.write(pc.bw, pc.isProxy, wr.req.extra)
-			if err == nil {
-				err = pc.bw.Flush()
-			}
-			if err != nil {
-				pc.markBroken()
-				wr.req.Request.closeBody()
-			}
-			pc.writeErrCh <- err // to the body reader, which might recycle us
-			wr.ch <- err         // to the roundTrip function
-		case <-pc.closech:
-			return
-		}
-	}
-}
-
-// wroteRequest is a check before recycling a connection that the previous write
-// (from writeLoop above) happened and was successful.
-func (pc *persistConn) wroteRequest() bool {
-	select {
-	case err := <-pc.writeErrCh:
-		// Common case: the write happened well before the response, so
-		// avoid creating a timer.
-		return err == nil
-	default:
-		// Rare case: the request was written in writeLoop above but
-		// before it could send to pc.writeErrCh, the reader read it
-		// all, processed it, and called us here. In this case, give the
-		// write goroutine a bit of time to finish its send.
-		//
-		// Less rare case: We also get here in the legitimate case of
-		// Issue 7569, where the writer is still writing (or stalled),
-		// but the server has already replied. In this case, we don't
-		// want to wait too long, and we want to return false so this
-		// connection isn't re-used.
-		select {
-		case err := <-pc.writeErrCh:
-			return err == nil
-		case <-time.After(50 * time.Millisecond):
-			return false
-		}
-	}
-}
-
-type responseAndError struct {
-	res *Response
-	err error
-}
-
-type requestAndChan struct {
-	req *Request
-	ch  chan responseAndError
-
-	// did the Transport (as opposed to the client code) add an
-	// Accept-Encoding gzip header? only if it we set it do
-	// we transparently decode the gzip.
-	addedGzip bool
-}
-
-// A writeRequest is sent by the readLoop's goroutine to the
-// writeLoop's goroutine to write a request while the read loop
-// concurrently waits on both the write response and the server's
-// reply.
-type writeRequest struct {
-	req *transportRequest
-	ch  chan<- error
-}
-
-type httpError struct {
-	err     string
-	timeout bool
-}
-
-func (e *httpError) Error() string   { return e.err }
-func (e *httpError) Timeout() bool   { return e.timeout }
-func (e *httpError) Temporary() bool { return true }
-
-var errTimeout error = &httpError{err: "net/http: timeout awaiting response headers", timeout: true}
-var errClosed error = &httpError{err: "net/http: transport closed before response was received"}
-
-func (pc *persistConn) roundTrip(req *transportRequest) (resp *Response, err error) {
-	pc.t.setReqCanceler(req.Request, pc.cancelRequest)
-	pc.lk.Lock()
-	pc.numExpectedResponses++
-	headerFn := pc.mutateHeaderFunc
-	pc.lk.Unlock()
-
-	if headerFn != nil {
-		headerFn(req.extraHeaders())
-	}
-
-	// Ask for a compressed version if the caller didn't set their
-	// own value for Accept-Encoding. We only attempted to
-	// uncompress the gzip stream if we were the layer that
-	// requested it.
-	requestedGzip := false
-	if !pc.t.DisableCompression && req.Header.Get("Accept-Encoding") == "" && req.Method != "HEAD" {
-		// Request gzip only, not deflate. Deflate is ambiguous and
-		// not as universally supported anyway.
-		// See: http://www.gzip.org/zlib/zlib_faq.html#faq38
-		//
-		// Note that we don't request this for HEAD requests,
-		// due to a bug in nginx:
-		//   http://trac.nginx.org/nginx/ticket/358
-		//   http://golang.org/issue/5522
-		requestedGzip = true
-		req.extraHeaders().Set("Accept-Encoding", "gzip")
-	}
-
-	// Write the request concurrently with waiting for a response,
-	// in case the server decides to reply before reading our full
-	// request body.
-	writeErrCh := make(chan error, 1)
-	pc.writech <- writeRequest{req, writeErrCh}
-
-	resc := make(chan responseAndError, 1)
-	pc.reqch <- requestAndChan{req.Request, resc, requestedGzip}
-
-	var re responseAndError
-	var pconnDeadCh = pc.closech
-	var failTicker <-chan time.Time
-	var respHeaderTimer <-chan time.Time
-WaitResponse:
-	for {
-		select {
-		case err := <-writeErrCh:
-			if err != nil {
-				re = responseAndError{nil, err}
-				pc.close()
-				break WaitResponse
-			}
-			if d := pc.t.ResponseHeaderTimeout; d > 0 {
-				respHeaderTimer = time.After(d)
-			}
-		case <-pconnDeadCh:
-			// The persist connection is dead. This shouldn't
-			// usually happen (only with Connection: close responses
-			// with no response bodies), but if it does happen it
-			// means either a) the remote server hung up on us
-			// prematurely, or b) the readLoop sent us a response &
-			// closed its closech at roughly the same time, and we
-			// selected this case first, in which case a response
-			// might still be coming soon.
-			//
-			// We can't avoid the select race in b) by using a unbuffered
-			// resc channel instead, because then goroutines can
-			// leak if we exit due to other errors.
-			pconnDeadCh = nil                               // avoid spinning
-			failTicker = time.After(100 * time.Millisecond) // arbitrary time to wait for resc
-		case <-failTicker:
-			re = responseAndError{err: errClosed}
-			break WaitResponse
-		case <-respHeaderTimer:
-			pc.close()
-			re = responseAndError{err: errTimeout}
-			break WaitResponse
-		case re = <-resc:
-			break WaitResponse
-		}
-	}
-
-	pc.lk.Lock()
-	pc.numExpectedResponses--
-	pc.lk.Unlock()
-
-	if re.err != nil {
-		pc.t.setReqCanceler(req.Request, nil)
-	}
-	return re.res, re.err
-}
-
-// markBroken marks a connection as broken (so it's not reused).
-// It differs from close in that it doesn't close the underlying
-// connection for use when it's still being read.
-func (pc *persistConn) markBroken() {
-	pc.lk.Lock()
-	defer pc.lk.Unlock()
-	pc.broken = true
-}
-
-func (pc *persistConn) close() {
-	pc.lk.Lock()
-	defer pc.lk.Unlock()
-	pc.closeLocked()
-}
-
-func (pc *persistConn) closeLocked() {
-	pc.broken = true
-	if !pc.closed {
-		pc.conn.Close()
-		pc.closed = true
-		close(pc.closech)
-	}
-	pc.mutateHeaderFunc = nil
-}
-
-var portMap = map[string]string{
-	"http":  "80",
-	"https": "443",
-}
-
-// canonicalAddr returns url.Host but always with a ":port" suffix
-func canonicalAddr(url *url.URL) string {
-	addr := url.Host
-	if !hasPort(addr) {
-		return addr + ":" + portMap[url.Scheme]
-	}
-	return addr
-}
-
-// bodyEOFSignal wraps a ReadCloser but runs fn (if non-nil) at most
-// once, right before its final (error-producing) Read or Close call
-// returns. If earlyCloseFn is non-nil and Close is called before
-// io.EOF is seen, earlyCloseFn is called instead of fn, and its
-// return value is the return value from Close.
-type bodyEOFSignal struct {
-	body         io.ReadCloser
-	mu           sync.Mutex   // guards following 4 fields
-	closed       bool         // whether Close has been called
-	rerr         error        // sticky Read error
-	fn           func(error)  // error will be nil on Read io.EOF
-	earlyCloseFn func() error // optional alt Close func used if io.EOF not seen
-}
-
-func (es *bodyEOFSignal) Read(p []byte) (n int, err error) {
-	es.mu.Lock()
-	closed, rerr := es.closed, es.rerr
-	es.mu.Unlock()
-	if closed {
-		return 0, errors.New("http: read on closed response body")
-	}
-	if rerr != nil {
-		return 0, rerr
-	}
-
-	n, err = es.body.Read(p)
-	if err != nil {
-		es.mu.Lock()
-		defer es.mu.Unlock()
-		if es.rerr == nil {
-			es.rerr = err
-		}
-		es.condfn(err)
-	}
-	return
-}
-
-func (es *bodyEOFSignal) Close() error {
-	es.mu.Lock()
-	defer es.mu.Unlock()
-	if es.closed {
-		return nil
-	}
-	es.closed = true
-	if es.earlyCloseFn != nil && es.rerr != io.EOF {
-		return es.earlyCloseFn()
-	}
-	err := es.body.Close()
-	es.condfn(err)
-	return err
-}
-
-// caller must hold es.mu.
-func (es *bodyEOFSignal) condfn(err error) {
-	if es.fn == nil {
-		return
-	}
-	if err == io.EOF {
-		err = nil
-	}
-	es.fn(err)
-	es.fn = nil
-}
-
-// gzipReader wraps a response body so it can lazily
-// call gzip.NewReader on the first call to Read
-type gzipReader struct {
-	body io.ReadCloser // underlying Response.Body
-	zr   io.Reader     // lazily-initialized gzip reader
-}
-
-func (gz *gzipReader) Read(p []byte) (n int, err error) {
-	if gz.zr == nil {
-		gz.zr, err = gzip.NewReader(gz.body)
-		if err != nil {
-			return 0, err
-		}
-	}
-	return gz.zr.Read(p)
-}
-
-func (gz *gzipReader) Close() error {
-	return gz.body.Close()
-}
-
-type readerAndCloser struct {
-	io.Reader
-	io.Closer
-}
-
-type tlsHandshakeTimeoutError struct{}
-
-func (tlsHandshakeTimeoutError) Timeout() bool   { return true }
-func (tlsHandshakeTimeoutError) Temporary() bool { return true }
-func (tlsHandshakeTimeoutError) Error() string   { return "net/http: TLS handshake timeout" }
-
-type noteEOFReader struct {
-	r      io.Reader
-	sawEOF *bool
-}
-
-func (nr noteEOFReader) Read(p []byte) (n int, err error) {
-	n, err = nr.r.Read(p)
-	if err == io.EOF {
-		*nr.sawEOF = true
-	}
-	return
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/alert.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/alert.go
deleted file mode 100644
index 0856311e4..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/alert.go
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright 2009 The Go 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 tls
-
-import "strconv"
-
-type alert uint8
-
-const (
-	// alert level
-	alertLevelWarning = 1
-	alertLevelError   = 2
-)
-
-const (
-	alertCloseNotify            alert = 0
-	alertUnexpectedMessage      alert = 10
-	alertBadRecordMAC           alert = 20
-	alertDecryptionFailed       alert = 21
-	alertRecordOverflow         alert = 22
-	alertDecompressionFailure   alert = 30
-	alertHandshakeFailure       alert = 40
-	alertBadCertificate         alert = 42
-	alertUnsupportedCertificate alert = 43
-	alertCertificateRevoked     alert = 44
-	alertCertificateExpired     alert = 45
-	alertCertificateUnknown     alert = 46
-	alertIllegalParameter       alert = 47
-	alertUnknownCA              alert = 48
-	alertAccessDenied           alert = 49
-	alertDecodeError            alert = 50
-	alertDecryptError           alert = 51
-	alertProtocolVersion        alert = 70
-	alertInsufficientSecurity   alert = 71
-	alertInternalError          alert = 80
-	alertUserCanceled           alert = 90
-	alertNoRenegotiation        alert = 100
-)
-
-var alertText = map[alert]string{
-	alertCloseNotify:            "close notify",
-	alertUnexpectedMessage:      "unexpected message",
-	alertBadRecordMAC:           "bad record MAC",
-	alertDecryptionFailed:       "decryption failed",
-	alertRecordOverflow:         "record overflow",
-	alertDecompressionFailure:   "decompression failure",
-	alertHandshakeFailure:       "handshake failure",
-	alertBadCertificate:         "bad certificate",
-	alertUnsupportedCertificate: "unsupported certificate",
-	alertCertificateRevoked:     "revoked certificate",
-	alertCertificateExpired:     "expired certificate",
-	alertCertificateUnknown:     "unknown certificate",
-	alertIllegalParameter:       "illegal parameter",
-	alertUnknownCA:              "unknown certificate authority",
-	alertAccessDenied:           "access denied",
-	alertDecodeError:            "error decoding message",
-	alertDecryptError:           "error decrypting message",
-	alertProtocolVersion:        "protocol version not supported",
-	alertInsufficientSecurity:   "insufficient security level",
-	alertInternalError:          "internal error",
-	alertUserCanceled:           "user canceled",
-	alertNoRenegotiation:        "no renegotiation",
-}
-
-func (e alert) String() string {
-	s, ok := alertText[e]
-	if ok {
-		return s
-	}
-	return "alert(" + strconv.Itoa(int(e)) + ")"
-}
-
-func (e alert) Error() string {
-	return e.String()
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/cipher_suites.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/cipher_suites.go
deleted file mode 100644
index 39a51459d..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/cipher_suites.go
+++ /dev/null
@@ -1,270 +0,0 @@
-// Copyright 2010 The Go 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 tls
-
-import (
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/des"
-	"crypto/hmac"
-	"crypto/rc4"
-	"crypto/sha1"
-	"crypto/x509"
-	"hash"
-)
-
-// a keyAgreement implements the client and server side of a TLS key agreement
-// protocol by generating and processing key exchange messages.
-type keyAgreement interface {
-	// On the server side, the first two methods are called in order.
-
-	// In the case that the key agreement protocol doesn't use a
-	// ServerKeyExchange message, generateServerKeyExchange can return nil,
-	// nil.
-	generateServerKeyExchange(*Config, *Certificate, *clientHelloMsg, *serverHelloMsg) (*serverKeyExchangeMsg, error)
-	processClientKeyExchange(*Config, *Certificate, *clientKeyExchangeMsg, uint16) ([]byte, error)
-
-	// On the client side, the next two methods are called in order.
-
-	// This method may not be called if the server doesn't send a
-	// ServerKeyExchange message.
-	processServerKeyExchange(*Config, *clientHelloMsg, *serverHelloMsg, *x509.Certificate, *serverKeyExchangeMsg) error
-	generateClientKeyExchange(*Config, *clientHelloMsg, *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error)
-}
-
-const (
-	// suiteECDH indicates that the cipher suite involves elliptic curve
-	// Diffie-Hellman. This means that it should only be selected when the
-	// client indicates that it supports ECC with a curve and point format
-	// that we're happy with.
-	suiteECDHE = 1 << iota
-	// suiteECDSA indicates that the cipher suite involves an ECDSA
-	// signature and therefore may only be selected when the server's
-	// certificate is ECDSA. If this is not set then the cipher suite is
-	// RSA based.
-	suiteECDSA
-	// suiteTLS12 indicates that the cipher suite should only be advertised
-	// and accepted when using TLS 1.2.
-	suiteTLS12
-)
-
-// A cipherSuite is a specific combination of key agreement, cipher and MAC
-// function. All cipher suites currently assume RSA key agreement.
-type cipherSuite struct {
-	id uint16
-	// the lengths, in bytes, of the key material needed for each component.
-	keyLen int
-	macLen int
-	ivLen  int
-	ka     func(version uint16) keyAgreement
-	// flags is a bitmask of the suite* values, above.
-	flags  int
-	cipher func(key, iv []byte, isRead bool) interface{}
-	mac    func(version uint16, macKey []byte) macFunction
-	aead   func(key, fixedNonce []byte) cipher.AEAD
-}
-
-var cipherSuites = []*cipherSuite{
-	// Ciphersuite order is chosen so that ECDHE comes before plain RSA
-	// and RC4 comes before AES (because of the Lucky13 attack).
-	{TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 16, 0, 4, ecdheRSAKA, suiteECDHE | suiteTLS12, nil, nil, aeadAESGCM},
-	{TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 16, 0, 4, ecdheECDSAKA, suiteECDHE | suiteECDSA | suiteTLS12, nil, nil, aeadAESGCM},
-	{TLS_ECDHE_RSA_WITH_RC4_128_SHA, 16, 20, 0, ecdheRSAKA, suiteECDHE, cipherRC4, macSHA1, nil},
-	{TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, 16, 20, 0, ecdheECDSAKA, suiteECDHE | suiteECDSA, cipherRC4, macSHA1, nil},
-	{TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, 16, 20, 16, ecdheRSAKA, suiteECDHE, cipherAES, macSHA1, nil},
-	{TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, 16, 20, 16, ecdheECDSAKA, suiteECDHE | suiteECDSA, cipherAES, macSHA1, nil},
-	{TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, 32, 20, 16, ecdheRSAKA, suiteECDHE, cipherAES, macSHA1, nil},
-	{TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, 32, 20, 16, ecdheECDSAKA, suiteECDHE | suiteECDSA, cipherAES, macSHA1, nil},
-	{TLS_RSA_WITH_RC4_128_SHA, 16, 20, 0, rsaKA, 0, cipherRC4, macSHA1, nil},
-	{TLS_RSA_WITH_AES_128_CBC_SHA, 16, 20, 16, rsaKA, 0, cipherAES, macSHA1, nil},
-	{TLS_RSA_WITH_AES_256_CBC_SHA, 32, 20, 16, rsaKA, 0, cipherAES, macSHA1, nil},
-	{TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, 24, 20, 8, ecdheRSAKA, suiteECDHE, cipher3DES, macSHA1, nil},
-	{TLS_RSA_WITH_3DES_EDE_CBC_SHA, 24, 20, 8, rsaKA, 0, cipher3DES, macSHA1, nil},
-}
-
-func cipherRC4(key, iv []byte, isRead bool) interface{} {
-	cipher, _ := rc4.NewCipher(key)
-	return cipher
-}
-
-func cipher3DES(key, iv []byte, isRead bool) interface{} {
-	block, _ := des.NewTripleDESCipher(key)
-	if isRead {
-		return cipher.NewCBCDecrypter(block, iv)
-	}
-	return cipher.NewCBCEncrypter(block, iv)
-}
-
-func cipherAES(key, iv []byte, isRead bool) interface{} {
-	block, _ := aes.NewCipher(key)
-	if isRead {
-		return cipher.NewCBCDecrypter(block, iv)
-	}
-	return cipher.NewCBCEncrypter(block, iv)
-}
-
-// macSHA1 returns a macFunction for the given protocol version.
-func macSHA1(version uint16, key []byte) macFunction {
-	if version == VersionSSL30 {
-		mac := ssl30MAC{
-			h:   sha1.New(),
-			key: make([]byte, len(key)),
-		}
-		copy(mac.key, key)
-		return mac
-	}
-	return tls10MAC{hmac.New(sha1.New, key)}
-}
-
-type macFunction interface {
-	Size() int
-	MAC(digestBuf, seq, header, data []byte) []byte
-}
-
-// fixedNonceAEAD wraps an AEAD and prefixes a fixed portion of the nonce to
-// each call.
-type fixedNonceAEAD struct {
-	// sealNonce and openNonce are buffers where the larger nonce will be
-	// constructed. Since a seal and open operation may be running
-	// concurrently, there is a separate buffer for each.
-	sealNonce, openNonce []byte
-	aead                 cipher.AEAD
-}
-
-func (f *fixedNonceAEAD) NonceSize() int { return 8 }
-func (f *fixedNonceAEAD) Overhead() int  { return f.aead.Overhead() }
-
-func (f *fixedNonceAEAD) Seal(out, nonce, plaintext, additionalData []byte) []byte {
-	copy(f.sealNonce[len(f.sealNonce)-8:], nonce)
-	return f.aead.Seal(out, f.sealNonce, plaintext, additionalData)
-}
-
-func (f *fixedNonceAEAD) Open(out, nonce, plaintext, additionalData []byte) ([]byte, error) {
-	copy(f.openNonce[len(f.openNonce)-8:], nonce)
-	return f.aead.Open(out, f.openNonce, plaintext, additionalData)
-}
-
-func aeadAESGCM(key, fixedNonce []byte) cipher.AEAD {
-	aes, err := aes.NewCipher(key)
-	if err != nil {
-		panic(err)
-	}
-	aead, err := cipher.NewGCM(aes)
-	if err != nil {
-		panic(err)
-	}
-
-	nonce1, nonce2 := make([]byte, 12), make([]byte, 12)
-	copy(nonce1, fixedNonce)
-	copy(nonce2, fixedNonce)
-
-	return &fixedNonceAEAD{nonce1, nonce2, aead}
-}
-
-// ssl30MAC implements the SSLv3 MAC function, as defined in
-// www.mozilla.org/projects/security/pki/nss/ssl/draft302.txt section 5.2.3.1
-type ssl30MAC struct {
-	h   hash.Hash
-	key []byte
-}
-
-func (s ssl30MAC) Size() int {
-	return s.h.Size()
-}
-
-var ssl30Pad1 = [48]byte{0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36}
-
-var ssl30Pad2 = [48]byte{0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c}
-
-func (s ssl30MAC) MAC(digestBuf, seq, header, data []byte) []byte {
-	padLength := 48
-	if s.h.Size() == 20 {
-		padLength = 40
-	}
-
-	s.h.Reset()
-	s.h.Write(s.key)
-	s.h.Write(ssl30Pad1[:padLength])
-	s.h.Write(seq)
-	s.h.Write(header[:1])
-	s.h.Write(header[3:5])
-	s.h.Write(data)
-	digestBuf = s.h.Sum(digestBuf[:0])
-
-	s.h.Reset()
-	s.h.Write(s.key)
-	s.h.Write(ssl30Pad2[:padLength])
-	s.h.Write(digestBuf)
-	return s.h.Sum(digestBuf[:0])
-}
-
-// tls10MAC implements the TLS 1.0 MAC function. RFC 2246, section 6.2.3.
-type tls10MAC struct {
-	h hash.Hash
-}
-
-func (s tls10MAC) Size() int {
-	return s.h.Size()
-}
-
-func (s tls10MAC) MAC(digestBuf, seq, header, data []byte) []byte {
-	s.h.Reset()
-	s.h.Write(seq)
-	s.h.Write(header)
-	s.h.Write(data)
-	return s.h.Sum(digestBuf[:0])
-}
-
-func rsaKA(version uint16) keyAgreement {
-	return rsaKeyAgreement{}
-}
-
-func ecdheECDSAKA(version uint16) keyAgreement {
-	return &ecdheKeyAgreement{
-		sigType: signatureECDSA,
-		version: version,
-	}
-}
-
-func ecdheRSAKA(version uint16) keyAgreement {
-	return &ecdheKeyAgreement{
-		sigType: signatureRSA,
-		version: version,
-	}
-}
-
-// mutualCipherSuite returns a cipherSuite given a list of supported
-// ciphersuites and the id requested by the peer.
-func mutualCipherSuite(have []uint16, want uint16) *cipherSuite {
-	for _, id := range have {
-		if id == want {
-			for _, suite := range cipherSuites {
-				if suite.id == want {
-					return suite
-				}
-			}
-			return nil
-		}
-	}
-	return nil
-}
-
-// A list of the possible cipher suite ids. Taken from
-// http://www.iana.org/assignments/tls-parameters/tls-parameters.xml
-const (
-	TLS_RSA_WITH_RC4_128_SHA                uint16 = 0x0005
-	TLS_RSA_WITH_3DES_EDE_CBC_SHA           uint16 = 0x000a
-	TLS_RSA_WITH_AES_128_CBC_SHA            uint16 = 0x002f
-	TLS_RSA_WITH_AES_256_CBC_SHA            uint16 = 0x0035
-	TLS_ECDHE_ECDSA_WITH_RC4_128_SHA        uint16 = 0xc007
-	TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA    uint16 = 0xc009
-	TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA    uint16 = 0xc00a
-	TLS_ECDHE_RSA_WITH_RC4_128_SHA          uint16 = 0xc011
-	TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA     uint16 = 0xc012
-	TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA      uint16 = 0xc013
-	TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA      uint16 = 0xc014
-	TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256   uint16 = 0xc02f
-	TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 uint16 = 0xc02b
-)
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/common.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/common.go
deleted file mode 100644
index 7eb283c5a..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/common.go
+++ /dev/null
@@ -1,438 +0,0 @@
-// Copyright 2009 The Go 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 tls
-
-import (
-	"crypto"
-	"crypto/rand"
-	"crypto/x509"
-	"io"
-	"math/big"
-	"strings"
-	"sync"
-	"time"
-)
-
-const (
-	VersionSSL30 = 0x0300
-	VersionTLS10 = 0x0301
-	VersionTLS11 = 0x0302
-	VersionTLS12 = 0x0303
-)
-
-const (
-	maxPlaintext    = 16384        // maximum plaintext payload length
-	maxCiphertext   = 16384 + 2048 // maximum ciphertext payload length
-	recordHeaderLen = 5            // record header length
-	maxHandshake    = 65536        // maximum handshake we support (protocol max is 16 MB)
-
-	minVersion = VersionSSL30
-	maxVersion = VersionTLS12
-)
-
-// TLS record types.
-type recordType uint8
-
-const (
-	recordTypeChangeCipherSpec recordType = 20
-	recordTypeAlert            recordType = 21
-	recordTypeHandshake        recordType = 22
-	recordTypeApplicationData  recordType = 23
-)
-
-// TLS handshake message types.
-const (
-	typeHelloRequest       uint8 = 0
-	typeClientHello        uint8 = 1
-	typeServerHello        uint8 = 2
-	typeNewSessionTicket   uint8 = 4
-	typeCertificate        uint8 = 11
-	typeServerKeyExchange  uint8 = 12
-	typeCertificateRequest uint8 = 13
-	typeServerHelloDone    uint8 = 14
-	typeCertificateVerify  uint8 = 15
-	typeClientKeyExchange  uint8 = 16
-	typeFinished           uint8 = 20
-	typeCertificateStatus  uint8 = 22
-	typeNextProtocol       uint8 = 67 // Not IANA assigned
-)
-
-// TLS compression types.
-const (
-	compressionNone uint8 = 0
-)
-
-// TLS extension numbers
-var (
-	extensionServerName          uint16 = 0
-	extensionStatusRequest       uint16 = 5
-	extensionSupportedCurves     uint16 = 10
-	extensionSupportedPoints     uint16 = 11
-	extensionSignatureAlgorithms uint16 = 13
-	extensionSessionTicket       uint16 = 35
-	extensionNextProtoNeg        uint16 = 13172 // not IANA assigned
-)
-
-// TLS Elliptic Curves
-// http://www.iana.org/assignments/tls-parameters/tls-parameters.xml#tls-parameters-8
-var (
-	curveP256 uint16 = 23
-	curveP384 uint16 = 24
-	curveP521 uint16 = 25
-)
-
-// TLS Elliptic Curve Point Formats
-// http://www.iana.org/assignments/tls-parameters/tls-parameters.xml#tls-parameters-9
-var (
-	pointFormatUncompressed uint8 = 0
-)
-
-// TLS CertificateStatusType (RFC 3546)
-const (
-	statusTypeOCSP uint8 = 1
-)
-
-// Certificate types (for certificateRequestMsg)
-const (
-	certTypeRSASign    = 1 // A certificate containing an RSA key
-	certTypeDSSSign    = 2 // A certificate containing a DSA key
-	certTypeRSAFixedDH = 3 // A certificate containing a static DH key
-	certTypeDSSFixedDH = 4 // A certificate containing a static DH key
-
-	// See RFC4492 sections 3 and 5.5.
-	certTypeECDSASign      = 64 // A certificate containing an ECDSA-capable public key, signed with ECDSA.
-	certTypeRSAFixedECDH   = 65 // A certificate containing an ECDH-capable public key, signed with RSA.
-	certTypeECDSAFixedECDH = 66 // A certificate containing an ECDH-capable public key, signed with ECDSA.
-
-	// Rest of these are reserved by the TLS spec
-)
-
-// Hash functions for TLS 1.2 (See RFC 5246, section A.4.1)
-const (
-	hashSHA1   uint8 = 2
-	hashSHA256 uint8 = 4
-)
-
-// Signature algorithms for TLS 1.2 (See RFC 5246, section A.4.1)
-const (
-	signatureRSA   uint8 = 1
-	signatureECDSA uint8 = 3
-)
-
-// signatureAndHash mirrors the TLS 1.2, SignatureAndHashAlgorithm struct. See
-// RFC 5246, section A.4.1.
-type signatureAndHash struct {
-	hash, signature uint8
-}
-
-// supportedSKXSignatureAlgorithms contains the signature and hash algorithms
-// that the code advertises as supported in a TLS 1.2 ClientHello.
-var supportedSKXSignatureAlgorithms = []signatureAndHash{
-	{hashSHA256, signatureRSA},
-	{hashSHA256, signatureECDSA},
-	{hashSHA1, signatureRSA},
-	{hashSHA1, signatureECDSA},
-}
-
-// supportedClientCertSignatureAlgorithms contains the signature and hash
-// algorithms that the code advertises as supported in a TLS 1.2
-// CertificateRequest.
-var supportedClientCertSignatureAlgorithms = []signatureAndHash{
-	{hashSHA256, signatureRSA},
-	{hashSHA256, signatureECDSA},
-}
-
-// ConnectionState records basic TLS details about the connection.
-type ConnectionState struct {
-	HandshakeComplete          bool                  // TLS handshake is complete
-	DidResume                  bool                  // connection resumes a previous TLS connection
-	CipherSuite                uint16                // cipher suite in use (TLS_RSA_WITH_RC4_128_SHA, ...)
-	NegotiatedProtocol         string                // negotiated next protocol (from Config.NextProtos)
-	NegotiatedProtocolIsMutual bool                  // negotiated protocol was advertised by server
-	ServerName                 string                // server name requested by client, if any (server side only)
-	PeerCertificates           []*x509.Certificate   // certificate chain presented by remote peer
-	VerifiedChains             [][]*x509.Certificate // verified chains built from PeerCertificates
-}
-
-// ClientAuthType declares the policy the server will follow for
-// TLS Client Authentication.
-type ClientAuthType int
-
-const (
-	NoClientCert ClientAuthType = iota
-	RequestClientCert
-	RequireAnyClientCert
-	VerifyClientCertIfGiven
-	RequireAndVerifyClientCert
-)
-
-// A Config structure is used to configure a TLS client or server. After one
-// has been passed to a TLS function it must not be modified.
-type Config struct {
-	// Rand provides the source of entropy for nonces and RSA blinding.
-	// If Rand is nil, TLS uses the cryptographic random reader in package
-	// crypto/rand.
-	Rand io.Reader
-
-	// Time returns the current time as the number of seconds since the epoch.
-	// If Time is nil, TLS uses time.Now.
-	Time func() time.Time
-
-	// Certificates contains one or more certificate chains
-	// to present to the other side of the connection.
-	// Server configurations must include at least one certificate.
-	Certificates []Certificate
-
-	// NameToCertificate maps from a certificate name to an element of
-	// Certificates. Note that a certificate name can be of the form
-	// '*.example.com' and so doesn't have to be a domain name as such.
-	// See Config.BuildNameToCertificate
-	// The nil value causes the first element of Certificates to be used
-	// for all connections.
-	NameToCertificate map[string]*Certificate
-
-	// RootCAs defines the set of root certificate authorities
-	// that clients use when verifying server certificates.
-	// If RootCAs is nil, TLS uses the host's root CA set.
-	RootCAs *x509.CertPool
-
-	// NextProtos is a list of supported, application level protocols.
-	NextProtos []string
-
-	// ServerName is included in the client's handshake to support virtual
-	// hosting.
-	ServerName string
-
-	// ClientAuth determines the server's policy for
-	// TLS Client Authentication. The default is NoClientCert.
-	ClientAuth ClientAuthType
-
-	// ClientCAs defines the set of root certificate authorities
-	// that servers use if required to verify a client certificate
-	// by the policy in ClientAuth.
-	ClientCAs *x509.CertPool
-
-	// InsecureSkipVerify controls whether a client verifies the
-	// server's certificate chain and host name.
-	// If InsecureSkipVerify is true, TLS accepts any certificate
-	// presented by the server and any host name in that certificate.
-	// In this mode, TLS is susceptible to man-in-the-middle attacks.
-	// This should be used only for testing.
-	InsecureSkipVerify bool
-
-	// CipherSuites is a list of supported cipher suites. If CipherSuites
-	// is nil, TLS uses a list of suites supported by the implementation.
-	CipherSuites []uint16
-
-	// PreferServerCipherSuites controls whether the server selects the
-	// client's most preferred ciphersuite, or the server's most preferred
-	// ciphersuite. If true then the server's preference, as expressed in
-	// the order of elements in CipherSuites, is used.
-	PreferServerCipherSuites bool
-
-	// SessionTicketsDisabled may be set to true to disable session ticket
-	// (resumption) support.
-	SessionTicketsDisabled bool
-
-	// SessionTicketKey is used by TLS servers to provide session
-	// resumption. See RFC 5077. If zero, it will be filled with
-	// random data before the first server handshake.
-	//
-	// If multiple servers are terminating connections for the same host
-	// they should all have the same SessionTicketKey. If the
-	// SessionTicketKey leaks, previously recorded and future TLS
-	// connections using that key are compromised.
-	SessionTicketKey [32]byte
-
-	// MinVersion contains the minimum SSL/TLS version that is acceptable.
-	// If zero, then SSLv3 is taken as the minimum.
-	MinVersion uint16
-
-	// MaxVersion contains the maximum SSL/TLS version that is acceptable.
-	// If zero, then the maximum version supported by this package is used,
-	// which is currently TLS 1.2.
-	MaxVersion uint16
-
-	serverInitOnce sync.Once // guards calling (*Config).serverInit
-}
-
-func (c *Config) serverInit() {
-	if c.SessionTicketsDisabled {
-		return
-	}
-
-	// If the key has already been set then we have nothing to do.
-	for _, b := range c.SessionTicketKey {
-		if b != 0 {
-			return
-		}
-	}
-
-	if _, err := io.ReadFull(c.rand(), c.SessionTicketKey[:]); err != nil {
-		c.SessionTicketsDisabled = true
-	}
-}
-
-func (c *Config) rand() io.Reader {
-	r := c.Rand
-	if r == nil {
-		return rand.Reader
-	}
-	return r
-}
-
-func (c *Config) time() time.Time {
-	t := c.Time
-	if t == nil {
-		t = time.Now
-	}
-	return t()
-}
-
-func (c *Config) cipherSuites() []uint16 {
-	s := c.CipherSuites
-	if s == nil {
-		s = defaultCipherSuites()
-	}
-	return s
-}
-
-func (c *Config) minVersion() uint16 {
-	if c == nil || c.MinVersion == 0 {
-		return minVersion
-	}
-	return c.MinVersion
-}
-
-func (c *Config) maxVersion() uint16 {
-	if c == nil || c.MaxVersion == 0 {
-		return maxVersion
-	}
-	return c.MaxVersion
-}
-
-// mutualVersion returns the protocol version to use given the advertised
-// version of the peer.
-func (c *Config) mutualVersion(vers uint16) (uint16, bool) {
-	minVersion := c.minVersion()
-	maxVersion := c.maxVersion()
-
-	if vers < minVersion {
-		return 0, false
-	}
-	if vers > maxVersion {
-		vers = maxVersion
-	}
-	return vers, true
-}
-
-// getCertificateForName returns the best certificate for the given name,
-// defaulting to the first element of c.Certificates if there are no good
-// options.
-func (c *Config) getCertificateForName(name string) *Certificate {
-	if len(c.Certificates) == 1 || c.NameToCertificate == nil {
-		// There's only one choice, so no point doing any work.
-		return &c.Certificates[0]
-	}
-
-	name = strings.ToLower(name)
-	for len(name) > 0 && name[len(name)-1] == '.' {
-		name = name[:len(name)-1]
-	}
-
-	if cert, ok := c.NameToCertificate[name]; ok {
-		return cert
-	}
-
-	// try replacing labels in the name with wildcards until we get a
-	// match.
-	labels := strings.Split(name, ".")
-	for i := range labels {
-		labels[i] = "*"
-		candidate := strings.Join(labels, ".")
-		if cert, ok := c.NameToCertificate[candidate]; ok {
-			return cert
-		}
-	}
-
-	// If nothing matches, return the first certificate.
-	return &c.Certificates[0]
-}
-
-// BuildNameToCertificate parses c.Certificates and builds c.NameToCertificate
-// from the CommonName and SubjectAlternateName fields of each of the leaf
-// certificates.
-func (c *Config) BuildNameToCertificate() {
-	c.NameToCertificate = make(map[string]*Certificate)
-	for i := range c.Certificates {
-		cert := &c.Certificates[i]
-		x509Cert, err := x509.ParseCertificate(cert.Certificate[0])
-		if err != nil {
-			continue
-		}
-		if len(x509Cert.Subject.CommonName) > 0 {
-			c.NameToCertificate[x509Cert.Subject.CommonName] = cert
-		}
-		for _, san := range x509Cert.DNSNames {
-			c.NameToCertificate[san] = cert
-		}
-	}
-}
-
-// A Certificate is a chain of one or more certificates, leaf first.
-type Certificate struct {
-	Certificate [][]byte
-	PrivateKey  crypto.PrivateKey // supported types: *rsa.PrivateKey, *ecdsa.PrivateKey
-	// OCSPStaple contains an optional OCSP response which will be served
-	// to clients that request it.
-	OCSPStaple []byte
-	// Leaf is the parsed form of the leaf certificate, which may be
-	// initialized using x509.ParseCertificate to reduce per-handshake
-	// processing for TLS clients doing client authentication. If nil, the
-	// leaf certificate will be parsed as needed.
-	Leaf *x509.Certificate
-}
-
-// A TLS record.
-type record struct {
-	contentType  recordType
-	major, minor uint8
-	payload      []byte
-}
-
-type handshakeMessage interface {
-	marshal() []byte
-	unmarshal([]byte) bool
-}
-
-// TODO(jsing): Make these available to both crypto/x509 and crypto/tls.
-type dsaSignature struct {
-	R, S *big.Int
-}
-
-type ecdsaSignature dsaSignature
-
-var emptyConfig Config
-
-func defaultConfig() *Config {
-	return &emptyConfig
-}
-
-var (
-	once                   sync.Once
-	varDefaultCipherSuites []uint16
-)
-
-func defaultCipherSuites() []uint16 {
-	once.Do(initDefaultCipherSuites)
-	return varDefaultCipherSuites
-}
-
-func initDefaultCipherSuites() {
-	varDefaultCipherSuites = make([]uint16, len(cipherSuites))
-	for i, suite := range cipherSuites {
-		varDefaultCipherSuites[i] = suite.id
-	}
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/conn.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/conn.go
deleted file mode 100644
index db036f967..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/conn.go
+++ /dev/null
@@ -1,1026 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// TLS low level connection and record layer
-
-package tls
-
-import (
-	"bytes"
-	"crypto/cipher"
-	"crypto/subtle"
-	"crypto/x509"
-	"errors"
-	"io"
-	"net"
-	"sync"
-	"time"
-)
-
-// A Conn represents a secured connection.
-// It implements the net.Conn interface.
-type Conn struct {
-	// constant
-	conn     net.Conn
-	isClient bool
-
-	// constant after handshake; protected by handshakeMutex
-	handshakeMutex    sync.Mutex // handshakeMutex < in.Mutex, out.Mutex, errMutex
-	vers              uint16     // TLS version
-	haveVers          bool       // version has been negotiated
-	config            *Config    // configuration passed to constructor
-	handshakeComplete bool
-	didResume         bool // whether this connection was a session resumption
-	cipherSuite       uint16
-	ocspResponse      []byte // stapled OCSP response
-	peerCertificates  []*x509.Certificate
-	// verifiedChains contains the certificate chains that we built, as
-	// opposed to the ones presented by the server.
-	verifiedChains [][]*x509.Certificate
-	// serverName contains the server name indicated by the client, if any.
-	serverName string
-
-	clientProtocol         string
-	clientProtocolFallback bool
-
-	// first permanent error
-	connErr
-
-	// input/output
-	in, out  halfConn     // in.Mutex < out.Mutex
-	rawInput *block       // raw input, right off the wire
-	input    *block       // application data waiting to be read
-	hand     bytes.Buffer // handshake data waiting to be read
-
-	tmp [16]byte
-}
-
-type connErr struct {
-	mu    sync.Mutex
-	value error
-}
-
-func (e *connErr) setError(err error) error {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	if e.value == nil {
-		e.value = err
-	}
-	return err
-}
-
-func (e *connErr) error() error {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	return e.value
-}
-
-// Access to net.Conn methods.
-// Cannot just embed net.Conn because that would
-// export the struct field too.
-
-// LocalAddr returns the local network address.
-func (c *Conn) LocalAddr() net.Addr {
-	return c.conn.LocalAddr()
-}
-
-// RemoteAddr returns the remote network address.
-func (c *Conn) RemoteAddr() net.Addr {
-	return c.conn.RemoteAddr()
-}
-
-// SetDeadline sets the read and write deadlines associated with the connection.
-// A zero value for t means Read and Write will not time out.
-// After a Write has timed out, the TLS state is corrupt and all future writes will return the same error.
-func (c *Conn) SetDeadline(t time.Time) error {
-	return c.conn.SetDeadline(t)
-}
-
-// SetReadDeadline sets the read deadline on the underlying connection.
-// A zero value for t means Read will not time out.
-func (c *Conn) SetReadDeadline(t time.Time) error {
-	return c.conn.SetReadDeadline(t)
-}
-
-// SetWriteDeadline sets the write deadline on the underlying conneciton.
-// A zero value for t means Write will not time out.
-// After a Write has timed out, the TLS state is corrupt and all future writes will return the same error.
-func (c *Conn) SetWriteDeadline(t time.Time) error {
-	return c.conn.SetWriteDeadline(t)
-}
-
-// A halfConn represents one direction of the record layer
-// connection, either sending or receiving.
-type halfConn struct {
-	sync.Mutex
-	version uint16      // protocol version
-	cipher  interface{} // cipher algorithm
-	mac     macFunction
-	seq     [8]byte // 64-bit sequence number
-	bfree   *block  // list of free blocks
-
-	nextCipher interface{} // next encryption state
-	nextMac    macFunction // next MAC algorithm
-
-	// used to save allocating a new buffer for each MAC.
-	inDigestBuf, outDigestBuf []byte
-}
-
-// prepareCipherSpec sets the encryption and MAC states
-// that a subsequent changeCipherSpec will use.
-func (hc *halfConn) prepareCipherSpec(version uint16, cipher interface{}, mac macFunction) {
-	hc.version = version
-	hc.nextCipher = cipher
-	hc.nextMac = mac
-}
-
-// changeCipherSpec changes the encryption and MAC states
-// to the ones previously passed to prepareCipherSpec.
-func (hc *halfConn) changeCipherSpec() error {
-	if hc.nextCipher == nil {
-		return alertInternalError
-	}
-	hc.cipher = hc.nextCipher
-	hc.mac = hc.nextMac
-	hc.nextCipher = nil
-	hc.nextMac = nil
-	for i := range hc.seq {
-		hc.seq[i] = 0
-	}
-	return nil
-}
-
-// incSeq increments the sequence number.
-func (hc *halfConn) incSeq() {
-	for i := 7; i >= 0; i-- {
-		hc.seq[i]++
-		if hc.seq[i] != 0 {
-			return
-		}
-	}
-
-	// Not allowed to let sequence number wrap.
-	// Instead, must renegotiate before it does.
-	// Not likely enough to bother.
-	panic("TLS: sequence number wraparound")
-}
-
-// resetSeq resets the sequence number to zero.
-func (hc *halfConn) resetSeq() {
-	for i := range hc.seq {
-		hc.seq[i] = 0
-	}
-}
-
-// removePadding returns an unpadded slice, in constant time, which is a prefix
-// of the input. It also returns a byte which is equal to 255 if the padding
-// was valid and 0 otherwise. See RFC 2246, section 6.2.3.2
-func removePadding(payload []byte) ([]byte, byte) {
-	if len(payload) < 1 {
-		return payload, 0
-	}
-
-	paddingLen := payload[len(payload)-1]
-	t := uint(len(payload)-1) - uint(paddingLen)
-	// if len(payload) >= (paddingLen - 1) then the MSB of t is zero
-	good := byte(int32(^t) >> 31)
-
-	toCheck := 255 // the maximum possible padding length
-	// The length of the padded data is public, so we can use an if here
-	if toCheck+1 > len(payload) {
-		toCheck = len(payload) - 1
-	}
-
-	for i := 0; i < toCheck; i++ {
-		t := uint(paddingLen) - uint(i)
-		// if i <= paddingLen then the MSB of t is zero
-		mask := byte(int32(^t) >> 31)
-		b := payload[len(payload)-1-i]
-		good &^= mask&paddingLen ^ mask&b
-	}
-
-	// We AND together the bits of good and replicate the result across
-	// all the bits.
-	good &= good << 4
-	good &= good << 2
-	good &= good << 1
-	good = uint8(int8(good) >> 7)
-
-	toRemove := good&paddingLen + 1
-	return payload[:len(payload)-int(toRemove)], good
-}
-
-// removePaddingSSL30 is a replacement for removePadding in the case that the
-// protocol version is SSLv3. In this version, the contents of the padding
-// are random and cannot be checked.
-func removePaddingSSL30(payload []byte) ([]byte, byte) {
-	if len(payload) < 1 {
-		return payload, 0
-	}
-
-	paddingLen := int(payload[len(payload)-1]) + 1
-	if paddingLen > len(payload) {
-		return payload, 0
-	}
-
-	return payload[:len(payload)-paddingLen], 255
-}
-
-func roundUp(a, b int) int {
-	return a + (b-a%b)%b
-}
-
-// cbcMode is an interface for block ciphers using cipher block chaining.
-type cbcMode interface {
-	cipher.BlockMode
-	SetIV([]byte)
-}
-
-// decrypt checks and strips the mac and decrypts the data in b. Returns a
-// success boolean, the number of bytes to skip from the start of the record in
-// order to get the application payload, and an optional alert value.
-func (hc *halfConn) decrypt(b *block) (ok bool, prefixLen int, alertValue alert) {
-	// pull out payload
-	payload := b.data[recordHeaderLen:]
-
-	macSize := 0
-	if hc.mac != nil {
-		macSize = hc.mac.Size()
-	}
-
-	paddingGood := byte(255)
-	explicitIVLen := 0
-
-	// decrypt
-	if hc.cipher != nil {
-		switch c := hc.cipher.(type) {
-		case cipher.Stream:
-			c.XORKeyStream(payload, payload)
-		case cipher.AEAD:
-			explicitIVLen = 8
-			if len(payload) < explicitIVLen {
-				return false, 0, alertBadRecordMAC
-			}
-			nonce := payload[:8]
-			payload = payload[8:]
-
-			var additionalData [13]byte
-			copy(additionalData[:], hc.seq[:])
-			copy(additionalData[8:], b.data[:3])
-			n := len(payload) - c.Overhead()
-			additionalData[11] = byte(n >> 8)
-			additionalData[12] = byte(n)
-			var err error
-			payload, err = c.Open(payload[:0], nonce, payload, additionalData[:])
-			if err != nil {
-				return false, 0, alertBadRecordMAC
-			}
-			b.resize(recordHeaderLen + explicitIVLen + len(payload))
-		case cbcMode:
-			blockSize := c.BlockSize()
-			if hc.version >= VersionTLS11 {
-				explicitIVLen = blockSize
-			}
-
-			if len(payload)%blockSize != 0 || len(payload) < roundUp(explicitIVLen+macSize+1, blockSize) {
-				return false, 0, alertBadRecordMAC
-			}
-
-			if explicitIVLen > 0 {
-				c.SetIV(payload[:explicitIVLen])
-				payload = payload[explicitIVLen:]
-			}
-			c.CryptBlocks(payload, payload)
-			if hc.version == VersionSSL30 {
-				payload, paddingGood = removePaddingSSL30(payload)
-			} else {
-				payload, paddingGood = removePadding(payload)
-			}
-			b.resize(recordHeaderLen + explicitIVLen + len(payload))
-
-			// note that we still have a timing side-channel in the
-			// MAC check, below. An attacker can align the record
-			// so that a correct padding will cause one less hash
-			// block to be calculated. Then they can iteratively
-			// decrypt a record by breaking each byte. See
-			// "Password Interception in a SSL/TLS Channel", Brice
-			// Canvel et al.
-			//
-			// However, our behavior matches OpenSSL, so we leak
-			// only as much as they do.
-		default:
-			panic("unknown cipher type")
-		}
-	}
-
-	// check, strip mac
-	if hc.mac != nil {
-		if len(payload) < macSize {
-			return false, 0, alertBadRecordMAC
-		}
-
-		// strip mac off payload, b.data
-		n := len(payload) - macSize
-		b.data[3] = byte(n >> 8)
-		b.data[4] = byte(n)
-		b.resize(recordHeaderLen + explicitIVLen + n)
-		remoteMAC := payload[n:]
-		localMAC := hc.mac.MAC(hc.inDigestBuf, hc.seq[0:], b.data[:recordHeaderLen], payload[:n])
-
-		if subtle.ConstantTimeCompare(localMAC, remoteMAC) != 1 || paddingGood != 255 {
-			return false, 0, alertBadRecordMAC
-		}
-		hc.inDigestBuf = localMAC
-	}
-	hc.incSeq()
-
-	return true, recordHeaderLen + explicitIVLen, 0
-}
-
-// padToBlockSize calculates the needed padding block, if any, for a payload.
-// On exit, prefix aliases payload and extends to the end of the last full
-// block of payload. finalBlock is a fresh slice which contains the contents of
-// any suffix of payload as well as the needed padding to make finalBlock a
-// full block.
-func padToBlockSize(payload []byte, blockSize int) (prefix, finalBlock []byte) {
-	overrun := len(payload) % blockSize
-	paddingLen := blockSize - overrun
-	prefix = payload[:len(payload)-overrun]
-	finalBlock = make([]byte, blockSize)
-	copy(finalBlock, payload[len(payload)-overrun:])
-	for i := overrun; i < blockSize; i++ {
-		finalBlock[i] = byte(paddingLen - 1)
-	}
-	return
-}
-
-// encrypt encrypts and macs the data in b.
-func (hc *halfConn) encrypt(b *block, explicitIVLen int) (bool, alert) {
-	// mac
-	if hc.mac != nil {
-		mac := hc.mac.MAC(hc.outDigestBuf, hc.seq[0:], b.data[:recordHeaderLen], b.data[recordHeaderLen+explicitIVLen:])
-
-		n := len(b.data)
-		b.resize(n + len(mac))
-		copy(b.data[n:], mac)
-		hc.outDigestBuf = mac
-	}
-
-	payload := b.data[recordHeaderLen:]
-
-	// encrypt
-	if hc.cipher != nil {
-		switch c := hc.cipher.(type) {
-		case cipher.Stream:
-			c.XORKeyStream(payload, payload)
-		case cipher.AEAD:
-			payloadLen := len(b.data) - recordHeaderLen - explicitIVLen
-			b.resize(len(b.data) + c.Overhead())
-			nonce := b.data[recordHeaderLen : recordHeaderLen+explicitIVLen]
-			payload := b.data[recordHeaderLen+explicitIVLen:]
-			payload = payload[:payloadLen]
-
-			var additionalData [13]byte
-			copy(additionalData[:], hc.seq[:])
-			copy(additionalData[8:], b.data[:3])
-			additionalData[11] = byte(payloadLen >> 8)
-			additionalData[12] = byte(payloadLen)
-
-			c.Seal(payload[:0], nonce, payload, additionalData[:])
-		case cbcMode:
-			blockSize := c.BlockSize()
-			if explicitIVLen > 0 {
-				c.SetIV(payload[:explicitIVLen])
-				payload = payload[explicitIVLen:]
-			}
-			prefix, finalBlock := padToBlockSize(payload, blockSize)
-			b.resize(recordHeaderLen + explicitIVLen + len(prefix) + len(finalBlock))
-			c.CryptBlocks(b.data[recordHeaderLen+explicitIVLen:], prefix)
-			c.CryptBlocks(b.data[recordHeaderLen+explicitIVLen+len(prefix):], finalBlock)
-		default:
-			panic("unknown cipher type")
-		}
-	}
-
-	// update length to include MAC and any block padding needed.
-	n := len(b.data) - recordHeaderLen
-	b.data[3] = byte(n >> 8)
-	b.data[4] = byte(n)
-	hc.incSeq()
-
-	return true, 0
-}
-
-// A block is a simple data buffer.
-type block struct {
-	data []byte
-	off  int // index for Read
-	link *block
-}
-
-// resize resizes block to be n bytes, growing if necessary.
-func (b *block) resize(n int) {
-	if n > cap(b.data) {
-		b.reserve(n)
-	}
-	b.data = b.data[0:n]
-}
-
-// reserve makes sure that block contains a capacity of at least n bytes.
-func (b *block) reserve(n int) {
-	if cap(b.data) >= n {
-		return
-	}
-	m := cap(b.data)
-	if m == 0 {
-		m = 1024
-	}
-	for m < n {
-		m *= 2
-	}
-	data := make([]byte, len(b.data), m)
-	copy(data, b.data)
-	b.data = data
-}
-
-// readFromUntil reads from r into b until b contains at least n bytes
-// or else returns an error.
-func (b *block) readFromUntil(r io.Reader, n int) error {
-	// quick case
-	if len(b.data) >= n {
-		return nil
-	}
-
-	// read until have enough.
-	b.reserve(n)
-	for {
-		m, err := r.Read(b.data[len(b.data):cap(b.data)])
-		b.data = b.data[0 : len(b.data)+m]
-		if len(b.data) >= n {
-			break
-		}
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (b *block) Read(p []byte) (n int, err error) {
-	n = copy(p, b.data[b.off:])
-	b.off += n
-	return
-}
-
-// newBlock allocates a new block, from hc's free list if possible.
-func (hc *halfConn) newBlock() *block {
-	b := hc.bfree
-	if b == nil {
-		return new(block)
-	}
-	hc.bfree = b.link
-	b.link = nil
-	b.resize(0)
-	return b
-}
-
-// freeBlock returns a block to hc's free list.
-// The protocol is such that each side only has a block or two on
-// its free list at a time, so there's no need to worry about
-// trimming the list, etc.
-func (hc *halfConn) freeBlock(b *block) {
-	b.link = hc.bfree
-	hc.bfree = b
-}
-
-// splitBlock splits a block after the first n bytes,
-// returning a block with those n bytes and a
-// block with the remainder.  the latter may be nil.
-func (hc *halfConn) splitBlock(b *block, n int) (*block, *block) {
-	if len(b.data) <= n {
-		return b, nil
-	}
-	bb := hc.newBlock()
-	bb.resize(len(b.data) - n)
-	copy(bb.data, b.data[n:])
-	b.data = b.data[0:n]
-	return b, bb
-}
-
-// readRecord reads the next TLS record from the connection
-// and updates the record layer state.
-// c.in.Mutex <= L; c.input == nil.
-func (c *Conn) readRecord(want recordType) error {
-	// Caller must be in sync with connection:
-	// handshake data if handshake not yet completed,
-	// else application data.  (We don't support renegotiation.)
-	switch want {
-	default:
-		return c.sendAlert(alertInternalError)
-	case recordTypeHandshake, recordTypeChangeCipherSpec:
-		if c.handshakeComplete {
-			return c.sendAlert(alertInternalError)
-		}
-	case recordTypeApplicationData:
-		if !c.handshakeComplete {
-			return c.sendAlert(alertInternalError)
-		}
-	}
-
-Again:
-	if c.rawInput == nil {
-		c.rawInput = c.in.newBlock()
-	}
-	b := c.rawInput
-
-	// Read header, payload.
-	if err := b.readFromUntil(c.conn, recordHeaderLen); err != nil {
-		// RFC suggests that EOF without an alertCloseNotify is
-		// an error, but popular web sites seem to do this,
-		// so we can't make it an error.
-		// if err == io.EOF {
-		// 	err = io.ErrUnexpectedEOF
-		// }
-		if e, ok := err.(net.Error); !ok || !e.Temporary() {
-			c.setError(err)
-		}
-		return err
-	}
-	typ := recordType(b.data[0])
-
-	// No valid TLS record has a type of 0x80, however SSLv2 handshakes
-	// start with a uint16 length where the MSB is set and the first record
-	// is always < 256 bytes long. Therefore typ == 0x80 strongly suggests
-	// an SSLv2 client.
-	if want == recordTypeHandshake && typ == 0x80 {
-		c.sendAlert(alertProtocolVersion)
-		return errors.New("tls: unsupported SSLv2 handshake received")
-	}
-
-	vers := uint16(b.data[1])<<8 | uint16(b.data[2])
-	n := int(b.data[3])<<8 | int(b.data[4])
-	if c.haveVers && vers != c.vers {
-		return c.sendAlert(alertProtocolVersion)
-	}
-	if n > maxCiphertext {
-		return c.sendAlert(alertRecordOverflow)
-	}
-	if !c.haveVers {
-		// First message, be extra suspicious:
-		// this might not be a TLS client.
-		// Bail out before reading a full 'body', if possible.
-		// The current max version is 3.1.
-		// If the version is >= 16.0, it's probably not real.
-		// Similarly, a clientHello message encodes in
-		// well under a kilobyte.  If the length is >= 12 kB,
-		// it's probably not real.
-		if (typ != recordTypeAlert && typ != want) || vers >= 0x1000 || n >= 0x3000 {
-			return c.sendAlert(alertUnexpectedMessage)
-		}
-	}
-	if err := b.readFromUntil(c.conn, recordHeaderLen+n); err != nil {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-		if e, ok := err.(net.Error); !ok || !e.Temporary() {
-			c.setError(err)
-		}
-		return err
-	}
-
-	// Process message.
-	b, c.rawInput = c.in.splitBlock(b, recordHeaderLen+n)
-	ok, off, err := c.in.decrypt(b)
-	if !ok {
-		return c.sendAlert(err)
-	}
-	b.off = off
-	data := b.data[b.off:]
-	if len(data) > maxPlaintext {
-		c.sendAlert(alertRecordOverflow)
-		c.in.freeBlock(b)
-		return c.error()
-	}
-
-	switch typ {
-	default:
-		c.sendAlert(alertUnexpectedMessage)
-
-	case recordTypeAlert:
-		if len(data) != 2 {
-			c.sendAlert(alertUnexpectedMessage)
-			break
-		}
-		if alert(data[1]) == alertCloseNotify {
-			c.setError(io.EOF)
-			break
-		}
-		switch data[0] {
-		case alertLevelWarning:
-			// drop on the floor
-			c.in.freeBlock(b)
-			goto Again
-		case alertLevelError:
-			c.setError(&net.OpError{Op: "remote error", Err: alert(data[1])})
-		default:
-			c.sendAlert(alertUnexpectedMessage)
-		}
-
-	case recordTypeChangeCipherSpec:
-		if typ != want || len(data) != 1 || data[0] != 1 {
-			c.sendAlert(alertUnexpectedMessage)
-			break
-		}
-		err := c.in.changeCipherSpec()
-		if err != nil {
-			c.sendAlert(err.(alert))
-		}
-
-	case recordTypeApplicationData:
-		if typ != want {
-			c.sendAlert(alertUnexpectedMessage)
-			break
-		}
-		c.input = b
-		b = nil
-
-	case recordTypeHandshake:
-		// TODO(rsc): Should at least pick off connection close.
-		if typ != want && !c.isClient {
-			return c.sendAlert(alertNoRenegotiation)
-		}
-		c.hand.Write(data)
-	}
-
-	if b != nil {
-		c.in.freeBlock(b)
-	}
-	return c.error()
-}
-
-// sendAlert sends a TLS alert message.
-// c.out.Mutex <= L.
-func (c *Conn) sendAlertLocked(err alert) error {
-	switch err {
-	case alertNoRenegotiation, alertCloseNotify:
-		c.tmp[0] = alertLevelWarning
-	default:
-		c.tmp[0] = alertLevelError
-	}
-	c.tmp[1] = byte(err)
-	c.writeRecord(recordTypeAlert, c.tmp[0:2])
-	// closeNotify is a special case in that it isn't an error:
-	if err != alertCloseNotify {
-		return c.setError(&net.OpError{Op: "local error", Err: err})
-	}
-	return nil
-}
-
-// sendAlert sends a TLS alert message.
-// L < c.out.Mutex.
-func (c *Conn) sendAlert(err alert) error {
-	c.out.Lock()
-	defer c.out.Unlock()
-	return c.sendAlertLocked(err)
-}
-
-// writeRecord writes a TLS record with the given type and payload
-// to the connection and updates the record layer state.
-// c.out.Mutex <= L.
-func (c *Conn) writeRecord(typ recordType, data []byte) (n int, err error) {
-	b := c.out.newBlock()
-	for len(data) > 0 {
-		m := len(data)
-		if m > maxPlaintext {
-			m = maxPlaintext
-		}
-		explicitIVLen := 0
-		explicitIVIsSeq := false
-
-		var cbc cbcMode
-		if c.out.version >= VersionTLS11 {
-			var ok bool
-			if cbc, ok = c.out.cipher.(cbcMode); ok {
-				explicitIVLen = cbc.BlockSize()
-			}
-		}
-		if explicitIVLen == 0 {
-			if _, ok := c.out.cipher.(cipher.AEAD); ok {
-				explicitIVLen = 8
-				// The AES-GCM construction in TLS has an
-				// explicit nonce so that the nonce can be
-				// random. However, the nonce is only 8 bytes
-				// which is too small for a secure, random
-				// nonce. Therefore we use the sequence number
-				// as the nonce.
-				explicitIVIsSeq = true
-			}
-		}
-		b.resize(recordHeaderLen + explicitIVLen + m)
-		b.data[0] = byte(typ)
-		vers := c.vers
-		if vers == 0 {
-			// Some TLS servers fail if the record version is
-			// greater than TLS 1.0 for the initial ClientHello.
-			vers = VersionTLS10
-		}
-		b.data[1] = byte(vers >> 8)
-		b.data[2] = byte(vers)
-		b.data[3] = byte(m >> 8)
-		b.data[4] = byte(m)
-		if explicitIVLen > 0 {
-			explicitIV := b.data[recordHeaderLen : recordHeaderLen+explicitIVLen]
-			if explicitIVIsSeq {
-				copy(explicitIV, c.out.seq[:])
-			} else {
-				if _, err = io.ReadFull(c.config.rand(), explicitIV); err != nil {
-					break
-				}
-			}
-		}
-		copy(b.data[recordHeaderLen+explicitIVLen:], data)
-		c.out.encrypt(b, explicitIVLen)
-		_, err = c.conn.Write(b.data)
-		if err != nil {
-			break
-		}
-		n += m
-		data = data[m:]
-	}
-	c.out.freeBlock(b)
-
-	if typ == recordTypeChangeCipherSpec {
-		err = c.out.changeCipherSpec()
-		if err != nil {
-			// Cannot call sendAlert directly,
-			// because we already hold c.out.Mutex.
-			c.tmp[0] = alertLevelError
-			c.tmp[1] = byte(err.(alert))
-			c.writeRecord(recordTypeAlert, c.tmp[0:2])
-			return n, c.setError(&net.OpError{Op: "local error", Err: err})
-		}
-	}
-	return
-}
-
-// readHandshake reads the next handshake message from
-// the record layer.
-// c.in.Mutex < L; c.out.Mutex < L.
-func (c *Conn) readHandshake() (interface{}, error) {
-	for c.hand.Len() < 4 {
-		if err := c.error(); err != nil {
-			return nil, err
-		}
-		if err := c.readRecord(recordTypeHandshake); err != nil {
-			return nil, err
-		}
-	}
-
-	data := c.hand.Bytes()
-	n := int(data[1])<<16 | int(data[2])<<8 | int(data[3])
-	if n > maxHandshake {
-		c.sendAlert(alertInternalError)
-		return nil, c.error()
-	}
-	for c.hand.Len() < 4+n {
-		if err := c.error(); err != nil {
-			return nil, err
-		}
-		if err := c.readRecord(recordTypeHandshake); err != nil {
-			return nil, err
-		}
-	}
-	data = c.hand.Next(4 + n)
-	var m handshakeMessage
-	switch data[0] {
-	case typeHelloRequest:
-		m = new(helloRequestMsg)
-	case typeClientHello:
-		m = new(clientHelloMsg)
-	case typeServerHello:
-		m = new(serverHelloMsg)
-	case typeCertificate:
-		m = new(certificateMsg)
-	case typeCertificateRequest:
-		m = &certificateRequestMsg{
-			hasSignatureAndHash: c.vers >= VersionTLS12,
-		}
-	case typeCertificateStatus:
-		m = new(certificateStatusMsg)
-	case typeServerKeyExchange:
-		m = new(serverKeyExchangeMsg)
-	case typeServerHelloDone:
-		m = new(serverHelloDoneMsg)
-	case typeClientKeyExchange:
-		m = new(clientKeyExchangeMsg)
-	case typeCertificateVerify:
-		m = &certificateVerifyMsg{
-			hasSignatureAndHash: c.vers >= VersionTLS12,
-		}
-	case typeNextProtocol:
-		m = new(nextProtoMsg)
-	case typeFinished:
-		m = new(finishedMsg)
-	default:
-		c.sendAlert(alertUnexpectedMessage)
-		return nil, alertUnexpectedMessage
-	}
-
-	// The handshake message unmarshallers
-	// expect to be able to keep references to data,
-	// so pass in a fresh copy that won't be overwritten.
-	data = append([]byte(nil), data...)
-
-	if !m.unmarshal(data) {
-		c.sendAlert(alertUnexpectedMessage)
-		return nil, alertUnexpectedMessage
-	}
-	return m, nil
-}
-
-// Write writes data to the connection.
-func (c *Conn) Write(b []byte) (int, error) {
-	if err := c.error(); err != nil {
-		return 0, err
-	}
-
-	if err := c.Handshake(); err != nil {
-		return 0, c.setError(err)
-	}
-
-	c.out.Lock()
-	defer c.out.Unlock()
-
-	if !c.handshakeComplete {
-		return 0, alertInternalError
-	}
-
-	// SSL 3.0 and TLS 1.0 are susceptible to a chosen-plaintext
-	// attack when using block mode ciphers due to predictable IVs.
-	// This can be prevented by splitting each Application Data
-	// record into two records, effectively randomizing the IV.
-	//
-	// http://www.openssl.org/~bodo/tls-cbc.txt
-	// https://bugzilla.mozilla.org/show_bug.cgi?id=665814
-	// http://www.imperialviolet.org/2012/01/15/beastfollowup.html
-
-	var m int
-	if len(b) > 1 && c.vers <= VersionTLS10 {
-		if _, ok := c.out.cipher.(cipher.BlockMode); ok {
-			n, err := c.writeRecord(recordTypeApplicationData, b[:1])
-			if err != nil {
-				return n, c.setError(err)
-			}
-			m, b = 1, b[1:]
-		}
-	}
-
-	n, err := c.writeRecord(recordTypeApplicationData, b)
-	return n + m, c.setError(err)
-}
-
-func (c *Conn) handleRenegotiation() error {
-	c.handshakeComplete = false
-	if !c.isClient {
-		panic("renegotiation should only happen for a client")
-	}
-
-	msg, err := c.readHandshake()
-	if err != nil {
-		return err
-	}
-	_, ok := msg.(*helloRequestMsg)
-	if !ok {
-		c.sendAlert(alertUnexpectedMessage)
-		return alertUnexpectedMessage
-	}
-
-	return c.Handshake()
-}
-
-// Read can be made to time out and return a net.Error with Timeout() == true
-// after a fixed time limit; see SetDeadline and SetReadDeadline.
-func (c *Conn) Read(b []byte) (n int, err error) {
-	if err = c.Handshake(); err != nil {
-		return
-	}
-
-	c.in.Lock()
-	defer c.in.Unlock()
-
-	// Some OpenSSL servers send empty records in order to randomize the
-	// CBC IV. So this loop ignores a limited number of empty records.
-	const maxConsecutiveEmptyRecords = 100
-	for emptyRecordCount := 0; emptyRecordCount <= maxConsecutiveEmptyRecords; emptyRecordCount++ {
-		for c.input == nil && c.error() == nil {
-			if err := c.readRecord(recordTypeApplicationData); err != nil {
-				// Soft error, like EAGAIN
-				return 0, err
-			}
-			if c.hand.Len() > 0 {
-				// We received handshake bytes, indicating the start of
-				// a renegotiation.
-				if err := c.handleRenegotiation(); err != nil {
-					return 0, err
-				}
-				continue
-			}
-		}
-		if err := c.error(); err != nil {
-			return 0, err
-		}
-
-		n, err = c.input.Read(b)
-		if c.input.off >= len(c.input.data) {
-			c.in.freeBlock(c.input)
-			c.input = nil
-		}
-
-		if n != 0 || err != nil {
-			return n, err
-		}
-	}
-
-	return 0, io.ErrNoProgress
-}
-
-// Close closes the connection.
-func (c *Conn) Close() error {
-	var alertErr error
-
-	c.handshakeMutex.Lock()
-	defer c.handshakeMutex.Unlock()
-	if c.handshakeComplete {
-		alertErr = c.sendAlert(alertCloseNotify)
-	}
-
-	if err := c.conn.Close(); err != nil {
-		return err
-	}
-	return alertErr
-}
-
-// Handshake runs the client or server handshake
-// protocol if it has not yet been run.
-// Most uses of this package need not call Handshake
-// explicitly: the first Read or Write will call it automatically.
-func (c *Conn) Handshake() error {
-	c.handshakeMutex.Lock()
-	defer c.handshakeMutex.Unlock()
-	if err := c.error(); err != nil {
-		return err
-	}
-	if c.handshakeComplete {
-		return nil
-	}
-	if c.isClient {
-		return c.clientHandshake()
-	}
-	return c.serverHandshake()
-}
-
-// ConnectionState returns basic TLS details about the connection.
-func (c *Conn) ConnectionState() ConnectionState {
-	c.handshakeMutex.Lock()
-	defer c.handshakeMutex.Unlock()
-
-	var state ConnectionState
-	state.HandshakeComplete = c.handshakeComplete
-	if c.handshakeComplete {
-		state.NegotiatedProtocol = c.clientProtocol
-		state.DidResume = c.didResume
-		state.NegotiatedProtocolIsMutual = !c.clientProtocolFallback
-		state.CipherSuite = c.cipherSuite
-		state.PeerCertificates = c.peerCertificates
-		state.VerifiedChains = c.verifiedChains
-		state.ServerName = c.serverName
-	}
-
-	return state
-}
-
-// OCSPResponse returns the stapled OCSP response from the TLS server, if
-// any. (Only valid for client connections.)
-func (c *Conn) OCSPResponse() []byte {
-	c.handshakeMutex.Lock()
-	defer c.handshakeMutex.Unlock()
-
-	return c.ocspResponse
-}
-
-// VerifyHostname checks that the peer certificate chain is valid for
-// connecting to host.  If so, it returns nil; if not, it returns an error
-// describing the problem.
-func (c *Conn) VerifyHostname(host string) error {
-	c.handshakeMutex.Lock()
-	defer c.handshakeMutex.Unlock()
-	if !c.isClient {
-		return errors.New("VerifyHostname called on TLS server connection")
-	}
-	if !c.handshakeComplete {
-		return errors.New("TLS handshake has not yet been performed")
-	}
-	return c.peerCertificates[0].VerifyHostname(host)
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_client.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_client.go
deleted file mode 100644
index 85e4adefc..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_client.go
+++ /dev/null
@@ -1,411 +0,0 @@
-// Copyright 2009 The Go 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 tls
-
-import (
-	"bytes"
-	"crypto/ecdsa"
-	"crypto/rsa"
-	"crypto/subtle"
-	"crypto/x509"
-	"encoding/asn1"
-	"errors"
-	"io"
-	"strconv"
-)
-
-func (c *Conn) clientHandshake() error {
-	if c.config == nil {
-		c.config = defaultConfig()
-	}
-
-	hello := &clientHelloMsg{
-		vers:               c.config.maxVersion(),
-		compressionMethods: []uint8{compressionNone},
-		random:             make([]byte, 32),
-		ocspStapling:       true,
-		serverName:         c.config.ServerName,
-		supportedCurves:    []uint16{curveP256, curveP384, curveP521},
-		supportedPoints:    []uint8{pointFormatUncompressed},
-		nextProtoNeg:       len(c.config.NextProtos) > 0,
-	}
-
-	possibleCipherSuites := c.config.cipherSuites()
-	hello.cipherSuites = make([]uint16, 0, len(possibleCipherSuites))
-
-NextCipherSuite:
-	for _, suiteId := range possibleCipherSuites {
-		for _, suite := range cipherSuites {
-			if suite.id != suiteId {
-				continue
-			}
-			// Don't advertise TLS 1.2-only cipher suites unless
-			// we're attempting TLS 1.2.
-			if hello.vers < VersionTLS12 && suite.flags&suiteTLS12 != 0 {
-				continue
-			}
-			hello.cipherSuites = append(hello.cipherSuites, suiteId)
-			continue NextCipherSuite
-		}
-	}
-
-	t := uint32(c.config.time().Unix())
-	hello.random[0] = byte(t >> 24)
-	hello.random[1] = byte(t >> 16)
-	hello.random[2] = byte(t >> 8)
-	hello.random[3] = byte(t)
-	_, err := io.ReadFull(c.config.rand(), hello.random[4:])
-	if err != nil {
-		c.sendAlert(alertInternalError)
-		return errors.New("short read from Rand")
-	}
-
-	if hello.vers >= VersionTLS12 {
-		hello.signatureAndHashes = supportedSKXSignatureAlgorithms
-	}
-
-	c.writeRecord(recordTypeHandshake, hello.marshal())
-
-	msg, err := c.readHandshake()
-	if err != nil {
-		return err
-	}
-	serverHello, ok := msg.(*serverHelloMsg)
-	if !ok {
-		return c.sendAlert(alertUnexpectedMessage)
-	}
-
-	vers, ok := c.config.mutualVersion(serverHello.vers)
-	if !ok || vers < VersionTLS10 {
-		// TLS 1.0 is the minimum version supported as a client.
-		return c.sendAlert(alertProtocolVersion)
-	}
-	c.vers = vers
-	c.haveVers = true
-
-	finishedHash := newFinishedHash(c.vers)
-	finishedHash.Write(hello.marshal())
-	finishedHash.Write(serverHello.marshal())
-
-	if serverHello.compressionMethod != compressionNone {
-		return c.sendAlert(alertUnexpectedMessage)
-	}
-
-	if !hello.nextProtoNeg && serverHello.nextProtoNeg {
-		c.sendAlert(alertHandshakeFailure)
-		return errors.New("server advertised unrequested NPN")
-	}
-
-	suite := mutualCipherSuite(c.config.cipherSuites(), serverHello.cipherSuite)
-	if suite == nil {
-		return c.sendAlert(alertHandshakeFailure)
-	}
-
-	msg, err = c.readHandshake()
-	if err != nil {
-		return err
-	}
-	certMsg, ok := msg.(*certificateMsg)
-	if !ok || len(certMsg.certificates) == 0 {
-		return c.sendAlert(alertUnexpectedMessage)
-	}
-	finishedHash.Write(certMsg.marshal())
-
-	certs := make([]*x509.Certificate, len(certMsg.certificates))
-	for i, asn1Data := range certMsg.certificates {
-		cert, err := x509.ParseCertificate(asn1Data)
-		if err != nil {
-			c.sendAlert(alertBadCertificate)
-			return errors.New("failed to parse certificate from server: " + err.Error())
-		}
-		certs[i] = cert
-	}
-
-	if !c.config.InsecureSkipVerify {
-		opts := x509.VerifyOptions{
-			Roots:         c.config.RootCAs,
-			CurrentTime:   c.config.time(),
-			DNSName:       c.config.ServerName,
-			Intermediates: x509.NewCertPool(),
-		}
-
-		for i, cert := range certs {
-			if i == 0 {
-				continue
-			}
-			opts.Intermediates.AddCert(cert)
-		}
-		c.verifiedChains, err = certs[0].Verify(opts)
-		if err != nil {
-			c.sendAlert(alertBadCertificate)
-			return err
-		}
-	}
-
-	switch certs[0].PublicKey.(type) {
-	case *rsa.PublicKey, *ecdsa.PublicKey:
-		break
-	default:
-		return c.sendAlert(alertUnsupportedCertificate)
-	}
-
-	c.peerCertificates = certs
-
-	if serverHello.ocspStapling {
-		msg, err = c.readHandshake()
-		if err != nil {
-			return err
-		}
-		cs, ok := msg.(*certificateStatusMsg)
-		if !ok {
-			return c.sendAlert(alertUnexpectedMessage)
-		}
-		finishedHash.Write(cs.marshal())
-
-		if cs.statusType == statusTypeOCSP {
-			c.ocspResponse = cs.response
-		}
-	}
-
-	msg, err = c.readHandshake()
-	if err != nil {
-		return err
-	}
-
-	keyAgreement := suite.ka(c.vers)
-
-	skx, ok := msg.(*serverKeyExchangeMsg)
-	if ok {
-		finishedHash.Write(skx.marshal())
-		err = keyAgreement.processServerKeyExchange(c.config, hello, serverHello, certs[0], skx)
-		if err != nil {
-			c.sendAlert(alertUnexpectedMessage)
-			return err
-		}
-
-		msg, err = c.readHandshake()
-		if err != nil {
-			return err
-		}
-	}
-
-	var chainToSend *Certificate
-	var certRequested bool
-	certReq, ok := msg.(*certificateRequestMsg)
-	if ok {
-		certRequested = true
-
-		// RFC 4346 on the certificateAuthorities field:
-		// A list of the distinguished names of acceptable certificate
-		// authorities. These distinguished names may specify a desired
-		// distinguished name for a root CA or for a subordinate CA;
-		// thus, this message can be used to describe both known roots
-		// and a desired authorization space. If the
-		// certificate_authorities list is empty then the client MAY
-		// send any certificate of the appropriate
-		// ClientCertificateType, unless there is some external
-		// arrangement to the contrary.
-
-		finishedHash.Write(certReq.marshal())
-
-		var rsaAvail, ecdsaAvail bool
-		for _, certType := range certReq.certificateTypes {
-			switch certType {
-			case certTypeRSASign:
-				rsaAvail = true
-			case certTypeECDSASign:
-				ecdsaAvail = true
-			}
-		}
-
-		// We need to search our list of client certs for one
-		// where SignatureAlgorithm is RSA and the Issuer is in
-		// certReq.certificateAuthorities
-	findCert:
-		for i, chain := range c.config.Certificates {
-			if !rsaAvail && !ecdsaAvail {
-				continue
-			}
-
-			for j, cert := range chain.Certificate {
-				x509Cert := chain.Leaf
-				// parse the certificate if this isn't the leaf
-				// node, or if chain.Leaf was nil
-				if j != 0 || x509Cert == nil {
-					if x509Cert, err = x509.ParseCertificate(cert); err != nil {
-						c.sendAlert(alertInternalError)
-						return errors.New("tls: failed to parse client certificate #" + strconv.Itoa(i) + ": " + err.Error())
-					}
-				}
-
-				switch {
-				case rsaAvail && x509Cert.PublicKeyAlgorithm == x509.RSA:
-				case ecdsaAvail && x509Cert.PublicKeyAlgorithm == x509.ECDSA:
-				default:
-					continue findCert
-				}
-
-				if len(certReq.certificateAuthorities) == 0 {
-					// they gave us an empty list, so just take the
-					// first RSA cert from c.config.Certificates
-					chainToSend = &chain
-					break findCert
-				}
-
-				for _, ca := range certReq.certificateAuthorities {
-					if bytes.Equal(x509Cert.RawIssuer, ca) {
-						chainToSend = &chain
-						break findCert
-					}
-				}
-			}
-		}
-
-		msg, err = c.readHandshake()
-		if err != nil {
-			return err
-		}
-	}
-
-	shd, ok := msg.(*serverHelloDoneMsg)
-	if !ok {
-		return c.sendAlert(alertUnexpectedMessage)
-	}
-	finishedHash.Write(shd.marshal())
-
-	// If the server requested a certificate then we have to send a
-	// Certificate message, even if it's empty because we don't have a
-	// certificate to send.
-	if certRequested {
-		certMsg = new(certificateMsg)
-		if chainToSend != nil {
-			certMsg.certificates = chainToSend.Certificate
-		}
-		finishedHash.Write(certMsg.marshal())
-		c.writeRecord(recordTypeHandshake, certMsg.marshal())
-	}
-
-	preMasterSecret, ckx, err := keyAgreement.generateClientKeyExchange(c.config, hello, certs[0])
-	if err != nil {
-		c.sendAlert(alertInternalError)
-		return err
-	}
-	if ckx != nil {
-		finishedHash.Write(ckx.marshal())
-		c.writeRecord(recordTypeHandshake, ckx.marshal())
-	}
-
-	if chainToSend != nil {
-		var signed []byte
-		certVerify := &certificateVerifyMsg{
-			hasSignatureAndHash: c.vers >= VersionTLS12,
-		}
-
-		switch key := c.config.Certificates[0].PrivateKey.(type) {
-		case *ecdsa.PrivateKey:
-			digest, _, hashId := finishedHash.hashForClientCertificate(signatureECDSA)
-			r, s, err := ecdsa.Sign(c.config.rand(), key, digest)
-			if err == nil {
-				signed, err = asn1.Marshal(ecdsaSignature{r, s})
-			}
-			certVerify.signatureAndHash.signature = signatureECDSA
-			certVerify.signatureAndHash.hash = hashId
-		case *rsa.PrivateKey:
-			digest, hashFunc, hashId := finishedHash.hashForClientCertificate(signatureRSA)
-			signed, err = rsa.SignPKCS1v15(c.config.rand(), key, hashFunc, digest)
-			certVerify.signatureAndHash.signature = signatureRSA
-			certVerify.signatureAndHash.hash = hashId
-		default:
-			err = errors.New("unknown private key type")
-		}
-		if err != nil {
-			return c.sendAlert(alertInternalError)
-		}
-		certVerify.signature = signed
-
-		finishedHash.Write(certVerify.marshal())
-		c.writeRecord(recordTypeHandshake, certVerify.marshal())
-	}
-
-	masterSecret := masterFromPreMasterSecret(c.vers, preMasterSecret, hello.random, serverHello.random)
-	clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV :=
-		keysFromMasterSecret(c.vers, masterSecret, hello.random, serverHello.random, suite.macLen, suite.keyLen, suite.ivLen)
-
-	var clientCipher interface{}
-	var clientHash macFunction
-	if suite.cipher != nil {
-		clientCipher = suite.cipher(clientKey, clientIV, false /* not for reading */)
-		clientHash = suite.mac(c.vers, clientMAC)
-	} else {
-		clientCipher = suite.aead(clientKey, clientIV)
-	}
-	c.out.prepareCipherSpec(c.vers, clientCipher, clientHash)
-	c.writeRecord(recordTypeChangeCipherSpec, []byte{1})
-
-	if serverHello.nextProtoNeg {
-		nextProto := new(nextProtoMsg)
-		proto, fallback := mutualProtocol(c.config.NextProtos, serverHello.nextProtos)
-		nextProto.proto = proto
-		c.clientProtocol = proto
-		c.clientProtocolFallback = fallback
-
-		finishedHash.Write(nextProto.marshal())
-		c.writeRecord(recordTypeHandshake, nextProto.marshal())
-	}
-
-	finished := new(finishedMsg)
-	finished.verifyData = finishedHash.clientSum(masterSecret)
-	finishedHash.Write(finished.marshal())
-	c.writeRecord(recordTypeHandshake, finished.marshal())
-
-	var serverCipher interface{}
-	var serverHash macFunction
-	if suite.cipher != nil {
-		serverCipher = suite.cipher(serverKey, serverIV, true /* for reading */)
-		serverHash = suite.mac(c.vers, serverMAC)
-	} else {
-		serverCipher = suite.aead(serverKey, serverIV)
-	}
-	c.in.prepareCipherSpec(c.vers, serverCipher, serverHash)
-	c.readRecord(recordTypeChangeCipherSpec)
-	if err := c.error(); err != nil {
-		return err
-	}
-
-	msg, err = c.readHandshake()
-	if err != nil {
-		return err
-	}
-	serverFinished, ok := msg.(*finishedMsg)
-	if !ok {
-		return c.sendAlert(alertUnexpectedMessage)
-	}
-
-	verify := finishedHash.serverSum(masterSecret)
-	if len(verify) != len(serverFinished.verifyData) ||
-		subtle.ConstantTimeCompare(verify, serverFinished.verifyData) != 1 {
-		return c.sendAlert(alertHandshakeFailure)
-	}
-
-	c.handshakeComplete = true
-	c.cipherSuite = suite.id
-	return nil
-}
-
-// mutualProtocol finds the mutual Next Protocol Negotiation protocol given the
-// set of client and server supported protocols. The set of client supported
-// protocols must not be empty. It returns the resulting protocol and flag
-// indicating if the fallback case was reached.
-func mutualProtocol(clientProtos, serverProtos []string) (string, bool) {
-	for _, s := range serverProtos {
-		for _, c := range clientProtos {
-			if s == c {
-				return s, false
-			}
-		}
-	}
-
-	return clientProtos[0], true
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_messages.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_messages.go
deleted file mode 100644
index 8197391e3..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_messages.go
+++ /dev/null
@@ -1,1304 +0,0 @@
-// Copyright 2009 The Go 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 tls
-
-import "bytes"
-
-type clientHelloMsg struct {
-	raw                []byte
-	vers               uint16
-	random             []byte
-	sessionId          []byte
-	cipherSuites       []uint16
-	compressionMethods []uint8
-	nextProtoNeg       bool
-	serverName         string
-	ocspStapling       bool
-	supportedCurves    []uint16
-	supportedPoints    []uint8
-	ticketSupported    bool
-	sessionTicket      []uint8
-	signatureAndHashes []signatureAndHash
-}
-
-func (m *clientHelloMsg) equal(i interface{}) bool {
-	m1, ok := i.(*clientHelloMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		m.vers == m1.vers &&
-		bytes.Equal(m.random, m1.random) &&
-		bytes.Equal(m.sessionId, m1.sessionId) &&
-		eqUint16s(m.cipherSuites, m1.cipherSuites) &&
-		bytes.Equal(m.compressionMethods, m1.compressionMethods) &&
-		m.nextProtoNeg == m1.nextProtoNeg &&
-		m.serverName == m1.serverName &&
-		m.ocspStapling == m1.ocspStapling &&
-		eqUint16s(m.supportedCurves, m1.supportedCurves) &&
-		bytes.Equal(m.supportedPoints, m1.supportedPoints) &&
-		m.ticketSupported == m1.ticketSupported &&
-		bytes.Equal(m.sessionTicket, m1.sessionTicket) &&
-		eqSignatureAndHashes(m.signatureAndHashes, m1.signatureAndHashes)
-}
-
-func (m *clientHelloMsg) marshal() []byte {
-	if m.raw != nil {
-		return m.raw
-	}
-
-	length := 2 + 32 + 1 + len(m.sessionId) + 2 + len(m.cipherSuites)*2 + 1 + len(m.compressionMethods)
-	numExtensions := 0
-	extensionsLength := 0
-	if m.nextProtoNeg {
-		numExtensions++
-	}
-	if m.ocspStapling {
-		extensionsLength += 1 + 2 + 2
-		numExtensions++
-	}
-	if len(m.serverName) > 0 {
-		extensionsLength += 5 + len(m.serverName)
-		numExtensions++
-	}
-	if len(m.supportedCurves) > 0 {
-		extensionsLength += 2 + 2*len(m.supportedCurves)
-		numExtensions++
-	}
-	if len(m.supportedPoints) > 0 {
-		extensionsLength += 1 + len(m.supportedPoints)
-		numExtensions++
-	}
-	if m.ticketSupported {
-		extensionsLength += len(m.sessionTicket)
-		numExtensions++
-	}
-	if len(m.signatureAndHashes) > 0 {
-		extensionsLength += 2 + 2*len(m.signatureAndHashes)
-		numExtensions++
-	}
-	if numExtensions > 0 {
-		extensionsLength += 4 * numExtensions
-		length += 2 + extensionsLength
-	}
-
-	x := make([]byte, 4+length)
-	x[0] = typeClientHello
-	x[1] = uint8(length >> 16)
-	x[2] = uint8(length >> 8)
-	x[3] = uint8(length)
-	x[4] = uint8(m.vers >> 8)
-	x[5] = uint8(m.vers)
-	copy(x[6:38], m.random)
-	x[38] = uint8(len(m.sessionId))
-	copy(x[39:39+len(m.sessionId)], m.sessionId)
-	y := x[39+len(m.sessionId):]
-	y[0] = uint8(len(m.cipherSuites) >> 7)
-	y[1] = uint8(len(m.cipherSuites) << 1)
-	for i, suite := range m.cipherSuites {
-		y[2+i*2] = uint8(suite >> 8)
-		y[3+i*2] = uint8(suite)
-	}
-	z := y[2+len(m.cipherSuites)*2:]
-	z[0] = uint8(len(m.compressionMethods))
-	copy(z[1:], m.compressionMethods)
-
-	z = z[1+len(m.compressionMethods):]
-	if numExtensions > 0 {
-		z[0] = byte(extensionsLength >> 8)
-		z[1] = byte(extensionsLength)
-		z = z[2:]
-	}
-	if m.nextProtoNeg {
-		z[0] = byte(extensionNextProtoNeg >> 8)
-		z[1] = byte(extensionNextProtoNeg)
-		// The length is always 0
-		z = z[4:]
-	}
-	if len(m.serverName) > 0 {
-		z[0] = byte(extensionServerName >> 8)
-		z[1] = byte(extensionServerName)
-		l := len(m.serverName) + 5
-		z[2] = byte(l >> 8)
-		z[3] = byte(l)
-		z = z[4:]
-
-		// RFC 3546, section 3.1
-		//
-		// struct {
-		//     NameType name_type;
-		//     select (name_type) {
-		//         case host_name: HostName;
-		//     } name;
-		// } ServerName;
-		//
-		// enum {
-		//     host_name(0), (255)
-		// } NameType;
-		//
-		// opaque HostName<1..2^16-1>;
-		//
-		// struct {
-		//     ServerName server_name_list<1..2^16-1>
-		// } ServerNameList;
-
-		z[0] = byte((len(m.serverName) + 3) >> 8)
-		z[1] = byte(len(m.serverName) + 3)
-		z[3] = byte(len(m.serverName) >> 8)
-		z[4] = byte(len(m.serverName))
-		copy(z[5:], []byte(m.serverName))
-		z = z[l:]
-	}
-	if m.ocspStapling {
-		// RFC 4366, section 3.6
-		z[0] = byte(extensionStatusRequest >> 8)
-		z[1] = byte(extensionStatusRequest)
-		z[2] = 0
-		z[3] = 5
-		z[4] = 1 // OCSP type
-		// Two zero valued uint16s for the two lengths.
-		z = z[9:]
-	}
-	if len(m.supportedCurves) > 0 {
-		// http://tools.ietf.org/html/rfc4492#section-5.5.1
-		z[0] = byte(extensionSupportedCurves >> 8)
-		z[1] = byte(extensionSupportedCurves)
-		l := 2 + 2*len(m.supportedCurves)
-		z[2] = byte(l >> 8)
-		z[3] = byte(l)
-		l -= 2
-		z[4] = byte(l >> 8)
-		z[5] = byte(l)
-		z = z[6:]
-		for _, curve := range m.supportedCurves {
-			z[0] = byte(curve >> 8)
-			z[1] = byte(curve)
-			z = z[2:]
-		}
-	}
-	if len(m.supportedPoints) > 0 {
-		// http://tools.ietf.org/html/rfc4492#section-5.5.2
-		z[0] = byte(extensionSupportedPoints >> 8)
-		z[1] = byte(extensionSupportedPoints)
-		l := 1 + len(m.supportedPoints)
-		z[2] = byte(l >> 8)
-		z[3] = byte(l)
-		l--
-		z[4] = byte(l)
-		z = z[5:]
-		for _, pointFormat := range m.supportedPoints {
-			z[0] = byte(pointFormat)
-			z = z[1:]
-		}
-	}
-	if m.ticketSupported {
-		// http://tools.ietf.org/html/rfc5077#section-3.2
-		z[0] = byte(extensionSessionTicket >> 8)
-		z[1] = byte(extensionSessionTicket)
-		l := len(m.sessionTicket)
-		z[2] = byte(l >> 8)
-		z[3] = byte(l)
-		z = z[4:]
-		copy(z, m.sessionTicket)
-		z = z[len(m.sessionTicket):]
-	}
-	if len(m.signatureAndHashes) > 0 {
-		// https://tools.ietf.org/html/rfc5246#section-7.4.1.4.1
-		z[0] = byte(extensionSignatureAlgorithms >> 8)
-		z[1] = byte(extensionSignatureAlgorithms)
-		l := 2 + 2*len(m.signatureAndHashes)
-		z[2] = byte(l >> 8)
-		z[3] = byte(l)
-		z = z[4:]
-
-		l -= 2
-		z[0] = byte(l >> 8)
-		z[1] = byte(l)
-		z = z[2:]
-		for _, sigAndHash := range m.signatureAndHashes {
-			z[0] = sigAndHash.hash
-			z[1] = sigAndHash.signature
-			z = z[2:]
-		}
-	}
-
-	m.raw = x
-
-	return x
-}
-
-func (m *clientHelloMsg) unmarshal(data []byte) bool {
-	if len(data) < 42 {
-		return false
-	}
-	m.raw = data
-	m.vers = uint16(data[4])<<8 | uint16(data[5])
-	m.random = data[6:38]
-	sessionIdLen := int(data[38])
-	if sessionIdLen > 32 || len(data) < 39+sessionIdLen {
-		return false
-	}
-	m.sessionId = data[39 : 39+sessionIdLen]
-	data = data[39+sessionIdLen:]
-	if len(data) < 2 {
-		return false
-	}
-	// cipherSuiteLen is the number of bytes of cipher suite numbers. Since
-	// they are uint16s, the number must be even.
-	cipherSuiteLen := int(data[0])<<8 | int(data[1])
-	if cipherSuiteLen%2 == 1 || len(data) < 2+cipherSuiteLen {
-		return false
-	}
-	numCipherSuites := cipherSuiteLen / 2
-	m.cipherSuites = make([]uint16, numCipherSuites)
-	for i := 0; i < numCipherSuites; i++ {
-		m.cipherSuites[i] = uint16(data[2+2*i])<<8 | uint16(data[3+2*i])
-	}
-	data = data[2+cipherSuiteLen:]
-	if len(data) < 1 {
-		return false
-	}
-	compressionMethodsLen := int(data[0])
-	if len(data) < 1+compressionMethodsLen {
-		return false
-	}
-	m.compressionMethods = data[1 : 1+compressionMethodsLen]
-
-	data = data[1+compressionMethodsLen:]
-
-	m.nextProtoNeg = false
-	m.serverName = ""
-	m.ocspStapling = false
-	m.ticketSupported = false
-	m.sessionTicket = nil
-	m.signatureAndHashes = nil
-
-	if len(data) == 0 {
-		// ClientHello is optionally followed by extension data
-		return true
-	}
-	if len(data) < 2 {
-		return false
-	}
-
-	extensionsLength := int(data[0])<<8 | int(data[1])
-	data = data[2:]
-	if extensionsLength != len(data) {
-		return false
-	}
-
-	for len(data) != 0 {
-		if len(data) < 4 {
-			return false
-		}
-		extension := uint16(data[0])<<8 | uint16(data[1])
-		length := int(data[2])<<8 | int(data[3])
-		data = data[4:]
-		if len(data) < length {
-			return false
-		}
-
-		switch extension {
-		case extensionServerName:
-			if length < 2 {
-				return false
-			}
-			numNames := int(data[0])<<8 | int(data[1])
-			d := data[2:]
-			for i := 0; i < numNames; i++ {
-				if len(d) < 3 {
-					return false
-				}
-				nameType := d[0]
-				nameLen := int(d[1])<<8 | int(d[2])
-				d = d[3:]
-				if len(d) < nameLen {
-					return false
-				}
-				if nameType == 0 {
-					m.serverName = string(d[0:nameLen])
-					break
-				}
-				d = d[nameLen:]
-			}
-		case extensionNextProtoNeg:
-			if length > 0 {
-				return false
-			}
-			m.nextProtoNeg = true
-		case extensionStatusRequest:
-			m.ocspStapling = length > 0 && data[0] == statusTypeOCSP
-		case extensionSupportedCurves:
-			// http://tools.ietf.org/html/rfc4492#section-5.5.1
-			if length < 2 {
-				return false
-			}
-			l := int(data[0])<<8 | int(data[1])
-			if l%2 == 1 || length != l+2 {
-				return false
-			}
-			numCurves := l / 2
-			m.supportedCurves = make([]uint16, numCurves)
-			d := data[2:]
-			for i := 0; i < numCurves; i++ {
-				m.supportedCurves[i] = uint16(d[0])<<8 | uint16(d[1])
-				d = d[2:]
-			}
-		case extensionSupportedPoints:
-			// http://tools.ietf.org/html/rfc4492#section-5.5.2
-			if length < 1 {
-				return false
-			}
-			l := int(data[0])
-			if length != l+1 {
-				return false
-			}
-			m.supportedPoints = make([]uint8, l)
-			copy(m.supportedPoints, data[1:])
-		case extensionSessionTicket:
-			// http://tools.ietf.org/html/rfc5077#section-3.2
-			m.ticketSupported = true
-			m.sessionTicket = data[:length]
-		case extensionSignatureAlgorithms:
-			// https://tools.ietf.org/html/rfc5246#section-7.4.1.4.1
-			if length < 2 || length&1 != 0 {
-				return false
-			}
-			l := int(data[0])<<8 | int(data[1])
-			if l != length-2 {
-				return false
-			}
-			n := l / 2
-			d := data[2:]
-			m.signatureAndHashes = make([]signatureAndHash, n)
-			for i := range m.signatureAndHashes {
-				m.signatureAndHashes[i].hash = d[0]
-				m.signatureAndHashes[i].signature = d[1]
-				d = d[2:]
-			}
-		}
-		data = data[length:]
-	}
-
-	return true
-}
-
-type serverHelloMsg struct {
-	raw               []byte
-	vers              uint16
-	random            []byte
-	sessionId         []byte
-	cipherSuite       uint16
-	compressionMethod uint8
-	nextProtoNeg      bool
-	nextProtos        []string
-	ocspStapling      bool
-	ticketSupported   bool
-}
-
-func (m *serverHelloMsg) equal(i interface{}) bool {
-	m1, ok := i.(*serverHelloMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		m.vers == m1.vers &&
-		bytes.Equal(m.random, m1.random) &&
-		bytes.Equal(m.sessionId, m1.sessionId) &&
-		m.cipherSuite == m1.cipherSuite &&
-		m.compressionMethod == m1.compressionMethod &&
-		m.nextProtoNeg == m1.nextProtoNeg &&
-		eqStrings(m.nextProtos, m1.nextProtos) &&
-		m.ocspStapling == m1.ocspStapling &&
-		m.ticketSupported == m1.ticketSupported
-}
-
-func (m *serverHelloMsg) marshal() []byte {
-	if m.raw != nil {
-		return m.raw
-	}
-
-	length := 38 + len(m.sessionId)
-	numExtensions := 0
-	extensionsLength := 0
-
-	nextProtoLen := 0
-	if m.nextProtoNeg {
-		numExtensions++
-		for _, v := range m.nextProtos {
-			nextProtoLen += len(v)
-		}
-		nextProtoLen += len(m.nextProtos)
-		extensionsLength += nextProtoLen
-	}
-	if m.ocspStapling {
-		numExtensions++
-	}
-	if m.ticketSupported {
-		numExtensions++
-	}
-	if numExtensions > 0 {
-		extensionsLength += 4 * numExtensions
-		length += 2 + extensionsLength
-	}
-
-	x := make([]byte, 4+length)
-	x[0] = typeServerHello
-	x[1] = uint8(length >> 16)
-	x[2] = uint8(length >> 8)
-	x[3] = uint8(length)
-	x[4] = uint8(m.vers >> 8)
-	x[5] = uint8(m.vers)
-	copy(x[6:38], m.random)
-	x[38] = uint8(len(m.sessionId))
-	copy(x[39:39+len(m.sessionId)], m.sessionId)
-	z := x[39+len(m.sessionId):]
-	z[0] = uint8(m.cipherSuite >> 8)
-	z[1] = uint8(m.cipherSuite)
-	z[2] = uint8(m.compressionMethod)
-
-	z = z[3:]
-	if numExtensions > 0 {
-		z[0] = byte(extensionsLength >> 8)
-		z[1] = byte(extensionsLength)
-		z = z[2:]
-	}
-	if m.nextProtoNeg {
-		z[0] = byte(extensionNextProtoNeg >> 8)
-		z[1] = byte(extensionNextProtoNeg)
-		z[2] = byte(nextProtoLen >> 8)
-		z[3] = byte(nextProtoLen)
-		z = z[4:]
-
-		for _, v := range m.nextProtos {
-			l := len(v)
-			if l > 255 {
-				l = 255
-			}
-			z[0] = byte(l)
-			copy(z[1:], []byte(v[0:l]))
-			z = z[1+l:]
-		}
-	}
-	if m.ocspStapling {
-		z[0] = byte(extensionStatusRequest >> 8)
-		z[1] = byte(extensionStatusRequest)
-		z = z[4:]
-	}
-	if m.ticketSupported {
-		z[0] = byte(extensionSessionTicket >> 8)
-		z[1] = byte(extensionSessionTicket)
-		z = z[4:]
-	}
-
-	m.raw = x
-
-	return x
-}
-
-func (m *serverHelloMsg) unmarshal(data []byte) bool {
-	if len(data) < 42 {
-		return false
-	}
-	m.raw = data
-	m.vers = uint16(data[4])<<8 | uint16(data[5])
-	m.random = data[6:38]
-	sessionIdLen := int(data[38])
-	if sessionIdLen > 32 || len(data) < 39+sessionIdLen {
-		return false
-	}
-	m.sessionId = data[39 : 39+sessionIdLen]
-	data = data[39+sessionIdLen:]
-	if len(data) < 3 {
-		return false
-	}
-	m.cipherSuite = uint16(data[0])<<8 | uint16(data[1])
-	m.compressionMethod = data[2]
-	data = data[3:]
-
-	m.nextProtoNeg = false
-	m.nextProtos = nil
-	m.ocspStapling = false
-	m.ticketSupported = false
-
-	if len(data) == 0 {
-		// ServerHello is optionally followed by extension data
-		return true
-	}
-	if len(data) < 2 {
-		return false
-	}
-
-	extensionsLength := int(data[0])<<8 | int(data[1])
-	data = data[2:]
-	if len(data) != extensionsLength {
-		return false
-	}
-
-	for len(data) != 0 {
-		if len(data) < 4 {
-			return false
-		}
-		extension := uint16(data[0])<<8 | uint16(data[1])
-		length := int(data[2])<<8 | int(data[3])
-		data = data[4:]
-		if len(data) < length {
-			return false
-		}
-
-		switch extension {
-		case extensionNextProtoNeg:
-			m.nextProtoNeg = true
-			d := data[:length]
-			for len(d) > 0 {
-				l := int(d[0])
-				d = d[1:]
-				if l == 0 || l > len(d) {
-					return false
-				}
-				m.nextProtos = append(m.nextProtos, string(d[:l]))
-				d = d[l:]
-			}
-		case extensionStatusRequest:
-			if length > 0 {
-				return false
-			}
-			m.ocspStapling = true
-		case extensionSessionTicket:
-			if length > 0 {
-				return false
-			}
-			m.ticketSupported = true
-		}
-		data = data[length:]
-	}
-
-	return true
-}
-
-type certificateMsg struct {
-	raw          []byte
-	certificates [][]byte
-}
-
-func (m *certificateMsg) equal(i interface{}) bool {
-	m1, ok := i.(*certificateMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		eqByteSlices(m.certificates, m1.certificates)
-}
-
-func (m *certificateMsg) marshal() (x []byte) {
-	if m.raw != nil {
-		return m.raw
-	}
-
-	var i int
-	for _, slice := range m.certificates {
-		i += len(slice)
-	}
-
-	length := 3 + 3*len(m.certificates) + i
-	x = make([]byte, 4+length)
-	x[0] = typeCertificate
-	x[1] = uint8(length >> 16)
-	x[2] = uint8(length >> 8)
-	x[3] = uint8(length)
-
-	certificateOctets := length - 3
-	x[4] = uint8(certificateOctets >> 16)
-	x[5] = uint8(certificateOctets >> 8)
-	x[6] = uint8(certificateOctets)
-
-	y := x[7:]
-	for _, slice := range m.certificates {
-		y[0] = uint8(len(slice) >> 16)
-		y[1] = uint8(len(slice) >> 8)
-		y[2] = uint8(len(slice))
-		copy(y[3:], slice)
-		y = y[3+len(slice):]
-	}
-
-	m.raw = x
-	return
-}
-
-func (m *certificateMsg) unmarshal(data []byte) bool {
-	if len(data) < 7 {
-		return false
-	}
-
-	m.raw = data
-	certsLen := uint32(data[4])<<16 | uint32(data[5])<<8 | uint32(data[6])
-	if uint32(len(data)) != certsLen+7 {
-		return false
-	}
-
-	numCerts := 0
-	d := data[7:]
-	for certsLen > 0 {
-		if len(d) < 4 {
-			return false
-		}
-		certLen := uint32(d[0])<<16 | uint32(d[1])<<8 | uint32(d[2])
-		if uint32(len(d)) < 3+certLen {
-			return false
-		}
-		d = d[3+certLen:]
-		certsLen -= 3 + certLen
-		numCerts++
-	}
-
-	m.certificates = make([][]byte, numCerts)
-	d = data[7:]
-	for i := 0; i < numCerts; i++ {
-		certLen := uint32(d[0])<<16 | uint32(d[1])<<8 | uint32(d[2])
-		m.certificates[i] = d[3 : 3+certLen]
-		d = d[3+certLen:]
-	}
-
-	return true
-}
-
-type serverKeyExchangeMsg struct {
-	raw []byte
-	key []byte
-}
-
-func (m *serverKeyExchangeMsg) equal(i interface{}) bool {
-	m1, ok := i.(*serverKeyExchangeMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		bytes.Equal(m.key, m1.key)
-}
-
-func (m *serverKeyExchangeMsg) marshal() []byte {
-	if m.raw != nil {
-		return m.raw
-	}
-	length := len(m.key)
-	x := make([]byte, length+4)
-	x[0] = typeServerKeyExchange
-	x[1] = uint8(length >> 16)
-	x[2] = uint8(length >> 8)
-	x[3] = uint8(length)
-	copy(x[4:], m.key)
-
-	m.raw = x
-	return x
-}
-
-func (m *serverKeyExchangeMsg) unmarshal(data []byte) bool {
-	m.raw = data
-	if len(data) < 4 {
-		return false
-	}
-	m.key = data[4:]
-	return true
-}
-
-type certificateStatusMsg struct {
-	raw        []byte
-	statusType uint8
-	response   []byte
-}
-
-func (m *certificateStatusMsg) equal(i interface{}) bool {
-	m1, ok := i.(*certificateStatusMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		m.statusType == m1.statusType &&
-		bytes.Equal(m.response, m1.response)
-}
-
-func (m *certificateStatusMsg) marshal() []byte {
-	if m.raw != nil {
-		return m.raw
-	}
-
-	var x []byte
-	if m.statusType == statusTypeOCSP {
-		x = make([]byte, 4+4+len(m.response))
-		x[0] = typeCertificateStatus
-		l := len(m.response) + 4
-		x[1] = byte(l >> 16)
-		x[2] = byte(l >> 8)
-		x[3] = byte(l)
-		x[4] = statusTypeOCSP
-
-		l -= 4
-		x[5] = byte(l >> 16)
-		x[6] = byte(l >> 8)
-		x[7] = byte(l)
-		copy(x[8:], m.response)
-	} else {
-		x = []byte{typeCertificateStatus, 0, 0, 1, m.statusType}
-	}
-
-	m.raw = x
-	return x
-}
-
-func (m *certificateStatusMsg) unmarshal(data []byte) bool {
-	m.raw = data
-	if len(data) < 5 {
-		return false
-	}
-	m.statusType = data[4]
-
-	m.response = nil
-	if m.statusType == statusTypeOCSP {
-		if len(data) < 8 {
-			return false
-		}
-		respLen := uint32(data[5])<<16 | uint32(data[6])<<8 | uint32(data[7])
-		if uint32(len(data)) != 4+4+respLen {
-			return false
-		}
-		m.response = data[8:]
-	}
-	return true
-}
-
-type serverHelloDoneMsg struct{}
-
-func (m *serverHelloDoneMsg) equal(i interface{}) bool {
-	_, ok := i.(*serverHelloDoneMsg)
-	return ok
-}
-
-func (m *serverHelloDoneMsg) marshal() []byte {
-	x := make([]byte, 4)
-	x[0] = typeServerHelloDone
-	return x
-}
-
-func (m *serverHelloDoneMsg) unmarshal(data []byte) bool {
-	return len(data) == 4
-}
-
-type clientKeyExchangeMsg struct {
-	raw        []byte
-	ciphertext []byte
-}
-
-func (m *clientKeyExchangeMsg) equal(i interface{}) bool {
-	m1, ok := i.(*clientKeyExchangeMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		bytes.Equal(m.ciphertext, m1.ciphertext)
-}
-
-func (m *clientKeyExchangeMsg) marshal() []byte {
-	if m.raw != nil {
-		return m.raw
-	}
-	length := len(m.ciphertext)
-	x := make([]byte, length+4)
-	x[0] = typeClientKeyExchange
-	x[1] = uint8(length >> 16)
-	x[2] = uint8(length >> 8)
-	x[3] = uint8(length)
-	copy(x[4:], m.ciphertext)
-
-	m.raw = x
-	return x
-}
-
-func (m *clientKeyExchangeMsg) unmarshal(data []byte) bool {
-	m.raw = data
-	if len(data) < 4 {
-		return false
-	}
-	l := int(data[1])<<16 | int(data[2])<<8 | int(data[3])
-	if l != len(data)-4 {
-		return false
-	}
-	m.ciphertext = data[4:]
-	return true
-}
-
-type finishedMsg struct {
-	raw        []byte
-	verifyData []byte
-}
-
-func (m *finishedMsg) equal(i interface{}) bool {
-	m1, ok := i.(*finishedMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		bytes.Equal(m.verifyData, m1.verifyData)
-}
-
-func (m *finishedMsg) marshal() (x []byte) {
-	if m.raw != nil {
-		return m.raw
-	}
-
-	x = make([]byte, 4+len(m.verifyData))
-	x[0] = typeFinished
-	x[3] = byte(len(m.verifyData))
-	copy(x[4:], m.verifyData)
-	m.raw = x
-	return
-}
-
-func (m *finishedMsg) unmarshal(data []byte) bool {
-	m.raw = data
-	if len(data) < 4 {
-		return false
-	}
-	m.verifyData = data[4:]
-	return true
-}
-
-type nextProtoMsg struct {
-	raw   []byte
-	proto string
-}
-
-func (m *nextProtoMsg) equal(i interface{}) bool {
-	m1, ok := i.(*nextProtoMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		m.proto == m1.proto
-}
-
-func (m *nextProtoMsg) marshal() []byte {
-	if m.raw != nil {
-		return m.raw
-	}
-	l := len(m.proto)
-	if l > 255 {
-		l = 255
-	}
-
-	padding := 32 - (l+2)%32
-	length := l + padding + 2
-	x := make([]byte, length+4)
-	x[0] = typeNextProtocol
-	x[1] = uint8(length >> 16)
-	x[2] = uint8(length >> 8)
-	x[3] = uint8(length)
-
-	y := x[4:]
-	y[0] = byte(l)
-	copy(y[1:], []byte(m.proto[0:l]))
-	y = y[1+l:]
-	y[0] = byte(padding)
-
-	m.raw = x
-
-	return x
-}
-
-func (m *nextProtoMsg) unmarshal(data []byte) bool {
-	m.raw = data
-
-	if len(data) < 5 {
-		return false
-	}
-	data = data[4:]
-	protoLen := int(data[0])
-	data = data[1:]
-	if len(data) < protoLen {
-		return false
-	}
-	m.proto = string(data[0:protoLen])
-	data = data[protoLen:]
-
-	if len(data) < 1 {
-		return false
-	}
-	paddingLen := int(data[0])
-	data = data[1:]
-	if len(data) != paddingLen {
-		return false
-	}
-
-	return true
-}
-
-type certificateRequestMsg struct {
-	raw []byte
-	// hasSignatureAndHash indicates whether this message includes a list
-	// of signature and hash functions. This change was introduced with TLS
-	// 1.2.
-	hasSignatureAndHash bool
-
-	certificateTypes       []byte
-	signatureAndHashes     []signatureAndHash
-	certificateAuthorities [][]byte
-}
-
-func (m *certificateRequestMsg) equal(i interface{}) bool {
-	m1, ok := i.(*certificateRequestMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		bytes.Equal(m.certificateTypes, m1.certificateTypes) &&
-		eqByteSlices(m.certificateAuthorities, m1.certificateAuthorities) &&
-		eqSignatureAndHashes(m.signatureAndHashes, m1.signatureAndHashes)
-}
-
-func (m *certificateRequestMsg) marshal() (x []byte) {
-	if m.raw != nil {
-		return m.raw
-	}
-
-	// See http://tools.ietf.org/html/rfc4346#section-7.4.4
-	length := 1 + len(m.certificateTypes) + 2
-	casLength := 0
-	for _, ca := range m.certificateAuthorities {
-		casLength += 2 + len(ca)
-	}
-	length += casLength
-
-	if m.hasSignatureAndHash {
-		length += 2 + 2*len(m.signatureAndHashes)
-	}
-
-	x = make([]byte, 4+length)
-	x[0] = typeCertificateRequest
-	x[1] = uint8(length >> 16)
-	x[2] = uint8(length >> 8)
-	x[3] = uint8(length)
-
-	x[4] = uint8(len(m.certificateTypes))
-
-	copy(x[5:], m.certificateTypes)
-	y := x[5+len(m.certificateTypes):]
-
-	if m.hasSignatureAndHash {
-		n := len(m.signatureAndHashes) * 2
-		y[0] = uint8(n >> 8)
-		y[1] = uint8(n)
-		y = y[2:]
-		for _, sigAndHash := range m.signatureAndHashes {
-			y[0] = sigAndHash.hash
-			y[1] = sigAndHash.signature
-			y = y[2:]
-		}
-	}
-
-	y[0] = uint8(casLength >> 8)
-	y[1] = uint8(casLength)
-	y = y[2:]
-	for _, ca := range m.certificateAuthorities {
-		y[0] = uint8(len(ca) >> 8)
-		y[1] = uint8(len(ca))
-		y = y[2:]
-		copy(y, ca)
-		y = y[len(ca):]
-	}
-
-	m.raw = x
-	return
-}
-
-func (m *certificateRequestMsg) unmarshal(data []byte) bool {
-	m.raw = data
-
-	if len(data) < 5 {
-		return false
-	}
-
-	length := uint32(data[1])<<16 | uint32(data[2])<<8 | uint32(data[3])
-	if uint32(len(data))-4 != length {
-		return false
-	}
-
-	numCertTypes := int(data[4])
-	data = data[5:]
-	if numCertTypes == 0 || len(data) <= numCertTypes {
-		return false
-	}
-
-	m.certificateTypes = make([]byte, numCertTypes)
-	if copy(m.certificateTypes, data) != numCertTypes {
-		return false
-	}
-
-	data = data[numCertTypes:]
-
-	if m.hasSignatureAndHash {
-		if len(data) < 2 {
-			return false
-		}
-		sigAndHashLen := uint16(data[0])<<8 | uint16(data[1])
-		data = data[2:]
-		if sigAndHashLen&1 != 0 {
-			return false
-		}
-		if len(data) < int(sigAndHashLen) {
-			return false
-		}
-		numSigAndHash := sigAndHashLen / 2
-		m.signatureAndHashes = make([]signatureAndHash, numSigAndHash)
-		for i := range m.signatureAndHashes {
-			m.signatureAndHashes[i].hash = data[0]
-			m.signatureAndHashes[i].signature = data[1]
-			data = data[2:]
-		}
-	}
-
-	if len(data) < 2 {
-		return false
-	}
-	casLength := uint16(data[0])<<8 | uint16(data[1])
-	data = data[2:]
-	if len(data) < int(casLength) {
-		return false
-	}
-	cas := make([]byte, casLength)
-	copy(cas, data)
-	data = data[casLength:]
-
-	m.certificateAuthorities = nil
-	for len(cas) > 0 {
-		if len(cas) < 2 {
-			return false
-		}
-		caLen := uint16(cas[0])<<8 | uint16(cas[1])
-		cas = cas[2:]
-
-		if len(cas) < int(caLen) {
-			return false
-		}
-
-		m.certificateAuthorities = append(m.certificateAuthorities, cas[:caLen])
-		cas = cas[caLen:]
-	}
-	if len(data) > 0 {
-		return false
-	}
-
-	return true
-}
-
-type certificateVerifyMsg struct {
-	raw                 []byte
-	hasSignatureAndHash bool
-	signatureAndHash    signatureAndHash
-	signature           []byte
-}
-
-func (m *certificateVerifyMsg) equal(i interface{}) bool {
-	m1, ok := i.(*certificateVerifyMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		m.hasSignatureAndHash == m1.hasSignatureAndHash &&
-		m.signatureAndHash.hash == m1.signatureAndHash.hash &&
-		m.signatureAndHash.signature == m1.signatureAndHash.signature &&
-		bytes.Equal(m.signature, m1.signature)
-}
-
-func (m *certificateVerifyMsg) marshal() (x []byte) {
-	if m.raw != nil {
-		return m.raw
-	}
-
-	// See http://tools.ietf.org/html/rfc4346#section-7.4.8
-	siglength := len(m.signature)
-	length := 2 + siglength
-	if m.hasSignatureAndHash {
-		length += 2
-	}
-	x = make([]byte, 4+length)
-	x[0] = typeCertificateVerify
-	x[1] = uint8(length >> 16)
-	x[2] = uint8(length >> 8)
-	x[3] = uint8(length)
-	y := x[4:]
-	if m.hasSignatureAndHash {
-		y[0] = m.signatureAndHash.hash
-		y[1] = m.signatureAndHash.signature
-		y = y[2:]
-	}
-	y[0] = uint8(siglength >> 8)
-	y[1] = uint8(siglength)
-	copy(y[2:], m.signature)
-
-	m.raw = x
-
-	return
-}
-
-func (m *certificateVerifyMsg) unmarshal(data []byte) bool {
-	m.raw = data
-
-	if len(data) < 6 {
-		return false
-	}
-
-	length := uint32(data[1])<<16 | uint32(data[2])<<8 | uint32(data[3])
-	if uint32(len(data))-4 != length {
-		return false
-	}
-
-	data = data[4:]
-	if m.hasSignatureAndHash {
-		m.signatureAndHash.hash = data[0]
-		m.signatureAndHash.signature = data[1]
-		data = data[2:]
-	}
-
-	if len(data) < 2 {
-		return false
-	}
-	siglength := int(data[0])<<8 + int(data[1])
-	data = data[2:]
-	if len(data) != siglength {
-		return false
-	}
-
-	m.signature = data
-
-	return true
-}
-
-type newSessionTicketMsg struct {
-	raw    []byte
-	ticket []byte
-}
-
-func (m *newSessionTicketMsg) equal(i interface{}) bool {
-	m1, ok := i.(*newSessionTicketMsg)
-	if !ok {
-		return false
-	}
-
-	return bytes.Equal(m.raw, m1.raw) &&
-		bytes.Equal(m.ticket, m1.ticket)
-}
-
-func (m *newSessionTicketMsg) marshal() (x []byte) {
-	if m.raw != nil {
-		return m.raw
-	}
-
-	// See http://tools.ietf.org/html/rfc5077#section-3.3
-	ticketLen := len(m.ticket)
-	length := 2 + 4 + ticketLen
-	x = make([]byte, 4+length)
-	x[0] = typeNewSessionTicket
-	x[1] = uint8(length >> 16)
-	x[2] = uint8(length >> 8)
-	x[3] = uint8(length)
-	x[8] = uint8(ticketLen >> 8)
-	x[9] = uint8(ticketLen)
-	copy(x[10:], m.ticket)
-
-	m.raw = x
-
-	return
-}
-
-func (m *newSessionTicketMsg) unmarshal(data []byte) bool {
-	m.raw = data
-
-	if len(data) < 10 {
-		return false
-	}
-
-	length := uint32(data[1])<<16 | uint32(data[2])<<8 | uint32(data[3])
-	if uint32(len(data))-4 != length {
-		return false
-	}
-
-	ticketLen := int(data[8])<<8 + int(data[9])
-	if len(data)-10 != ticketLen {
-		return false
-	}
-
-	m.ticket = data[10:]
-
-	return true
-}
-
-type helloRequestMsg struct {
-}
-
-func (*helloRequestMsg) marshal() []byte {
-	return []byte{typeHelloRequest, 0, 0, 0}
-}
-
-func (*helloRequestMsg) unmarshal(data []byte) bool {
-	return len(data) == 4
-}
-
-func eqUint16s(x, y []uint16) bool {
-	if len(x) != len(y) {
-		return false
-	}
-	for i, v := range x {
-		if y[i] != v {
-			return false
-		}
-	}
-	return true
-}
-
-func eqStrings(x, y []string) bool {
-	if len(x) != len(y) {
-		return false
-	}
-	for i, v := range x {
-		if y[i] != v {
-			return false
-		}
-	}
-	return true
-}
-
-func eqByteSlices(x, y [][]byte) bool {
-	if len(x) != len(y) {
-		return false
-	}
-	for i, v := range x {
-		if !bytes.Equal(v, y[i]) {
-			return false
-		}
-	}
-	return true
-}
-
-func eqSignatureAndHashes(x, y []signatureAndHash) bool {
-	if len(x) != len(y) {
-		return false
-	}
-	for i, v := range x {
-		v2 := y[i]
-		if v.hash != v2.hash || v.signature != v2.signature {
-			return false
-		}
-	}
-	return true
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_server.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_server.go
deleted file mode 100644
index c9ccf675c..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/handshake_server.go
+++ /dev/null
@@ -1,638 +0,0 @@
-// Copyright 2009 The Go 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 tls
-
-import (
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/rsa"
-	"crypto/subtle"
-	"crypto/x509"
-	"encoding/asn1"
-	"errors"
-	"io"
-)
-
-// serverHandshakeState contains details of a server handshake in progress.
-// It's discarded once the handshake has completed.
-type serverHandshakeState struct {
-	c               *Conn
-	clientHello     *clientHelloMsg
-	hello           *serverHelloMsg
-	suite           *cipherSuite
-	ellipticOk      bool
-	ecdsaOk         bool
-	sessionState    *sessionState
-	finishedHash    finishedHash
-	masterSecret    []byte
-	certsFromClient [][]byte
-	cert            *Certificate
-}
-
-// serverHandshake performs a TLS handshake as a server.
-func (c *Conn) serverHandshake() error {
-	config := c.config
-
-	// If this is the first server handshake, we generate a random key to
-	// encrypt the tickets with.
-	config.serverInitOnce.Do(config.serverInit)
-
-	hs := serverHandshakeState{
-		c: c,
-	}
-	isResume, err := hs.readClientHello()
-	if err != nil {
-		return err
-	}
-
-	// For an overview of TLS handshaking, see https://tools.ietf.org/html/rfc5246#section-7.3
-	if isResume {
-		// The client has included a session ticket and so we do an abbreviated handshake.
-		if err := hs.doResumeHandshake(); err != nil {
-			return err
-		}
-		if err := hs.establishKeys(); err != nil {
-			return err
-		}
-		if err := hs.sendFinished(); err != nil {
-			return err
-		}
-		if err := hs.readFinished(); err != nil {
-			return err
-		}
-		c.didResume = true
-	} else {
-		// The client didn't include a session ticket, or it wasn't
-		// valid so we do a full handshake.
-		if err := hs.doFullHandshake(); err != nil {
-			return err
-		}
-		if err := hs.establishKeys(); err != nil {
-			return err
-		}
-		if err := hs.readFinished(); err != nil {
-			return err
-		}
-		if err := hs.sendSessionTicket(); err != nil {
-			return err
-		}
-		if err := hs.sendFinished(); err != nil {
-			return err
-		}
-	}
-	c.handshakeComplete = true
-
-	return nil
-}
-
-// readClientHello reads a ClientHello message from the client and decides
-// whether we will perform session resumption.
-func (hs *serverHandshakeState) readClientHello() (isResume bool, err error) {
-	config := hs.c.config
-	c := hs.c
-
-	msg, err := c.readHandshake()
-	if err != nil {
-		return false, err
-	}
-	var ok bool
-	hs.clientHello, ok = msg.(*clientHelloMsg)
-	if !ok {
-		return false, c.sendAlert(alertUnexpectedMessage)
-	}
-	c.vers, ok = config.mutualVersion(hs.clientHello.vers)
-	if !ok {
-		return false, c.sendAlert(alertProtocolVersion)
-	}
-	c.haveVers = true
-
-	hs.finishedHash = newFinishedHash(c.vers)
-	hs.finishedHash.Write(hs.clientHello.marshal())
-
-	hs.hello = new(serverHelloMsg)
-
-	supportedCurve := false
-Curves:
-	for _, curve := range hs.clientHello.supportedCurves {
-		switch curve {
-		case curveP256, curveP384, curveP521:
-			supportedCurve = true
-			break Curves
-		}
-	}
-
-	supportedPointFormat := false
-	for _, pointFormat := range hs.clientHello.supportedPoints {
-		if pointFormat == pointFormatUncompressed {
-			supportedPointFormat = true
-			break
-		}
-	}
-	hs.ellipticOk = supportedCurve && supportedPointFormat
-
-	foundCompression := false
-	// We only support null compression, so check that the client offered it.
-	for _, compression := range hs.clientHello.compressionMethods {
-		if compression == compressionNone {
-			foundCompression = true
-			break
-		}
-	}
-
-	if !foundCompression {
-		return false, c.sendAlert(alertHandshakeFailure)
-	}
-
-	hs.hello.vers = c.vers
-	t := uint32(config.time().Unix())
-	hs.hello.random = make([]byte, 32)
-	hs.hello.random[0] = byte(t >> 24)
-	hs.hello.random[1] = byte(t >> 16)
-	hs.hello.random[2] = byte(t >> 8)
-	hs.hello.random[3] = byte(t)
-	_, err = io.ReadFull(config.rand(), hs.hello.random[4:])
-	if err != nil {
-		return false, c.sendAlert(alertInternalError)
-	}
-	hs.hello.compressionMethod = compressionNone
-	if len(hs.clientHello.serverName) > 0 {
-		c.serverName = hs.clientHello.serverName
-	}
-	// Although sending an empty NPN extension is reasonable, Firefox has
-	// had a bug around this. Best to send nothing at all if
-	// config.NextProtos is empty. See
-	// https://code.google.com/p/go/issues/detail?id=5445.
-	if hs.clientHello.nextProtoNeg && len(config.NextProtos) > 0 {
-		hs.hello.nextProtoNeg = true
-		hs.hello.nextProtos = config.NextProtos
-	}
-
-	if len(config.Certificates) == 0 {
-		return false, c.sendAlert(alertInternalError)
-	}
-	hs.cert = &config.Certificates[0]
-	if len(hs.clientHello.serverName) > 0 {
-		hs.cert = config.getCertificateForName(hs.clientHello.serverName)
-	}
-
-	_, hs.ecdsaOk = hs.cert.PrivateKey.(*ecdsa.PrivateKey)
-
-	if hs.checkForResumption() {
-		return true, nil
-	}
-
-	var preferenceList, supportedList []uint16
-	if c.config.PreferServerCipherSuites {
-		preferenceList = c.config.cipherSuites()
-		supportedList = hs.clientHello.cipherSuites
-	} else {
-		preferenceList = hs.clientHello.cipherSuites
-		supportedList = c.config.cipherSuites()
-	}
-
-	for _, id := range preferenceList {
-		if hs.suite = c.tryCipherSuite(id, supportedList, c.vers, hs.ellipticOk, hs.ecdsaOk); hs.suite != nil {
-			break
-		}
-	}
-
-	if hs.suite == nil {
-		return false, c.sendAlert(alertHandshakeFailure)
-	}
-
-	return false, nil
-}
-
-// checkForResumption returns true if we should perform resumption on this connection.
-func (hs *serverHandshakeState) checkForResumption() bool {
-	c := hs.c
-
-	var ok bool
-	if hs.sessionState, ok = c.decryptTicket(hs.clientHello.sessionTicket); !ok {
-		return false
-	}
-
-	if hs.sessionState.vers > hs.clientHello.vers {
-		return false
-	}
-	if vers, ok := c.config.mutualVersion(hs.sessionState.vers); !ok || vers != hs.sessionState.vers {
-		return false
-	}
-
-	cipherSuiteOk := false
-	// Check that the client is still offering the ciphersuite in the session.
-	for _, id := range hs.clientHello.cipherSuites {
-		if id == hs.sessionState.cipherSuite {
-			cipherSuiteOk = true
-			break
-		}
-	}
-	if !cipherSuiteOk {
-		return false
-	}
-
-	// Check that we also support the ciphersuite from the session.
-	hs.suite = c.tryCipherSuite(hs.sessionState.cipherSuite, c.config.cipherSuites(), hs.sessionState.vers, hs.ellipticOk, hs.ecdsaOk)
-	if hs.suite == nil {
-		return false
-	}
-
-	sessionHasClientCerts := len(hs.sessionState.certificates) != 0
-	needClientCerts := c.config.ClientAuth == RequireAnyClientCert || c.config.ClientAuth == RequireAndVerifyClientCert
-	if needClientCerts && !sessionHasClientCerts {
-		return false
-	}
-	if sessionHasClientCerts && c.config.ClientAuth == NoClientCert {
-		return false
-	}
-
-	return true
-}
-
-func (hs *serverHandshakeState) doResumeHandshake() error {
-	c := hs.c
-
-	hs.hello.cipherSuite = hs.suite.id
-	// We echo the client's session ID in the ServerHello to let it know
-	// that we're doing a resumption.
-	hs.hello.sessionId = hs.clientHello.sessionId
-	hs.finishedHash.Write(hs.hello.marshal())
-	c.writeRecord(recordTypeHandshake, hs.hello.marshal())
-
-	if len(hs.sessionState.certificates) > 0 {
-		if _, err := hs.processCertsFromClient(hs.sessionState.certificates); err != nil {
-			return err
-		}
-	}
-
-	hs.masterSecret = hs.sessionState.masterSecret
-
-	return nil
-}
-
-func (hs *serverHandshakeState) doFullHandshake() error {
-	config := hs.c.config
-	c := hs.c
-
-	if hs.clientHello.ocspStapling && len(hs.cert.OCSPStaple) > 0 {
-		hs.hello.ocspStapling = true
-	}
-
-	hs.hello.ticketSupported = hs.clientHello.ticketSupported && !config.SessionTicketsDisabled
-	hs.hello.cipherSuite = hs.suite.id
-	hs.finishedHash.Write(hs.hello.marshal())
-	c.writeRecord(recordTypeHandshake, hs.hello.marshal())
-
-	certMsg := new(certificateMsg)
-	certMsg.certificates = hs.cert.Certificate
-	hs.finishedHash.Write(certMsg.marshal())
-	c.writeRecord(recordTypeHandshake, certMsg.marshal())
-
-	if hs.hello.ocspStapling {
-		certStatus := new(certificateStatusMsg)
-		certStatus.statusType = statusTypeOCSP
-		certStatus.response = hs.cert.OCSPStaple
-		hs.finishedHash.Write(certStatus.marshal())
-		c.writeRecord(recordTypeHandshake, certStatus.marshal())
-	}
-
-	keyAgreement := hs.suite.ka(c.vers)
-	skx, err := keyAgreement.generateServerKeyExchange(config, hs.cert, hs.clientHello, hs.hello)
-	if err != nil {
-		c.sendAlert(alertHandshakeFailure)
-		return err
-	}
-	if skx != nil {
-		hs.finishedHash.Write(skx.marshal())
-		c.writeRecord(recordTypeHandshake, skx.marshal())
-	}
-
-	if config.ClientAuth >= RequestClientCert {
-		// Request a client certificate
-		certReq := new(certificateRequestMsg)
-		certReq.certificateTypes = []byte{
-			byte(certTypeRSASign),
-			byte(certTypeECDSASign),
-		}
-		if c.vers >= VersionTLS12 {
-			certReq.hasSignatureAndHash = true
-			certReq.signatureAndHashes = supportedClientCertSignatureAlgorithms
-		}
-
-		// An empty list of certificateAuthorities signals to
-		// the client that it may send any certificate in response
-		// to our request. When we know the CAs we trust, then
-		// we can send them down, so that the client can choose
-		// an appropriate certificate to give to us.
-		if config.ClientCAs != nil {
-			certReq.certificateAuthorities = config.ClientCAs.Subjects()
-		}
-		hs.finishedHash.Write(certReq.marshal())
-		c.writeRecord(recordTypeHandshake, certReq.marshal())
-	}
-
-	helloDone := new(serverHelloDoneMsg)
-	hs.finishedHash.Write(helloDone.marshal())
-	c.writeRecord(recordTypeHandshake, helloDone.marshal())
-
-	var pub crypto.PublicKey // public key for client auth, if any
-
-	msg, err := c.readHandshake()
-	if err != nil {
-		return err
-	}
-
-	var ok bool
-	// If we requested a client certificate, then the client must send a
-	// certificate message, even if it's empty.
-	if config.ClientAuth >= RequestClientCert {
-		if certMsg, ok = msg.(*certificateMsg); !ok {
-			return c.sendAlert(alertHandshakeFailure)
-		}
-		hs.finishedHash.Write(certMsg.marshal())
-
-		if len(certMsg.certificates) == 0 {
-			// The client didn't actually send a certificate
-			switch config.ClientAuth {
-			case RequireAnyClientCert, RequireAndVerifyClientCert:
-				c.sendAlert(alertBadCertificate)
-				return errors.New("tls: client didn't provide a certificate")
-			}
-		}
-
-		pub, err = hs.processCertsFromClient(certMsg.certificates)
-		if err != nil {
-			return err
-		}
-
-		msg, err = c.readHandshake()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Get client key exchange
-	ckx, ok := msg.(*clientKeyExchangeMsg)
-	if !ok {
-		return c.sendAlert(alertUnexpectedMessage)
-	}
-	hs.finishedHash.Write(ckx.marshal())
-
-	// If we received a client cert in response to our certificate request message,
-	// the client will send us a certificateVerifyMsg immediately after the
-	// clientKeyExchangeMsg.  This message is a digest of all preceding
-	// handshake-layer messages that is signed using the private key corresponding
-	// to the client's certificate. This allows us to verify that the client is in
-	// possession of the private key of the certificate.
-	if len(c.peerCertificates) > 0 {
-		msg, err = c.readHandshake()
-		if err != nil {
-			return err
-		}
-		certVerify, ok := msg.(*certificateVerifyMsg)
-		if !ok {
-			return c.sendAlert(alertUnexpectedMessage)
-		}
-
-		switch key := pub.(type) {
-		case *ecdsa.PublicKey:
-			ecdsaSig := new(ecdsaSignature)
-			if _, err = asn1.Unmarshal(certVerify.signature, ecdsaSig); err != nil {
-				break
-			}
-			if ecdsaSig.R.Sign() <= 0 || ecdsaSig.S.Sign() <= 0 {
-				err = errors.New("ECDSA signature contained zero or negative values")
-				break
-			}
-			digest, _, _ := hs.finishedHash.hashForClientCertificate(signatureECDSA)
-			if !ecdsa.Verify(key, digest, ecdsaSig.R, ecdsaSig.S) {
-				err = errors.New("ECDSA verification failure")
-				break
-			}
-		case *rsa.PublicKey:
-			digest, hashFunc, _ := hs.finishedHash.hashForClientCertificate(signatureRSA)
-			err = rsa.VerifyPKCS1v15(key, hashFunc, digest, certVerify.signature)
-		}
-		if err != nil {
-			c.sendAlert(alertBadCertificate)
-			return errors.New("could not validate signature of connection nonces: " + err.Error())
-		}
-
-		hs.finishedHash.Write(certVerify.marshal())
-	}
-
-	preMasterSecret, err := keyAgreement.processClientKeyExchange(config, hs.cert, ckx, c.vers)
-	if err != nil {
-		c.sendAlert(alertHandshakeFailure)
-		return err
-	}
-	hs.masterSecret = masterFromPreMasterSecret(c.vers, preMasterSecret, hs.clientHello.random, hs.hello.random)
-
-	return nil
-}
-
-func (hs *serverHandshakeState) establishKeys() error {
-	c := hs.c
-
-	clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV :=
-		keysFromMasterSecret(c.vers, hs.masterSecret, hs.clientHello.random, hs.hello.random, hs.suite.macLen, hs.suite.keyLen, hs.suite.ivLen)
-
-	var clientCipher, serverCipher interface{}
-	var clientHash, serverHash macFunction
-
-	if hs.suite.aead == nil {
-		clientCipher = hs.suite.cipher(clientKey, clientIV, true /* for reading */)
-		clientHash = hs.suite.mac(c.vers, clientMAC)
-		serverCipher = hs.suite.cipher(serverKey, serverIV, false /* not for reading */)
-		serverHash = hs.suite.mac(c.vers, serverMAC)
-	} else {
-		clientCipher = hs.suite.aead(clientKey, clientIV)
-		serverCipher = hs.suite.aead(serverKey, serverIV)
-	}
-
-	c.in.prepareCipherSpec(c.vers, clientCipher, clientHash)
-	c.out.prepareCipherSpec(c.vers, serverCipher, serverHash)
-
-	return nil
-}
-
-func (hs *serverHandshakeState) readFinished() error {
-	c := hs.c
-
-	c.readRecord(recordTypeChangeCipherSpec)
-	if err := c.error(); err != nil {
-		return err
-	}
-
-	if hs.hello.nextProtoNeg {
-		msg, err := c.readHandshake()
-		if err != nil {
-			return err
-		}
-		nextProto, ok := msg.(*nextProtoMsg)
-		if !ok {
-			return c.sendAlert(alertUnexpectedMessage)
-		}
-		hs.finishedHash.Write(nextProto.marshal())
-		c.clientProtocol = nextProto.proto
-	}
-
-	msg, err := c.readHandshake()
-	if err != nil {
-		return err
-	}
-	clientFinished, ok := msg.(*finishedMsg)
-	if !ok {
-		return c.sendAlert(alertUnexpectedMessage)
-	}
-
-	verify := hs.finishedHash.clientSum(hs.masterSecret)
-	if len(verify) != len(clientFinished.verifyData) ||
-		subtle.ConstantTimeCompare(verify, clientFinished.verifyData) != 1 {
-		return c.sendAlert(alertHandshakeFailure)
-	}
-
-	hs.finishedHash.Write(clientFinished.marshal())
-	return nil
-}
-
-func (hs *serverHandshakeState) sendSessionTicket() error {
-	if !hs.hello.ticketSupported {
-		return nil
-	}
-
-	c := hs.c
-	m := new(newSessionTicketMsg)
-
-	var err error
-	state := sessionState{
-		vers:         c.vers,
-		cipherSuite:  hs.suite.id,
-		masterSecret: hs.masterSecret,
-		certificates: hs.certsFromClient,
-	}
-	m.ticket, err = c.encryptTicket(&state)
-	if err != nil {
-		return err
-	}
-
-	hs.finishedHash.Write(m.marshal())
-	c.writeRecord(recordTypeHandshake, m.marshal())
-
-	return nil
-}
-
-func (hs *serverHandshakeState) sendFinished() error {
-	c := hs.c
-
-	c.writeRecord(recordTypeChangeCipherSpec, []byte{1})
-
-	finished := new(finishedMsg)
-	finished.verifyData = hs.finishedHash.serverSum(hs.masterSecret)
-	hs.finishedHash.Write(finished.marshal())
-	c.writeRecord(recordTypeHandshake, finished.marshal())
-
-	c.cipherSuite = hs.suite.id
-
-	return nil
-}
-
-// processCertsFromClient takes a chain of client certificates either from a
-// Certificates message or from a sessionState and verifies them. It returns
-// the public key of the leaf certificate.
-func (hs *serverHandshakeState) processCertsFromClient(certificates [][]byte) (crypto.PublicKey, error) {
-	c := hs.c
-
-	hs.certsFromClient = certificates
-	certs := make([]*x509.Certificate, len(certificates))
-	var err error
-	for i, asn1Data := range certificates {
-		if certs[i], err = x509.ParseCertificate(asn1Data); err != nil {
-			c.sendAlert(alertBadCertificate)
-			return nil, errors.New("tls: failed to parse client certificate: " + err.Error())
-		}
-	}
-
-	if c.config.ClientAuth >= VerifyClientCertIfGiven && len(certs) > 0 {
-		opts := x509.VerifyOptions{
-			Roots:         c.config.ClientCAs,
-			CurrentTime:   c.config.time(),
-			Intermediates: x509.NewCertPool(),
-			KeyUsages:     []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
-		}
-
-		for _, cert := range certs[1:] {
-			opts.Intermediates.AddCert(cert)
-		}
-
-		chains, err := certs[0].Verify(opts)
-		if err != nil {
-			c.sendAlert(alertBadCertificate)
-			return nil, errors.New("tls: failed to verify client's certificate: " + err.Error())
-		}
-
-		ok := false
-		for _, ku := range certs[0].ExtKeyUsage {
-			if ku == x509.ExtKeyUsageClientAuth {
-				ok = true
-				break
-			}
-		}
-		if !ok {
-			c.sendAlert(alertHandshakeFailure)
-			return nil, errors.New("tls: client's certificate's extended key usage doesn't permit it to be used for client authentication")
-		}
-
-		c.verifiedChains = chains
-	}
-
-	if len(certs) > 0 {
-		var pub crypto.PublicKey
-		switch key := certs[0].PublicKey.(type) {
-		case *ecdsa.PublicKey, *rsa.PublicKey:
-			pub = key
-		default:
-			return nil, c.sendAlert(alertUnsupportedCertificate)
-		}
-		c.peerCertificates = certs
-		return pub, nil
-	}
-
-	return nil, nil
-}
-
-// tryCipherSuite returns a cipherSuite with the given id if that cipher suite
-// is acceptable to use.
-func (c *Conn) tryCipherSuite(id uint16, supportedCipherSuites []uint16, version uint16, ellipticOk, ecdsaOk bool) *cipherSuite {
-	for _, supported := range supportedCipherSuites {
-		if id == supported {
-			var candidate *cipherSuite
-
-			for _, s := range cipherSuites {
-				if s.id == id {
-					candidate = s
-					break
-				}
-			}
-			if candidate == nil {
-				continue
-			}
-			// Don't select a ciphersuite which we can't
-			// support for this client.
-			if (candidate.flags&suiteECDHE != 0) && !ellipticOk {
-				continue
-			}
-			if (candidate.flags&suiteECDSA != 0) != ecdsaOk {
-				continue
-			}
-			if version < VersionTLS12 && candidate.flags&suiteTLS12 != 0 {
-				continue
-			}
-			return candidate
-		}
-	}
-
-	return nil
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/key_agreement.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/key_agreement.go
deleted file mode 100644
index 7e820c1e7..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/key_agreement.go
+++ /dev/null
@@ -1,400 +0,0 @@
-// Copyright 2010 The Go 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 tls
-
-import (
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/md5"
-	"crypto/rsa"
-	"crypto/sha1"
-	"crypto/sha256"
-	"crypto/x509"
-	"encoding/asn1"
-	"errors"
-	"io"
-	"math/big"
-)
-
-// rsaKeyAgreement implements the standard TLS key agreement where the client
-// encrypts the pre-master secret to the server's public key.
-type rsaKeyAgreement struct{}
-
-func (ka rsaKeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
-	return nil, nil
-}
-
-func (ka rsaKeyAgreement) processClientKeyExchange(config *Config, cert *Certificate, ckx *clientKeyExchangeMsg, version uint16) ([]byte, error) {
-	preMasterSecret := make([]byte, 48)
-	_, err := io.ReadFull(config.rand(), preMasterSecret[2:])
-	if err != nil {
-		return nil, err
-	}
-
-	if len(ckx.ciphertext) < 2 {
-		return nil, errors.New("bad ClientKeyExchange")
-	}
-
-	ciphertext := ckx.ciphertext
-	if version != VersionSSL30 {
-		ciphertextLen := int(ckx.ciphertext[0])<<8 | int(ckx.ciphertext[1])
-		if ciphertextLen != len(ckx.ciphertext)-2 {
-			return nil, errors.New("bad ClientKeyExchange")
-		}
-		ciphertext = ckx.ciphertext[2:]
-	}
-
-	err = rsa.DecryptPKCS1v15SessionKey(config.rand(), cert.PrivateKey.(*rsa.PrivateKey), ciphertext, preMasterSecret)
-	if err != nil {
-		return nil, err
-	}
-	// We don't check the version number in the premaster secret.  For one,
-	// by checking it, we would leak information about the validity of the
-	// encrypted pre-master secret. Secondly, it provides only a small
-	// benefit against a downgrade attack and some implementations send the
-	// wrong version anyway. See the discussion at the end of section
-	// 7.4.7.1 of RFC 4346.
-	return preMasterSecret, nil
-}
-
-func (ka rsaKeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
-	return errors.New("unexpected ServerKeyExchange")
-}
-
-func (ka rsaKeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
-	preMasterSecret := make([]byte, 48)
-	preMasterSecret[0] = byte(clientHello.vers >> 8)
-	preMasterSecret[1] = byte(clientHello.vers)
-	_, err := io.ReadFull(config.rand(), preMasterSecret[2:])
-	if err != nil {
-		return nil, nil, err
-	}
-
-	encrypted, err := rsa.EncryptPKCS1v15(config.rand(), cert.PublicKey.(*rsa.PublicKey), preMasterSecret)
-	if err != nil {
-		return nil, nil, err
-	}
-	ckx := new(clientKeyExchangeMsg)
-	ckx.ciphertext = make([]byte, len(encrypted)+2)
-	ckx.ciphertext[0] = byte(len(encrypted) >> 8)
-	ckx.ciphertext[1] = byte(len(encrypted))
-	copy(ckx.ciphertext[2:], encrypted)
-	return preMasterSecret, ckx, nil
-}
-
-// sha1Hash calculates a SHA1 hash over the given byte slices.
-func sha1Hash(slices [][]byte) []byte {
-	hsha1 := sha1.New()
-	for _, slice := range slices {
-		hsha1.Write(slice)
-	}
-	return hsha1.Sum(nil)
-}
-
-// md5SHA1Hash implements TLS 1.0's hybrid hash function which consists of the
-// concatenation of an MD5 and SHA1 hash.
-func md5SHA1Hash(slices [][]byte) []byte {
-	md5sha1 := make([]byte, md5.Size+sha1.Size)
-	hmd5 := md5.New()
-	for _, slice := range slices {
-		hmd5.Write(slice)
-	}
-	copy(md5sha1, hmd5.Sum(nil))
-	copy(md5sha1[md5.Size:], sha1Hash(slices))
-	return md5sha1
-}
-
-// sha256Hash implements TLS 1.2's hash function.
-func sha256Hash(slices [][]byte) []byte {
-	h := sha256.New()
-	for _, slice := range slices {
-		h.Write(slice)
-	}
-	return h.Sum(nil)
-}
-
-// hashForServerKeyExchange hashes the given slices and returns their digest
-// and the identifier of the hash function used. The hashFunc argument is only
-// used for >= TLS 1.2 and precisely identifies the hash function to use.
-func hashForServerKeyExchange(sigType, hashFunc uint8, version uint16, slices ...[]byte) ([]byte, crypto.Hash, error) {
-	if version >= VersionTLS12 {
-		switch hashFunc {
-		case hashSHA256:
-			return sha256Hash(slices), crypto.SHA256, nil
-		case hashSHA1:
-			return sha1Hash(slices), crypto.SHA1, nil
-		default:
-			return nil, crypto.Hash(0), errors.New("tls: unknown hash function used by peer")
-		}
-	}
-	if sigType == signatureECDSA {
-		return sha1Hash(slices), crypto.SHA1, nil
-	}
-	return md5SHA1Hash(slices), crypto.MD5SHA1, nil
-}
-
-// pickTLS12HashForSignature returns a TLS 1.2 hash identifier for signing a
-// ServerKeyExchange given the signature type being used and the client's
-// advertized list of supported signature and hash combinations.
-func pickTLS12HashForSignature(sigType uint8, clientSignatureAndHashes []signatureAndHash) (uint8, error) {
-	if len(clientSignatureAndHashes) == 0 {
-		// If the client didn't specify any signature_algorithms
-		// extension then we can assume that it supports SHA1. See
-		// http://tools.ietf.org/html/rfc5246#section-7.4.1.4.1
-		return hashSHA1, nil
-	}
-
-	for _, sigAndHash := range clientSignatureAndHashes {
-		if sigAndHash.signature != sigType {
-			continue
-		}
-		switch sigAndHash.hash {
-		case hashSHA1, hashSHA256:
-			return sigAndHash.hash, nil
-		}
-	}
-
-	return 0, errors.New("tls: client doesn't support any common hash functions")
-}
-
-// ecdheRSAKeyAgreement implements a TLS key agreement where the server
-// generates a ephemeral EC public/private key pair and signs it. The
-// pre-master secret is then calculated using ECDH. The signature may
-// either be ECDSA or RSA.
-type ecdheKeyAgreement struct {
-	version    uint16
-	sigType    uint8
-	privateKey []byte
-	curve      elliptic.Curve
-	x, y       *big.Int
-}
-
-func (ka *ecdheKeyAgreement) generateServerKeyExchange(config *Config, cert *Certificate, clientHello *clientHelloMsg, hello *serverHelloMsg) (*serverKeyExchangeMsg, error) {
-	var curveid uint16
-
-Curve:
-	for _, c := range clientHello.supportedCurves {
-		switch c {
-		case curveP256:
-			ka.curve = elliptic.P256()
-			curveid = c
-			break Curve
-		case curveP384:
-			ka.curve = elliptic.P384()
-			curveid = c
-			break Curve
-		case curveP521:
-			ka.curve = elliptic.P521()
-			curveid = c
-			break Curve
-		}
-	}
-
-	if curveid == 0 {
-		return nil, errors.New("tls: no supported elliptic curves offered")
-	}
-
-	var x, y *big.Int
-	var err error
-	ka.privateKey, x, y, err = elliptic.GenerateKey(ka.curve, config.rand())
-	if err != nil {
-		return nil, err
-	}
-	ecdhePublic := elliptic.Marshal(ka.curve, x, y)
-
-	// http://tools.ietf.org/html/rfc4492#section-5.4
-	serverECDHParams := make([]byte, 1+2+1+len(ecdhePublic))
-	serverECDHParams[0] = 3 // named curve
-	serverECDHParams[1] = byte(curveid >> 8)
-	serverECDHParams[2] = byte(curveid)
-	serverECDHParams[3] = byte(len(ecdhePublic))
-	copy(serverECDHParams[4:], ecdhePublic)
-
-	var tls12HashId uint8
-	if ka.version >= VersionTLS12 {
-		if tls12HashId, err = pickTLS12HashForSignature(ka.sigType, clientHello.signatureAndHashes); err != nil {
-			return nil, err
-		}
-	}
-
-	digest, hashFunc, err := hashForServerKeyExchange(ka.sigType, tls12HashId, ka.version, clientHello.random, hello.random, serverECDHParams)
-	if err != nil {
-		return nil, err
-	}
-	var sig []byte
-	switch ka.sigType {
-	case signatureECDSA:
-		privKey, ok := cert.PrivateKey.(*ecdsa.PrivateKey)
-		if !ok {
-			return nil, errors.New("ECDHE ECDSA requires an ECDSA server private key")
-		}
-		r, s, err := ecdsa.Sign(config.rand(), privKey, digest)
-		if err != nil {
-			return nil, errors.New("failed to sign ECDHE parameters: " + err.Error())
-		}
-		sig, err = asn1.Marshal(ecdsaSignature{r, s})
-	case signatureRSA:
-		privKey, ok := cert.PrivateKey.(*rsa.PrivateKey)
-		if !ok {
-			return nil, errors.New("ECDHE RSA requires a RSA server private key")
-		}
-		sig, err = rsa.SignPKCS1v15(config.rand(), privKey, hashFunc, digest)
-		if err != nil {
-			return nil, errors.New("failed to sign ECDHE parameters: " + err.Error())
-		}
-	default:
-		return nil, errors.New("unknown ECDHE signature algorithm")
-	}
-
-	skx := new(serverKeyExchangeMsg)
-	sigAndHashLen := 0
-	if ka.version >= VersionTLS12 {
-		sigAndHashLen = 2
-	}
-	skx.key = make([]byte, len(serverECDHParams)+sigAndHashLen+2+len(sig))
-	copy(skx.key, serverECDHParams)
-	k := skx.key[len(serverECDHParams):]
-	if ka.version >= VersionTLS12 {
-		k[0] = tls12HashId
-		k[1] = ka.sigType
-		k = k[2:]
-	}
-	k[0] = byte(len(sig) >> 8)
-	k[1] = byte(len(sig))
-	copy(k[2:], sig)
-
-	return skx, nil
-}
-
-func (ka *ecdheKeyAgreement) processClientKeyExchange(config *Config, cert *Certificate, ckx *clientKeyExchangeMsg, version uint16) ([]byte, error) {
-	if len(ckx.ciphertext) == 0 || int(ckx.ciphertext[0]) != len(ckx.ciphertext)-1 {
-		return nil, errors.New("bad ClientKeyExchange")
-	}
-	x, y := elliptic.Unmarshal(ka.curve, ckx.ciphertext[1:])
-	if x == nil {
-		return nil, errors.New("bad ClientKeyExchange")
-	}
-	x, _ = ka.curve.ScalarMult(x, y, ka.privateKey)
-	preMasterSecret := make([]byte, (ka.curve.Params().BitSize+7)>>3)
-	xBytes := x.Bytes()
-	copy(preMasterSecret[len(preMasterSecret)-len(xBytes):], xBytes)
-
-	return preMasterSecret, nil
-}
-
-var errServerKeyExchange = errors.New("invalid ServerKeyExchange")
-
-func (ka *ecdheKeyAgreement) processServerKeyExchange(config *Config, clientHello *clientHelloMsg, serverHello *serverHelloMsg, cert *x509.Certificate, skx *serverKeyExchangeMsg) error {
-	if len(skx.key) < 4 {
-		return errServerKeyExchange
-	}
-	if skx.key[0] != 3 { // named curve
-		return errors.New("server selected unsupported curve")
-	}
-	curveid := uint16(skx.key[1])<<8 | uint16(skx.key[2])
-
-	switch curveid {
-	case curveP256:
-		ka.curve = elliptic.P256()
-	case curveP384:
-		ka.curve = elliptic.P384()
-	case curveP521:
-		ka.curve = elliptic.P521()
-	default:
-		return errors.New("server selected unsupported curve")
-	}
-
-	publicLen := int(skx.key[3])
-	if publicLen+4 > len(skx.key) {
-		return errServerKeyExchange
-	}
-	ka.x, ka.y = elliptic.Unmarshal(ka.curve, skx.key[4:4+publicLen])
-	if ka.x == nil {
-		return errServerKeyExchange
-	}
-	serverECDHParams := skx.key[:4+publicLen]
-
-	sig := skx.key[4+publicLen:]
-	if len(sig) < 2 {
-		return errServerKeyExchange
-	}
-
-	var tls12HashId uint8
-	if ka.version >= VersionTLS12 {
-		// handle SignatureAndHashAlgorithm
-		var sigAndHash []uint8
-		sigAndHash, sig = sig[:2], sig[2:]
-		if sigAndHash[1] != ka.sigType {
-			return errServerKeyExchange
-		}
-		tls12HashId = sigAndHash[0]
-		if len(sig) < 2 {
-			return errServerKeyExchange
-		}
-	}
-	sigLen := int(sig[0])<<8 | int(sig[1])
-	if sigLen+2 != len(sig) {
-		return errServerKeyExchange
-	}
-	sig = sig[2:]
-
-	digest, hashFunc, err := hashForServerKeyExchange(ka.sigType, tls12HashId, ka.version, clientHello.random, serverHello.random, serverECDHParams)
-	if err != nil {
-		return err
-	}
-	switch ka.sigType {
-	case signatureECDSA:
-		pubKey, ok := cert.PublicKey.(*ecdsa.PublicKey)
-		if !ok {
-			return errors.New("ECDHE ECDSA requires a ECDSA server public key")
-		}
-		ecdsaSig := new(ecdsaSignature)
-		if _, err := asn1.Unmarshal(sig, ecdsaSig); err != nil {
-			return err
-		}
-		if ecdsaSig.R.Sign() <= 0 || ecdsaSig.S.Sign() <= 0 {
-			return errors.New("ECDSA signature contained zero or negative values")
-		}
-		if !ecdsa.Verify(pubKey, digest, ecdsaSig.R, ecdsaSig.S) {
-			return errors.New("ECDSA verification failure")
-		}
-	case signatureRSA:
-		pubKey, ok := cert.PublicKey.(*rsa.PublicKey)
-		if !ok {
-			return errors.New("ECDHE RSA requires a RSA server public key")
-		}
-		if err := rsa.VerifyPKCS1v15(pubKey, hashFunc, digest, sig); err != nil {
-			return err
-		}
-	default:
-		return errors.New("unknown ECDHE signature algorithm")
-	}
-
-	return nil
-}
-
-func (ka *ecdheKeyAgreement) generateClientKeyExchange(config *Config, clientHello *clientHelloMsg, cert *x509.Certificate) ([]byte, *clientKeyExchangeMsg, error) {
-	if ka.curve == nil {
-		return nil, nil, errors.New("missing ServerKeyExchange message")
-	}
-	priv, mx, my, err := elliptic.GenerateKey(ka.curve, config.rand())
-	if err != nil {
-		return nil, nil, err
-	}
-	x, _ := ka.curve.ScalarMult(ka.x, ka.y, priv)
-	preMasterSecret := make([]byte, (ka.curve.Params().BitSize+7)>>3)
-	xBytes := x.Bytes()
-	copy(preMasterSecret[len(preMasterSecret)-len(xBytes):], xBytes)
-
-	serialized := elliptic.Marshal(ka.curve, mx, my)
-
-	ckx := new(clientKeyExchangeMsg)
-	ckx.ciphertext = make([]byte, 1+len(serialized))
-	ckx.ciphertext[0] = byte(len(serialized))
-	copy(ckx.ciphertext[1:], serialized)
-
-	return preMasterSecret, ckx, nil
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/prf.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/prf.go
deleted file mode 100644
index fb8b3ab4d..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/prf.go
+++ /dev/null
@@ -1,291 +0,0 @@
-// Copyright 2009 The Go 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 tls
-
-import (
-	"crypto"
-	"crypto/hmac"
-	"crypto/md5"
-	"crypto/sha1"
-	"crypto/sha256"
-	"hash"
-)
-
-// Split a premaster secret in two as specified in RFC 4346, section 5.
-func splitPreMasterSecret(secret []byte) (s1, s2 []byte) {
-	s1 = secret[0 : (len(secret)+1)/2]
-	s2 = secret[len(secret)/2:]
-	return
-}
-
-// pHash implements the P_hash function, as defined in RFC 4346, section 5.
-func pHash(result, secret, seed []byte, hash func() hash.Hash) {
-	h := hmac.New(hash, secret)
-	h.Write(seed)
-	a := h.Sum(nil)
-
-	j := 0
-	for j < len(result) {
-		h.Reset()
-		h.Write(a)
-		h.Write(seed)
-		b := h.Sum(nil)
-		todo := len(b)
-		if j+todo > len(result) {
-			todo = len(result) - j
-		}
-		copy(result[j:j+todo], b)
-		j += todo
-
-		h.Reset()
-		h.Write(a)
-		a = h.Sum(nil)
-	}
-}
-
-// prf10 implements the TLS 1.0 pseudo-random function, as defined in RFC 2246, section 5.
-func prf10(result, secret, label, seed []byte) {
-	hashSHA1 := sha1.New
-	hashMD5 := md5.New
-
-	labelAndSeed := make([]byte, len(label)+len(seed))
-	copy(labelAndSeed, label)
-	copy(labelAndSeed[len(label):], seed)
-
-	s1, s2 := splitPreMasterSecret(secret)
-	pHash(result, s1, labelAndSeed, hashMD5)
-	result2 := make([]byte, len(result))
-	pHash(result2, s2, labelAndSeed, hashSHA1)
-
-	for i, b := range result2 {
-		result[i] ^= b
-	}
-}
-
-// prf12 implements the TLS 1.2 pseudo-random function, as defined in RFC 5246, section 5.
-func prf12(result, secret, label, seed []byte) {
-	labelAndSeed := make([]byte, len(label)+len(seed))
-	copy(labelAndSeed, label)
-	copy(labelAndSeed[len(label):], seed)
-
-	pHash(result, secret, labelAndSeed, sha256.New)
-}
-
-// prf30 implements the SSL 3.0 pseudo-random function, as defined in
-// www.mozilla.org/projects/security/pki/nss/ssl/draft302.txt section 6.
-func prf30(result, secret, label, seed []byte) {
-	hashSHA1 := sha1.New()
-	hashMD5 := md5.New()
-
-	done := 0
-	i := 0
-	// RFC5246 section 6.3 says that the largest PRF output needed is 128
-	// bytes. Since no more ciphersuites will be added to SSLv3, this will
-	// remain true. Each iteration gives us 16 bytes so 10 iterations will
-	// be sufficient.
-	var b [11]byte
-	for done < len(result) {
-		for j := 0; j <= i; j++ {
-			b[j] = 'A' + byte(i)
-		}
-
-		hashSHA1.Reset()
-		hashSHA1.Write(b[:i+1])
-		hashSHA1.Write(secret)
-		hashSHA1.Write(seed)
-		digest := hashSHA1.Sum(nil)
-
-		hashMD5.Reset()
-		hashMD5.Write(secret)
-		hashMD5.Write(digest)
-
-		done += copy(result[done:], hashMD5.Sum(nil))
-		i++
-	}
-}
-
-const (
-	tlsRandomLength      = 32 // Length of a random nonce in TLS 1.1.
-	masterSecretLength   = 48 // Length of a master secret in TLS 1.1.
-	finishedVerifyLength = 12 // Length of verify_data in a Finished message.
-)
-
-var masterSecretLabel = []byte("master secret")
-var keyExpansionLabel = []byte("key expansion")
-var clientFinishedLabel = []byte("client finished")
-var serverFinishedLabel = []byte("server finished")
-
-func prfForVersion(version uint16) func(result, secret, label, seed []byte) {
-	switch version {
-	case VersionSSL30:
-		return prf30
-	case VersionTLS10, VersionTLS11:
-		return prf10
-	case VersionTLS12:
-		return prf12
-	default:
-		panic("unknown version")
-	}
-}
-
-// masterFromPreMasterSecret generates the master secret from the pre-master
-// secret. See http://tools.ietf.org/html/rfc5246#section-8.1
-func masterFromPreMasterSecret(version uint16, preMasterSecret, clientRandom, serverRandom []byte) []byte {
-	var seed [tlsRandomLength * 2]byte
-	copy(seed[0:len(clientRandom)], clientRandom)
-	copy(seed[len(clientRandom):], serverRandom)
-	masterSecret := make([]byte, masterSecretLength)
-	prfForVersion(version)(masterSecret, preMasterSecret, masterSecretLabel, seed[0:])
-	return masterSecret
-}
-
-// keysFromMasterSecret generates the connection keys from the master
-// secret, given the lengths of the MAC key, cipher key and IV, as defined in
-// RFC 2246, section 6.3.
-func keysFromMasterSecret(version uint16, masterSecret, clientRandom, serverRandom []byte, macLen, keyLen, ivLen int) (clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV []byte) {
-	var seed [tlsRandomLength * 2]byte
-	copy(seed[0:len(clientRandom)], serverRandom)
-	copy(seed[len(serverRandom):], clientRandom)
-
-	n := 2*macLen + 2*keyLen + 2*ivLen
-	keyMaterial := make([]byte, n)
-	prfForVersion(version)(keyMaterial, masterSecret, keyExpansionLabel, seed[0:])
-	clientMAC = keyMaterial[:macLen]
-	keyMaterial = keyMaterial[macLen:]
-	serverMAC = keyMaterial[:macLen]
-	keyMaterial = keyMaterial[macLen:]
-	clientKey = keyMaterial[:keyLen]
-	keyMaterial = keyMaterial[keyLen:]
-	serverKey = keyMaterial[:keyLen]
-	keyMaterial = keyMaterial[keyLen:]
-	clientIV = keyMaterial[:ivLen]
-	keyMaterial = keyMaterial[ivLen:]
-	serverIV = keyMaterial[:ivLen]
-	return
-}
-
-func newFinishedHash(version uint16) finishedHash {
-	if version >= VersionTLS12 {
-		return finishedHash{sha256.New(), sha256.New(), nil, nil, version}
-	}
-	return finishedHash{sha1.New(), sha1.New(), md5.New(), md5.New(), version}
-}
-
-// A finishedHash calculates the hash of a set of handshake messages suitable
-// for including in a Finished message.
-type finishedHash struct {
-	client hash.Hash
-	server hash.Hash
-
-	// Prior to TLS 1.2, an additional MD5 hash is required.
-	clientMD5 hash.Hash
-	serverMD5 hash.Hash
-
-	version uint16
-}
-
-func (h finishedHash) Write(msg []byte) (n int, err error) {
-	h.client.Write(msg)
-	h.server.Write(msg)
-
-	if h.version < VersionTLS12 {
-		h.clientMD5.Write(msg)
-		h.serverMD5.Write(msg)
-	}
-	return len(msg), nil
-}
-
-// finishedSum30 calculates the contents of the verify_data member of a SSLv3
-// Finished message given the MD5 and SHA1 hashes of a set of handshake
-// messages.
-func finishedSum30(md5, sha1 hash.Hash, masterSecret []byte, magic [4]byte) []byte {
-	md5.Write(magic[:])
-	md5.Write(masterSecret)
-	md5.Write(ssl30Pad1[:])
-	md5Digest := md5.Sum(nil)
-
-	md5.Reset()
-	md5.Write(masterSecret)
-	md5.Write(ssl30Pad2[:])
-	md5.Write(md5Digest)
-	md5Digest = md5.Sum(nil)
-
-	sha1.Write(magic[:])
-	sha1.Write(masterSecret)
-	sha1.Write(ssl30Pad1[:40])
-	sha1Digest := sha1.Sum(nil)
-
-	sha1.Reset()
-	sha1.Write(masterSecret)
-	sha1.Write(ssl30Pad2[:40])
-	sha1.Write(sha1Digest)
-	sha1Digest = sha1.Sum(nil)
-
-	ret := make([]byte, len(md5Digest)+len(sha1Digest))
-	copy(ret, md5Digest)
-	copy(ret[len(md5Digest):], sha1Digest)
-	return ret
-}
-
-var ssl3ClientFinishedMagic = [4]byte{0x43, 0x4c, 0x4e, 0x54}
-var ssl3ServerFinishedMagic = [4]byte{0x53, 0x52, 0x56, 0x52}
-
-// clientSum returns the contents of the verify_data member of a client's
-// Finished message.
-func (h finishedHash) clientSum(masterSecret []byte) []byte {
-	if h.version == VersionSSL30 {
-		return finishedSum30(h.clientMD5, h.client, masterSecret, ssl3ClientFinishedMagic)
-	}
-
-	out := make([]byte, finishedVerifyLength)
-	if h.version >= VersionTLS12 {
-		seed := h.client.Sum(nil)
-		prf12(out, masterSecret, clientFinishedLabel, seed)
-	} else {
-		seed := make([]byte, 0, md5.Size+sha1.Size)
-		seed = h.clientMD5.Sum(seed)
-		seed = h.client.Sum(seed)
-		prf10(out, masterSecret, clientFinishedLabel, seed)
-	}
-	return out
-}
-
-// serverSum returns the contents of the verify_data member of a server's
-// Finished message.
-func (h finishedHash) serverSum(masterSecret []byte) []byte {
-	if h.version == VersionSSL30 {
-		return finishedSum30(h.serverMD5, h.server, masterSecret, ssl3ServerFinishedMagic)
-	}
-
-	out := make([]byte, finishedVerifyLength)
-	if h.version >= VersionTLS12 {
-		seed := h.server.Sum(nil)
-		prf12(out, masterSecret, serverFinishedLabel, seed)
-	} else {
-		seed := make([]byte, 0, md5.Size+sha1.Size)
-		seed = h.serverMD5.Sum(seed)
-		seed = h.server.Sum(seed)
-		prf10(out, masterSecret, serverFinishedLabel, seed)
-	}
-	return out
-}
-
-// hashForClientCertificate returns a digest, hash function, and TLS 1.2 hash
-// id suitable for signing by a TLS client certificate.
-func (h finishedHash) hashForClientCertificate(sigType uint8) ([]byte, crypto.Hash, uint8) {
-	if h.version >= VersionTLS12 {
-		digest := h.server.Sum(nil)
-		return digest, crypto.SHA256, hashSHA256
-	}
-	if sigType == signatureECDSA {
-		digest := h.server.Sum(nil)
-		return digest, crypto.SHA1, hashSHA1
-	}
-
-	digest := make([]byte, 0, 36)
-	digest = h.serverMD5.Sum(digest)
-	digest = h.server.Sum(digest)
-	return digest, crypto.MD5SHA1, 0 /* not specified in TLS 1.2. */
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/ticket.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/ticket.go
deleted file mode 100644
index 4cfc5a53f..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/ticket.go
+++ /dev/null
@@ -1,182 +0,0 @@
-// Copyright 2012 The Go 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 tls
-
-import (
-	"bytes"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/hmac"
-	"crypto/sha256"
-	"crypto/subtle"
-	"errors"
-	"io"
-)
-
-// sessionState contains the information that is serialized into a session
-// ticket in order to later resume a connection.
-type sessionState struct {
-	vers         uint16
-	cipherSuite  uint16
-	masterSecret []byte
-	certificates [][]byte
-}
-
-func (s *sessionState) equal(i interface{}) bool {
-	s1, ok := i.(*sessionState)
-	if !ok {
-		return false
-	}
-
-	if s.vers != s1.vers ||
-		s.cipherSuite != s1.cipherSuite ||
-		!bytes.Equal(s.masterSecret, s1.masterSecret) {
-		return false
-	}
-
-	if len(s.certificates) != len(s1.certificates) {
-		return false
-	}
-
-	for i := range s.certificates {
-		if !bytes.Equal(s.certificates[i], s1.certificates[i]) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (s *sessionState) marshal() []byte {
-	length := 2 + 2 + 2 + len(s.masterSecret) + 2
-	for _, cert := range s.certificates {
-		length += 4 + len(cert)
-	}
-
-	ret := make([]byte, length)
-	x := ret
-	x[0] = byte(s.vers >> 8)
-	x[1] = byte(s.vers)
-	x[2] = byte(s.cipherSuite >> 8)
-	x[3] = byte(s.cipherSuite)
-	x[4] = byte(len(s.masterSecret) >> 8)
-	x[5] = byte(len(s.masterSecret))
-	x = x[6:]
-	copy(x, s.masterSecret)
-	x = x[len(s.masterSecret):]
-
-	x[0] = byte(len(s.certificates) >> 8)
-	x[1] = byte(len(s.certificates))
-	x = x[2:]
-
-	for _, cert := range s.certificates {
-		x[0] = byte(len(cert) >> 24)
-		x[1] = byte(len(cert) >> 16)
-		x[2] = byte(len(cert) >> 8)
-		x[3] = byte(len(cert))
-		copy(x[4:], cert)
-		x = x[4+len(cert):]
-	}
-
-	return ret
-}
-
-func (s *sessionState) unmarshal(data []byte) bool {
-	if len(data) < 8 {
-		return false
-	}
-
-	s.vers = uint16(data[0])<<8 | uint16(data[1])
-	s.cipherSuite = uint16(data[2])<<8 | uint16(data[3])
-	masterSecretLen := int(data[4])<<8 | int(data[5])
-	data = data[6:]
-	if len(data) < masterSecretLen {
-		return false
-	}
-
-	s.masterSecret = data[:masterSecretLen]
-	data = data[masterSecretLen:]
-
-	if len(data) < 2 {
-		return false
-	}
-
-	numCerts := int(data[0])<<8 | int(data[1])
-	data = data[2:]
-
-	s.certificates = make([][]byte, numCerts)
-	for i := range s.certificates {
-		if len(data) < 4 {
-			return false
-		}
-		certLen := int(data[0])<<24 | int(data[1])<<16 | int(data[2])<<8 | int(data[3])
-		data = data[4:]
-		if certLen < 0 {
-			return false
-		}
-		if len(data) < certLen {
-			return false
-		}
-		s.certificates[i] = data[:certLen]
-		data = data[certLen:]
-	}
-
-	if len(data) > 0 {
-		return false
-	}
-
-	return true
-}
-
-func (c *Conn) encryptTicket(state *sessionState) ([]byte, error) {
-	serialized := state.marshal()
-	encrypted := make([]byte, aes.BlockSize+len(serialized)+sha256.Size)
-	iv := encrypted[:aes.BlockSize]
-	macBytes := encrypted[len(encrypted)-sha256.Size:]
-
-	if _, err := io.ReadFull(c.config.rand(), iv); err != nil {
-		return nil, err
-	}
-	block, err := aes.NewCipher(c.config.SessionTicketKey[:16])
-	if err != nil {
-		return nil, errors.New("tls: failed to create cipher while encrypting ticket: " + err.Error())
-	}
-	cipher.NewCTR(block, iv).XORKeyStream(encrypted[aes.BlockSize:], serialized)
-
-	mac := hmac.New(sha256.New, c.config.SessionTicketKey[16:32])
-	mac.Write(encrypted[:len(encrypted)-sha256.Size])
-	mac.Sum(macBytes[:0])
-
-	return encrypted, nil
-}
-
-func (c *Conn) decryptTicket(encrypted []byte) (*sessionState, bool) {
-	if len(encrypted) < aes.BlockSize+sha256.Size {
-		return nil, false
-	}
-
-	iv := encrypted[:aes.BlockSize]
-	macBytes := encrypted[len(encrypted)-sha256.Size:]
-
-	mac := hmac.New(sha256.New, c.config.SessionTicketKey[16:32])
-	mac.Write(encrypted[:len(encrypted)-sha256.Size])
-	expected := mac.Sum(nil)
-
-	if subtle.ConstantTimeCompare(macBytes, expected) != 1 {
-		return nil, false
-	}
-
-	block, err := aes.NewCipher(c.config.SessionTicketKey[:16])
-	if err != nil {
-		return nil, false
-	}
-	ciphertext := encrypted[aes.BlockSize : len(encrypted)-sha256.Size]
-	plaintext := ciphertext
-	cipher.NewCTR(block, iv).XORKeyStream(plaintext, ciphertext)
-
-	state := new(sessionState)
-	ok := state.unmarshal(plaintext)
-	return state, ok
-}
diff --git a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/tls.go b/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/tls.go
deleted file mode 100644
index 6c67506fc..000000000
--- a/vendor/github.com/masterzen/azure-sdk-for-go/core/tls/tls.go
+++ /dev/null
@@ -1,225 +0,0 @@
-// Copyright 2009 The Go 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 tls partially implements TLS 1.2, as specified in RFC 5246.
-package tls
-
-import (
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/rsa"
-	"crypto/x509"
-	"encoding/pem"
-	"errors"
-	"io/ioutil"
-	"net"
-	"strings"
-)
-
-// Server returns a new TLS server side connection
-// using conn as the underlying transport.
-// The configuration config must be non-nil and must have
-// at least one certificate.
-func Server(conn net.Conn, config *Config) *Conn {
-	return &Conn{conn: conn, config: config}
-}
-
-// Client returns a new TLS client side connection
-// using conn as the underlying transport.
-// Client interprets a nil configuration as equivalent to
-// the zero configuration; see the documentation of Config
-// for the defaults.
-func Client(conn net.Conn, config *Config) *Conn {
-	return &Conn{conn: conn, config: config, isClient: true}
-}
-
-// A listener implements a network listener (net.Listener) for TLS connections.
-type listener struct {
-	net.Listener
-	config *Config
-}
-
-// Accept waits for and returns the next incoming TLS connection.
-// The returned connection c is a *tls.Conn.
-func (l *listener) Accept() (c net.Conn, err error) {
-	c, err = l.Listener.Accept()
-	if err != nil {
-		return
-	}
-	c = Server(c, l.config)
-	return
-}
-
-// NewListener creates a Listener which accepts connections from an inner
-// Listener and wraps each connection with Server.
-// The configuration config must be non-nil and must have
-// at least one certificate.
-func NewListener(inner net.Listener, config *Config) net.Listener {
-	l := new(listener)
-	l.Listener = inner
-	l.config = config
-	return l
-}
-
-// Listen creates a TLS listener accepting connections on the
-// given network address using net.Listen.
-// The configuration config must be non-nil and must have
-// at least one certificate.
-func Listen(network, laddr string, config *Config) (net.Listener, error) {
-	if config == nil || len(config.Certificates) == 0 {
-		return nil, errors.New("tls.Listen: no certificates in configuration")
-	}
-	l, err := net.Listen(network, laddr)
-	if err != nil {
-		return nil, err
-	}
-	return NewListener(l, config), nil
-}
-
-// Dial connects to the given network address using net.Dial
-// and then initiates a TLS handshake, returning the resulting
-// TLS connection.
-// Dial interprets a nil configuration as equivalent to
-// the zero configuration; see the documentation of Config
-// for the defaults.
-func Dial(network, addr string, config *Config) (*Conn, error) {
-	raddr := addr
-	c, err := net.Dial(network, raddr)
-	if err != nil {
-		return nil, err
-	}
-
-	colonPos := strings.LastIndex(raddr, ":")
-	if colonPos == -1 {
-		colonPos = len(raddr)
-	}
-	hostname := raddr[:colonPos]
-
-	if config == nil {
-		config = defaultConfig()
-	}
-	// If no ServerName is set, infer the ServerName
-	// from the hostname we're connecting to.
-	if config.ServerName == "" {
-		// Make a copy to avoid polluting argument or default.
-		c := *config
-		c.ServerName = hostname
-		config = &c
-	}
-	conn := Client(c, config)
-	if err = conn.Handshake(); err != nil {
-		c.Close()
-		return nil, err
-	}
-	return conn, nil
-}
-
-// LoadX509KeyPair reads and parses a public/private key pair from a pair of
-// files. The files must contain PEM encoded data.
-func LoadX509KeyPair(certFile, keyFile string) (cert Certificate, err error) {
-	certPEMBlock, err := ioutil.ReadFile(certFile)
-	if err != nil {
-		return
-	}
-	keyPEMBlock, err := ioutil.ReadFile(keyFile)
-	if err != nil {
-		return
-	}
-	return X509KeyPair(certPEMBlock, keyPEMBlock)
-}
-
-// X509KeyPair parses a public/private key pair from a pair of
-// PEM encoded data.
-func X509KeyPair(certPEMBlock, keyPEMBlock []byte) (cert Certificate, err error) {
-	var certDERBlock *pem.Block
-	for {
-		certDERBlock, certPEMBlock = pem.Decode(certPEMBlock)
-		if certDERBlock == nil {
-			break
-		}
-		if certDERBlock.Type == "CERTIFICATE" {
-			cert.Certificate = append(cert.Certificate, certDERBlock.Bytes)
-		}
-	}
-
-	if len(cert.Certificate) == 0 {
-		err = errors.New("crypto/tls: failed to parse certificate PEM data")
-		return
-	}
-
-	var keyDERBlock *pem.Block
-	for {
-		keyDERBlock, keyPEMBlock = pem.Decode(keyPEMBlock)
-		if keyDERBlock == nil {
-			err = errors.New("crypto/tls: failed to parse key PEM data")
-			return
-		}
-		if keyDERBlock.Type == "PRIVATE KEY" || strings.HasSuffix(keyDERBlock.Type, " PRIVATE KEY") {
-			break
-		}
-	}
-
-	cert.PrivateKey, err = parsePrivateKey(keyDERBlock.Bytes)
-	if err != nil {
-		return
-	}
-
-	// We don't need to parse the public key for TLS, but we so do anyway
-	// to check that it looks sane and matches the private key.
-	x509Cert, err := x509.ParseCertificate(cert.Certificate[0])
-	if err != nil {
-		return
-	}
-
-	switch pub := x509Cert.PublicKey.(type) {
-	case *rsa.PublicKey:
-		priv, ok := cert.PrivateKey.(*rsa.PrivateKey)
-		if !ok {
-			err = errors.New("crypto/tls: private key type does not match public key type")
-			return
-		}
-		if pub.N.Cmp(priv.N) != 0 {
-			err = errors.New("crypto/tls: private key does not match public key")
-			return
-		}
-	case *ecdsa.PublicKey:
-		priv, ok := cert.PrivateKey.(*ecdsa.PrivateKey)
-		if !ok {
-			err = errors.New("crypto/tls: private key type does not match public key type")
-			return
-
-		}
-		if pub.X.Cmp(priv.X) != 0 || pub.Y.Cmp(priv.Y) != 0 {
-			err = errors.New("crypto/tls: private key does not match public key")
-			return
-		}
-	default:
-		err = errors.New("crypto/tls: unknown public key algorithm")
-		return
-	}
-
-	return
-}
-
-// Attempt to parse the given private key DER block. OpenSSL 0.9.8 generates
-// PKCS#1 private keys by default, while OpenSSL 1.0.0 generates PKCS#8 keys.
-// OpenSSL ecparam generates SEC1 EC private keys for ECDSA. We try all three.
-func parsePrivateKey(der []byte) (crypto.PrivateKey, error) {
-	if key, err := x509.ParsePKCS1PrivateKey(der); err == nil {
-		return key, nil
-	}
-	if key, err := x509.ParsePKCS8PrivateKey(der); err == nil {
-		switch key := key.(type) {
-		case *rsa.PrivateKey, *ecdsa.PrivateKey:
-			return key, nil
-		default:
-			return nil, errors.New("crypto/tls: found unknown private key type in PKCS#8 wrapping")
-		}
-	}
-	if key, err := x509.ParseECPrivateKey(der); err == nil {
-		return key, nil
-	}
-
-	return nil, errors.New("crypto/tls: failed to parse private key")
-}
diff --git a/vendor/github.com/masterzen/winrm/.travis.yml b/vendor/github.com/masterzen/winrm/.travis.yml
index 7da672a34..18c04d4c1 100644
--- a/vendor/github.com/masterzen/winrm/.travis.yml
+++ b/vendor/github.com/masterzen/winrm/.travis.yml
@@ -1,8 +1,6 @@
 sudo: false
 language: go
 go:
-- 1.5
-- 1.6
 - 1.7
 - 1.8
 - 1.9
diff --git a/vendor/github.com/masterzen/winrm/README.md b/vendor/github.com/masterzen/winrm/README.md
index 2f1d0ad5c..ac4aff970 100644
--- a/vendor/github.com/masterzen/winrm/README.md
+++ b/vendor/github.com/masterzen/winrm/README.md
@@ -18,6 +18,8 @@ _Note_: this library doesn't support domain users (it doesn't support GSSAPI nor
 ## Getting Started
 WinRM is available on Windows Server 2008 and up. This project natively supports basic authentication for local accounts, see the steps in the next section on how to prepare the remote Windows machine for this scenario. The authentication model is pluggable, see below for an example on using Negotiate/NTLM authentication (e.g. for connecting to vanilla Azure VMs).
 
+_Note_: This library only supports Golang 1.7+
+
 ### Preparing the remote Windows machine for Basic authentication
 This project supports only basic authentication for local accounts (domain users are not supported). The remote windows system must be prepared for winrm:
 
@@ -132,6 +134,44 @@ if err != nil {
 
 ```
 
+By passing a Dial in the Parameters struct it is possible to use different dialer (e.g. tunnel through SSH)
+
+```go
+package main
+     
+ import (
+    "github.com/masterzen/winrm"
+    "golang.org/x/crypto/ssh"
+    "os"
+ )
+ 
+ func main() {
+ 
+    sshClient, err := ssh.Dial("tcp","localhost:22", &ssh.ClientConfig{
+        User:"ubuntu",
+        Auth: []ssh.AuthMethod{ssh.Password("ubuntu")},
+        HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+    })
+ 
+    endpoint := winrm.NewEndpoint("other-host", 5985, false, false, nil, nil, nil, 0)
+ 
+    params := winrm.DefaultParameters
+    params.Dial = sshClient.Dial
+ 
+    client, err := winrm.NewClientWithParameters(endpoint, "test", "test", params)
+    if err != nil {
+        panic(err)
+    }
+ 
+    _, err = client.RunWithInput("ipconfig", os.Stdout, os.Stderr, os.Stdin)
+    if err != nil {
+        panic(err)
+    }
+ }
+
+```
+
+
 For a more complex example, it is possible to call the various functions directly:
 
 ```go
diff --git a/vendor/github.com/masterzen/winrm/auth.go b/vendor/github.com/masterzen/winrm/auth.go
index 2e7c3757f..0ae5d9972 100644
--- a/vendor/github.com/masterzen/winrm/auth.go
+++ b/vendor/github.com/masterzen/winrm/auth.go
@@ -1,20 +1,20 @@
 package winrm
 
 import (
+	"crypto/tls"
 	"fmt"
 	"io/ioutil"
 	"net"
+	"net/http"
 	"strings"
 	"time"
 
-	"github.com/masterzen/azure-sdk-for-go/core/http"
-	"github.com/masterzen/azure-sdk-for-go/core/tls"
-
 	"github.com/masterzen/winrm/soap"
 )
 
 type ClientAuthRequest struct {
 	transport http.RoundTripper
+	dial func(network, addr string) (net.Conn, error)
 }
 
 func (c *ClientAuthRequest) Transport(endpoint *Endpoint) error {
@@ -23,16 +23,22 @@ func (c *ClientAuthRequest) Transport(endpoint *Endpoint) error {
 		return err
 	}
 
+	dial := (&net.Dialer{
+		Timeout:   30 * time.Second,
+		KeepAlive: 30 * time.Second,
+	}).Dial
+
+	if c.dial != nil {
+		dial = c.dial
+	}
+
 	transport := &http.Transport{
 		Proxy: http.ProxyFromEnvironment,
 		TLSClientConfig: &tls.Config{
 			InsecureSkipVerify: endpoint.Insecure,
 			Certificates:       []tls.Certificate{cert},
 		},
-		Dial: (&net.Dialer{
-			Timeout:   30 * time.Second,
-			KeepAlive: 30 * time.Second,
-		}).Dial,
+		Dial: dial,
 		ResponseHeaderTimeout: endpoint.Timeout,
 	}
 
@@ -104,3 +110,9 @@ func (c ClientAuthRequest) Post(client *Client, request *soap.SoapMessage) (stri
 
 	return body, err
 }
+
+func NewClientAuthRequestWithDial(dial func(network, addr string) (net.Conn, error)) *ClientAuthRequest {
+	return &ClientAuthRequest{
+		dial:dial,
+	}
+}
\ No newline at end of file
diff --git a/vendor/github.com/masterzen/winrm/client.go b/vendor/github.com/masterzen/winrm/client.go
index c19515194..fb68c3cac 100644
--- a/vendor/github.com/masterzen/winrm/client.go
+++ b/vendor/github.com/masterzen/winrm/client.go
@@ -46,7 +46,7 @@ func NewClientWithParameters(endpoint *Endpoint, user, password string, params *
 		url:        endpoint.url(),
 		useHTTPS:   endpoint.HTTPS,
 		// default transport
-		http: &clientRequest{},
+		http: &clientRequest{ dial:params.Dial },
 	}
 
 	// switch to other transport if provided
diff --git a/vendor/github.com/masterzen/winrm/go.mod b/vendor/github.com/masterzen/winrm/go.mod
new file mode 100644
index 000000000..8c674377f
--- /dev/null
+++ b/vendor/github.com/masterzen/winrm/go.mod
@@ -0,0 +1,13 @@
+module github.com/masterzen/winrm
+
+require (
+	github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4
+	github.com/ChrisTrenkamp/goxpath v0.0.0-20170922090931-c385f95c6022
+	github.com/kr/pretty v0.1.0 // indirect
+	github.com/masterzen/simplexml v0.0.0-20160608183007-4572e39b1ab9
+	github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d
+	golang.org/x/crypto v0.0.0-20190222235706-ffb98f73852f // indirect
+	golang.org/x/net v0.0.0-20190213061140-3a22650c66bd // indirect
+	golang.org/x/text v0.3.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127
+)
diff --git a/vendor/github.com/masterzen/winrm/go.sum b/vendor/github.com/masterzen/winrm/go.sum
new file mode 100644
index 000000000..7e343bd10
--- /dev/null
+++ b/vendor/github.com/masterzen/winrm/go.sum
@@ -0,0 +1,21 @@
+github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4 h1:pSm8mp0T2OH2CPmPDPtwHPr3VAQaOwVF/JbllOPP4xA=
+github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4/go.mod h1:chxPXzSsl7ZWRAuOIE23GDNzjWuZquvFlgA8xmpunjU=
+github.com/ChrisTrenkamp/goxpath v0.0.0-20170922090931-c385f95c6022 h1:y8Gs8CzNfDF5AZvjr+5UyGQvQEBL7pwo+v+wX6q9JI8=
+github.com/ChrisTrenkamp/goxpath v0.0.0-20170922090931-c385f95c6022/go.mod h1:nuWgzSkT5PnyOd+272uUmV0dnAnAn42Mk7PiQC5VzN4=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/masterzen/simplexml v0.0.0-20160608183007-4572e39b1ab9 h1:SmVbOZFWAlyQshuMfOkiAx1f5oUTsOGG5IXplAEYeeM=
+github.com/masterzen/simplexml v0.0.0-20160608183007-4572e39b1ab9/go.mod h1:kCEbxUJlNDEBNbdQMkPSp6yaKcRXVI6f4ddk8Riv4bc=
+github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d h1:VhgPp6v9qf9Agr/56bj7Y/xa04UccTW04VP0Qed4vnQ=
+github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d/go.mod h1:YUTz3bUH2ZwIWBy3CJBeOBEugqcmXREj14T+iG/4k4U=
+golang.org/x/crypto v0.0.0-20190222235706-ffb98f73852f h1:qWFY9ZxP3tfI37wYIs/MnIAqK0vlXp1xnYEa5HxFSSY=
+golang.org/x/crypto v0.0.0-20190222235706-ffb98f73852f/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd h1:HuTn7WObtcDo9uEEU7rEqL0jYthdXAmZ6PP+meazmaU=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/vendor/github.com/masterzen/winrm/http.go b/vendor/github.com/masterzen/winrm/http.go
index 929ea82c8..9767c2145 100644
--- a/vendor/github.com/masterzen/winrm/http.go
+++ b/vendor/github.com/masterzen/winrm/http.go
@@ -39,19 +39,27 @@ func body(response *http.Response) (string, error) {
 
 type clientRequest struct {
 	transport http.RoundTripper
+	dial func(network, addr string) (net.Conn, error)
 }
 
 func (c *clientRequest) Transport(endpoint *Endpoint) error {
+
+	dial := (&net.Dialer{
+		Timeout:   30 * time.Second,
+		KeepAlive: 30 * time.Second,
+	}).Dial
+
+	if c.dial != nil {
+		dial = c.dial
+	}
+
 	transport := &http.Transport{
 		Proxy: http.ProxyFromEnvironment,
 		TLSClientConfig: &tls.Config{
 			InsecureSkipVerify: endpoint.Insecure,
 			ServerName:         endpoint.TLSServerName,
 		},
-		Dial: (&net.Dialer{
-			Timeout:   30 * time.Second,
-			KeepAlive: 30 * time.Second,
-		}).Dial,
+		Dial: dial,
 		ResponseHeaderTimeout: endpoint.Timeout,
 	}
 
@@ -99,3 +107,10 @@ func (c clientRequest) Post(client *Client, request *soap.SoapMessage) (string,
 
 	return body, err
 }
+
+
+func NewClientWithDial(dial func(network, addr string) (net.Conn, error)) *clientRequest {
+	return &clientRequest{
+		dial:dial,
+	}
+}
\ No newline at end of file
diff --git a/vendor/github.com/masterzen/winrm/ntlm.go b/vendor/github.com/masterzen/winrm/ntlm.go
index 6a0ee1060..08de8a522 100644
--- a/vendor/github.com/masterzen/winrm/ntlm.go
+++ b/vendor/github.com/masterzen/winrm/ntlm.go
@@ -3,6 +3,7 @@ package winrm
 import (
 	"github.com/Azure/go-ntlmssp"
 	"github.com/masterzen/winrm/soap"
+	"net"
 )
 
 // ClientNTLM provides a transport via NTLMv2
@@ -21,3 +22,12 @@ func (c *ClientNTLM) Transport(endpoint *Endpoint) error {
 func (c ClientNTLM) Post(client *Client, request *soap.SoapMessage) (string, error) {
 	return c.clientRequest.Post(client, request)
 }
+
+
+func NewClientNTLMWithDial(dial func(network, addr string) (net.Conn, error)) *ClientNTLM {
+	return &ClientNTLM{
+		clientRequest{
+			dial:dial,
+		},
+	}
+}
\ No newline at end of file
diff --git a/vendor/github.com/masterzen/winrm/parameters.go b/vendor/github.com/masterzen/winrm/parameters.go
index eb3771be1..08adcc99f 100644
--- a/vendor/github.com/masterzen/winrm/parameters.go
+++ b/vendor/github.com/masterzen/winrm/parameters.go
@@ -1,5 +1,7 @@
 package winrm
 
+import "net"
+
 // Parameters struct defines
 // metadata information and http transport config
 type Parameters struct {
@@ -7,6 +9,7 @@ type Parameters struct {
 	Locale             string
 	EnvelopeSize       int
 	TransportDecorator func() Transporter
+	Dial               func(network, addr string) (net.Conn, error)
 }
 
 // DefaultParameters return constant config
diff --git a/vendor/github.com/mattn/go-colorable/colorable_windows.go b/vendor/github.com/mattn/go-colorable/colorable_windows.go
index e17a5474e..404e10ca0 100644
--- a/vendor/github.com/mattn/go-colorable/colorable_windows.go
+++ b/vendor/github.com/mattn/go-colorable/colorable_windows.go
@@ -29,6 +29,15 @@ const (
 	backgroundMask      = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
 )
 
+const (
+	genericRead  = 0x80000000
+	genericWrite = 0x40000000
+)
+
+const (
+	consoleTextmodeBuffer = 0x1
+)
+
 type wchar uint16
 type short int16
 type dword uint32
@@ -69,14 +78,17 @@ var (
 	procGetConsoleCursorInfo       = kernel32.NewProc("GetConsoleCursorInfo")
 	procSetConsoleCursorInfo       = kernel32.NewProc("SetConsoleCursorInfo")
 	procSetConsoleTitle            = kernel32.NewProc("SetConsoleTitleW")
+	procCreateConsoleScreenBuffer  = kernel32.NewProc("CreateConsoleScreenBuffer")
 )
 
 // Writer provide colorable Writer to the console
 type Writer struct {
-	out     io.Writer
-	handle  syscall.Handle
-	oldattr word
-	oldpos  coord
+	out       io.Writer
+	handle    syscall.Handle
+	althandle syscall.Handle
+	oldattr   word
+	oldpos    coord
+	rest      bytes.Buffer
 }
 
 // NewColorable return new instance of Writer which handle escape sequence from File.
@@ -407,7 +419,18 @@ func (w *Writer) Write(data []byte) (n int, err error) {
 	var csbi consoleScreenBufferInfo
 	procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 
-	er := bytes.NewReader(data)
+	handle := w.handle
+
+	var er *bytes.Reader
+	if w.rest.Len() > 0 {
+		var rest bytes.Buffer
+		w.rest.WriteTo(&rest)
+		w.rest.Reset()
+		rest.Write(data)
+		er = bytes.NewReader(rest.Bytes())
+	} else {
+		er = bytes.NewReader(data)
+	}
 	var bw [1]byte
 loop:
 	for {
@@ -425,29 +448,55 @@ loop:
 			break loop
 		}
 
-		if c2 == ']' {
-			if err := doTitleSequence(er); err != nil {
+		switch c2 {
+		case '>':
+			continue
+		case ']':
+			w.rest.WriteByte(c1)
+			w.rest.WriteByte(c2)
+			er.WriteTo(&w.rest)
+			if bytes.IndexByte(w.rest.Bytes(), 0x07) == -1 {
 				break loop
 			}
-			continue
-		}
-		if c2 != 0x5b {
-			continue
-		}
-
-		var buf bytes.Buffer
-		var m byte
-		for {
-			c, err := er.ReadByte()
+			er = bytes.NewReader(w.rest.Bytes()[2:])
+			err := doTitleSequence(er)
 			if err != nil {
 				break loop
 			}
+			w.rest.Reset()
+			continue
+		// https://github.com/mattn/go-colorable/issues/27
+		case '7':
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+			w.oldpos = csbi.cursorPosition
+			continue
+		case '8':
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&w.oldpos)))
+			continue
+		case 0x5b:
+			// execute part after switch
+		default:
+			continue
+		}
+
+		w.rest.WriteByte(c1)
+		w.rest.WriteByte(c2)
+		er.WriteTo(&w.rest)
+
+		var buf bytes.Buffer
+		var m byte
+		for i, c := range w.rest.Bytes()[2:] {
 			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
 				m = c
+				er = bytes.NewReader(w.rest.Bytes()[2+i+1:])
+				w.rest.Reset()
 				break
 			}
 			buf.Write([]byte(string(c)))
 		}
+		if m == 0 {
+			break loop
+		}
 
 		switch m {
 		case 'A':
@@ -455,61 +504,64 @@ loop:
 			if err != nil {
 				continue
 			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.y -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'B':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.y += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'C':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'D':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+			if csbi.cursorPosition.x < 0 {
+				csbi.cursorPosition.x = 0
+			}
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'E':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x = 0
 			csbi.cursorPosition.y += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'F':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x = 0
 			csbi.cursorPosition.y -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'G':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x = short(n - 1)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'H', 'f':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			if buf.Len() > 0 {
 				token := strings.Split(buf.String(), ";")
 				switch len(token) {
@@ -534,7 +586,7 @@ loop:
 			} else {
 				csbi.cursorPosition.y = 0
 			}
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'J':
 			n := 0
 			if buf.Len() > 0 {
@@ -545,20 +597,20 @@ loop:
 			}
 			var count, written dword
 			var cursor coord
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			switch n {
 			case 0:
 				cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
+				count = dword(csbi.size.x) - dword(csbi.cursorPosition.x) + dword(csbi.size.y-csbi.cursorPosition.y)*dword(csbi.size.x)
 			case 1:
 				cursor = coord{x: csbi.window.left, y: csbi.window.top}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.window.top-csbi.cursorPosition.y)*csbi.size.x)
+				count = dword(csbi.size.x) - dword(csbi.cursorPosition.x) + dword(csbi.window.top-csbi.cursorPosition.y)*dword(csbi.size.x)
 			case 2:
 				cursor = coord{x: csbi.window.left, y: csbi.window.top}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
+				count = dword(csbi.size.x) - dword(csbi.cursorPosition.x) + dword(csbi.size.y-csbi.cursorPosition.y)*dword(csbi.size.x)
 			}
-			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
+			procFillConsoleOutputCharacter.Call(uintptr(handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
+			procFillConsoleOutputAttribute.Call(uintptr(handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
 		case 'K':
 			n := 0
 			if buf.Len() > 0 {
@@ -567,28 +619,28 @@ loop:
 					continue
 				}
 			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			var cursor coord
 			var count, written dword
 			switch n {
 			case 0:
-				cursor = coord{x: csbi.cursorPosition.x + 1, y: csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x - 1)
+				cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y}
+				count = dword(csbi.size.x - csbi.cursorPosition.x)
 			case 1:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
+				cursor = coord{x: csbi.window.left, y: csbi.cursorPosition.y}
 				count = dword(csbi.size.x - csbi.cursorPosition.x)
 			case 2:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
+				cursor = coord{x: csbi.window.left, y: csbi.cursorPosition.y}
 				count = dword(csbi.size.x)
 			}
-			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
+			procFillConsoleOutputCharacter.Call(uintptr(handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
+			procFillConsoleOutputAttribute.Call(uintptr(handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
 		case 'm':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			attr := csbi.attributes
 			cs := buf.String()
 			if cs == "" {
-				procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr))
+				procSetConsoleTextAttribute.Call(uintptr(handle), uintptr(w.oldattr))
 				continue
 			}
 			token := strings.Split(cs, ";")
@@ -627,6 +679,21 @@ loop:
 								attr |= n256foreAttr[n256]
 								i += 2
 							}
+						} else if len(token) == 5 && token[i+1] == "2" {
+							var r, g, b int
+							r, _ = strconv.Atoi(token[i+2])
+							g, _ = strconv.Atoi(token[i+3])
+							b, _ = strconv.Atoi(token[i+4])
+							i += 4
+							if r > 127 {
+								attr |= foregroundRed
+							}
+							if g > 127 {
+								attr |= foregroundGreen
+							}
+							if b > 127 {
+								attr |= foregroundBlue
+							}
 						} else {
 							attr = attr & (w.oldattr & backgroundMask)
 						}
@@ -654,6 +721,21 @@ loop:
 								attr |= n256backAttr[n256]
 								i += 2
 							}
+						} else if len(token) == 5 && token[i+1] == "2" {
+							var r, g, b int
+							r, _ = strconv.Atoi(token[i+2])
+							g, _ = strconv.Atoi(token[i+3])
+							b, _ = strconv.Atoi(token[i+4])
+							i += 4
+							if r > 127 {
+								attr |= backgroundRed
+							}
+							if g > 127 {
+								attr |= backgroundGreen
+							}
+							if b > 127 {
+								attr |= backgroundBlue
+							}
 						} else {
 							attr = attr & (w.oldattr & foregroundMask)
 						}
@@ -685,38 +767,52 @@ loop:
 							attr |= backgroundBlue
 						}
 					}
-					procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr))
+					procSetConsoleTextAttribute.Call(uintptr(handle), uintptr(attr))
 				}
 			}
 		case 'h':
 			var ci consoleCursorInfo
 			cs := buf.String()
 			if cs == "5>" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
+				procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
 				ci.visible = 0
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
+				procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
 			} else if cs == "?25" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
+				procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
 				ci.visible = 1
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
+				procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+			} else if cs == "?1049" {
+				if w.althandle == 0 {
+					h, _, _ := procCreateConsoleScreenBuffer.Call(uintptr(genericRead|genericWrite), 0, 0, uintptr(consoleTextmodeBuffer), 0, 0)
+					w.althandle = syscall.Handle(h)
+					if w.althandle != 0 {
+						handle = w.althandle
+					}
+				}
 			}
 		case 'l':
 			var ci consoleCursorInfo
 			cs := buf.String()
 			if cs == "5>" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
+				procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
 				ci.visible = 1
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
+				procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
 			} else if cs == "?25" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
+				procGetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
 				ci.visible = 0
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
+				procSetConsoleCursorInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&ci)))
+			} else if cs == "?1049" {
+				if w.althandle != 0 {
+					syscall.CloseHandle(w.althandle)
+					w.althandle = 0
+					handle = w.handle
+				}
 			}
 		case 's':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+			procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 			w.oldpos = csbi.cursorPosition
 		case 'u':
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&w.oldpos)))
+			procSetConsoleCursorPosition.Call(uintptr(handle), *(*uintptr)(unsafe.Pointer(&w.oldpos)))
 		}
 	}
 
diff --git a/vendor/github.com/mattn/go-colorable/go.mod b/vendor/github.com/mattn/go-colorable/go.mod
new file mode 100644
index 000000000..9d9f42485
--- /dev/null
+++ b/vendor/github.com/mattn/go-colorable/go.mod
@@ -0,0 +1,3 @@
+module github.com/mattn/go-colorable
+
+require github.com/mattn/go-isatty v0.0.5
diff --git a/vendor/github.com/mattn/go-colorable/go.sum b/vendor/github.com/mattn/go-colorable/go.sum
new file mode 100644
index 000000000..2c12960ec
--- /dev/null
+++ b/vendor/github.com/mattn/go-colorable/go.sum
@@ -0,0 +1,4 @@
+github.com/mattn/go-isatty v0.0.5 h1:tHXDdz1cpzGaovsTB+TVB8q90WEokoVmfMqoVcrLUgw=
+github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223 h1:DH4skfRX4EBpamg7iV4ZlCpblAHI6s6TDM39bFZumv8=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
diff --git a/vendor/github.com/mattn/go-isatty/go.mod b/vendor/github.com/mattn/go-isatty/go.mod
new file mode 100644
index 000000000..f310320c3
--- /dev/null
+++ b/vendor/github.com/mattn/go-isatty/go.mod
@@ -0,0 +1,3 @@
+module github.com/mattn/go-isatty
+
+require golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223
diff --git a/vendor/github.com/mattn/go-isatty/go.sum b/vendor/github.com/mattn/go-isatty/go.sum
new file mode 100644
index 000000000..426c8973c
--- /dev/null
+++ b/vendor/github.com/mattn/go-isatty/go.sum
@@ -0,0 +1,2 @@
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223 h1:DH4skfRX4EBpamg7iV4ZlCpblAHI6s6TDM39bFZumv8=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
diff --git a/vendor/github.com/mattn/go-isatty/isatty_appengine.go b/vendor/github.com/mattn/go-isatty/isatty_appengine.go
deleted file mode 100644
index 9584a9884..000000000
--- a/vendor/github.com/mattn/go-isatty/isatty_appengine.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// +build appengine
-
-package isatty
-
-// IsTerminal returns true if the file descriptor is terminal which
-// is always false on on appengine classic which is a sandboxed PaaS.
-func IsTerminal(fd uintptr) bool {
-	return false
-}
-
-// IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
-// terminal. This is also always false on this environment.
-func IsCygwinTerminal(fd uintptr) bool {
-	return false
-}
diff --git a/vendor/github.com/mattn/go-isatty/isatty_bsd.go b/vendor/github.com/mattn/go-isatty/isatty_bsd.go
index 42f2514d1..07e93039d 100644
--- a/vendor/github.com/mattn/go-isatty/isatty_bsd.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_bsd.go
@@ -16,3 +16,9 @@ func IsTerminal(fd uintptr) bool {
 	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
 	return err == 0
 }
+
+// IsCygwinTerminal return true if the file descriptor is a cygwin or msys2
+// terminal. This is also always false on this environment.
+func IsCygwinTerminal(fd uintptr) bool {
+	return false
+}
diff --git a/vendor/github.com/mattn/go-isatty/isatty_linux.go b/vendor/github.com/mattn/go-isatty/isatty_linux.go
index 7384cf991..e004038ee 100644
--- a/vendor/github.com/mattn/go-isatty/isatty_linux.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_linux.go
@@ -1,18 +1,18 @@
 // +build linux
-// +build !appengine,!ppc64,!ppc64le
+// +build !appengine
 
 package isatty
 
-import (
-	"syscall"
-	"unsafe"
-)
-
-const ioctlReadTermios = syscall.TCGETS
+import "golang.org/x/sys/unix"
 
 // IsTerminal return true if the file descriptor is terminal.
 func IsTerminal(fd uintptr) bool {
-	var termios syscall.Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
+	_, err := unix.IoctlGetTermios(int(fd), unix.TCGETS)
+	return err == nil
+}
+
+// IsCygwinTerminal return true if the file descriptor is a cygwin or msys2
+// terminal. This is also always false on this environment.
+func IsCygwinTerminal(fd uintptr) bool {
+	return false
 }
diff --git a/vendor/github.com/mattn/go-isatty/isatty_linux_ppc64x.go b/vendor/github.com/mattn/go-isatty/isatty_linux_ppc64x.go
deleted file mode 100644
index 44e5d2130..000000000
--- a/vendor/github.com/mattn/go-isatty/isatty_linux_ppc64x.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// +build linux
-// +build ppc64 ppc64le
-
-package isatty
-
-import (
-	"unsafe"
-
-	syscall "golang.org/x/sys/unix"
-)
-
-const ioctlReadTermios = syscall.TCGETS
-
-// IsTerminal return true if the file descriptor is terminal.
-func IsTerminal(fd uintptr) bool {
-	var termios syscall.Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
-}
diff --git a/vendor/github.com/mattn/go-isatty/isatty_others.go b/vendor/github.com/mattn/go-isatty/isatty_others.go
index 9d8b4a599..f02849c56 100644
--- a/vendor/github.com/mattn/go-isatty/isatty_others.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_others.go
@@ -1,9 +1,14 @@
-// +build !windows
-// +build !appengine
+// +build appengine js
 
 package isatty
 
-// IsCygwinTerminal return true if the file descriptor is a cygwin or msys2
+// IsTerminal returns true if the file descriptor is terminal which
+// is always false on js and appengine classic which is a sandboxed PaaS.
+func IsTerminal(fd uintptr) bool {
+	return false
+}
+
+// IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
 // terminal. This is also always false on this environment.
 func IsCygwinTerminal(fd uintptr) bool {
 	return false
diff --git a/vendor/github.com/mattn/go-isatty/isatty_solaris.go b/vendor/github.com/mattn/go-isatty/isatty_solaris.go
index 1f0c6bf53..bdd5c79a0 100644
--- a/vendor/github.com/mattn/go-isatty/isatty_solaris.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_solaris.go
@@ -14,3 +14,9 @@ func IsTerminal(fd uintptr) bool {
 	err := unix.IoctlSetTermio(int(fd), unix.TCGETA, &termio)
 	return err == nil
 }
+
+// IsCygwinTerminal return true if the file descriptor is a cygwin or msys2
+// terminal. This is also always false on this environment.
+func IsCygwinTerminal(fd uintptr) bool {
+	return false
+}
diff --git a/vendor/github.com/mitchellh/go-homedir/homedir.go b/vendor/github.com/mitchellh/go-homedir/homedir.go
index fb87bef94..25378537e 100644
--- a/vendor/github.com/mitchellh/go-homedir/homedir.go
+++ b/vendor/github.com/mitchellh/go-homedir/homedir.go
@@ -76,6 +76,16 @@ func Expand(path string) (string, error) {
 	return filepath.Join(dir, path[1:]), nil
 }
 
+// Reset clears the cache, forcing the next call to Dir to re-detect
+// the home directory. This generally never has to be called, but can be
+// useful in tests if you're modifying the home directory via the HOME
+// env var or something.
+func Reset() {
+	cacheLock.Lock()
+	defer cacheLock.Unlock()
+	homedirCache = ""
+}
+
 func dirUnix() (string, error) {
 	homeEnv := "HOME"
 	if runtime.GOOS == "plan9" {
diff --git a/vendor/github.com/mitchellh/go-wordwrap/LICENSE.md b/vendor/github.com/mitchellh/go-wordwrap/LICENSE.md
new file mode 100644
index 000000000..229851590
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mitchell Hashimoto
+
+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/github.com/mitchellh/go-wordwrap/README.md b/vendor/github.com/mitchellh/go-wordwrap/README.md
new file mode 100644
index 000000000..60ae31170
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/README.md
@@ -0,0 +1,39 @@
+# go-wordwrap
+
+`go-wordwrap` (Golang package: `wordwrap`) is a package for Go that
+automatically wraps words into multiple lines. The primary use case for this
+is in formatting CLI output, but of course word wrapping is a generally useful
+thing to do.
+
+## Installation and Usage
+
+Install using `go get github.com/mitchellh/go-wordwrap`.
+
+Full documentation is available at
+http://godoc.org/github.com/mitchellh/go-wordwrap
+
+Below is an example of its usage ignoring errors:
+
+```go
+wrapped := wordwrap.WrapString("foo bar baz", 3)
+fmt.Println(wrapped)
+```
+
+Would output:
+
+```
+foo
+bar
+baz
+```
+
+## Word Wrap Algorithm
+
+This library doesn't use any clever algorithm for word wrapping. The wrapping
+is actually very naive: whenever there is whitespace or an explicit linebreak.
+The goal of this library is for word wrapping CLI output, so the input is
+typically pretty well controlled human language. Because of this, the naive
+approach typically works just fine.
+
+In the future, we'd like to make the algorithm more advanced. We would do
+so without breaking the API.
diff --git a/vendor/github.com/mitchellh/go-wordwrap/go.mod b/vendor/github.com/mitchellh/go-wordwrap/go.mod
new file mode 100644
index 000000000..2ae411b20
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/go-wordwrap
diff --git a/vendor/github.com/mitchellh/go-wordwrap/wordwrap.go b/vendor/github.com/mitchellh/go-wordwrap/wordwrap.go
new file mode 100644
index 000000000..ac67205bc
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/wordwrap.go
@@ -0,0 +1,73 @@
+package wordwrap
+
+import (
+	"bytes"
+	"unicode"
+)
+
+// WrapString wraps the given string within lim width in characters.
+//
+// Wrapping is currently naive and only happens at white-space. A future
+// version of the library will implement smarter wrapping. This means that
+// pathological cases can dramatically reach past the limit, such as a very
+// long word.
+func WrapString(s string, lim uint) string {
+	// Initialize a buffer with a slightly larger size to account for breaks
+	init := make([]byte, 0, len(s))
+	buf := bytes.NewBuffer(init)
+
+	var current uint
+	var wordBuf, spaceBuf bytes.Buffer
+
+	for _, char := range s {
+		if char == '\n' {
+			if wordBuf.Len() == 0 {
+				if current+uint(spaceBuf.Len()) > lim {
+					current = 0
+				} else {
+					current += uint(spaceBuf.Len())
+					spaceBuf.WriteTo(buf)
+				}
+				spaceBuf.Reset()
+			} else {
+				current += uint(spaceBuf.Len() + wordBuf.Len())
+				spaceBuf.WriteTo(buf)
+				spaceBuf.Reset()
+				wordBuf.WriteTo(buf)
+				wordBuf.Reset()
+			}
+			buf.WriteRune(char)
+			current = 0
+		} else if unicode.IsSpace(char) {
+			if spaceBuf.Len() == 0 || wordBuf.Len() > 0 {
+				current += uint(spaceBuf.Len() + wordBuf.Len())
+				spaceBuf.WriteTo(buf)
+				spaceBuf.Reset()
+				wordBuf.WriteTo(buf)
+				wordBuf.Reset()
+			}
+
+			spaceBuf.WriteRune(char)
+		} else {
+
+			wordBuf.WriteRune(char)
+
+			if current+uint(spaceBuf.Len()+wordBuf.Len()) > lim && uint(wordBuf.Len()) < lim {
+				buf.WriteRune('\n')
+				current = 0
+				spaceBuf.Reset()
+			}
+		}
+	}
+
+	if wordBuf.Len() == 0 {
+		if current+uint(spaceBuf.Len()) <= lim {
+			spaceBuf.WriteTo(buf)
+		}
+	} else {
+		spaceBuf.WriteTo(buf)
+		wordBuf.WriteTo(buf)
+	}
+
+	return buf.String()
+}
diff --git a/vendor/github.com/mitchellh/panicwrap/go.mod b/vendor/github.com/mitchellh/panicwrap/go.mod
new file mode 100644
index 000000000..c35fabba8
--- /dev/null
+++ b/vendor/github.com/mitchellh/panicwrap/go.mod
@@ -0,0 +1,3 @@
+module github.com/mitchellh/panicwrap
+
+require github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1
diff --git a/vendor/github.com/mitchellh/panicwrap/go.sum b/vendor/github.com/mitchellh/panicwrap/go.sum
new file mode 100644
index 000000000..fd3e4dafa
--- /dev/null
+++ b/vendor/github.com/mitchellh/panicwrap/go.sum
@@ -0,0 +1,2 @@
+github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1 h1:PJPDf8OUfOK1bb/NeTKd4f1QXZItOX389VN3B6qC8ro=
+github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
diff --git a/vendor/github.com/mitchellh/prefixedio/go.mod b/vendor/github.com/mitchellh/prefixedio/go.mod
new file mode 100644
index 000000000..72d6d5268
--- /dev/null
+++ b/vendor/github.com/mitchellh/prefixedio/go.mod
@@ -0,0 +1 @@
+module github.com/mitchellh/prefixedio
diff --git a/vendor/github.com/posener/complete/.gitignore b/vendor/github.com/posener/complete/.gitignore
index 136372081..293955f99 100644
--- a/vendor/github.com/posener/complete/.gitignore
+++ b/vendor/github.com/posener/complete/.gitignore
@@ -1,2 +1,4 @@
 .idea
 coverage.txt
+gocomplete/gocomplete
+example/self/self
diff --git a/vendor/github.com/posener/complete/.travis.yml b/vendor/github.com/posener/complete/.travis.yml
index c2798f8f3..2fae94541 100644
--- a/vendor/github.com/posener/complete/.travis.yml
+++ b/vendor/github.com/posener/complete/.travis.yml
@@ -1,17 +1,16 @@
 language: go
 sudo: false
 go:
+  - 1.11
+  - 1.10.x
   - 1.9
   - 1.8
 
 before_install:
   - go get -u -t ./...
-  - go get -u gopkg.in/alecthomas/gometalinter.v1
-  - gometalinter.v1 --install
 
 script:
-  - gometalinter.v1 --config metalinter.json ./...
-  - ./test.sh
+  - GO111MODULE=on ./test.sh
 
 after_success:
   - bash <(curl -s https://codecov.io/bash)
diff --git a/vendor/github.com/posener/complete/args.go b/vendor/github.com/posener/complete/args.go
index 1ba4d6919..17ab2c6d6 100644
--- a/vendor/github.com/posener/complete/args.go
+++ b/vendor/github.com/posener/complete/args.go
@@ -57,11 +57,20 @@ func newArgs(line string) Args {
 	}
 }
 
+// splitFields returns a list of fields from the given command line.
+// If the last character is space, it appends an empty field in the end
+// indicating that the field before it was completed.
+// If the last field is of the form "a=b", it splits it to two fields: "a", "b",
+// So it can be completed.
 func splitFields(line string) []string {
 	parts := strings.Fields(line)
+
+	// Add empty field if the last field was completed.
 	if len(line) > 0 && unicode.IsSpace(rune(line[len(line)-1])) {
 		parts = append(parts, "")
 	}
+
+	// Treat the last field if it is of the form "a=b"
 	parts = splitLastEqual(parts)
 	return parts
 }
diff --git a/vendor/github.com/posener/complete/cmd/cmd.go b/vendor/github.com/posener/complete/cmd/cmd.go
index 7137dee17..b99fe5290 100644
--- a/vendor/github.com/posener/complete/cmd/cmd.go
+++ b/vendor/github.com/posener/complete/cmd/cmd.go
@@ -103,7 +103,7 @@ func (f *CLI) AddFlags(flags *flag.FlagSet) {
 			fmt.Sprintf("Uninstall completion for %s command", f.Name))
 	}
 	if flags.Lookup("y") == nil {
-		flags.BoolVar(&f.yes, "y", false, "Don't prompt user for typing 'yes'")
+		flags.BoolVar(&f.yes, "y", false, "Don't prompt user for typing 'yes' when installing completion")
 	}
 }
 
diff --git a/vendor/github.com/posener/complete/cmd/install/fish.go b/vendor/github.com/posener/complete/cmd/install/fish.go
index f04e7c3ac..6467196bc 100644
--- a/vendor/github.com/posener/complete/cmd/install/fish.go
+++ b/vendor/github.com/posener/complete/cmd/install/fish.go
@@ -16,7 +16,10 @@ type fish struct {
 
 func (f fish) Install(cmd, bin string) error {
 	completionFile := filepath.Join(f.configDir, "completions", fmt.Sprintf("%s.fish", cmd))
-	completeCmd := f.cmd(cmd, bin)
+	completeCmd, err := f.cmd(cmd, bin)
+	if err != nil {
+		return err
+	}
 	if _, err := os.Stat(completionFile); err == nil {
 		return fmt.Errorf("already installed at %s", completionFile)
 	}
@@ -33,10 +36,10 @@ func (f fish) Uninstall(cmd, bin string) error {
 	return os.Remove(completionFile)
 }
 
-func (f fish) cmd(cmd, bin string) string {
+func (f fish) cmd(cmd, bin string) (string, error) {
 	var buf bytes.Buffer
 	params := struct{ Cmd, Bin string }{cmd, bin}
-	template.Must(template.New("cmd").Parse(`
+	tmpl := template.Must(template.New("cmd").Parse(`
 function __complete_{{.Cmd}}
     set -lx COMP_LINE (string join ' ' (commandline -o))
     test (commandline -ct) = ""
@@ -44,7 +47,10 @@ function __complete_{{.Cmd}}
     {{.Bin}}
 end
 complete -c {{.Cmd}} -a "(__complete_{{.Cmd}})"
-`)).Execute(&buf, params)
-
-	return string(buf.Bytes())
+`))
+	err := tmpl.Execute(&buf, params)
+	if err != nil {
+		return "", err
+	}
+	return buf.String(), nil
 }
diff --git a/vendor/github.com/posener/complete/cmd/install/install.go b/vendor/github.com/posener/complete/cmd/install/install.go
index 4a706242f..dfa1963b8 100644
--- a/vendor/github.com/posener/complete/cmd/install/install.go
+++ b/vendor/github.com/posener/complete/cmd/install/install.go
@@ -51,7 +51,7 @@ func Uninstall(cmd string) error {
 	for _, i := range is {
 		errI := i.Uninstall(cmd, bin)
 		if errI != nil {
-			multierror.Append(err, errI)
+			err = multierror.Append(err, errI)
 		}
 	}
 
diff --git a/vendor/github.com/posener/complete/cmd/install/utils.go b/vendor/github.com/posener/complete/cmd/install/utils.go
index bb709bc6c..d34ac8cae 100644
--- a/vendor/github.com/posener/complete/cmd/install/utils.go
+++ b/vendor/github.com/posener/complete/cmd/install/utils.go
@@ -115,7 +115,10 @@ func removeContentToTempFile(name, content string) (string, error) {
 		if str == content {
 			continue
 		}
-		wf.WriteString(str + "\n")
+		_, err = wf.WriteString(str + "\n")
+		if err != nil {
+			return "", err
+		}
 		prefix = prefix[:0]
 	}
 	return wf.Name(), nil
diff --git a/vendor/github.com/posener/complete/complete.go b/vendor/github.com/posener/complete/complete.go
index 185d1e8bd..725c4debc 100644
--- a/vendor/github.com/posener/complete/complete.go
+++ b/vendor/github.com/posener/complete/complete.go
@@ -10,14 +10,16 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"strconv"
 
 	"github.com/posener/complete/cmd"
 	"github.com/posener/complete/match"
 )
 
 const (
-	envComplete = "COMP_LINE"
-	envDebug    = "COMP_DEBUG"
+	envLine  = "COMP_LINE"
+	envPoint = "COMP_POINT"
+	envDebug = "COMP_DEBUG"
 )
 
 // Complete structs define completion for a command with CLI options
@@ -55,13 +57,18 @@ func (c *Complete) Run() bool {
 // For installation: it assumes that flags were added and parsed before
 // it was called.
 func (c *Complete) Complete() bool {
-	line, ok := getLine()
+	line, point, ok := getEnv()
 	if !ok {
 		// make sure flags parsed,
 		// in case they were not added in the main program
 		return c.CLI.Run()
 	}
-	Log("Completing line: %s", line)
+
+	if point >= 0 && point < len(line) {
+		line = line[:point]
+	}
+
+	Log("Completing phrase: %s", line)
 	a := newArgs(line)
 	Log("Completing last field: %s", a.Last)
 	options := c.Command.Predict(a)
@@ -79,12 +86,19 @@ func (c *Complete) Complete() bool {
 	return true
 }
 
-func getLine() (string, bool) {
-	line := os.Getenv(envComplete)
+func getEnv() (line string, point int, ok bool) {
+	line = os.Getenv(envLine)
 	if line == "" {
-		return "", false
+		return
 	}
-	return line, true
+	point, err := strconv.Atoi(os.Getenv(envPoint))
+	if err != nil {
+		// If failed parsing point for some reason, set it to point
+		// on the end of the line.
+		Log("Failed parsing point %s: %v", os.Getenv(envPoint), err)
+		point = len(line)
+	}
+	return line, point, true
 }
 
 func (c *Complete) output(options []string) {
diff --git a/vendor/github.com/posener/complete/go.mod b/vendor/github.com/posener/complete/go.mod
new file mode 100644
index 000000000..fef0c440d
--- /dev/null
+++ b/vendor/github.com/posener/complete/go.mod
@@ -0,0 +1,3 @@
+module github.com/posener/complete
+
+require github.com/hashicorp/go-multierror v1.0.0
diff --git a/vendor/github.com/posener/complete/go.sum b/vendor/github.com/posener/complete/go.sum
new file mode 100644
index 000000000..d2f13301d
--- /dev/null
+++ b/vendor/github.com/posener/complete/go.sum
@@ -0,0 +1,4 @@
+github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o=
+github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
diff --git a/vendor/github.com/posener/complete/log.go b/vendor/github.com/posener/complete/log.go
index 797a80ced..c3029556e 100644
--- a/vendor/github.com/posener/complete/log.go
+++ b/vendor/github.com/posener/complete/log.go
@@ -1,7 +1,6 @@
 package complete
 
 import (
-	"io"
 	"io/ioutil"
 	"log"
 	"os"
@@ -15,7 +14,7 @@ import (
 var Log = getLogger()
 
 func getLogger() func(format string, args ...interface{}) {
-	var logfile io.Writer = ioutil.Discard
+	var logfile = ioutil.Discard
 	if os.Getenv(envDebug) != "" {
 		logfile = os.Stderr
 	}
diff --git a/vendor/github.com/posener/complete/metalinter.json b/vendor/github.com/posener/complete/metalinter.json
deleted file mode 100644
index 799c1d03f..000000000
--- a/vendor/github.com/posener/complete/metalinter.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-    "Vendor": true,
-    "DisableAll": true,
-    "Enable": [
-        "gofmt",
-        "goimports",
-        "interfacer",
-        "goconst",
-        "misspell",
-        "unconvert",
-        "gosimple",
-        "golint",
-        "structcheck",
-        "deadcode",
-        "vet"
-    ],
-    "Exclude": [
-        "initTests is unused"
-    ],
-    "Deadline": "2m"
-}
diff --git a/vendor/github.com/posener/complete/readme.md b/vendor/github.com/posener/complete/readme.md
index 2a999ba76..6d757ef82 100644
--- a/vendor/github.com/posener/complete/readme.md
+++ b/vendor/github.com/posener/complete/readme.md
@@ -4,6 +4,7 @@ A tool for bash writing bash completion in go, and bash completion for the go co
 
 [![Build Status](https://travis-ci.org/posener/complete.svg?branch=master)](https://travis-ci.org/posener/complete)
 [![codecov](https://codecov.io/gh/posener/complete/branch/master/graph/badge.svg)](https://codecov.io/gh/posener/complete)
+[![golangci](https://golangci.com/badges/github.com/posener/complete.svg)](https://golangci.com/r/github.com/posener/complete)
 [![GoDoc](https://godoc.org/github.com/posener/complete?status.svg)](http://godoc.org/github.com/posener/complete)
 [![Go Report Card](https://goreportcard.com/badge/github.com/posener/complete)](https://goreportcard.com/report/github.com/posener/complete)
 
diff --git a/vendor/github.com/ugorji/go/codec/0doc.go b/vendor/github.com/ugorji/go/codec/0doc.go
index bd7361c87..b61a8180e 100644
--- a/vendor/github.com/ugorji/go/codec/0doc.go
+++ b/vendor/github.com/ugorji/go/codec/0doc.go
@@ -1,9 +1,10 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // 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.
+Package codec provides a
+High Performance, Feature-Rich Idiomatic Go 1.4+ codec/encoding library
+for binc, msgpack, cbor, json.
 
 Supported Serialization formats are:
 
@@ -11,21 +12,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 +32,16 @@ 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
+  - Excellent code coverage ( > 90% )
   - Very High Performance.
     Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
-  - Multiple conversions:
-    Package coerces types where appropriate 
-    e.g. decode an int in the stream into a float, etc.
-  - Corner Cases: 
+  - 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
+  - Coerce types where appropriate
+    e.g. decode an int in the stream into a float, decode numbers from formatted strings, etc
+  - 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
@@ -48,15 +49,21 @@ Rich Feature Set includes:
     (struct, slice, map, primitives, pointers, interface{}, etc)
   - Extensions to support efficient encoding/decoding of any named types
   - Support encoding.(Binary|Text)(M|Unm)arshaler interfaces
+  - Support IsZero() bool to determine if a value is a zero value.
+    Analogous to time.Time.IsZero() bool.
   - Decoding without a schema (into a interface{}).
     Includes Options to configure what specific map or slice type to use
     when decoding an encoded list or map into a nil interface{}
+  - Mapping a non-interface type to an interface, so we can decode appropriately
+    into any interface type with a correctly configured non-interface value.
   - Encode a struct as an array, and decode struct from an array in the data stream
+  - Option to encode struct keys as numbers (instead of strings)
+    (to support structured streams with fields encoded as numeric codes)
   - Comprehensive support for anonymous fields
   - 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 +75,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 idiosynchracies 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
@@ -92,6 +99,27 @@ encoded as an empty map because it has no exported fields, while UUID
 would be encoded as a string. However, with extension support, you can
 encode any of these however you like.
 
+Custom Encoding and Decoding
+
+This package maintains symmetry in the encoding and decoding halfs.
+We determine how to encode or decode by walking this decision tree
+
+  - is type a codec.Selfer?
+  - is there an extension registered for the type?
+  - is format binary, and is type a encoding.BinaryMarshaler and BinaryUnmarshaler?
+  - is format specifically json, and is type a encoding/json.Marshaler and Unmarshaler?
+  - is format text-based, and type an encoding.TextMarshaler?
+  - else we use a pair of functions based on the "kind" of the type e.g. map, slice, int64, etc
+
+This symmetry is important to reduce chances of issues happening because the
+encoding and decoding sides are out of sync e.g. decoded via very specific
+encoding.TextUnmarshaler but encoded via kind-specific generalized mode.
+
+Consequently, if a type only defines one-half of the symmetry
+(e.g. it implements UnmarshalJSON() but not MarshalJSON() ),
+then that type doesn't satisfy the check and we will continue walking down the
+decision tree.
+
 RPC
 
 RPC Client and Server Codecs are implemented, so the codecs can be used
@@ -160,40 +188,77 @@ 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 .
+
+Caveats
+
+Struct fields matching the following are ignored during encoding and decoding
+    - struct tag value set to -
+    - func, complex numbers, unsafe pointers
+    - unexported and not embedded
+    - unexported and embedded and not struct kind
+    - unexported and embedded pointers (from go1.10)
+
+Every other field in a struct will be encoded/decoded.
+
+Embedded fields are encoded as if they exist in the top-level struct,
+with some caveats. See Encode documentation.
+
 */
 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:
+//   - For Go 1.11, when mid-stack inlining is enabled,
+//     we should use committed functions for writeXXX and readXXX calls.
+//     This involves uncommenting the methods for decReaderSwitch and encWriterSwitch
+//     and using those (decReaderSwitch and encWriterSwitch) in all handles
+//     instead of encWriter and decReader.
+//     The benefit is that, for the (En|De)coder over []byte, the encWriter/decReader
+//     will be inlined, giving a performance bump for that typical case.
+//     However, it will only  be inlined if mid-stack inlining is enabled,
+//     as we call panic to raise errors, and panic currently prevents inlining.
 //
-//   - 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 cnsider 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 } }
+// PUNTED:
+//   - To make Handle comparable, make extHandle in BasicHandle a non-embedded pointer,
+//     and use overlay methods on *BasicHandle to call through to extHandle after initializing
+//     the "xh *extHandle" to point to a real slice.
+//
+// BEFORE EACH RELEASE:
+//   - Look through and fix padding for each type, to eliminate false sharing
+//     - critical shared objects that are read many times
+//       TypeInfos
+//     - pooled objects:
+//       decNaked, decNakedContainers, codecFner, typeInfoLoadArray, 
+//     - small objects allocated independently, that we read/use much across threads:
+//       codecFn, typeInfo
+//     - Objects allocated independently and used a lot
+//       Decoder, Encoder,
+//       xxxHandle, xxxEncDriver, xxxDecDriver (xxx = json, msgpack, cbor, binc, simple)
+//     - In all above, arrange values modified together to be close to each other.
+//
+//     For all of these, either ensure that they occupy full cache lines,
+//     or ensure that the things just past the cache line boundary are hardly read/written
+//     e.g. JsonHandle.RawBytesExt - which is copied into json(En|De)cDriver at init
+//
+//     Occupying full cache lines means they occupy 8*N words (where N is an integer).
+//     Check this out by running: ./run.sh -z
+//     - look at those tagged ****, meaning they are not occupying full cache lines
+//     - look at those tagged <<<<, meaning they are larger than 32 words (something to watch)
+//   - Run "golint -min_confidence 0.81"
diff --git a/vendor/github.com/ugorji/go/codec/README.md b/vendor/github.com/ugorji/go/codec/README.md
index a790a52bb..50d65e550 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,11 +30,15 @@ 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
+  - Excellent code coverage ( > 90% )
   - Very High Performance.
     Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
-  - Multiple conversions:
-    Package coerces types where appropriate 
-    e.g. decode an int in the stream into a float, etc.
+  - 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
+  - Coerce types where appropriate
+    e.g. decode an int in the stream into a float, decode numbers from formatted strings, etc
   - Corner Cases: 
     Overflows, nil maps/slices, nil values in streams are handled correctly
   - Standard field renaming via tags
@@ -49,10 +47,16 @@ Rich Feature Set includes:
     (struct, slice, map, primitives, pointers, interface{}, etc)
   - Extensions to support efficient encoding/decoding of any named types
   - Support encoding.(Binary|Text)(M|Unm)arshaler interfaces
+  - Support IsZero() bool to determine if a value is a zero value.
+    Analogous to time.Time.IsZero() bool.
   - Decoding without a schema (into a interface{}).
     Includes Options to configure what specific map or slice type to use
     when decoding an encoded list or map into a nil interface{}
+  - Mapping a non-interface type to an interface, so we can decode appropriately
+    into any interface type with a correctly configured non-interface value.
   - Encode a struct as an array, and decode struct from an array in the data stream
+  - Option to encode struct keys as numbers (instead of strings)
+    (to support structured streams with fields encoded as numeric codes)
   - Comprehensive support for anonymous fields
   - Fast (no-reflection) encoding/decoding of common maps and slices
   - Code-generation for faster performance.
@@ -68,7 +72,7 @@ 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 idiosynchracies of codecs e.g. 
+  - 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:
@@ -92,6 +96,27 @@ encoded as an empty map because it has no exported fields, while UUID
 would be encoded as a string. However, with extension support, you can
 encode any of these however you like.
 
+## Custom Encoding and Decoding
+
+This package maintains symmetry in the encoding and decoding halfs.
+We determine how to encode or decode by walking this decision tree
+
+  - is type a codec.Selfer?
+  - is there an extension registered for the type?
+  - is format binary, and is type a encoding.BinaryMarshaler and BinaryUnmarshaler?
+  - is format specifically json, and is type a encoding/json.Marshaler and Unmarshaler?
+  - is format text-based, and type an encoding.TextMarshaler?
+  - else we use a pair of functions based on the "kind" of the type e.g. map, slice, int64, etc
+
+This symmetry is important to reduce chances of issues happening because the
+encoding and decoding sides are out of sync e.g. decoded via very specific
+encoding.TextUnmarshaler but encoded via kind-specific generalized mode.
+
+Consequently, if a type only defines one-half of the symmetry
+(e.g. it implements UnmarshalJSON() but not MarshalJSON() ),
+then that type doesn't satisfy the check and we will continue walking down the
+decision tree.
+
 ## RPC
 
 RPC Client and Server Codecs are implemented, so the codecs can be used
@@ -146,3 +171,36 @@ 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 .
+
+## Caveats
+
+Struct fields matching the following are ignored during encoding and decoding
+
+  - struct tag value set to -
+  - func, complex numbers, unsafe pointers
+  - unexported and not embedded
+  - unexported and embedded and not struct kind
+  - unexported and embedded pointers (from go1.10)
+
+Every other field in a struct will be encoded/decoded.
+
+Embedded fields are encoded as if they exist in the top-level struct,
+with some caveats. See Encode documentation.
diff --git a/vendor/github.com/ugorji/go/codec/binc.go b/vendor/github.com/ugorji/go/codec/binc.go
index 766d26cf6..a3c96fe74 100644
--- a/vendor/github.com/ugorji/go/codec/binc.go
+++ b/vendor/github.com/ugorji/go/codec/binc.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 package codec
@@ -55,39 +55,77 @@ const (
 	// others not currently supported
 )
 
+func bincdesc(vd, vs byte) string {
+	switch vd {
+	case bincVdSpecial:
+		switch vs {
+		case bincSpNil:
+			return "nil"
+		case bincSpFalse:
+			return "false"
+		case bincSpTrue:
+			return "true"
+		case bincSpNan, bincSpPosInf, bincSpNegInf, bincSpZeroFloat:
+			return "float"
+		case bincSpZero:
+			return "uint"
+		case bincSpNegOne:
+			return "int"
+		default:
+			return "unknown"
+		}
+	case bincVdSmallInt, bincVdPosInt:
+		return "uint"
+	case bincVdNegInt:
+		return "int"
+	case bincVdFloat:
+		return "float"
+	case bincVdSymbol:
+		return "string"
+	case bincVdString:
+		return "string"
+	case bincVdByteArray:
+		return "bytes"
+	case bincVdTimestamp:
+		return "time"
+	case bincVdCustomExt:
+		return "ext"
+	case bincVdArray:
+		return "array"
+	case bincVdMap:
+		return "map"
+	default:
+		return "unknown"
+	}
+}
+
 type bincEncDriver struct {
 	e *Encoder
+	h *BincHandle
 	w encWriter
 	m map[string]uint16 // symbols
-	b [scratchByteArrayLen]byte
-	s uint16 // symbols sequencer
-	encNoSeparator
-}
-
-func (e *bincEncDriver) IsBuiltinType(rt uintptr) bool {
-	return rt == timeTypId
-}
-
-func (e *bincEncDriver) EncodeBuiltin(rt uintptr, v interface{}) {
-	if rt == timeTypId {
-		var bs []byte
-		switch x := v.(type) {
-		case time.Time:
-			bs = encodeTime(x)
-		case *time.Time:
-			bs = encodeTime(*x)
-		default:
-			e.e.errorf("binc error encoding builtin: expect time.Time, received %T", v)
-		}
-		e.w.writen1(bincVdTimestamp<<4 | uint8(len(bs)))
-		e.w.writeb(bs)
-	}
+	b [16]byte          // scratch, used for encoding numbers - bigendian style
+	s uint16            // symbols sequencer
+	// c containerState
+	encDriverTrackContainerWriter
+	noBuiltInTypes
+	// encNoSeparator
 }
 
 func (e *bincEncDriver) EncodeNil() {
 	e.w.writen1(bincVdSpecial<<4 | bincSpNil)
 }
 
+func (e *bincEncDriver) EncodeTime(t time.Time) {
+	if t.IsZero() {
+		e.EncodeNil()
+	} else {
+		bs := bincEncodeTime(t)
+		e.w.writen1(bincVdTimestamp<<4 | uint8(len(bs)))
+		e.w.writeb(bs)
+	}
+}
+
 func (e *bincEncDriver) EncodeBool(b bool) {
 	if b {
 		e.w.writen1(bincVdSpecial<<4 | bincSpTrue)
@@ -195,15 +233,21 @@ 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))
+	e.c = containerArrayStart
 }
 
-func (e *bincEncDriver) EncodeMapStart(length int) {
+func (e *bincEncDriver) WriteMapStart(length int) {
 	e.encLen(bincVdMap<<4, uint64(length))
+	e.c = containerMapStart
 }
 
 func (e *bincEncDriver) EncodeString(c charEncoding, v string) {
+	if e.c == containerMapKey && c == cUTF8 && (e.h.AsSymbols == 0 || e.h.AsSymbols == 1) {
+		e.EncodeSymbol(v)
+		return
+	}
 	l := uint64(len(v))
 	e.encBytesLen(c, l)
 	if l > 0 {
@@ -213,7 +257,7 @@ func (e *bincEncDriver) EncodeString(c charEncoding, v string) {
 
 func (e *bincEncDriver) EncodeSymbol(v string) {
 	// if WriteSymbolsNoRefs {
-	// 	e.encodeString(c_UTF8, v)
+	// 	e.encodeString(cUTF8, v)
 	// 	return
 	// }
 
@@ -223,10 +267,10 @@ func (e *bincEncDriver) EncodeSymbol(v string) {
 
 	l := len(v)
 	if l == 0 {
-		e.encBytesLen(c_UTF8, 0)
+		e.encBytesLen(cUTF8, 0)
 		return
 	} else if l == 1 {
-		e.encBytesLen(c_UTF8, 1)
+		e.encBytesLen(cUTF8, 1)
 		e.w.writen1(v[0])
 		return
 	}
@@ -276,6 +320,10 @@ func (e *bincEncDriver) EncodeSymbol(v string) {
 }
 
 func (e *bincEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
+	if v == nil {
+		e.EncodeNil()
+		return
+	}
 	l := uint64(len(v))
 	e.encBytesLen(c, l)
 	if l > 0 {
@@ -285,7 +333,7 @@ func (e *bincEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
 
 func (e *bincEncDriver) encBytesLen(c charEncoding, length uint64) {
 	//TODO: support bincUnicodeOther (for now, just use string or bytearray)
-	if c == c_RAW {
+	if c == cRAW {
 		e.encLen(bincVdByteArray<<4, length)
 	} else {
 		e.encLen(bincVdString<<4, length)
@@ -324,6 +372,9 @@ type bincDecSymbol struct {
 }
 
 type bincDecDriver struct {
+	decDriverNoopContainerReader
+	noBuiltInTypes
+
 	d      *Decoder
 	h      *BincHandle
 	r      decReader
@@ -332,13 +383,15 @@ type bincDecDriver struct {
 	bd     byte
 	vd     byte
 	vs     byte
-	noStreamingCodec
-	decNoSeparator
-	b [scratchByteArrayLen]byte
-
+	_      [3]byte // padding
 	// linear searching on this slice is ok,
 	// because we typically expect < 32 symbols in each stream.
 	s []bincDecSymbol
+
+	// noStreamingCodec
+	// decNoSeparator
+
+	b [8 * 8]byte // scratch
 }
 
 func (d *bincDecDriver) readNextBd() {
@@ -348,7 +401,17 @@ func (d *bincDecDriver) readNextBd() {
 	d.bdRead = true
 }
 
+func (d *bincDecDriver) uncacheRead() {
+	if d.bdRead {
+		d.r.unreadn1()
+		d.bdRead = false
+	}
+}
+
 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 {
@@ -359,9 +422,10 @@ func (d *bincDecDriver) ContainerType() (vt valueType) {
 		return valueTypeArray
 	} else if d.vd == bincVdMap {
 		return valueTypeMap
-	} else {
-		// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
 	}
+	// else {
+	// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+	// }
 	return valueTypeUnset
 }
 
@@ -376,27 +440,24 @@ func (d *bincDecDriver) TryDecodeAsNil() bool {
 	return false
 }
 
-func (d *bincDecDriver) IsBuiltinType(rt uintptr) bool {
-	return rt == timeTypId
-}
-
-func (d *bincDecDriver) DecodeBuiltin(rt uintptr, v interface{}) {
+func (d *bincDecDriver) DecodeTime() (t time.Time) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
-	if rt == timeTypId {
-		if d.vd != bincVdTimestamp {
-			d.d.errorf("Invalid d.vd. Expecting 0x%x. Received: 0x%x", bincVdTimestamp, d.vd)
-			return
-		}
-		tt, err := decodeTime(d.r.readx(int(d.vs)))
-		if err != nil {
-			panic(err)
-		}
-		var vt *time.Time = v.(*time.Time)
-		*vt = tt
+	if d.bd == bincVdSpecial<<4|bincSpNil {
 		d.bdRead = false
+		return
 	}
+	if d.vd != bincVdTimestamp {
+		d.d.errorf("cannot decode time - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
+		return
+	}
+	t, err := bincDecodeTime(d.r.readx(int(d.vs)))
+	if err != nil {
+		panic(err)
+	}
+	d.bdRead = false
+	return
 }
 
 func (d *bincDecDriver) decFloatPre(vs, defaultLen byte) {
@@ -405,7 +466,7 @@ func (d *bincDecDriver) decFloatPre(vs, defaultLen byte) {
 	} else {
 		l := d.r.readn1()
 		if l > 8 {
-			d.d.errorf("At most 8 bytes used to represent float. Received: %v bytes", l)
+			d.d.errorf("cannot read float - at most 8 bytes used to represent float - received %v bytes", l)
 			return
 		}
 		for i := l; i < 8; i++ {
@@ -424,7 +485,7 @@ func (d *bincDecDriver) decFloat() (f float64) {
 		d.decFloatPre(d.vs, 8)
 		f = math.Float64frombits(bigen.Uint64(d.b[0:8]))
 	} else {
-		d.d.errorf("only float32 and float64 are supported. d.vd: 0x%x, d.vs: 0x%x", d.vd, d.vs)
+		d.d.errorf("read float - only float32 and float64 are supported - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
 		return
 	}
 	return
@@ -481,49 +542,38 @@ func (d *bincDecDriver) decCheckInteger() (ui uint64, neg bool) {
 			neg = true
 			ui = 1
 		} else {
-			d.d.errorf("numeric decode fails for special value: d.vs: 0x%x", d.vs)
+			d.d.errorf("integer decode fails - invalid special value from descriptor %x-%x/%s",
+				d.vd, d.vs, bincdesc(d.vd, d.vs))
 			return
 		}
 	} else {
-		d.d.errorf("number can only be decoded from uint or int values. d.bd: 0x%x, d.vd: 0x%x", d.bd, d.vd)
+		d.d.errorf("integer can only be decoded from int/uint. d.bd: 0x%x, d.vd: 0x%x", d.bd, d.vd)
 		return
 	}
 	return
 }
 
-func (d *bincDecDriver) DecodeInt(bitsize uint8) (i int64) {
+func (d *bincDecDriver) DecodeInt64() (i int64) {
 	ui, neg := d.decCheckInteger()
-	i, overflow := chkOvf.SignedInt(ui)
-	if overflow {
-		d.d.errorf("simple: overflow converting %v to signed integer", ui)
-		return
-	}
+	i = chkOvf.SignedIntV(ui)
 	if neg {
 		i = -i
 	}
-	if chkOvf.Int(i, bitsize) {
-		d.d.errorf("binc: overflow integer: %v", i)
-		return
-	}
 	d.bdRead = false
 	return
 }
 
-func (d *bincDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
+func (d *bincDecDriver) DecodeUint64() (ui uint64) {
 	ui, neg := d.decCheckInteger()
 	if neg {
-		d.d.errorf("Assigning negative signed value to unsigned type")
-		return
-	}
-	if chkOvf.Uint(ui, bitsize) {
-		d.d.errorf("binc: overflow integer: %v", ui)
+		d.d.errorf("assigning negative signed value to unsigned integer type")
 		return
 	}
 	d.bdRead = false
 	return
 }
 
-func (d *bincDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+func (d *bincDecDriver) DecodeFloat64() (f float64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -539,17 +589,14 @@ func (d *bincDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
 		} else if vs == bincSpNegInf {
 			return math.Inf(-1)
 		} else {
-			d.d.errorf("Invalid d.vs decoding float where d.vd=bincVdSpecial: %v", d.vs)
+			d.d.errorf("float - invalid special value from descriptor %x-%x/%s",
+				d.vd, d.vs, bincdesc(d.vd, d.vs))
 			return
 		}
 	} else if vd == bincVdFloat {
 		f = d.decFloat()
 	} else {
-		f = float64(d.DecodeInt(64))
-	}
-	if chkOverflow32 && chkOvf.Float32(f) {
-		d.d.errorf("binc: float32 overflow: %v", f)
-		return
+		f = float64(d.DecodeInt64())
 	}
 	d.bdRead = false
 	return
@@ -565,7 +612,7 @@ func (d *bincDecDriver) DecodeBool() (b bool) {
 	} else if bd == (bincVdSpecial | bincSpTrue) {
 		b = true
 	} else {
-		d.d.errorf("Invalid single-byte value for bool: %s: %x", msgBadDesc, d.bd)
+		d.d.errorf("bool - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
 		return
 	}
 	d.bdRead = false
@@ -573,8 +620,11 @@ 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)
+		d.d.errorf("map - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
 		return
 	}
 	length = d.decLen()
@@ -583,8 +633,11 @@ 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)
+		d.d.errorf("array - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
 		return
 	}
 	length = d.decLen()
@@ -615,7 +668,8 @@ func (d *bincDecDriver) decLenNumber() (v uint64) {
 	return
 }
 
-func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool) (bs2 []byte, s string) {
+func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool) (
+	bs2 []byte, s string) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -623,7 +677,7 @@ func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool)
 		d.bdRead = false
 		return
 	}
-	var slen int = -1
+	var slen = -1
 	// var ok bool
 	switch d.vd {
 	case bincVdString, bincVdByteArray:
@@ -632,12 +686,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)
@@ -689,15 +743,14 @@ 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)
 			}
 			d.s = append(d.s, bincDecSymbol{i: symbol, s: s, b: bs2})
 		}
 	default:
-		d.d.errorf("Invalid d.vd. Expecting string:0x%x, bytearray:0x%x or symbol: 0x%x. Got: 0x%x",
-			bincVdString, bincVdByteArray, bincVdSymbol, d.vd)
+		d.d.errorf("string/bytes - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
 		return
 	}
 	d.bdRead = false
@@ -705,18 +758,19 @@ func (d *bincDecDriver) decStringAndBytes(bs []byte, withString, zerocopy bool)
 }
 
 func (d *bincDecDriver) DecodeString() (s string) {
-	// DecodeBytes does not accomodate symbols, whose impl stores string version in map.
+	// DecodeBytes does not accommodate symbols, whose impl stores string version in map.
 	// Use decStringAndBytes directly.
 	// return string(d.DecodeBytes(d.b[:], true, true))
 	_, s = d.decStringAndBytes(d.b[:], true, true)
 	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()
 	}
@@ -724,12 +778,16 @@ func (d *bincDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut [
 		d.bdRead = false
 		return nil
 	}
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	if d.vd == bincVdArray {
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		return
+	}
 	var clen int
 	if d.vd == bincVdString || d.vd == bincVdByteArray {
 		clen = d.decLen()
 	} else {
-		d.d.errorf("Invalid d.vd for bytes. Expecting string:0x%x or bytearray:0x%x. Got: 0x%x",
-			bincVdString, bincVdByteArray, d.vd)
+		d.d.errorf("bytes - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
 		return
 	}
 	d.bdRead = false
@@ -740,12 +798,12 @@ 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) {
 	if xtag > 0xff {
-		d.d.errorf("decodeExt: tag must be <= 0xff; got: %v", xtag)
+		d.d.errorf("ext: tag must be <= 0xff; got: %v", xtag)
 		return
 	}
 	realxtag1, xbs := d.decodeExtV(ext != nil, uint8(xtag))
@@ -768,14 +826,14 @@ func (d *bincDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs []b
 		l := d.decLen()
 		xtag = d.r.readn1()
 		if verifyTag && xtag != tag {
-			d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", xtag, tag)
+			d.d.errorf("wrong extension tag - got %b, expecting: %v", xtag, tag)
 			return
 		}
 		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)
+		d.d.errorf("ext - expecting extensions or byte array - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
 		return
 	}
 	d.bdRead = false
@@ -787,7 +845,7 @@ func (d *bincDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch d.vd {
@@ -820,7 +878,7 @@ func (d *bincDecDriver) DecodeNaked() {
 			n.v = valueTypeInt
 			n.i = int64(-1) // int8(-1)
 		default:
-			d.d.errorf("decodeNaked: Unrecognized special value 0x%x", d.vs)
+			d.d.errorf("cannot infer value - unrecognized special value from descriptor %x-%x/%s", d.vd, d.vs, bincdesc(d.vd, d.vs))
 		}
 	case bincVdSmallInt:
 		n.v = valueTypeUint
@@ -842,10 +900,10 @@ 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)))
+		n.v = valueTypeTime
+		tt, err := bincDecodeTime(d.r.readx(int(d.vs)))
 		if err != nil {
 			panic(err)
 		}
@@ -862,7 +920,7 @@ func (d *bincDecDriver) DecodeNaked() {
 		n.v = valueTypeMap
 		decodeFurther = true
 	default:
-		d.d.errorf("decodeNaked: Unrecognized d.vd: 0x%x", d.vd)
+		d.d.errorf("cannot infer value - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
 	}
 
 	if !decodeFurther {
@@ -892,31 +950,219 @@ func (d *bincDecDriver) DecodeNaked() {
 type BincHandle struct {
 	BasicHandle
 	binaryEncodingType
+	noElemSeparators
+
+	// AsSymbols defines what should be encoded as symbols.
+	//
+	// Encoding as symbols can reduce the encoded size significantly.
+	//
+	// However, during decoding, each string to be encoded as a symbol must
+	// be checked to see if it has been seen before. Consequently, encoding time
+	// will increase if using symbols, because string comparisons has a clear cost.
+	//
+	// Values:
+	// - 0: default: library uses best judgement
+	// - 1: use symbols
+	// - 2: do not use symbols
+	AsSymbols uint8
+
+	// AsSymbols: may later on introduce more options ...
+	// - m: map keys
+	// - s: struct fields
+	// - n: none
+	// - a: all: same as m, s, ...
+
+	// _ [1]uint64 // padding
 }
 
+// Name returns the name of the handle: binc
+func (h *BincHandle) Name() string { return "binc" }
+
+// SetBytesExt sets an extension
 func (h *BincHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
-	return h.SetExt(rt, tag, &setExtWrapper{b: ext})
+	return h.SetExt(rt, tag, &extWrapper{ext, interfaceExtFailer{}})
 }
 
 func (h *BincHandle) newEncDriver(e *Encoder) encDriver {
-	return &bincEncDriver{e: e, w: e.w}
+	return &bincEncDriver{e: e, h: h, w: e.w}
 }
 
 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 (e *bincEncDriver) reset() {
 	e.w = e.e.w
 	e.s = 0
+	e.c = 0
 	e.m = nil
 }
 
 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
 }
 
+// var timeDigits = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
+
+// EncodeTime encodes a time.Time as a []byte, including
+// information on the instant in time and UTC offset.
+//
+// Format Description
+//
+//   A timestamp is composed of 3 components:
+//
+//   - secs: signed integer representing seconds since unix epoch
+//   - nsces: unsigned integer representing fractional seconds as a
+//     nanosecond offset within secs, in the range 0 <= nsecs < 1e9
+//   - tz: signed integer representing timezone offset in minutes east of UTC,
+//     and a dst (daylight savings time) flag
+//
+//   When encoding a timestamp, the first byte is the descriptor, which
+//   defines which components are encoded and how many bytes are used to
+//   encode secs and nsecs components. *If secs/nsecs is 0 or tz is UTC, it
+//   is not encoded in the byte array explicitly*.
+//
+//       Descriptor 8 bits are of the form `A B C DDD EE`:
+//           A:   Is secs component encoded? 1 = true
+//           B:   Is nsecs component encoded? 1 = true
+//           C:   Is tz component encoded? 1 = true
+//           DDD: Number of extra bytes for secs (range 0-7).
+//                If A = 1, secs encoded in DDD+1 bytes.
+//                    If A = 0, secs is not encoded, and is assumed to be 0.
+//                    If A = 1, then we need at least 1 byte to encode secs.
+//                    DDD says the number of extra bytes beyond that 1.
+//                    E.g. if DDD=0, then secs is represented in 1 byte.
+//                         if DDD=2, then secs is represented in 3 bytes.
+//           EE:  Number of extra bytes for nsecs (range 0-3).
+//                If B = 1, nsecs encoded in EE+1 bytes (similar to secs/DDD above)
+//
+//   Following the descriptor bytes, subsequent bytes are:
+//
+//       secs component encoded in `DDD + 1` bytes (if A == 1)
+//       nsecs component encoded in `EE + 1` bytes (if B == 1)
+//       tz component encoded in 2 bytes (if C == 1)
+//
+//   secs and nsecs components are integers encoded in a BigEndian
+//   2-complement encoding format.
+//
+//   tz component is encoded as 2 bytes (16 bits). Most significant bit 15 to
+//   Least significant bit 0 are described below:
+//
+//       Timezone offset has a range of -12:00 to +14:00 (ie -720 to +840 minutes).
+//       Bit 15 = have\_dst: set to 1 if we set the dst flag.
+//       Bit 14 = dst\_on: set to 1 if dst is in effect at the time, or 0 if not.
+//       Bits 13..0 = timezone offset in minutes. It is a signed integer in Big Endian format.
+//
+func bincEncodeTime(t time.Time) []byte {
+	//t := rv.Interface().(time.Time)
+	tsecs, tnsecs := t.Unix(), t.Nanosecond()
+	var (
+		bd   byte
+		btmp [8]byte
+		bs   [16]byte
+		i    int = 1
+	)
+	l := t.Location()
+	if l == time.UTC {
+		l = nil
+	}
+	if tsecs != 0 {
+		bd = bd | 0x80
+		bigen.PutUint64(btmp[:], uint64(tsecs))
+		f := pruneSignExt(btmp[:], tsecs >= 0)
+		bd = bd | (byte(7-f) << 2)
+		copy(bs[i:], btmp[f:])
+		i = i + (8 - f)
+	}
+	if tnsecs != 0 {
+		bd = bd | 0x40
+		bigen.PutUint32(btmp[:4], uint32(tnsecs))
+		f := pruneSignExt(btmp[:4], true)
+		bd = bd | byte(3-f)
+		copy(bs[i:], btmp[f:4])
+		i = i + (4 - f)
+	}
+	if l != nil {
+		bd = bd | 0x20
+		// Note that Go Libs do not give access to dst flag.
+		_, zoneOffset := t.Zone()
+		//zoneName, zoneOffset := t.Zone()
+		zoneOffset /= 60
+		z := uint16(zoneOffset)
+		bigen.PutUint16(btmp[:2], z)
+		// clear dst flags
+		bs[i] = btmp[0] & 0x3f
+		bs[i+1] = btmp[1]
+		i = i + 2
+	}
+	bs[0] = bd
+	return bs[0:i]
+}
+
+// bincDecodeTime decodes a []byte into a time.Time.
+func bincDecodeTime(bs []byte) (tt time.Time, err error) {
+	bd := bs[0]
+	var (
+		tsec  int64
+		tnsec uint32
+		tz    uint16
+		i     byte = 1
+		i2    byte
+		n     byte
+	)
+	if bd&(1<<7) != 0 {
+		var btmp [8]byte
+		n = ((bd >> 2) & 0x7) + 1
+		i2 = i + n
+		copy(btmp[8-n:], bs[i:i2])
+		//if first bit of bs[i] is set, then fill btmp[0..8-n] with 0xff (ie sign extend it)
+		if bs[i]&(1<<7) != 0 {
+			copy(btmp[0:8-n], bsAll0xff)
+			//for j,k := byte(0), 8-n; j < k; j++ {	btmp[j] = 0xff }
+		}
+		i = i2
+		tsec = int64(bigen.Uint64(btmp[:]))
+	}
+	if bd&(1<<6) != 0 {
+		var btmp [4]byte
+		n = (bd & 0x3) + 1
+		i2 = i + n
+		copy(btmp[4-n:], bs[i:i2])
+		i = i2
+		tnsec = bigen.Uint32(btmp[:])
+	}
+	if bd&(1<<5) == 0 {
+		tt = time.Unix(tsec, int64(tnsec)).UTC()
+		return
+	}
+	// In stdlib time.Parse, when a date is parsed without a zone name, it uses "" as zone name.
+	// However, we need name here, so it can be shown when time is printed.
+	// Zone name is in form: UTC-08:00.
+	// Note that Go Libs do not give access to dst flag, so we ignore dst bits
+
+	i2 = i + 2
+	tz = bigen.Uint16(bs[i:i2])
+	// i = i2
+	// sign extend sign bit into top 2 MSB (which were dst bits):
+	if tz&(1<<13) == 0 { // positive
+		tz = tz & 0x3fff //clear 2 MSBs: dst bits
+	} else { // negative
+		tz = tz | 0xc000 //set 2 MSBs: dst bits
+	}
+	tzint := int16(tz)
+	if tzint == 0 {
+		tt = time.Unix(tsec, int64(tnsec)).UTC()
+	} else {
+		// For Go Time, do not use a descriptive timezone.
+		// It's unnecessary, and makes it harder to do a reflect.DeepEqual.
+		// The Offset already tells what the offset should be, if not on UTC and unknown zone name.
+		// var zoneName = timeLocUTCName(tzint)
+		tt = time.Unix(tsec, int64(tnsec)).In(time.FixedZone("", int(tzint)*60))
+	}
+	return
+}
+
 var _ decDriver = (*bincDecDriver)(nil)
 var _ encDriver = (*bincEncDriver)(nil)
diff --git a/vendor/github.com/ugorji/go/codec/build.sh b/vendor/github.com/ugorji/go/codec/build.sh
new file mode 100644
index 000000000..1f4ac4662
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/build.sh
@@ -0,0 +1,220 @@
+#!/bin/bash
+
+# Run all the different permutations of all the tests and other things
+# This helps ensure that nothing gets broken.
+
+_tests() {
+    local gover=$( go version | cut -f 3 -d ' ' )
+    # note that codecgen requires fastpath, so you cannot do "codecgen notfastpath"
+    local a=( "" "safe"  "notfastpath" "notfastpath safe" "codecgen" "codecgen safe" )
+    for i in "${a[@]}"
+    do
+        echo ">>>> TAGS: $i"
+        local i2=${i:-default}
+        case $gover in
+            go1.[0-6]*) go vet -printfuncs "errorf" "$@" &&
+                              go test ${zargs[*]} -vet off -tags "$i" "$@" ;;
+            *) go vet -printfuncs "errorf" "$@" &&
+                     go test ${zargs[*]} -vet off -tags "alltests $i" -run "Suite" -coverprofile "${i2// /-}.cov.out" "$@" ;;
+        esac
+        if [[ "$?" != 0 ]]; then return 1; fi 
+    done
+    echo "++++++++ TEST SUITES ALL PASSED ++++++++"
+}
+
+
+# is a generation needed?
+_ng() {
+    local a="$1"
+    if [[ ! -e "$a" ]]; then echo 1; return; fi 
+    for i in `ls -1 *.go.tmpl gen.go values_test.go`
+    do
+        if [[ "$a" -ot "$i" ]]; then echo 1; return; fi 
+    done
+}
+
+_prependbt() {
+    cat > ${2} <<EOF
+// +build generated
+
+EOF
+    cat ${1} >> ${2}
+    rm -f ${1}
+}
+
+# _build generates fast-path.go and gen-helper.go.
+_build() {
+    if ! [[ "${zforce}" || $(_ng "fast-path.generated.go") || $(_ng "gen-helper.generated.go") || $(_ng "gen.generated.go") ]]; then return 0; fi 
+    
+    if [ "${zbak}" ]; then
+        _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 "gen${_gg}" ] && mv gen${_gg} gen${_gg}__${_zts}.bak
+    fi 
+    rm -f gen-helper.generated.go fast-path.generated.go gen.generated.go \
+       *safe.generated.go *_generated_test.go *.generated_ffjson_expose.go 
+
+    cat > gen.generated.go <<EOF
+// +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.
+
+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
+\`
+
+const genEncChanTmpl = \`
+EOF
+    cat >> gen.generated.go < gen-enc-chan.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) error {
+return genInternalGoFile(r, w)
+}
+EOF
+    cat > gen-from-tmpl.generated.go <<EOF
+//+build ignore
+
+package main
+
+import "${zpkg}"
+import "os"
+
+func run(fnameIn, fnameOut string) {
+println("____ " + fnameIn + " --> " + fnameOut + " ______")
+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)
+if err != nil { panic(err) }
+}
+
+func main() {
+run("fast-path.go.tmpl", "fast-path.generated.go")
+run("gen-helper.go.tmpl", "gen-helper.generated.go")
+run("mammoth-test.go.tmpl", "mammoth_generated_test.go")
+run("mammoth2-test.go.tmpl", "mammoth2_generated_test.go")
+}
+EOF
+
+    # explicitly return 0 if this passes, else return 1
+    go run -tags "notfastpath safe codecgen.exec" gen-from-tmpl.generated.go &&
+        rm -f gen-from-tmpl.*generated.go &&
+        return 0
+    return 1
+}
+
+_codegenerators() {
+    if ! [[ $zforce ||
+                $(_ng "values_codecgen${zsfx}") ]]; then return 0; fi
+
+    # Note: ensure you run the codecgen for this codebase  (using $zgobase/bin/codecgen)
+    local c9="codecgen-scratch.go"
+    true &&
+        echo "codecgen ... " &&
+        $zgobase/bin/codecgen -rt codecgen -t 'codecgen generated' -o values_codecgen${zsfx} -d 19780 $zfin $zfin2 &&
+        cp mammoth2_generated_test.go $c9 &&
+        $zgobase/bin/codecgen -t '!notfastpath' -o mammoth2_codecgen${zsfx} -d 19781 mammoth2_generated_test.go &&
+        rm -f $c9 &&
+        echo "generators done!" 
+}
+
+_prebuild() {
+    echo "prebuild: zforce: $zforce , zexternal: $zexternal"
+    zmydir=`pwd`
+    zfin="test_values.generated.go"
+    zfin2="test_values_flex.generated.go"
+    zsfx="_generated_test.go"
+    # zpkg="ugorji.net/codec"
+    zpkg=${zmydir##*/src/}
+    zgobase=${zmydir%%/src/*}
+    # rm -f *_generated_test.go 
+    rm -f codecgen-*.go &&
+        _build &&
+        cp $zmydir/values_test.go $zmydir/$zfin &&
+        cp $zmydir/values_flex_test.go $zmydir/$zfin2 &&
+        _codegenerators &&
+        if [[ "$(type -t _codegenerators_external )" = "function" ]]; then _codegenerators_external ; fi &&
+        if [[ $zforce ]]; then go install ${zargs[*]} .; fi &&
+        echo "prebuild done successfully"
+    rm -f $zmydir/$zfin $zmydir/$zfin2 
+}
+
+_make() {
+    zforce=1
+    zexternal=1
+    ( cd codecgen && go install ${zargs[*]} . ) && _prebuild && go install ${zargs[*]} .
+    unset zforce zexternal
+}
+
+_clean() {
+    rm -f gen-from-tmpl.*generated.go \
+       codecgen-*.go \
+       test_values.generated.go test_values_flex.generated.go
+}
+
+_usage() {
+    cat <<EOF
+primary usage: $0 
+    -[tmpfxnld] for [tests, make, prebuild (force) (external), inlining diagnostics, mid-stack inlining, race detector]
+EOF
+    if [[ "$(type -t _usage_run)" = "function" ]]; then _usage_run ; fi
+}
+
+_main() {
+    if [[ -z "$1" ]]; then _usage; return 1; fi
+    local x
+    unset zforce zexternal
+    zargs=()
+    while getopts ":ctbqmnrgupfxlzd" flag
+    do
+        case "x$flag" in
+            'xf') zforce=1 ;;
+            'xx') zexternal=1 ;;
+            'xl') zargs+=("-gcflags"); zargs+=("-l=4") ;;
+            'xn') zargs+=("-gcflags"); zargs+=("-m") ;;
+            'xd') zargs+=("-race") ;;
+            x\?) _usage; return 1 ;;
+            *) x=$flag ;;
+        esac
+    done
+    shift $((OPTIND-1))
+    case "x$x" in
+        'xt') _tests "$@" ;;
+        'xq') _benchquick "$@" ;;
+        'xb') _bench "$@" ;;
+        'xm') _make "$@" ;;
+        'xr') _release "$@" ;;
+        'xg') _go ;;
+        'xu') _githubupdate ;;
+        'xp') _prebuild "$@" ;;
+        'xc') _clean "$@" ;;
+        'xz') _analyze "$@" ;;
+    esac
+    unset zforce zexternal 
+}
+
+[ "." = `dirname $0` ] && _main "$@"
+
diff --git a/vendor/github.com/ugorji/go/codec/cbor.go b/vendor/github.com/ugorji/go/codec/cbor.go
index a224cd3a7..33086ade0 100644
--- a/vendor/github.com/ugorji/go/codec/cbor.go
+++ b/vendor/github.com/ugorji/go/codec/cbor.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 package codec
@@ -6,6 +6,7 @@ package codec
 import (
 	"math"
 	"reflect"
+	"time"
 )
 
 const (
@@ -38,6 +39,8 @@ const (
 	cborBdBreak                 = 0xff
 )
 
+// These define some in-stream descriptors for
+// manual encoding e.g. when doing explicit indefinite-length
 const (
 	CborStreamBytes  byte = 0x5f
 	CborStreamString      = 0x7f
@@ -57,15 +60,56 @@ const (
 	cborBaseSimple      = 0xe0
 )
 
+func cbordesc(bd byte) string {
+	switch bd {
+	case cborBdNil:
+		return "nil"
+	case cborBdFalse:
+		return "false"
+	case cborBdTrue:
+		return "true"
+	case cborBdFloat16, cborBdFloat32, cborBdFloat64:
+		return "float"
+	case cborBdIndefiniteBytes:
+		return "bytes*"
+	case cborBdIndefiniteString:
+		return "string*"
+	case cborBdIndefiniteArray:
+		return "array*"
+	case cborBdIndefiniteMap:
+		return "map*"
+	default:
+		switch {
+		case bd >= cborBaseUint && bd < cborBaseNegInt:
+			return "(u)int"
+		case bd >= cborBaseNegInt && bd < cborBaseBytes:
+			return "int"
+		case bd >= cborBaseBytes && bd < cborBaseString:
+			return "bytes"
+		case bd >= cborBaseString && bd < cborBaseArray:
+			return "string"
+		case bd >= cborBaseArray && bd < cborBaseMap:
+			return "array"
+		case bd >= cborBaseMap && bd < cborBaseTag:
+			return "map"
+		case bd >= cborBaseTag && bd < cborBaseSimple:
+			return "ext"
+		default:
+			return "unknown"
+		}
+	}
+}
+
 // -------------------
 
 type cborEncDriver struct {
 	noBuiltInTypes
-	encNoSeparator
+	encDriverNoopContainerWriter
 	e *Encoder
 	w encWriter
 	h *CborHandle
 	x [8]byte
+	// _ [3]uint64 // padding
 }
 
 func (e *cborEncDriver) EncodeNil() {
@@ -123,6 +167,24 @@ func (e *cborEncDriver) encLen(bd byte, length int) {
 	e.encUint(uint64(length), bd)
 }
 
+func (e *cborEncDriver) EncodeTime(t time.Time) {
+	if t.IsZero() {
+		e.EncodeNil()
+	} else if e.h.TimeRFC3339 {
+		e.encUint(0, cborBaseTag)
+		e.EncodeString(cUTF8, t.Format(time.RFC3339Nano))
+	} else {
+		e.encUint(1, cborBaseTag)
+		t = t.UTC().Round(time.Microsecond)
+		sec, nsec := t.Unix(), uint64(t.Nanosecond())
+		if nsec == 0 {
+			e.EncodeInt(sec)
+		} else {
+			e.EncodeFloat64(float64(sec) + float64(nsec)/1e9)
+		}
+	}
+}
+
 func (e *cborEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Encoder) {
 	e.encUint(uint64(xtag), cborBaseTag)
 	if v := ext.ConvertExt(rv); v == nil {
@@ -134,39 +196,89 @@ 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 {
-		en.encode(re.Data)
-	} else if re.Value == nil {
-		e.EncodeNil()
-	} else {
+	// only encodes re.Value (never re.Data)
+	// if false && re.Data != nil {
+	// 	en.encode(re.Data)
+	// } else if re.Value != nil {
+	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) {
-	e.encLen(cborBaseString, len(v))
-	e.w.writestr(v)
-}
-
-func (e *cborEncDriver) EncodeSymbol(v string) {
-	e.EncodeString(c_UTF8, v)
+	e.encStringBytesS(cborBaseString, v)
 }
 
 func (e *cborEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
-	if c == c_RAW {
-		e.encLen(cborBaseBytes, len(v))
+	if v == nil {
+		e.EncodeNil()
+	} else if c == cRAW {
+		e.encStringBytesS(cborBaseBytes, stringView(v))
 	} else {
-		e.encLen(cborBaseString, len(v))
+		e.encStringBytesS(cborBaseString, stringView(v))
+	}
+}
+
+func (e *cborEncDriver) encStringBytesS(bb byte, v string) {
+	if e.h.IndefiniteLength {
+		if bb == cborBaseBytes {
+			e.w.writen1(cborBdIndefiniteBytes)
+		} else {
+			e.w.writen1(cborBdIndefiniteString)
+		}
+		blen := len(v) / 4
+		if blen == 0 {
+			blen = 64
+		} else if blen > 1024 {
+			blen = 1024
+		}
+		for i := 0; i < len(v); {
+			var v2 string
+			i2 := i + blen
+			if i2 < len(v) {
+				v2 = v[i:i2]
+			} else {
+				v2 = v[i:]
+			}
+			e.encLen(bb, len(v2))
+			e.w.writestr(v2)
+			i = i2
+		}
+		e.w.writen1(cborBdBreak)
+	} else {
+		e.encLen(bb, len(v))
+		e.w.writestr(v)
 	}
-	e.w.writeb(v)
 }
 
 // ----------------------
@@ -175,12 +287,13 @@ type cborDecDriver struct {
 	d      *Decoder
 	h      *CborHandle
 	r      decReader
-	b      [scratchByteArrayLen]byte
 	br     bool // bytes reader
 	bdRead bool
 	bd     byte
 	noBuiltInTypes
-	decNoSeparator
+	// decNoSeparator
+	decDriverNoopContainerReader
+	// _ [3]uint64 // padding
 }
 
 func (d *cborDecDriver) readNextBd() {
@@ -188,7 +301,17 @@ func (d *cborDecDriver) readNextBd() {
 	d.bdRead = true
 }
 
+func (d *cborDecDriver) uncacheRead() {
+	if d.bdRead {
+		d.r.unreadn1()
+		d.bdRead = false
+	}
+}
+
 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) {
@@ -199,9 +322,10 @@ func (d *cborDecDriver) ContainerType() (vt valueType) {
 		return valueTypeArray
 	} else if d.bd == cborBdIndefiniteMap || (d.bd >= cborBaseMap && d.bd < cborBaseTag) {
 		return valueTypeMap
-	} else {
-		// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
 	}
+	// else {
+	// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+	// }
 	return valueTypeUnset
 }
 
@@ -242,7 +366,7 @@ func (d *cborDecDriver) decUint() (ui uint64) {
 		} else if v == 0x1b {
 			ui = uint64(bigen.Uint64(d.r.readx(8)))
 		} else {
-			d.d.errorf("decUint: Invalid descriptor: %v", d.bd)
+			d.d.errorf("invalid descriptor decoding uint: %x/%s", d.bd, cbordesc(d.bd))
 			return
 		}
 	}
@@ -258,52 +382,36 @@ func (d *cborDecDriver) decCheckInteger() (neg bool) {
 	} else if major == cborMajorNegInt {
 		neg = true
 	} else {
-		d.d.errorf("invalid major: %v (bd: %v)", major, d.bd)
+		d.d.errorf("not an integer - invalid major %v from descriptor %x/%s", major, d.bd, cbordesc(d.bd))
 		return
 	}
 	return
 }
 
-func (d *cborDecDriver) DecodeInt(bitsize uint8) (i int64) {
+func (d *cborDecDriver) DecodeInt64() (i int64) {
 	neg := d.decCheckInteger()
 	ui := d.decUint()
 	// check if this number can be converted to an int without overflow
-	var overflow bool
 	if neg {
-		if i, overflow = chkOvf.SignedInt(ui + 1); overflow {
-			d.d.errorf("cbor: overflow converting %v to signed integer", ui+1)
-			return
-		}
-		i = -i
+		i = -(chkOvf.SignedIntV(ui + 1))
 	} else {
-		if i, overflow = chkOvf.SignedInt(ui); overflow {
-			d.d.errorf("cbor: overflow converting %v to signed integer", ui)
-			return
-		}
-	}
-	if chkOvf.Int(i, bitsize) {
-		d.d.errorf("cbor: overflow integer: %v", i)
-		return
+		i = chkOvf.SignedIntV(ui)
 	}
 	d.bdRead = false
 	return
 }
 
-func (d *cborDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
+func (d *cborDecDriver) DecodeUint64() (ui uint64) {
 	if d.decCheckInteger() {
-		d.d.errorf("Assigning negative signed value to unsigned type")
+		d.d.errorf("assigning negative signed value to unsigned type")
 		return
 	}
 	ui = d.decUint()
-	if chkOvf.Uint(ui, bitsize) {
-		d.d.errorf("cbor: overflow integer: %v", ui)
-		return
-	}
 	d.bdRead = false
 	return
 }
 
-func (d *cborDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+func (d *cborDecDriver) DecodeFloat64() (f float64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -314,13 +422,9 @@ func (d *cborDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
 	} else if bd == cborBdFloat64 {
 		f = math.Float64frombits(bigen.Uint64(d.r.readx(8)))
 	} else if bd >= cborBaseUint && bd < cborBaseBytes {
-		f = float64(d.DecodeInt(64))
+		f = float64(d.DecodeInt64())
 	} else {
-		d.d.errorf("Float only valid from float16/32/64: Invalid descriptor: %v", bd)
-		return
-	}
-	if chkOverflow32 && chkOvf.Float32(f) {
-		d.d.errorf("cbor: float32 overflow: %v", f)
+		d.d.errorf("float only valid from float16/32/64 - invalid descriptor %x/%s", bd, cbordesc(bd))
 		return
 	}
 	d.bdRead = false
@@ -336,7 +440,7 @@ func (d *cborDecDriver) DecodeBool() (b bool) {
 		b = true
 	} else if bd == cborBdFalse {
 	} else {
-		d.d.errorf("Invalid single-byte value for bool: %s: %x", msgBadDesc, d.bd)
+		d.d.errorf("not bool - %s %x/%s", msgBadDesc, d.bd, cbordesc(d.bd))
 		return
 	}
 	d.bdRead = false
@@ -344,6 +448,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
@@ -352,6 +459,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
@@ -370,7 +480,8 @@ func (d *cborDecDriver) decAppendIndefiniteBytes(bs []byte) []byte {
 			break
 		}
 		if major := d.bd >> 5; major != cborMajorBytes && major != cborMajorText {
-			d.d.errorf("cbor: expect bytes or string major type in indefinite string/bytes; got: %v, byte: %v", major, d.bd)
+			d.d.errorf("expect bytes/string major type in indefinite string/bytes;"+
+				" got major %v from descriptor %x/%x", major, d.bd, cbordesc(d.bd))
 			return nil
 		}
 		n := d.decLen()
@@ -391,7 +502,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()
 	}
@@ -400,25 +511,84 @@ func (d *cborDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut [
 		return nil
 	}
 	if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
+		d.bdRead = false
 		if bs == nil {
-			return d.decAppendIndefiniteBytes(nil)
+			if zerocopy {
+				return d.decAppendIndefiniteBytes(d.d.b[:0])
+			}
+			return d.decAppendIndefiniteBytes(zeroByteSlice)
 		}
 		return d.decAppendIndefiniteBytes(bs[:0])
 	}
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	if d.bd == cborBdIndefiniteArray || (d.bd >= cborBaseArray && d.bd < cborBaseMap) {
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		return
+	}
 	clen := d.decLen()
 	d.bdRead = false
 	if zerocopy {
 		if d.br {
 			return d.r.readx(clen)
 		} else if len(bs) == 0 {
-			bs = d.b[:]
+			bs = d.d.b[:]
 		}
 	}
-	return decByteSlice(d.r, clen, bs)
+	return decByteSlice(d.r, clen, d.h.MaxInitLen, bs)
 }
 
 func (d *cborDecDriver) DecodeString() (s string) {
-	return string(d.DecodeBytes(d.b[:], true, true))
+	return string(d.DecodeBytes(d.d.b[:], true))
+}
+
+func (d *cborDecDriver) DecodeStringAsBytes() (s []byte) {
+	return d.DecodeBytes(d.d.b[:], true)
+}
+
+func (d *cborDecDriver) DecodeTime() (t time.Time) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.bd == cborBdNil || d.bd == cborBdUndefined {
+		d.bdRead = false
+		return
+	}
+	xtag := d.decUint()
+	d.bdRead = false
+	return d.decodeTime(xtag)
+}
+
+func (d *cborDecDriver) decodeTime(xtag uint64) (t time.Time) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	switch xtag {
+	case 0:
+		var err error
+		if t, err = time.Parse(time.RFC3339, stringView(d.DecodeStringAsBytes())); err != nil {
+			d.d.errorv(err)
+		}
+	case 1:
+		// decode an int64 or a float, and infer time.Time from there.
+		// for floats, round to microseconds, as that is what is guaranteed to fit well.
+		switch {
+		case d.bd == cborBdFloat16, d.bd == cborBdFloat32:
+			f1, f2 := math.Modf(d.DecodeFloat64())
+			t = time.Unix(int64(f1), int64(f2*1e9))
+		case d.bd == cborBdFloat64:
+			f1, f2 := math.Modf(d.DecodeFloat64())
+			t = time.Unix(int64(f1), int64(f2*1e9))
+		case d.bd >= cborBaseUint && d.bd < cborBaseNegInt,
+			d.bd >= cborBaseNegInt && d.bd < cborBaseBytes:
+			t = time.Unix(d.DecodeInt64(), 0)
+		default:
+			d.d.errorf("time.Time can only be decoded from a number (or RFC3339 string)")
+		}
+	default:
+		d.d.errorf("invalid tag for time.Time - expecting 0 or 1, got 0x%x", xtag)
+	}
+	t = t.UTC().Round(time.Microsecond)
+	return
 }
 
 func (d *cborDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
@@ -449,7 +619,7 @@ func (d *cborDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch d.bd {
@@ -461,15 +631,12 @@ func (d *cborDecDriver) DecodeNaked() {
 	case cborBdTrue:
 		n.v = valueTypeBool
 		n.b = true
-	case cborBdFloat16, cborBdFloat32:
+	case cborBdFloat16, cborBdFloat32, cborBdFloat64:
 		n.v = valueTypeFloat
-		n.f = d.DecodeFloat(true)
-	case cborBdFloat64:
-		n.v = valueTypeFloat
-		n.f = d.DecodeFloat(false)
+		n.f = d.DecodeFloat64()
 	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()
@@ -484,17 +651,17 @@ func (d *cborDecDriver) DecodeNaked() {
 		case d.bd >= cborBaseUint && d.bd < cborBaseNegInt:
 			if d.h.SignedInteger {
 				n.v = valueTypeInt
-				n.i = d.DecodeInt(64)
+				n.i = d.DecodeInt64()
 			} else {
 				n.v = valueTypeUint
-				n.u = d.DecodeUint(64)
+				n.u = d.DecodeUint64()
 			}
 		case d.bd >= cborBaseNegInt && d.bd < cborBaseBytes:
 			n.v = valueTypeInt
-			n.i = d.DecodeInt(64)
+			n.i = d.DecodeInt64()
 		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()
@@ -508,6 +675,11 @@ func (d *cborDecDriver) DecodeNaked() {
 			n.v = valueTypeExt
 			n.u = d.decUint()
 			n.l = nil
+			if n.u == 0 || n.u == 1 {
+				d.bdRead = false
+				n.v = valueTypeTime
+				n.t = d.decodeTime(n.u)
+			}
 			// d.bdRead = false
 			// d.d.decode(&re.Value) // handled by decode itself.
 			// decodeFurther = true
@@ -538,30 +710,29 @@ func (d *cborDecDriver) DecodeNaked() {
 //
 // None of the optional extensions (with tags) defined in the spec are supported out-of-the-box.
 // Users can implement them as needed (using SetExt), including spec-documented ones:
-//   - timestamp, BigNum, BigFloat, Decimals, Encoded Text (e.g. URL, regexp, base64, MIME Message), etc.
-//
-// To encode with indefinite lengths (streaming), users will use
-// (Must)Encode methods of *Encoder, along with writing CborStreamXXX constants.
-//
-// For example, to encode "one-byte" as an indefinite length string:
-//     var buf bytes.Buffer
-//     e := NewEncoder(&buf, new(CborHandle))
-//     buf.WriteByte(CborStreamString)
-//     e.MustEncode("one-")
-//     e.MustEncode("byte")
-//     buf.WriteByte(CborStreamBreak)
-//     encodedBytes := buf.Bytes()
-//     var vv interface{}
-//     NewDecoderBytes(buf.Bytes(), new(CborHandle)).MustDecode(&vv)
-//     // Now, vv contains the same string "one-byte"
-//
+//   - timestamp, BigNum, BigFloat, Decimals,
+//   - Encoded Text (e.g. URL, regexp, base64, MIME Message), etc.
 type CborHandle struct {
 	binaryEncodingType
+	noElemSeparators
 	BasicHandle
+
+	// IndefiniteLength=true, means that we encode using indefinitelength
+	IndefiniteLength bool
+
+	// TimeRFC3339 says to encode time.Time using RFC3339 format.
+	// If unset, we encode time.Time using seconds past epoch.
+	TimeRFC3339 bool
+
+	// _ [1]uint64 // padding
 }
 
+// Name returns the name of the handle: cbor
+func (h *CborHandle) Name() string { return "cbor" }
+
+// SetInterfaceExt sets an extension
 func (h *CborHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
-	return h.SetExt(rt, tag, &setExtWrapper{i: ext})
+	return h.SetExt(rt, tag, &extWrapper{bytesExtFailer{}, ext})
 }
 
 func (h *CborHandle) newEncDriver(e *Encoder) encDriver {
@@ -569,7 +740,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() {
@@ -577,7 +748,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 7e56f1eca..c73d91f3f 100644
--- a/vendor/github.com/ugorji/go/codec/decode.go
+++ b/vendor/github.com/ugorji/go/codec/decode.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 package codec
@@ -9,18 +9,33 @@ import (
 	"fmt"
 	"io"
 	"reflect"
+	"strconv"
+	"sync"
 	"time"
 )
 
 // Some tagging information for error messages.
 const (
-	msgBadDesc            = "Unrecognized descriptor byte"
+	msgBadDesc            = "unrecognized descriptor byte"
 	msgDecCannotExpandArr = "cannot expand go array from %v to stream length: %v"
 )
 
+const decDefSliceCap = 8
+const decDefChanCap = 64 // should be large, as cap cannot be expanded
+const decScratchByteArrayLen = cacheLineSize - 8
+
 var (
-	onlyMapOrArrayCanDecodeIntoStructErr = errors.New("only encoded map or array can be decoded into a struct")
-	cannotDecodeIntoNilErr               = errors.New("cannot decode into nil")
+	errstrOnlyMapOrArrayCanDecodeIntoStruct = "only encoded map or array can be decoded into a struct"
+	errstrCannotDecodeIntoNil               = "cannot decode into nil"
+
+	errmsgExpandSliceOverflow     = "expand slice: slice overflow"
+	errmsgExpandSliceCannotChange = "expand slice: cannot change"
+
+	errDecoderNotInitialized = errors.New("Decoder not initialized")
+
+	errDecUnreadByteNothingToRead   = errors.New("cannot unread - nothing has been read")
+	errDecUnreadByteLastByteNotRead = errors.New("cannot unread - last byte has not been read")
+	errDecUnreadByteUnknown         = errors.New("cannot unread - reason unknown")
 )
 
 // decReader abstracts the reading source, allowing implementations that can
@@ -34,25 +49,29 @@ type decReader interface {
 	readx(n int) []byte
 	readb([]byte)
 	readn1() uint8
-	readn1eof() (v uint8, eof bool)
 	numread() int // number of bytes read
 	track()
 	stopTrack() []byte
-}
 
-type decReaderByteScanner interface {
-	io.Reader
-	io.ByteScanner
+	// 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 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
-	DecodeBuiltin(rt uintptr, v interface{})
+	// IsBuiltinType(rt uintptr) bool
 
 	// DecodeNaked will decode primitives (number, bool, string, []byte) and RawExt.
 	// For maps and arrays, it will not do the decoding in-band, but will signal
@@ -66,9 +85,15 @@ type decDriver interface {
 	// extensions should also use readx to decode them, for efficiency.
 	// kInterface will extract the detached byte slice if it has to pass it outside its realm.
 	DecodeNaked()
-	DecodeInt(bitsize uint8) (i int64)
-	DecodeUint(bitsize uint8) (ui uint64)
-	DecodeFloat(chkOverflow32 bool) (f float64)
+
+	// Deprecated: use DecodeInt64 and DecodeUint64 instead
+	// DecodeInt(bitsize uint8) (i int64)
+	// DecodeUint(bitsize uint8) (ui uint64)
+
+	DecodeInt64() (i int64)
+	DecodeUint64() (ui uint64)
+
+	DecodeFloat64() (f float64)
 	DecodeBool() (b bool)
 	// DecodeString can also decode symbols.
 	// It looks redundant as DecodeBytes is available.
@@ -76,43 +101,69 @@ 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
+
+	DecodeTime() (t time.Time)
+
 	ReadArrayStart() int
+	ReadArrayElem()
+	ReadArrayEnd()
+	ReadMapStart() int
+	ReadMapElemKey()
+	ReadMapElemValue()
+	ReadMapEnd()
 
 	reset()
 	uncacheRead()
 }
 
-type decNoSeparator struct{}
+type decDriverNoopContainerReader struct{}
 
-func (_ decNoSeparator) ReadEnd()     {}
-func (_ decNoSeparator) uncacheRead() {}
+func (x decDriverNoopContainerReader) ReadArrayStart() (v int) { return }
+func (x decDriverNoopContainerReader) ReadArrayElem()          {}
+func (x decDriverNoopContainerReader) ReadArrayEnd()           {}
+func (x decDriverNoopContainerReader) ReadMapStart() (v int)   { return }
+func (x decDriverNoopContainerReader) ReadMapElemKey()         {}
+func (x decDriverNoopContainerReader) ReadMapElemValue()       {}
+func (x decDriverNoopContainerReader) ReadMapEnd()             {}
+func (x decDriverNoopContainerReader) CheckBreak() (v bool)    { return }
 
+// func (x decNoSeparator) uncacheRead() {}
+
+// DecodeOptions captures configuration options during decode.
 type DecodeOptions struct {
 	// MapType specifies type to use during schema-less decoding of a map in the stream.
-	// If nil, we use map[interface{}]interface{}
+	// If nil (unset), we default to map[string]interface{} iff json handle and MapStringAsKey=true,
+	// else map[interface{}]interface{}.
 	MapType reflect.Type
 
 	// SliceType specifies type to use during schema-less decoding of an array in the stream.
-	// If nil, we use []interface{}
+	// If nil (unset), we default to []interface{} for all formats.
 	SliceType reflect.Type
 
-	// MaxInitLen defines the initial length that we "make" a collection (slice, chan or map) with.
-	// If 0 or negative, we default to a sensible value based on the size of an element in the collection.
+	// 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.
-	// We should not auto-matically provision a slice of that length, to prevent Out-Of-Memory crash.
+	// For example, when decoding, a stream may say that it has 2^64 elements.
+	// We should not auto-matically provision a slice of that size, to prevent Out-Of-Memory crash.
 	// Instead, we provision up to MaxInitLen, fill that up, and start appending after that.
 	MaxInitLen int
 
+	// ReaderBufferSize is the size of the buffer used when reading.
+	//
+	// if > 0, we use a smart buffer internally for performance purposes.
+	ReaderBufferSize int
+
 	// If ErrorIfNoField, return an error when decoding a map
 	// from a codec stream into a struct, and no matching struct field is found.
 	ErrorIfNoField bool
@@ -139,6 +190,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{...},
@@ -159,22 +215,368 @@ 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.
+	//
+	// This only impacts decoding into a nil interface{}.
+	// Consequently, it has no effect on codecgen.
+	//
+	// *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
 }
 
 // ------------------------------------
 
-// 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
+
+	tr  []byte
+	trb bool
+	b   [4]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 errDecUnreadByteNothingToRead
+}
+
+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) 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
+	trb bool // tracking bytes turned on
+	_   bool
+	b   [4]byte // tiny buffer for reading single bytes
+
+	x  [scratchByteArrayLen]byte // for: get struct field name, swallow valueTypeBytes, etc
+	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
@@ -200,8 +602,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 {
@@ -211,30 +613,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 = errDecUnreadByteNothingToRead
+	case 1:
+		err = errDecUnreadByteLastByteNotRead
+	default:
+		err = errDecUnreadByteUnknown
 	}
 	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
 }
@@ -248,7 +640,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)
@@ -259,31 +651,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 {
@@ -299,6 +678,62 @@ 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) 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 {
@@ -326,7 +761,7 @@ func (z *ioDecReader) stopTrack() (bs []byte) {
 
 // ------------------------------------
 
-var bytesDecReaderCannotUnreadErr = errors.New("cannot unread last byte read")
+var errBytesDecReaderCannotUnread = errors.New("cannot unread last byte read")
 
 // bytesDecReader is a decReader that reads off a byte slice with zero copying
 type bytesDecReader struct {
@@ -349,7 +784,7 @@ func (z *bytesDecReader) numread() int {
 
 func (z *bytesDecReader) unreadn1() {
 	if z.c == 0 || len(z.b) == 0 {
-		panic(bytesDecReaderCannotUnreadErr)
+		panic(errBytesDecReaderCannotUnread)
 	}
 	z.c--
 	z.a++
@@ -375,6 +810,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)
@@ -385,19 +824,69 @@ func (z *bytesDecReader) readn1() (v uint8) {
 	return
 }
 
-func (z *bytesDecReader) readn1eof() (v uint8, eof bool) {
+// 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 {
-		eof = true
 		return
 	}
-	v = z.b[z.c]
-	z.c++
-	z.a--
+	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) readb(bs []byte) {
-	copy(bs, z.readx(len(bs)))
+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() {
@@ -408,168 +897,66 @@ 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 (d *Decoder) rawExt(f *codecFnInfo, rv reflect.Value) {
+	d.d.DecodeExt(rv2i(rv), 0, nil)
 }
 
-func (f *decFnInfo) builtin(rv reflect.Value) {
-	f.d.d.DecodeBuiltin(f.ti.rtid, rv.Addr().Interface())
+func (d *Decoder) ext(f *codecFnInfo, rv reflect.Value) {
+	d.d.DecodeExt(rv2i(rv), f.xfTag, f.xfFn)
 }
 
-func (f *decFnInfo) rawExt(rv reflect.Value) {
-	f.d.d.DecodeExt(rv.Addr().Interface(), 0, nil)
+func (d *Decoder) selferUnmarshal(f *codecFnInfo, rv reflect.Value) {
+	rv2i(rv).(Selfer).CodecDecodeSelf(d)
 }
 
-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{}) {
-	if indir == -1 {
-		v = rv.Addr().Interface()
-	} else if indir == 0 {
-		v = rv.Interface()
-	} else {
-		for j := int8(0); j < indir; j++ {
-			if rv.IsNil() {
-				rv.Set(reflect.New(rv.Type().Elem()))
-			}
-			rv = rv.Elem()
-		}
-		v = rv.Interface()
-	}
-	return
-}
-
-func (f *decFnInfo) selferUnmarshal(rv reflect.Value) {
-	f.getValueForUnmarshalInterface(rv, f.ti.csIndir).(Selfer).CodecDecodeSelf(f.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 := rv2i(rv).(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 := rv2i(rv).(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 := rv2i(rv).(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
 	}
 	// We cannot decode non-nil stream value into nil interface with methods (e.g. io.Reader).
-	// if num := f.ti.rt.NumMethod(); num > 0 {
 	if f.ti.numMeth > 0 {
 		d.errorf("cannot decode non-nil codec value into nil %v (%v methods)", f.ti.rt, f.ti.numMeth)
 		return
@@ -577,265 +964,311 @@ 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]
-		} 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]
+		// if json, default to a map type with string keys
+		mtid := d.mtid
+		if mtid == 0 {
+			if d.jsms {
+				mtid = mapStrIntfTypId
+			} else {
+				mtid = mapIntfIntfTypId
+			}
+		}
+		if mtid == mapIntfIntfTypId {
+			n.initContainers()
+			if n.lm < arrayCacheLen {
+				n.ma[n.lm] = nil
+				rvn = n.rma[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 mtid == mapStrIntfTypId { // for json performance
+			n.initContainers()
+			if n.ln < arrayCacheLen {
+				n.na[n.ln] = nil
+				rvn = n.rna[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.MapType).Elem()
-			d.decodeValue(rvn, nil)
+			if d.mtr {
+				rvn = reflect.New(d.h.MapType)
+				d.decode(rv2i(rvn))
+				rvn = rvn.Elem()
+			} else {
+				rvn = reflect.New(d.h.MapType).Elem()
+				d.decodeValue(rvn, nil, true)
+			}
 		}
 	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)
-			rvn = reflect.ValueOf(v2).Elem()
-			n.ss = n.ss[:l]
+			n.initContainers()
+			if n.ls < arrayCacheLen {
+				n.sa[n.ls] = nil
+				rvn = n.rsa[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).Elem()
-			d.decodeValue(rvn, nil)
+			if d.str {
+				rvn = reflect.New(d.h.SliceType)
+				d.decode(rv2i(rvn))
+				rvn = rvn.Elem()
+			} else {
+				rvn = reflect.New(d.h.SliceType).Elem()
+				d.decodeValue(rvn, nil, 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]
+			n.initContainers()
+			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.ri
 	case valueTypeUint:
-		rvn = reflect.ValueOf(&n.u).Elem()
+		rvn = n.ru
 	case valueTypeFloat:
-		rvn = reflect.ValueOf(&n.f).Elem()
+		rvn = n.rf
 	case valueTypeBool:
-		rvn = reflect.ValueOf(&n.b).Elem()
+		rvn = n.rb
 	case valueTypeString, valueTypeSymbol:
-		rvn = reflect.ValueOf(&n.s).Elem()
+		rvn = n.rs
 	case valueTypeBytes:
-		rvn = reflect.ValueOf(&n.l).Elem()
-	case valueTypeTimestamp:
-		rvn = reflect.ValueOf(&n.t).Elem()
+		rvn = n.rl
+	case valueTypeTime:
+		rvn = n.rt
 	default:
-		panic(fmt.Errorf("kInterfaceNaked: unexpected valueType: %d", n.v))
+		panicv.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() {
-			rv.Set(rvn)
-		}
-	} else if f.d.h.InterfaceReset {
-		rvn = f.kInterfaceNaked()
+	if rv.IsNil() || d.h.InterfaceReset {
+		// check if mapping to a type: if so, initialize it and move on
+		rvn = d.h.intf2impl(f.ti.rtid)
 		if rvn.IsValid() {
 			rv.Set(rvn)
 		} else {
-			// reset to zero value based on current type in there.
-			rv.Set(reflect.Zero(rv.Elem().Type()))
+			rvn = d.kInterfaceNaked(f)
+			if rvn.IsValid() {
+				rv.Set(rvn)
+			} else if d.h.InterfaceReset {
+				// reset to zero value based on current type in there.
+				rv.Set(reflect.Zero(rv.Elem().Type()))
+			}
+			return
 		}
 	} else {
+		// now we have a non-nil interface value, meaning it contains a type
 		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)
-		}
 	}
+	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)
+		return
+	}
+
+	rvn2 = reflect.New(rvn.Type()).Elem()
+	rvn2.Set(rvn)
+	d.decodeValue(rvn2, nil, true)
+	rv.Set(rvn2)
 }
 
-func (f *decFnInfo) kStruct(rv reflect.Value) {
+func decStructFieldKey(dd decDriver, keyType valueType, b *[decScratchByteArrayLen]byte) (rvkencname []byte) {
+	// use if-else-if, not switch (which compiles to binary-search)
+	// since keyType is typically valueTypeString, branch prediction is pretty good.
+
+	if keyType == valueTypeString {
+		rvkencname = dd.DecodeStringAsBytes()
+	} else if keyType == valueTypeInt {
+		rvkencname = strconv.AppendInt(b[:0], dd.DecodeInt64(), 10)
+	} else if keyType == valueTypeUint {
+		rvkencname = strconv.AppendUint(b[:0], dd.DecodeUint64(), 10)
+	} else if keyType == valueTypeFloat {
+		rvkencname = strconv.AppendFloat(b[:0], dd.DecodeFloat64(), 'f', -1, 64)
+	} else {
+		rvkencname = dd.DecodeStringAsBytes()
+	}
+	return rvkencname
+}
+
+func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 	fti := f.ti
-	d := f.d
 	dd := d.d
-	cr := d.cr
+	elemsep := d.esep
+	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
+		tisfi := fti.sfiSort
 		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)
-				}
+
+		var rvkencname []byte
+		for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+			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)
-				}
+			rvkencname = decStructFieldKey(dd, fti.keyType, &d.b)
+			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, true)
+				}
+			} else {
+				d.structFieldNotFound(-1, stringView(rvkencname))
+			}
+			// keepAlive4StringView(rvkencnameB) // 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() {
+		for j, si := range fti.sfiSrc {
+			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, true)
 			}
 		}
-		if containerLen > len(fti.sfip) {
+		if containerLen > len(fti.sfiSrc) {
 			// read remaining values and throw away
-			for j := len(fti.sfip); j < containerLen; j++ {
-				if cr != nil {
-					cr.sendContainerState(containerArrayElem)
+			for j := len(fti.sfiSrc); j < containerLen; j++ {
+				if elemsep {
+					dd.ReadArrayElem()
 				}
 				d.structFieldNotFound(j, "")
 			}
 		}
-		if cr != nil {
-			cr.sendContainerState(containerArrayEnd)
-		}
+		dd.ReadArrayEnd()
 	} else {
-		f.d.error(onlyMapOrArrayCanDecodeIntoStructErr)
+		d.errorstr(errstrOnlyMapOrArrayCanDecodeIntoStruct)
 		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
+	if f.seq == seqTypeChan && ti.chandir&uint8(reflect.SendDir) == 0 {
+		d.errorf("receive-only channel cannot be decoded")
+	}
 	dd := d.d
-	rtelem0 := ti.rt.Elem()
+	rtelem0 := ti.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/string in stream must decode into slice/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)
+			irv := rv2i(rv)
+			ch, ok := irv.(chan<- byte)
+			if !ok {
+				ch = irv.(chan byte)
+			}
 			for _, b := range bs2 {
 				ch <- b
 			}
 		} else {
 			rvbs := rv.Bytes()
-			bs2 := dd.DecodeBytes(rvbs, false, false)
-			if rvbs == nil && bs2 != nil || rvbs != nil && bs2 == nil || len(bs2) != len(rvbs) {
+			bs2 := dd.DecodeBytes(rvbs, false)
+			// if rvbs == nil && bs2 != nil || rvbs != nil && bs2 == nil || len(bs2) != len(rvbs) {
+			if !(len(bs2) > 0 && len(bs2) == len(rvbs) && &bs2[0] == &rvbs[0]) {
 				if rv.CanSet() {
 					rv.SetBytes(bs2)
-				} else {
+				} else if len(rvbs) > 0 && len(bs2) > 0 {
 					copy(rvbs, bs2)
 				}
 			}
@@ -847,199 +1280,225 @@ 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()
+	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 rv0, rv9 reflect.Value
-	rv0 = rv
-	rvChanged := false
+	var fn *codecFn
 
-	// 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
+	var rvCanset = rv.CanSet()
+	var rvChanged bool
+	var rv0 = rv
+	var rv9 reflect.Value
 
-			rvcap := rv.Cap()
-			rvlen = rv.Len()
-			if containerLenS > rvcap {
-				if f.seq == seqTypeArray {
-					d.arrayCannotExpand(rvlen, containerLenS)
-				} 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
+	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 rvCanset {
+					rv.SetLen(rvlen)
 				}
-				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 rvCanset {
+				rv = reflect.MakeSlice(ti.rt, rvlen, rvlen)
+				rvcap = rvlen
+				rvChanged = true
 			} 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)
+				d.errorf("cannot decode into non-settable slice")
+			}
+			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 rvCanset {
+				rv.SetLen(rvlen)
+			}
+			// else {
+			// rv = rv.Slice(0, rvlen)
+			// rvChanged = true
+			// d.errorf("cannot decode into non-settable slice")
+			// }
+		}
+	}
+
+	// consider creating new element once, and just decoding into it.
+	var rtelem0Zero reflect.Value
+	var rtelem0ZeroValid bool
+	var decodeAsNil bool
+	var j int
+	d.cfer()
+	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 if f.seq == seqTypeSlice {
+				rvlen = decDefSliceCap
+			} else {
+				rvlen = decDefChanCap
+			}
+			if rvCanset {
+				if f.seq == seqTypeSlice {
+					rv = reflect.MakeSlice(ti.rt, rvlen, rvlen)
+					rvChanged = true
+				} else { // chan
+					// xdebugf(">>>>>> haslen = %v, make chan of type '%v' with length: %v", hasLen, ti.rt, rvlen)
+					rv = reflect.MakeChan(ti.rt, rvlen)
+					rvChanged = true
 				}
+			} else {
+				d.errorf("cannot decode into non-settable slice")
 			}
 		}
-		if f.seq == seqTypeSlice {
-			if j < 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 fn == nil {
+				fn = d.cf.get(rtelem, true, true)
+			}
+			d.decodeValue(rv9, fn, true)
+			// xdebugf(">>>> rv9 sent on %v during decode: %v, with len=%v, cap=%v", rv.Type(), rv9, rv.Len(), rv.Cap())
+			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)) // append logic + varargs
+					var rvcap2 int
+					var rvErrmsg2 string
+					rv9, rvcap2, rvChanged, rvErrmsg2 =
+						expandSliceRV(rv, ti.rt, rvCanset, rtelem0Size, 1, rvlen, rvcap)
+					if rvErrmsg2 != "" {
+						d.errorf(rvErrmsg2)
+					}
+					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 fn == nil {
+					fn = d.cf.get(rtelem, true, true)
+				}
+				d.decodeValue(rv9, fn, true)
+			}
+		}
+	}
+	if f.seq == seqTypeSlice {
+		if j < rvlen {
+			if rv.CanSet() {
 				rv.SetLen(j)
-			} else if j == 0 && rv.IsNil() {
+			} else if rvCanset {
+				rv = rv.Slice(0, j)
+				rvChanged = true
+			} // else { d.errorf("kSlice: cannot change non-settable slice") }
+			rvlen = j
+		} else if j == 0 && rv.IsNil() {
+			if rvCanset {
 				rv = reflect.MakeSlice(ti.rt, 0, 0)
 				rvChanged = true
-			}
+			} // else { d.errorf("kSlice: cannot change non-settable slice") }
 		}
 	}
 	slh.End()
 
-	if rvChanged {
+	if rvChanged { // infers rvCanset=true, so it can be reset
 		rv0.Set(rv)
 	}
 }
 
-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.esep
 	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()
+	ktype, vtype := ti.key, ti.elem
+	ktypeId := rt2id(ktype)
 	vtypeKind := vtype.Kind()
-	var keyFn, valFn *decFn
-	var xtyp reflect.Type
-	for xtyp = ktype; 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() {
 	}
-	keyFn = d.getDecFn(xtyp, true, true)
-	for xtyp = vtype; xtyp.Kind() == reflect.Ptr; xtyp = xtyp.Elem() {
+
+	for vtypeLo = vtype; vtypeLo.Kind() == reflect.Ptr; vtypeLo = vtypeLo.Elem() {
 	}
-	valFn = d.getDecFn(xtyp, true, true)
+
 	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
@@ -1047,118 +1506,124 @@ 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
+	d.cfer()
+	for j := 0; (hasLen && j < containerLen) || !(hasLen || dd.CheckBreak()); j++ {
+		if rvkMut || !rvkp.IsValid() {
+			rvkp = reflect.New(ktype)
+			rvk = rvkp.Elem()
+		}
+		if elemsep {
+			dd.ReadMapElemKey()
+		}
+		if false && dd.TryDecodeAsNil() { // nil cannot be a map key, so disregard this block
+			// Previously, if a nil key, we just ignored the mapped value and continued.
+			// However, that makes the result of encoding and then decoding map[intf]intf{nil:nil}
+			// to be an empty map.
+			// Instead, we treat a nil key as the zero value of the type.
+			rvk.Set(reflect.Zero(ktype))
+		} else if ktypeIsString {
+			kstrbs = dd.DecodeStringAsBytes()
+			rvk.SetString(stringView(kstrbs))
+			// NOTE: if doing an insert, you MUST use a real string (not stringview)
+		} else {
+			if keyFn == nil {
+				keyFn = d.cf.get(ktypeLo, true, true)
 			}
-			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
-					}
+			d.decodeValue(rvk, keyFn, true)
+		}
+		// special case if a byte array.
+		if ktypeIsIntf {
+			if rvk2 := rvk.Elem(); rvk2.IsValid() {
+				if rvk2.Type() == uint8SliceTyp {
+					rvk = reflect.ValueOf(d.string(rvk2.Bytes()))
 				} else {
-					if rvz.IsValid() {
-						rvz.Set(reflect.Zero(vtype))
-					} else {
-						rvz = reflect.New(vtype).Elem()
-					}
-					rvv = rvz
+					rvk = rvk2
 				}
-			} 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)
 			}
 		}
-	} 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 valFn == nil {
+			valFn = d.cf.get(vtypeLo, true, true)
+		}
+		d.decodeValue(rvv, valFn, 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.
@@ -1169,7 +1634,7 @@ type decRtidFn struct {
 // primitives are being decoded.
 //
 // maps and arrays are not handled by this mechanism.
-// However, RawExt is, and we accomodate for extensions that decode
+// However, RawExt is, and we accommodate for extensions that decode
 // RawExt from DecodeNaked, but need to decode the value subsequently.
 // kInterfaceNaked and swallow, which call DecodeNaked, handle this caveat.
 //
@@ -1179,49 +1644,198 @@ type decRtidFn struct {
 //
 // kInterfaceNaked will ensure that there is no allocation for the common
 // uses.
+
+type decNakedContainers struct {
+	// array/stacks for reducing allocation
+	// keep arrays at the bottom? Chance is that they are not used much.
+	ia [arrayCacheLen]interface{}
+	ma [arrayCacheLen]map[interface{}]interface{}
+	na [arrayCacheLen]map[string]interface{}
+	sa [arrayCacheLen][]interface{}
+
+	// ria [arrayCacheLen]reflect.Value // not needed, as we decode directly into &ia[n]
+	rma, rna, rsa [arrayCacheLen]reflect.Value // reflect.Value mapping to above
+}
+
+func (n *decNakedContainers) init() {
+	for i := 0; i < arrayCacheLen; i++ {
+		// n.ria[i] = reflect.ValueOf(&(n.ia[i])).Elem()
+		n.rma[i] = reflect.ValueOf(&(n.ma[i])).Elem()
+		n.rna[i] = reflect.ValueOf(&(n.na[i])).Elem()
+		n.rsa[i] = reflect.ValueOf(&(n.sa[i])).Elem()
+	}
+}
+
 type decNaked struct {
 	// r RawExt // used for RawExt, uint, []byte.
+
+	// primitives below
 	u uint64
 	i int64
 	f float64
 	l []byte
 	s string
+
+	// ---- cpu cache line boundary?
 	t time.Time
 	b bool
-	v valueType
 
-	// stacks for reducing allocation
-	is []interface{}
-	ms []map[interface{}]interface{}
-	ns []map[string]interface{}
-	ss [][]interface{}
-	// rs []RawExt
+	// state
+	v              valueType
+	li, lm, ln, ls int8
+	inited         bool
 
-	// 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{}
-	// ra [2]RawExt
+	*decNakedContainers
+
+	ru, ri, rf, rl, rs, rb, rt reflect.Value // mapping to the primitives above
+
+	// _ [6]uint64 // padding // no padding - rt goes into next cache line
+}
+
+func (n *decNaked) init() {
+	if n.inited {
+		return
+	}
+	n.ru = reflect.ValueOf(&n.u).Elem()
+	n.ri = reflect.ValueOf(&n.i).Elem()
+	n.rf = reflect.ValueOf(&n.f).Elem()
+	n.rl = reflect.ValueOf(&n.l).Elem()
+	n.rs = reflect.ValueOf(&n.s).Elem()
+	n.rt = reflect.ValueOf(&n.t).Elem()
+	n.rb = reflect.ValueOf(&n.b).Elem()
+
+	n.inited = true
+	// n.rr[] = reflect.ValueOf(&n.)
+}
+
+func (n *decNaked) initContainers() {
+	if n.decNakedContainers == nil {
+		n.decNakedContainers = new(decNakedContainers)
+		n.decNakedContainers.init()
+	}
 }
 
 func (n *decNaked) reset() {
-	if n.ss != nil {
-		n.ss = n.ss[:0]
+	if n == nil {
+		return
 	}
-	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]
+	n.li, n.lm, n.ln, n.ls = 0, 0, 0, 0
+}
+
+type rtid2rv struct {
+	rtid uintptr
+	rv   reflect.Value
+}
+
+// --------------
+
+type decReaderSwitch struct {
+	rb bytesDecReader
+	// ---- cpu cache line boundary?
+	ri *ioDecReader
+	bi *bufioDecReader
+
+	mtr, str bool // whether maptype or slicetype are known types
+
+	be    bool // is binary encoding
+	bytes bool // is bytes reader
+	js    bool // is json handle
+	jsms  bool // is json handle, and MapKeyAsString
+	esep  bool // has elem separators
+	bufio bool // is this a bufioDecReader?
+}
+
+/*
+
+func (z *decReaderSwitch) unreadn1() {
+	if z.bytes {
+		z.rb.unreadn1()
+	} else if z.bufio {
+		z.bi.unreadn1()
+	} else {
+		z.ri.unreadn1()
 	}
 }
+func (z *decReaderSwitch) readx(n int) []byte {
+	if z.bytes {
+		return z.rb.readx(n)
+	} else if z.bufio {
+		return z.bi.readx(n)
+	}
+	return z.ri.readx(n)
+}
+func (z *decReaderSwitch) readb(s []byte) {
+	if z.bytes {
+		z.rb.readb(s)
+	} else if z.bufio {
+		z.bi.readb(s)
+	} else {
+		z.ri.readb(s)
+	}
+}
+func (z *decReaderSwitch) readn1() uint8 {
+	if z.bytes {
+		return z.rb.readn1()
+	} else if z.bufio {
+		return z.bi.readn1()
+	}
+	return z.ri.readn1()
+}
+func (z *decReaderSwitch) numread() int {
+	if z.bytes {
+		return z.rb.numread()
+	} else if z.bufio {
+		return z.bi.numread()
+	}
+	return z.ri.numread()
+}
+func (z *decReaderSwitch) track() {
+	if z.bytes {
+		z.rb.track()
+	} else if z.bufio {
+		z.bi.track()
+	} else {
+		z.ri.track()
+	}
+}
+func (z *decReaderSwitch) stopTrack() []byte {
+	if z.bytes {
+		return z.rb.stopTrack()
+	} else if z.bufio {
+		return z.bi.stopTrack()
+	}
+	return z.ri.stopTrack()
+}
+func (z *decReaderSwitch) skip(accept *bitset256) (token byte) {
+	if z.bytes {
+		return z.rb.skip(accept)
+	} else if z.bufio {
+		return z.bi.skip(accept)
+	}
+	return z.ri.skip(accept)
+}
+func (z *decReaderSwitch) readTo(in []byte, accept *bitset256) (out []byte) {
+	if z.bytes {
+		return z.rb.readTo(in, accept)
+	} else if z.bufio {
+		return z.bi.readTo(in, accept)
+	}
+	return z.ri.readTo(in, accept)
+}
+func (z *decReaderSwitch) readUntil(in []byte, stop byte) (out []byte) {
+	if z.bytes {
+		return z.rb.readUntil(in, stop)
+	} else if z.bufio {
+		return z.bi.readUntil(in, stop)
+	}
+	return z.ri.readUntil(in, stop)
+}
+
+*/
 
 // A Decoder reads and decodes an object from an input stream in the codec format.
 type Decoder struct {
+	panicHdl
 	// hopefully, reduce derefencing cost by laying the decReader inside the Decoder.
 	// Try to put things that go together to fit within a cache line (8 words).
 
@@ -1229,30 +1843,31 @@ type Decoder struct {
 	// 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
-	hh Handle
-
-	be    bool // is binary encoding
-	bytes bool // is bytes reader
-	js    bool // is json handle
-
-	rb bytesDecReader
-	ri ioDecReader
-	cr containerStateRecv
-
-	s []decRtidFn
-	f map[uintptr]*decFn
-
-	// _  uintptr // for alignment purposes, so next one starts from a cache line
-
+	// bi *bufioDecReader
 	// 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
+	n   *decNaked
+	nsp *sync.Pool
+
+	// ---- cpu cache line boundary?
+	decReaderSwitch
+
+	// ---- cpu cache line boundary?
+	codecFnPooler
+	// cr containerStateRecv
+	err error
+
+	h *BasicHandle
+	_ [1]uint64 // padding
+
+	// ---- cpu cache line boundary?
+	b  [decScratchByteArrayLen]byte // scratch buffer, used by Decoder and xxxEncDrivers
+	is map[string]string            // used for interning strings
+
+	// padding - false sharing help // modify 232 if Decoder struct changes.
+	// _ [cacheLineSize - 232%cacheLineSize]byte
 }
 
 // NewDecoder returns a Decoder for decoding a stream of bytes from an io.Reader.
@@ -1273,63 +1888,107 @@ 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]
-	_, d.js = h.(*JsonHandle)
+	d := &Decoder{h: h.getBasicHandle(), err: errDecoderNotInitialized}
+	d.hh = h
+	d.be = h.isBinary()
+	// NOTE: do not initialize d.n here. It is lazily initialized in d.naked()
+	var jh *JsonHandle
+	jh, d.js = h.(*JsonHandle)
+	if d.js {
+		d.jsms = jh.MapKeyAsString
+	}
+	d.esep = d.hh.hasElemSeparators()
 	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
 }
 
 func (d *Decoder) resetCommon() {
+	// d.r = &d.decReaderSwitch
 	d.n.reset()
 	d.d.reset()
-	// reset all things which were cached from the Handle,
-	// but could be changed.
+	d.err = nil
+	// reset all things which were cached from the Handle, but could change
 	d.mtid, d.stid = 0, 0
+	d.mtr, d.str = false, false
 	if d.h.MapType != nil {
-		d.mtid = reflect.ValueOf(d.h.MapType).Pointer()
+		d.mtid = rt2id(d.h.MapType)
+		d.mtr = fastpathAV.index(d.mtid) != -1
 	}
 	if d.h.SliceType != nil {
-		d.stid = reflect.ValueOf(d.h.SliceType).Pointer()
+		d.stid = rt2id(d.h.SliceType)
+		d.str = fastpathAV.index(d.stid) != -1
 	}
 }
 
+// Reset the Decoder with a new Reader to decode from,
+// clearing all state from last run(s).
 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 r == nil {
+		return
+	}
+	d.bytes = false
+	if d.h.ReaderBufferSize > 0 {
+		if d.bi == nil {
+			d.bi = new(bufioDecReader)
+		}
+		if cap(d.bi.buf) < d.h.ReaderBufferSize {
+			d.bi.buf = make([]byte, 0, d.h.ReaderBufferSize)
+		} else {
+			d.bi.buf = d.bi.buf[:0]
+		}
+		d.bi.reset(r)
+		d.r = d.bi
+		d.bufio = true
+	} else {
+		// d.ri.x = &d.b
+		// d.s = d.sa[:0]
+		if d.ri == nil {
+			d.ri = new(ioDecReader)
+		}
+		d.ri.reset(r)
+		d.r = d.ri
+		d.bufio = false
 	}
-	d.r = &d.ri
 	d.resetCommon()
 }
 
+// ResetBytes resets the Decoder with a new []byte to decode from,
+// clearing all state from last run(s).
 func (d *Decoder) ResetBytes(in []byte) {
-	// d.s = d.sa[:0]
+	if in == nil {
+		return
+	}
+	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)
-// 	}
-// }
+// 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
+}
 
 // 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
@@ -1381,427 +2040,292 @@ func (d *Decoder) ResetBytes(in []byte) {
 // However, when decoding a stream nil, we reset the destination container
 // to its "zero" value (e.g. nil for slice/map, etc).
 //
+// Note: we allow nil values in the stream anywhere except for map keys.
+// A nil value in the encoded stream where a map key is expected is treated as an error.
 func (d *Decoder) Decode(v interface{}) (err error) {
-	defer panicToErr(&err)
-	d.decode(v)
+	defer d.deferred(&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() {
+		setZero(v)
+	} else {
+		d.decode(v)
+	}
+	d.alwaysAtEnd()
+	// xprintf(">>>>>>>> >>>>>>>> num decFns: %v\n", d.cf.sn)
 }
 
+func (d *Decoder) deferred(err1 *error) {
+	d.alwaysAtEnd()
+	if recoverPanicToErr {
+		if x := recover(); x != nil {
+			panicValToErr(d, x, err1)
+			panicValToErr(d, x, &d.err)
+		}
+	}
+}
+
+func (d *Decoder) alwaysAtEnd() {
+	if d.n != nil {
+		// if n != nil, then nsp != nil (they are always set together)
+		d.nsp.Put(d.n)
+		d.n, d.nsp = nil, nil
+	}
+	d.codecFnPooler.alwaysAtEnd()
+}
+
+// // 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.esep
 	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 {
+			n.initContainers()
+			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 setZero(iv interface{}) {
+	if iv == nil || definitelyNil(iv) {
+		return
+	}
+	var canDecode bool
+	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 *time.Time:
+		*v = time.Time{}
+	case reflect.Value:
+		if v, canDecode = isDecodeable(v); canDecode && 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) {
+			v := reflect.ValueOf(iv)
+			if v, canDecode = isDecodeable(v); canDecode && 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 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.errorstr(errstrCannotDecodeIntoNil)
+		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, true)
 
 	case *string:
-
 		*v = d.d.DecodeString()
 	case *bool:
 		*v = d.d.DecodeBool()
 	case *int:
-		*v = int(d.d.DecodeInt(intBitsize))
+		*v = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 	case *int8:
-		*v = int8(d.d.DecodeInt(8))
+		*v = int8(chkOvf.IntV(d.d.DecodeInt64(), 8))
 	case *int16:
-		*v = int16(d.d.DecodeInt(16))
+		*v = int16(chkOvf.IntV(d.d.DecodeInt64(), 16))
 	case *int32:
-		*v = int32(d.d.DecodeInt(32))
+		*v = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 	case *int64:
-		*v = d.d.DecodeInt(64)
+		*v = d.d.DecodeInt64()
 	case *uint:
-		*v = uint(d.d.DecodeUint(uintBitsize))
+		*v = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
 	case *uint8:
-		*v = uint8(d.d.DecodeUint(8))
+		*v = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 	case *uint16:
-		*v = uint16(d.d.DecodeUint(16))
+		*v = uint16(chkOvf.UintV(d.d.DecodeUint64(), 16))
 	case *uint32:
-		*v = uint32(d.d.DecodeUint(32))
+		*v = uint32(chkOvf.UintV(d.d.DecodeUint64(), 32))
 	case *uint64:
-		*v = d.d.DecodeUint(64)
+		*v = d.d.DecodeUint64()
 	case *float32:
-		*v = float32(d.d.DecodeFloat(true))
+		f64 := d.d.DecodeFloat64()
+		if chkOvf.Float32(f64) {
+			d.errorf("float32 overflow: %v", f64)
+		}
+		*v = float32(f64)
 	case *float64:
-		*v = d.d.DecodeFloat(false)
+		*v = d.d.DecodeFloat64()
 	case *[]uint8:
-		*v = d.d.DecodeBytes(*v, false, false)
+		*v = d.d.DecodeBytes(*v, false)
+	case []uint8:
+		b := d.d.DecodeBytes(v, false)
+		if !(len(b) > 0 && len(b) == len(v) && &b[0] == &v[0]) {
+			copy(v, b)
+		}
+	case *time.Time:
+		*v = d.d.DecodeTime()
+	case *Raw:
+		*v = d.rawBytes()
 
 	case *interface{}:
-		d.decodeValueNotNil(reflect.ValueOf(iv).Elem(), nil)
+		d.decodeValue(reflect.ValueOf(iv).Elem(), nil, true)
+		// 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)
+			// 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, 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 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.cfer().get(rv.Type(), chkAll, true) // chkAll, chkAll)
+	}
+	if fn.i.addrD {
+		if rvpValid {
+			fn.fd(d, &fn.i, rvp)
+		} else if rv.CanAddr() {
+			fn.fd(d, &fn.i, rv.Addr())
+		} else if !fn.i.addrF {
+			fn.fd(d, &fn.i, rv)
+		} else {
+			d.errorf("cannot decode into a non-pointer value")
 		}
-		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 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) {
+	// NOTE: rvkencname may be a stringView, so don't pass it to another function.
 	if d.h.ErrorIfNoField {
 		if index >= 0 {
 			d.errorf("no matching struct field found when decoding stream array at index %v", index)
 			return
 		} else if rvkencname != "" {
-			d.errorf("no matching struct field found when decoding stream map with key %s", rvkencname)
+			d.errorf("no matching struct field found when decoding stream map with key " + rvkencname)
 			return
 		}
 	}
@@ -1814,63 +2338,88 @@ 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)
+		d.errorstr(errstrCannotDecodeIntoNil)
 		return
 	}
 	if !rv.CanInterface() {
 		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)
-}
-
-func (d *Decoder) error(err error) {
-	panic(err)
-}
-
-func (d *Decoder) errorf(format string, params ...interface{}) {
-	params2 := make([]interface{}, len(params)+1)
-	params2[0] = d.r.numread()
-	copy(params2[1:], params)
-	err := fmt.Errorf("[pos %d]: "+format, params2...)
-	panic(err)
+	rvi := rv2i(rv)
+	rvk := rv.Kind()
+	d.errorf("cannot decode into value of kind: %v, type: %T, %v", rvk, rvi, rvi)
+	return
 }
 
+// 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) rawBytes() []byte {
+	// ensure that this is not a view into the bytes
+	// i.e. make new copy always.
+	bs := d.nextValueBytes()
+	bs2 := make([]byte, len(bs))
+	copy(bs2, bs)
+	return bs2
+}
+
+func (d *Decoder) wrapErrstr(v interface{}, err *error) {
+	*err = fmt.Errorf("%s decode error [pos %d]: %v", d.hh.Name(), d.r.numread(), v)
+}
+
+// NumBytesRead returns the number of bytes read
+func (d *Decoder) NumBytesRead() int {
+	return d.r.numread()
 }
 
 // --------------------------------------------------
@@ -1886,12 +2435,13 @@ type decSliceHelper struct {
 func (d *Decoder) decSliceHelperStart() (x decSliceHelper, clen int) {
 	dd := d.d
 	ctyp := dd.ContainerType()
-	if ctyp == valueTypeArray {
+	switch ctyp {
+	case valueTypeArray:
 		x.array = true
 		clen = dd.ReadArrayStart()
-	} else if ctyp == valueTypeMap {
+	case valueTypeMap:
 		clen = dd.ReadMapStart() * 2
-	} else {
+	default:
 		d.errorf("only encoded map or array can be decoded into a slice (%d)", ctyp)
 	}
 	// x.ct = ctyp
@@ -1900,45 +2450,47 @@ 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 {
+		x.d.d.ReadMapElemKey()
 	} else {
-		if index%2 == 0 {
-			cr.sendContainerState(containerMapKey)
-		} 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
 }
 
@@ -1962,11 +2514,14 @@ 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
 	}
+	if unit == 0 {
+		return clen
+	}
 	if maxlen <= 0 {
 		// no maxlen defined. Use maximum of 256K memory, with a floor of 4K items.
 		// maxlen = 256 * 1024 / unit
@@ -1981,39 +2536,57 @@ 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 expandSliceRV(s reflect.Value, st reflect.Type, canChange bool, stElemSize, num, slen, scap int) (
+	s2 reflect.Value, scap2 int, changed bool, err string) {
+	l1 := slen + num // new slice length
+	if l1 < slen {
+		err = errmsgExpandSliceOverflow
+		return
+	}
+	if l1 <= scap {
+		if s.CanSet() {
+			s.SetLen(l1)
+		} else if canChange {
+			s2 = s.Slice(0, l1)
+			scap2 = scap
+			changed = true
+		} else {
+			err = errmsgExpandSliceCannotChange
+			return
+		}
+		return
+	}
+	if !canChange {
+		err = errmsgExpandSliceCannotChange
+		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 a874c744b..fb64d4394 100644
--- a/vendor/github.com/ugorji/go/codec/encode.go
+++ b/vendor/github.com/ugorji/go/codec/encode.go
@@ -1,42 +1,24 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 package codec
 
 import (
+	"bufio"
 	"encoding"
+	"errors"
 	"fmt"
 	"io"
 	"reflect"
 	"sort"
+	"strconv"
 	"sync"
+	"time"
 )
 
-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
-
-const (
-	// AsSymbolDefault is default.
-	// Currently, this means only encode struct field names as symbols.
-	// The default is subject to change.
-	AsSymbolDefault AsSymbolFlag = iota
-
-	// AsSymbolAll means encode anything which could be a symbol as a symbol.
-	AsSymbolAll = 0xfe
-
-	// AsSymbolNone means do not encode anything as a symbol.
-	AsSymbolNone = 1 << iota
-
-	// AsSymbolMapStringKeys means encode keys in map[string]XXX as symbols.
-	AsSymbolMapStringKeysFlag
-
-	// AsSymbolStructFieldName means encode struct field names as symbols.
-	AsSymbolStructFieldNameFlag
-)
+var errEncoderNotInitialized = errors.New("Encoder not initialized")
 
 // encWriter abstracts writing to a byte array or to an io.Writer.
 type encWriter interface {
@@ -49,8 +31,6 @@ type encWriter interface {
 
 // encDriver abstracts the actual codec (binc vs msgpack, etc)
 type encDriver interface {
-	IsBuiltinType(rt uintptr) bool
-	EncodeBuiltin(rt uintptr, v interface{})
 	EncodeNil()
 	EncodeInt(i int64)
 	EncodeUint(i uint64)
@@ -60,38 +40,78 @@ 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)
 	EncodeString(c charEncoding, v string)
-	EncodeSymbol(v string)
+	// EncodeSymbol(v string)
 	EncodeStringBytes(c charEncoding, v []byte)
-	//TODO
+	EncodeTime(time.Time)
 	//encBignum(f *big.Int)
 	//encStringRunes(c charEncoding, v []rune)
+	WriteArrayStart(length int)
+	WriteArrayElem()
+	WriteArrayEnd()
+	WriteMapStart(length int)
+	WriteMapElemKey()
+	WriteMapElemValue()
+	WriteMapEnd()
 
 	reset()
-}
-
-type encDriverAsis interface {
-	EncodeAsis(v []byte)
-}
-
-type encNoSeparator struct{}
-
-func (_ encNoSeparator) EncodeEnd() {}
-
-type ioEncWriterWriter interface {
-	WriteByte(c byte) error
-	WriteString(s string) (n int, err error)
-	Write(p []byte) (n int, err error)
+	atEndOfEncode()
 }
 
 type ioEncStringWriter interface {
 	WriteString(s string) (n int, err error)
 }
 
+type encDriverAsis interface {
+	EncodeAsis(v []byte)
+}
+
+type encDriverNoopContainerWriter struct{}
+
+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 encDriverTrackContainerWriter struct {
+	c containerState
+}
+
+func (e *encDriverTrackContainerWriter) WriteArrayStart(length int) { e.c = containerArrayStart }
+func (e *encDriverTrackContainerWriter) WriteArrayElem()            { e.c = containerArrayElem }
+func (e *encDriverTrackContainerWriter) WriteArrayEnd()             { e.c = containerArrayEnd }
+func (e *encDriverTrackContainerWriter) WriteMapStart(length int)   { e.c = containerMapStart }
+func (e *encDriverTrackContainerWriter) WriteMapElemKey()           { e.c = containerMapKey }
+func (e *encDriverTrackContainerWriter) WriteMapElemValue()         { e.c = containerMapValue }
+func (e *encDriverTrackContainerWriter) WriteMapEnd()               { e.c = containerMapEnd }
+func (e *encDriverTrackContainerWriter) atEndOfEncode()             {}
+
+// type ioEncWriterWriter interface {
+// 	WriteByte(c byte) error
+// 	WriteString(s string) (n int, err error)
+// 	Write(p []byte) (n int, err error)
+// }
+
+// EncodeOptions captures configuration options during encode.
 type EncodeOptions struct {
-	// Encode a struct as an array, and not as a map
+	// WriterBufferSize is the size of the buffer used when writing.
+	//
+	// if > 0, we use a smart buffer internally for performance purposes.
+	WriterBufferSize int
+
+	// ChanRecvTimeout is the timeout used when selecting from a chan.
+	//
+	// Configuring this controls how we receive from a chan during the encoding process.
+	//   - If ==0, we only consume the elements currently available in the chan.
+	//   - if  <0, we consume until the chan is closed.
+	//   - If  >0, we consume until this timeout.
+	ChanRecvTimeout time.Duration
+
+	// StructToArray specifies to encode a struct as an array, and not as a map
 	StructToArray bool
 
 	// Canonical representation means that encoding a value will always result in the same
@@ -119,302 +139,204 @@ type EncodeOptions struct {
 	// This is opt-in, as there may be a performance hit to checking circular references.
 	CheckCircularRef bool
 
-	// AsSymbols defines what should be encoded as symbols.
+	// RecursiveEmptyCheck controls whether we descend into interfaces, structs and pointers
+	// when checking if a value is empty.
 	//
-	// Encoding as symbols can reduce the encoded size significantly.
-	//
-	// However, during decoding, each string to be encoded as a symbol must
-	// be checked to see if it has been seen before. Consequently, encoding time
-	// will increase if using symbols, because string comparisons has a clear cost.
-	//
-	// Sample values:
-	//   AsSymbolNone
-	//   AsSymbolAll
-	//   AsSymbolMapStringKeys
-	//   AsSymbolMapStringKeysFlag | AsSymbolStructFieldNameFlag
-	AsSymbols AsSymbolFlag
+	// Note that this may make OmitEmpty more expensive, as it incurs a lot more reflect calls.
+	RecursiveEmptyCheck bool
+
+	// Raw controls whether we encode Raw values.
+	// This is a "dangerous" option and must be explicitly set.
+	// If set, we blindly encode Raw values as-is, without checking
+	// if they are a correct representation of a value in that format.
+	// If unset, we error out.
+	Raw bool
+
+	// // AsSymbols defines what should be encoded as symbols.
+	// //
+	// // Encoding as symbols can reduce the encoded size significantly.
+	// //
+	// // However, during decoding, each string to be encoded as a symbol must
+	// // be checked to see if it has been seen before. Consequently, encoding time
+	// // will increase if using symbols, because string comparisons has a clear cost.
+	// //
+	// // Sample values:
+	// //   AsSymbolNone
+	// //   AsSymbolAll
+	// //   AsSymbolMapStringKeys
+	// //   AsSymbolMapStringKeysFlag | AsSymbolStructFieldNameFlag
+	// AsSymbols AsSymbolFlag
 }
 
 // ---------------------------------------------
 
-type simpleIoEncWriterWriter struct {
+// ioEncWriter implements encWriter and can write to an io.Writer implementation
+type ioEncWriter struct {
 	w  io.Writer
+	ww io.Writer
 	bw io.ByteWriter
 	sw ioEncStringWriter
+	fw ioFlusher
+	b  [8]byte
 }
 
-func (o *simpleIoEncWriterWriter) WriteByte(c byte) (err error) {
-	if o.bw != nil {
-		return o.bw.WriteByte(c)
-	}
-	_, err = o.w.Write([]byte{c})
+func (z *ioEncWriter) WriteByte(b byte) (err error) {
+	z.b[0] = b
+	_, err = z.w.Write(z.b[:1])
 	return
 }
 
-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)
-}
-
-// ----------------------------------------
-
-// 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
+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 _, 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 _, 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) atEndOfEncode() {}
-
-// ----------------------------------------
-
-// bytesEncWriter implements encWriter and can write to an byte slice.
-// It is used by Marshal function.
-type bytesEncWriter struct {
-	b   []byte
-	c   int     // cursor
-	out *[]byte // write out on atEndOfEncode
-}
-
-func (z *bytesEncWriter) writeb(s []byte) {
-	if len(s) > 0 {
-		c := z.grow(len(s))
-		copy(z.b[c:], s)
-	}
-}
-
-func (z *bytesEncWriter) writestr(s string) {
-	if len(s) > 0 {
-		c := z.grow(len(s))
-		copy(z.b[c:], s)
-	}
-}
-
-func (z *bytesEncWriter) writen1(b1 byte) {
-	c := z.grow(1)
-	z.b[c] = b1
-}
-
-func (z *bytesEncWriter) writen2(b1 byte, b2 byte) {
-	c := z.grow(2)
-	z.b[c] = b1
-	z.b[c+1] = b2
-}
-
-func (z *bytesEncWriter) atEndOfEncode() {
-	*(z.out) = z.b[:z.c]
-}
-
-func (z *bytesEncWriter) grow(n int) (oldcursor int) {
-	oldcursor = z.c
-	z.c = oldcursor + n
-	if z.c > len(z.b) {
-		if z.c > cap(z.b) {
-			// appendslice logic (if cap < 1024, *2, else *1.25): more expensive. many copy calls.
-			// bytes.Buffer model (2*cap + n): much better
-			// bs := make([]byte, 2*cap(z.b)+n)
-			bs := make([]byte, growCap(cap(z.b), 1, n))
-			copy(bs, z.b[:oldcursor])
-			z.b = bs
-		} else {
-			z.b = z.b[:cap(z.b)]
+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) 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 {
+		if err := z.fw.Flush(); err != nil {
+			panic(err)
 		}
 	}
-	return
 }
 
 // ---------------------------------------------
 
-type encFnInfo struct {
-	e     *Encoder
-	ti    *typeInfo
-	xfFn  Ext
-	xfTag uint64
-	seq   seqType
+// bytesEncAppender implements encWriter and can write to an byte slice.
+type bytesEncAppender struct {
+	b   []byte
+	out *[]byte
 }
 
-func (f *encFnInfo) builtin(rv reflect.Value) {
-	f.e.e.EncodeBuiltin(f.ti.rtid, rv.Interface())
+func (z *bytesEncAppender) writeb(s []byte) {
+	z.b = append(z.b, s...)
+}
+func (z *bytesEncAppender) writestr(s string) {
+	z.b = append(z.b, s...)
+}
+func (z *bytesEncAppender) writen1(b1 byte) {
+	z.b = append(z.b, b1)
+}
+func (z *bytesEncAppender) writen2(b1, b2 byte) {
+	z.b = append(z.b, b1, b2)
+}
+func (z *bytesEncAppender) atEndOfEncode() {
+	*(z.out) = z.b
+}
+func (z *bytesEncAppender) reset(in []byte, out *[]byte) {
+	z.b = in[:0]
+	z.out = out
 }
 
-func (f *encFnInfo) rawExt(rv reflect.Value) {
-	// rev := rv.Interface().(RawExt)
-	// f.e.e.EncodeRawExt(&rev, f.e)
-	var re *RawExt
-	if rv.CanAddr() {
-		re = rv.Addr().Interface().(*RawExt)
-	} else {
-		rev := rv.Interface().(RawExt)
-		re = &rev
-	}
-	f.e.e.EncodeRawExt(re, f.e)
+// ---------------------------------------------
+
+func (e *Encoder) rawExt(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeRawExt(rv2i(rv).(*RawExt), e)
 }
 
-func (f *encFnInfo) ext(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)
+func (e *Encoder) ext(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeExt(rv2i(rv), f.xfTag, f.xfFn, e)
 }
 
-func (f *encFnInfo) getValueForMarshalInterface(rv reflect.Value, indir int8) (v interface{}, proceed bool) {
-	if indir == 0 {
-		v = rv.Interface()
-	} else if indir == -1 {
-		// If a non-pointer was passed to Encode(), then that value is not addressable.
-		// Take addr if addresable, else copy value to an addressable value.
-		if rv.CanAddr() {
-			v = rv.Addr().Interface()
-		} 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)
-		}
-	} else {
-		for j := int8(0); j < indir; j++ {
-			if rv.IsNil() {
-				f.e.e.EncodeNil()
-				return
-			}
-			rv = rv.Elem()
-		}
-		v = rv.Interface()
-	}
-	return v, true
+func (e *Encoder) selferMarshal(f *codecFnInfo, rv reflect.Value) {
+	rv2i(rv).(Selfer).CodecEncodeSelf(e)
 }
 
-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) binaryMarshal(f *codecFnInfo, rv reflect.Value) {
+	bs, fnerr := rv2i(rv).(encoding.BinaryMarshaler).MarshalBinary()
+	e.marshal(bs, fnerr, false, cRAW)
 }
 
-func (f *encFnInfo) binaryMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.bmIndir); proceed {
-		bs, fnerr := v.(encoding.BinaryMarshaler).MarshalBinary()
-		f.e.marshal(bs, fnerr, false, c_RAW)
-	}
+func (e *Encoder) textMarshal(f *codecFnInfo, rv reflect.Value) {
+	bs, fnerr := rv2i(rv).(encoding.TextMarshaler).MarshalText()
+	e.marshal(bs, fnerr, false, cUTF8)
 }
 
-func (f *encFnInfo) textMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.tmIndir); proceed {
-		// debugf(">>>> encoding.TextMarshaler: %T", rv.Interface())
-		bs, fnerr := v.(encoding.TextMarshaler).MarshalText()
-		f.e.marshal(bs, fnerr, false, c_UTF8)
-	}
+func (e *Encoder) jsonMarshal(f *codecFnInfo, rv reflect.Value) {
+	bs, fnerr := rv2i(rv).(jsonMarshaler).MarshalJSON()
+	e.marshal(bs, fnerr, true, cUTF8)
 }
 
-func (f *encFnInfo) jsonMarshal(rv reflect.Value) {
-	if v, proceed := f.getValueForMarshalInterface(rv, f.ti.jmIndir); proceed {
-		bs, fnerr := v.(jsonMarshaler).MarshalJSON()
-		f.e.marshal(bs, fnerr, true, c_UTF8)
-	}
+func (e *Encoder) raw(f *codecFnInfo, rv reflect.Value) {
+	e.rawBytes(rv2i(rv).(Raw))
 }
 
-func (f *encFnInfo) kBool(rv reflect.Value) {
-	f.e.e.EncodeBool(rv.Bool())
+func (e *Encoder) kInvalid(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeNil()
 }
 
-func (f *encFnInfo) kString(rv reflect.Value) {
-	f.e.e.EncodeString(c_UTF8, rv.String())
+func (e *Encoder) kErr(f *codecFnInfo, rv reflect.Value) {
+	e.errorf("unsupported kind %s, for %#v", rv.Kind(), rv)
 }
 
-func (f *encFnInfo) kFloat64(rv reflect.Value) {
-	f.e.e.EncodeFloat64(rv.Float())
-}
-
-func (f *encFnInfo) kFloat32(rv reflect.Value) {
-	f.e.e.EncodeFloat32(float32(rv.Float()))
-}
-
-func (f *encFnInfo) kInt(rv reflect.Value) {
-	f.e.e.EncodeInt(rv.Int())
-}
-
-func (f *encFnInfo) kUint(rv reflect.Value) {
-	f.e.e.EncodeUint(rv.Uint())
-}
-
-func (f *encFnInfo) kInvalid(rv reflect.Value) {
-	f.e.e.EncodeNil()
-}
-
-func (f *encFnInfo) kErr(rv reflect.Value) {
-	f.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(cRAW, rv.Bytes())
 			return
 		}
 	}
-	cr := e.cr
-	rtelem := ti.rt.Elem()
-	l := rv.Len()
-	if ti.rtid == uint8SliceTypId || rtelem.Kind() == reflect.Uint8 {
+	if f.seq == seqTypeChan && ti.chandir&uint8(reflect.RecvDir) == 0 {
+		e.errorf("send-only channel cannot be encoded")
+	}
+	elemsep := e.esep
+	rtelem := ti.elem
+	rtelemIsByte := uint8TypId == rt2id(rtelem) // NOT rtelem.Kind() == reflect.Uint8
+	var l int
+	// if a slice, array or chan of bytes, treat specially
+	if rtelemIsByte {
 		switch f.seq {
+		case seqTypeSlice:
+			ee.EncodeStringBytes(cRAW, rv.Bytes())
 		case seqTypeArray:
-			// if l == 0 { e.e.encodeStringBytes(c_RAW, nil) } else
+			l = rv.Len()
 			if rv.CanAddr() {
-				e.e.EncodeStringBytes(c_RAW, rv.Slice(0, l).Bytes())
+				ee.EncodeStringBytes(cRAW, rv.Slice(0, l).Bytes())
 			} else {
 				var bs []byte
 				if l <= cap(e.b) {
@@ -423,118 +345,267 @@ 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(cRAW, bs)
 			}
-		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)
+			// for b := range rv2i(rv).(<-chan byte) { bs = append(bs, b) }
+			// ch := rv2i(rv).(<-chan byte) // fix error - that this is a chan byte, not a <-chan byte.
+
+			if rv.IsNil() {
+				ee.EncodeNil()
+				break
 			}
-			e.e.EncodeStringBytes(c_RAW, bs)
+			bs := e.b[:0]
+			irv := rv2i(rv)
+			ch, ok := irv.(<-chan byte)
+			if !ok {
+				ch = irv.(chan byte)
+			}
+
+		L1:
+			switch timeout := e.h.ChanRecvTimeout; {
+			case timeout == 0: // only consume available
+				for {
+					select {
+					case b := <-ch:
+						bs = append(bs, b)
+					default:
+						break L1
+					}
+				}
+			case timeout > 0: // consume until timeout
+				tt := time.NewTimer(timeout)
+				for {
+					select {
+					case b := <-ch:
+						bs = append(bs, b)
+					case <-tt.C:
+						// close(tt.C)
+						break L1
+					}
+				}
+			default: // consume until close
+				for b := range ch {
+					bs = append(bs, b)
+				}
+			}
+
+			ee.EncodeStringBytes(cRAW, bs)
 		}
 		return
 	}
 
+	// if chan, consume chan into a slice, and work off that slice.
+	var rvcs reflect.Value
+	if f.seq == seqTypeChan {
+		rvcs = reflect.Zero(reflect.SliceOf(rtelem))
+		timeout := e.h.ChanRecvTimeout
+		if timeout < 0 { // consume until close
+			for {
+				recv, recvOk := rv.Recv()
+				if !recvOk {
+					break
+				}
+				rvcs = reflect.Append(rvcs, recv)
+			}
+		} else {
+			cases := make([]reflect.SelectCase, 2)
+			cases[0] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: rv}
+			if timeout == 0 {
+				cases[1] = reflect.SelectCase{Dir: reflect.SelectDefault}
+			} else {
+				tt := time.NewTimer(timeout)
+				cases[1] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(tt.C)}
+			}
+			for {
+				chosen, recv, recvOk := reflect.Select(cases)
+				if chosen == 1 || !recvOk {
+					break
+				}
+				rvcs = reflect.Append(rvcs, recv)
+			}
+		}
+		rv = rvcs // TODO: ensure this doesn't mess up anywhere that rv of kind chan is expected
+	}
+
+	l = rv.Len()
 	if ti.mbs {
 		if l%2 == 1 {
 			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 {
+		var fn *codecFn
 		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)
+			fn = e.cfer().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)
-				} else {
-					e.encode(nil) // WE HAVE TO DO SOMETHING, so nil if nothing received.
-				}
-			} else {
-				e.encodeValue(rv.Index(j), fn)
-			}
+			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
-	tisfi := fti.sfip
+	elemsep := e.esep
+	tisfi := fti.sfiSrc
 	toMap := !(fti.toArray || e.h.StructToArray)
-	newlen := len(fti.sfi)
+	if toMap {
+		tisfi = fti.sfiSort
+	}
+	ee := e.e
+
+	sfn := structFieldNode{v: rv, update: false}
+	if toMap {
+		ee.WriteMapStart(len(tisfi))
+		if elemsep {
+			for _, si := range tisfi {
+				ee.WriteMapElemKey()
+				// ee.EncodeString(cUTF8, si.encName)
+				e.kStructFieldKey(fti.keyType, si)
+				ee.WriteMapElemValue()
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		} else {
+			for _, si := range tisfi {
+				// ee.EncodeString(cUTF8, si.encName)
+				e.kStructFieldKey(fti.keyType, si)
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		}
+		ee.WriteMapEnd()
+	} else {
+		ee.WriteArrayStart(len(tisfi))
+		if elemsep {
+			for _, si := range tisfi {
+				ee.WriteArrayElem()
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		} else {
+			for _, si := range tisfi {
+				e.encodeValue(sfn.field(si), nil, true)
+			}
+		}
+		ee.WriteArrayEnd()
+	}
+}
+
+func (e *Encoder) kStructFieldKey(keyType valueType, s *structFieldInfo) {
+	var m must
+	// use if-else-if, not switch (which compiles to binary-search)
+	// since keyType is typically valueTypeString, branch prediction is pretty good.
+	if keyType == valueTypeString {
+		if e.js && s.encNameAsciiAlphaNum { // keyType == valueTypeString
+			e.w.writen1('"')
+			e.w.writestr(s.encName)
+			e.w.writen1('"')
+		} else { // keyType == valueTypeString
+			e.e.EncodeString(cUTF8, s.encName)
+		}
+	} else if keyType == valueTypeInt {
+		e.e.EncodeInt(m.Int(strconv.ParseInt(s.encName, 10, 64)))
+	} else if keyType == valueTypeUint {
+		e.e.EncodeUint(m.Uint(strconv.ParseUint(s.encName, 10, 64)))
+	} else if keyType == valueTypeFloat {
+		e.e.EncodeFloat64(m.Float(strconv.ParseFloat(s.encName, 64)))
+	}
+}
+
+func (e *Encoder) kStruct(f *codecFnInfo, rv reflect.Value) {
+	fti := f.ti
+	elemsep := e.esep
+	tisfi := fti.sfiSrc
+	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.sfiSort
+	}
+	newlen := len(fti.sfiSort)
+	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)
+	//
+	// 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.
 
-	// if toMap, use the sorted array. If toArray, use unsorted array (to match sequence in struct)
-	if toMap {
-		tisfi = fti.sfi
+	var spool *sync.Pool
+	var poolv interface{}
+	var fkvs []sfiRv
+	// fmt.Printf(">>>>>>>>>>>>>> encode.kStruct: newlen: %d\n", newlen)
+	if newlen <= 8 {
+		spool, poolv = pool.sfiRv8()
+		fkvs = poolv.(*[8]sfiRv)[:newlen]
+	} else if newlen <= 16 {
+		spool, poolv = pool.sfiRv16()
+		fkvs = poolv.(*[16]sfiRv)[:newlen]
+	} else if newlen <= 32 {
+		spool, poolv = pool.sfiRv32()
+		fkvs = poolv.(*[32]sfiRv)[:newlen]
+	} else if newlen <= 64 {
+		spool, poolv = pool.sfiRv64()
+		fkvs = poolv.(*[64]sfiRv)[:newlen]
+	} else if newlen <= 128 {
+		spool, poolv = pool.sfiRv128()
+		fkvs = poolv.(*[128]sfiRv)[:newlen]
+	} else {
+		fkvs = make([]sfiRv, newlen)
 	}
+
 	newlen = 0
-	var kv stringRv
+	var kv sfiRv
+	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) {
+			if si.omitEmpty() && isEmptyValue(kv.r, e.h.TypeInfos, recur, recur) {
 				continue
 			}
-			kv.v = si.encName
+			kv.v = si // si.encName
 		} else {
 			// use the zero value.
 			// if a reference or struct, set to nil (so you do not output too much)
-			if si.omitEmpty && isEmptyValue(kv.r) {
+			if si.omitEmpty() && isEmptyValue(kv.r, e.h.TypeInfos, recur, recur) {
 				switch kv.r.Kind() {
-				case reflect.Struct, reflect.Interface, reflect.Ptr, reflect.Array,
-					reflect.Map, reflect.Slice:
+				case reflect.Struct, reflect.Interface, reflect.Ptr, reflect.Array, reflect.Map, reflect.Slice:
 					kv.r = reflect.Value{} //encode as nil
 				}
 			}
@@ -543,91 +614,64 @@ func (f *encFnInfo) kStruct(rv reflect.Value) {
 		newlen++
 	}
 
-	// debugf(">>>> kStruct: newlen: %v", newlen)
-	// sep := !e.be
-	ee := e.e //don't dereference everytime
-
 	if toMap {
-		ee.EncodeMapStart(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)
+		ee.WriteMapStart(newlen)
+		if elemsep {
+			for j := 0; j < newlen; j++ {
+				kv = fkvs[j]
+				ee.WriteMapElemKey()
+				// ee.EncodeString(cUTF8, kv.v)
+				e.kStructFieldKey(fti.keyType, kv.v)
+				ee.WriteMapElemValue()
+				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.EncodeString(cUTF8, kv.v)
+				e.kStructFieldKey(fti.keyType, kv.v)
+				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++ {
+				ee.WriteArrayElem()
+				e.encodeValue(fkvs[j].r, nil, true)
+			}
+		} else {
+			for j := 0; j < newlen; j++ {
+				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.esep
 	if l == 0 {
-		if cr != nil {
-			cr.sendContainerState(containerMapEnd)
-		}
+		ee.WriteMapEnd()
 		return
 	}
-	var asSymbols bool
+	// var asSymbols bool
 	// determine the underlying key and val encFn's for the map.
 	// This eliminates some work which is done for each loop iteration i.e.
 	// rv.Type(), ref.ValueOf(rt).Pointer(), then check map/list for fn.
@@ -635,269 +679,303 @@ 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.key
+	rtkey := rtkey0
+	rtval0 := ti.elem
+	rtval := rtval0
+	// rtkeyid := rt2id(rtkey0)
 	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.cfer().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)
-	} else {
-		for j := range mks {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
-			}
-			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)
+		e.kMapCanonical(rtkey, rv, mks, valFn)
+		ee.WriteMapEnd()
+		return
+	}
+
+	var keyTypeIsString = stringTypId == rt2id(rtkey0) // rtkeyid
+	if !keyTypeIsString {
+		for rtkey.Kind() == reflect.Ptr {
+			rtkey = rtkey.Elem()
+		}
+		if rtkey.Kind() != reflect.Interface {
+			// rtkeyid = rt2id(rtkey)
+			keyFn = e.cfer().get(rtkey, true, true)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
+
+	// for j, lmks := 0, len(mks); j < lmks; j++ {
+	for j := range mks {
+		if elemsep {
+			ee.WriteMapElemKey()
+		}
+		if keyTypeIsString {
+			ee.EncodeString(cUTF8, mks[j].String())
+		} else {
+			e.encodeValue(mks[j], keyFn, true)
+		}
+		if elemsep {
+			ee.WriteMapElemValue()
+		}
+		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) {
 	ee := e.e
-	cr := e.cr
+	elemsep := e.esep
 	// 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))
+	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))
+	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()
+			}
+			ee.EncodeString(cUTF8, mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			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()
+			}
+			ee.EncodeUint(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			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()
+			}
+			ee.EncodeInt(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			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()
+			}
+			ee.EncodeFloat32(float32(mksv[i].v))
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			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()
+			}
+			ee.EncodeFloat64(mksv[i].v)
+			if elemsep {
+				ee.WriteMapElemValue()
+			}
+			e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
+		}
+	case reflect.Struct:
+		if rv.Type() == timeTyp {
+			mksv := make([]timeRv, len(mks))
 			for i, k := range mks {
 				v := &mksv[i]
 				v.r = k
-				v.v = k.Bool()
+				v.v = rv2i(k).(time.Time)
 			}
-			sort.Sort(boolRvSlice(mksv))
+			sort.Sort(timeRvSlice(mksv))
 			for i := range mksv {
-				if cr != nil {
-					cr.sendContainerState(containerMapKey)
+				if elemsep {
+					ee.WriteMapElemKey()
 				}
-				ee.EncodeBool(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
+				ee.EncodeTime(mksv[i].v)
+				if elemsep {
+					ee.WriteMapElemValue()
 				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
+				e.encodeValue(rv.MapIndex(mksv[i].r), valFn, true)
 			}
-		case reflect.String:
-			mksv := make([]stringRv, len(mks))
-			for i, k := range mks {
-				v := &mksv[i]
-				v.r = k
-				v.v = k.String()
+			break
+		}
+		fallthrough
+	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()
 			}
-			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)
-			}
-		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 cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeUint(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
-			}
-		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 cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeInt(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
-			}
-		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 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)
-			}
-		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 cr != nil {
-					cr.sendContainerState(containerMapKey)
-				}
-				ee.EncodeFloat64(mksv[i].v)
-				if cr != nil {
-					cr.sendContainerState(containerMapValue)
-				}
-				e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
-			}
-		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 encWriterSwitch struct {
+	wi   *ioEncWriter
+	wb   bytesEncAppender
+	wx   bool      // if bytes, wx=true
+	esep bool      // whether it has elem separators
+	isas bool      // whether e.as != nil
+	js   bool      // here, so that no need to piggy back on *codecFner for this
+	be   bool      // here, so that no need to piggy back on *codecFner for this
+	_    [3]byte   // padding
+	_    [2]uint64 // padding
 }
 
-// --------------------------------------------------
+/*
 
-type encRtidFn struct {
-	rtid uintptr
-	fn   encFn
+func (z *encWriterSwitch) writeb(s []byte) {
+	if z.wx {
+		z.wb.writeb(s)
+	} else {
+		z.wi.writeb(s)
+	}
 }
+func (z *encWriterSwitch) writestr(s string) {
+	if z.wx {
+		z.wb.writestr(s)
+	} else {
+		z.wi.writestr(s)
+	}
+}
+func (z *encWriterSwitch) writen1(b1 byte) {
+	if z.wx {
+		z.wb.writen1(b1)
+	} else {
+		z.wi.writen1(b1)
+	}
+}
+func (z *encWriterSwitch) writen2(b1, b2 byte) {
+	if z.wx {
+		z.wb.writen2(b1, b2)
+	} else {
+		z.wi.writen2(b1, b2)
+	}
+}
+func (z *encWriterSwitch) atEndOfEncode() {
+	if z.wx {
+		z.wb.atEndOfEncode()
+	} else {
+		z.wi.atEndOfEncode()
+	}
+}
+
+*/
 
 // An Encoder writes an object to an output stream in the codec format.
 type Encoder struct {
+	panicHdl
 	// hopefully, reduce derefencing cost by laying the encWriter inside the Encoder
 	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
 
-	wi ioEncWriter
-	wb bytesEncWriter
-
-	h  *BasicHandle
-	hh Handle
-
-	cr containerStateRecv
+	// bw *bufio.Writer
 	as encDriverAsis
 
-	f map[uintptr]*encFn
-	b [scratchByteArrayLen]byte
+	err error
+
+	// ---- cpu cache line boundary?
+	encWriterSwitch
+
+	// ---- cpu cache line boundary?
+	h *BasicHandle
+	codecFnPooler
+	ci set
+
+	// ---- writable fields during execution --- *try* to keep in sep cache line
+
+	// ---- cpu cache line boundary?
+	// b [scratchByteArrayLen]byte
+	// _ [cacheLineSize - scratchByteArrayLen]byte // padding
+	b [cacheLineSize - 0]byte // used for encoding a chan or (non-addressable) array of bytes
 }
 
 // NewEncoder returns an Encoder for encoding into an io.Writer.
@@ -922,59 +1000,96 @@ 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.e = h.newEncDriver(e)
-	e.as, _ = e.e.(encDriverAsis)
-	e.cr, _ = e.e.(containerStateRecv)
+	e := &Encoder{h: h.getBasicHandle(), err: errEncoderNotInitialized}
+	e.hh = h
+	e.esep = h.hasElemSeparators()
 	return e
 }
 
-// Reset the Encoder with a new output stream.
-//
-// This accomodates 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
-	} 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)
+func (e *Encoder) resetCommon() {
+	// e.w = &e.encWriterSwitch
+	if e.e == nil || e.hh.recreateEncDriver(e.e) {
+		e.e = e.hh.newEncDriver(e)
+		e.as, e.isas = e.e.(encDriverAsis)
+		// e.cr, _ = e.e.(containerStateRecv)
 	}
-	e.w = &e.wi
+	e.be = e.hh.isBinary()
+	_, e.js = e.hh.(*JsonHandle)
 	e.e.reset()
+	e.err = nil
 }
 
+// Reset resets the Encoder with a new output stream.
+//
+// This accommodates using the state of the Encoder,
+// where it has "cached" information about sub-engines.
+func (e *Encoder) Reset(w io.Writer) {
+	if w == nil {
+		return
+	}
+	if e.wi == nil {
+		e.wi = new(ioEncWriter)
+	}
+	var ok bool
+	e.wx = false
+	e.wi.w = w
+	if e.h.WriterBufferSize > 0 {
+		bw := bufio.NewWriterSize(w, e.h.WriterBufferSize)
+		e.wi.bw = bw
+		e.wi.sw = bw
+		e.wi.fw = bw
+		e.wi.ww = bw
+	} else {
+		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.(ioFlusher)
+		e.wi.ww = w
+	}
+	e.w = e.wi
+	e.resetCommon()
+}
+
+// ResetBytes resets the Encoder with a new destination output []byte.
 func (e *Encoder) ResetBytes(out *[]byte) {
-	in := *out
+	if out == nil {
+		return
+	}
+	var in []byte
+	if out != nil {
+		in = *out
+	}
 	if in == nil {
 		in = make([]byte, defEncByteBufSize)
 	}
-	e.wb.b, e.wb.out, e.wb.c = in, out, 0
+	e.wx = true
+	e.wb.reset(in, out)
 	e.w = &e.wb
-	e.e.reset()
+	e.resetCommon()
 }
 
-// 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.
-// The "codec" key in struct field's tag value is the key name,
+// The key (in the struct tags) that we look at is configurable.
+//
+// By default, we look up the "codec" key in the struct field's tags,
+// and fall bak to the "json" key if "codec" is absent.
+// That key in struct field's tag value is the key name,
 // followed by an optional comma and options.
-// Note that the "json" key is used in the absence of the "codec" key.
 //
 // To set an option on all fields (e.g. omitempty on all fields), you
-// can create a field called _struct, and set flags on it.
+// can create a field called _struct, and set flags on it. The options
+// which can be set on _struct are:
+//    - omitempty: so all fields are omitted if empty
+//    - toarray: so struct is encoded as an array
+//    - int: so struct key names are encoded as signed integers (instead of strings)
+//    - uint: so struct key names are encoded as unsigned integers (instead of strings)
+//    - float: so struct key names are encoded as floats (instead of strings)
+// More details on these below.
 //
 // Struct values "usually" encode as maps. Each exported struct field is encoded unless:
 //    - the field's tag is "-", OR
@@ -982,10 +1097,19 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 //
 // When encoding as a map, the first string in the tag (before the comma)
 // is the map key string to use when encoding.
+// ...
+// This key is typically encoded as a string.
+// However, there are instances where the encoded stream has mapping keys encoded as numbers.
+// For example, some cbor streams have keys as integer codes in the stream, but they should map
+// to fields in a structured object. Consequently, a struct is the natural representation in code.
+// For these, configure the struct to encode/decode the keys as numbers (instead of string).
+// This is done with the int,uint or float option on the _struct field (see above).
 //
 // 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.
 //
@@ -1012,64 +1136,77 @@ 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
+//      }
+//
+//      type MyStruct struct {
+//          _struct bool    `codec:",uint"`        //encode struct with "unsigned integer" keys
+//          Field1 string   `codec:"1"`            //encode Field1 key using: EncodeInt(1)
+//          Field2 string   `codec:"2"`            //encode Field2 key using: EncodeInt(2)
 //      }
 //
 // The mode of encoding is based on the type of the value. When a value is seen:
 //   - If a Selfer, call its CodecEncodeSelf method
 //   - If an extension is registered for it, call that extension function
-//   - If it implements encoding.(Binary|Text|JSON)Marshaler, call its Marshal(Binary|Text|JSON) method
+//   - If implements encoding.(Binary|Text|JSON)Marshaler, call Marshal(Binary|Text|JSON) method
 //   - Else encode it based on its reflect.Kind
 //
 // Note that struct field names and keys in map[string]XXX will be treated as symbols.
 // 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 e.deferred(&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()
+	e.alwaysAtEnd()
 }
 
-// comment out these (Must)Write methods. They were only put there to support cbor.
-// However, users already have access to the streams, and can write directly.
-//
-// // Write allows users write to the Encoder stream directly.
-// func (e *Encoder) Write(bs []byte) (err error) {
-// 	defer panicToErr(&err)
-// 	e.w.writeb(bs)
-// 	return
-// }
-// // MustWrite is like write, but panics if unable to Write.
-// func (e *Encoder) MustWrite(bs []byte) {
-// 	e.w.writeb(bs)
+func (e *Encoder) deferred(err1 *error) {
+	e.alwaysAtEnd()
+	if recoverPanicToErr {
+		if x := recover(); x != nil {
+			panicValToErr(e, x, err1)
+			panicValToErr(e, x, &e.err)
+		}
+	}
+}
+
+// func (e *Encoder) alwaysAtEnd() {
+// 	e.codecFnPooler.alwaysAtEnd()
 // }
 
 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
+	}
+
+	// a switch with only concrete types can be optimized.
+	// consequently, we deal with nil and interfaces outside.
 
 	switch v := iv.(type) {
-	case nil:
-		e.e.EncodeNil()
-	case Selfer:
-		v.CodecEncodeSelf(e)
-
+	case Raw:
+		e.rawBytes(v)
 	case reflect.Value:
-		e.encodeValue(v, nil)
+		e.encodeValue(v, nil, true)
 
 	case string:
-		e.e.EncodeString(c_UTF8, v)
+		e.e.EncodeString(cUTF8, v)
 	case bool:
 		e.e.EncodeBool(v)
 	case int:
@@ -1092,16 +1229,22 @@ 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:
 		e.e.EncodeFloat64(v)
-
+	case time.Time:
+		e.e.EncodeTime(v)
 	case []uint8:
-		e.e.EncodeStringBytes(c_RAW, v)
+		e.e.EncodeStringBytes(cRAW, v)
+
+	case *Raw:
+		e.rawBytes(*v)
 
 	case *string:
-		e.e.EncodeString(c_UTF8, *v)
+		e.e.EncodeString(cUTF8, *v)
 	case *bool:
 		e.e.EncodeBool(*v)
 	case *int:
@@ -1124,24 +1267,31 @@ 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:
 		e.e.EncodeFloat64(*v)
+	case *time.Time:
+		e.e.EncodeTime(*v)
 
 	case *[]uint8:
-		e.e.EncodeStringBytes(c_RAW, *v)
+		e.e.EncodeStringBytes(cRAW, *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)
+			// checkfastpath=true (not false), as underlying slice/map type may be fast-path
+			e.encodeValue(reflect.ValueOf(iv), nil, true)
 		}
 	}
 }
 
-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
+	var rvp reflect.Value
+	var rvpValid bool
 TOP:
 	switch rv.Kind() {
 	case reflect.Ptr:
@@ -1149,6 +1299,8 @@ TOP:
 			e.e.EncodeNil()
 			return
 		}
+		rvpValid = true
+		rvp = rv
 		rv = rv.Elem()
 		if e.h.CheckCircularRef && rv.Kind() == reflect.Struct {
 			// TODO: Movable pointers will be an issue here. Future problem.
@@ -1173,165 +1325,33 @@ 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)
+		// always pass checkCodecSelfer=true, in case T or ****T is passed, where *T is a Selfer
+		fn = e.cfer().get(rt, checkFastpath, true)
+	}
+	if fn.i.addrE {
+		if rvpValid {
+			fn.fe(e, &fn.i, rvp)
+		} else if rv.CanAddr() {
+			fn.fe(e, &fn.i, rv.Addr())
+		} else {
+			rv2 := reflect.New(rv.Type())
+			rv2.Elem().Set(rv)
+			fn.fe(e, &fn.i, rv2)
+		}
+	} else {
+		fn.fe(e, &fn.i, rv)
 	}
-	fn.f(&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 == 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)
@@ -1346,74 +1366,21 @@ func (e *Encoder) marshal(bs []byte, fnerr error, asis bool, c charEncoding) {
 }
 
 func (e *Encoder) asis(v []byte) {
-	if e.as == nil {
-		e.w.writeb(v)
-	} else {
+	if e.isas {
 		e.as.EncodeAsis(v)
-	}
-}
-
-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)
+		e.w.writeb(v)
 	}
-	return
 }
 
-// ----------------------------------------
+func (e *Encoder) rawBytes(vv Raw) {
+	v := []byte(vv)
+	if !e.h.Raw {
+		e.errorf("Raw values cannot be encoded: %v", v)
+	}
+	e.asis(v)
+}
 
-// func encErr(format string, params ...interface{}) {
-// 	doPanic(msgTagEnc, format, params...)
-// }
+func (e *Encoder) wrapErrstr(v interface{}, err *error) {
+	*err = fmt.Errorf("%s encode error: %v", e.hh.Name(), v)
+}
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 cf6e00df2..87f2562f6 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.generated.go
+++ b/vendor/github.com/ugorji/go/codec/fast-path.generated.go
@@ -3,10 +3,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.
 
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED from fast-path.go.tmpl
-// ************************************************************
+// Code generated from fast-path.go.tmpl - DO NOT EDIT.
 
 package codec
 
@@ -18,19 +15,19 @@ package codec
 // This file can be omitted without causing a build failure.
 //
 // The advantage of fast paths is:
-//    - Many calls bypass reflection altogether
+//	  - Many calls bypass reflection altogether
 //
 // Currently support
-//    - slice of all builtin types,
-//    - map of all builtin types to string or interface value
-//    - symetrical maps of all builtin types (e.g. str-str, uint8-uint8)
+//	  - slice of all builtin types,
+//	  - map of all builtin types to string or interface value
+//	  - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
 // This should provide adequate "typical" implementations.
 //
 // Note that fast track decode functions must handle values for which an address cannot be obtained.
 // For example:
-//   m2 := map[string]int{}
-//   p2 := []interface{}{m2}
-//   // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
+//	 m2 := map[string]int{}
+//	 p2 := []interface{}{m2}
+//	 // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
 //
 
 import (
@@ -38,8 +35,7 @@ import (
 	"sort"
 )
 
-const fastpathCheckNilFalse = false // for reflect
-const fastpathCheckNilTrue = true   // for type switch
+const fastpathEnabled = true
 
 type fastpathT struct{}
 
@@ -48,8 +44,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
@@ -81,290 +77,289 @@ var fastpathAV fastpathA
 
 // due to possible initialization loop error, make fastpath in an init()
 func init() {
-	if !fastpathEnabled {
-		return
-	}
 	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)
 		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[:]))
 }
@@ -373,2749 +368,1096 @@ func init() {
 
 // -- -- fast path type switch
 func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
-	if !fastpathEnabled {
-		return false
-	}
 	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, e)
+	case *[]string:
+		fastpathTV.EncSliceStringV(*v, e)
+	case []float32:
+		fastpathTV.EncSliceFloat32V(v, e)
+	case *[]float32:
+		fastpathTV.EncSliceFloat32V(*v, e)
+	case []float64:
+		fastpathTV.EncSliceFloat64V(v, e)
+	case *[]float64:
+		fastpathTV.EncSliceFloat64V(*v, e)
+	case []uint:
+		fastpathTV.EncSliceUintV(v, e)
+	case *[]uint:
+		fastpathTV.EncSliceUintV(*v, e)
+	case []uint16:
+		fastpathTV.EncSliceUint16V(v, e)
+	case *[]uint16:
+		fastpathTV.EncSliceUint16V(*v, e)
+	case []uint32:
+		fastpathTV.EncSliceUint32V(v, e)
+	case *[]uint32:
+		fastpathTV.EncSliceUint32V(*v, e)
+	case []uint64:
+		fastpathTV.EncSliceUint64V(v, e)
+	case *[]uint64:
+		fastpathTV.EncSliceUint64V(*v, e)
+	case []uintptr:
+		fastpathTV.EncSliceUintptrV(v, e)
+	case *[]uintptr:
+		fastpathTV.EncSliceUintptrV(*v, e)
+	case []int:
+		fastpathTV.EncSliceIntV(v, e)
+	case *[]int:
+		fastpathTV.EncSliceIntV(*v, e)
+	case []int8:
+		fastpathTV.EncSliceInt8V(v, e)
+	case *[]int8:
+		fastpathTV.EncSliceInt8V(*v, e)
+	case []int16:
+		fastpathTV.EncSliceInt16V(v, e)
+	case *[]int16:
+		fastpathTV.EncSliceInt16V(*v, e)
+	case []int32:
+		fastpathTV.EncSliceInt32V(v, e)
+	case *[]int32:
+		fastpathTV.EncSliceInt32V(*v, e)
+	case []int64:
+		fastpathTV.EncSliceInt64V(v, e)
+	case *[]int64:
+		fastpathTV.EncSliceInt64V(*v, e)
+	case []bool:
+		fastpathTV.EncSliceBoolV(v, e)
+	case *[]bool:
+		fastpathTV.EncSliceBoolV(*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)
-
-	case []string:
-		fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e)
-	case *[]string:
-		fastpathTV.EncSliceStringV(*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)
-
-	case []float32:
-		fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e)
-	case *[]float32:
-		fastpathTV.EncSliceFloat32V(*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)
-
-	case []float64:
-		fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e)
-	case *[]float64:
-		fastpathTV.EncSliceFloat64V(*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)
-
-	case []uint:
-		fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e)
-	case *[]uint:
-		fastpathTV.EncSliceUintV(*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)
-
-	case []uint16:
-		fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e)
-	case *[]uint16:
-		fastpathTV.EncSliceUint16V(*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)
-
-	case []uint32:
-		fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e)
-	case *[]uint32:
-		fastpathTV.EncSliceUint32V(*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)
-
-	case []uint64:
-		fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e)
-	case *[]uint64:
-		fastpathTV.EncSliceUint64V(*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)
-
-	case []uintptr:
-		fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e)
-	case *[]uintptr:
-		fastpathTV.EncSliceUintptrV(*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)
-
-	case []int:
-		fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e)
-	case *[]int:
-		fastpathTV.EncSliceIntV(*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)
-
-	case []int8:
-		fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e)
-	case *[]int8:
-		fastpathTV.EncSliceInt8V(*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)
-
-	case []int16:
-		fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e)
-	case *[]int16:
-		fastpathTV.EncSliceInt16V(*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)
-
-	case []int32:
-		fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e)
-	case *[]int32:
-		fastpathTV.EncSliceInt32V(*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)
-
-	case []int64:
-		fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e)
-	case *[]int64:
-		fastpathTV.EncSliceInt64V(*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)
-
-	case []bool:
-		fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e)
-	case *[]bool:
-		fastpathTV.EncSliceBoolV(*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)
-		return false
-	}
-	return true
-}
-
-func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
-	if !fastpathEnabled {
-		return false
-	}
-	switch v := iv.(type) {
-
-	case []interface{}:
-		fastpathTV.EncSliceIntfV(v, fastpathCheckNilTrue, e)
-	case *[]interface{}:
-		fastpathTV.EncSliceIntfV(*v, fastpathCheckNilTrue, e)
-
-	case []string:
-		fastpathTV.EncSliceStringV(v, fastpathCheckNilTrue, e)
-	case *[]string:
-		fastpathTV.EncSliceStringV(*v, fastpathCheckNilTrue, e)
-
-	case []float32:
-		fastpathTV.EncSliceFloat32V(v, fastpathCheckNilTrue, e)
-	case *[]float32:
-		fastpathTV.EncSliceFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case []float64:
-		fastpathTV.EncSliceFloat64V(v, fastpathCheckNilTrue, e)
-	case *[]float64:
-		fastpathTV.EncSliceFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case []uint:
-		fastpathTV.EncSliceUintV(v, fastpathCheckNilTrue, e)
-	case *[]uint:
-		fastpathTV.EncSliceUintV(*v, fastpathCheckNilTrue, e)
-
-	case []uint16:
-		fastpathTV.EncSliceUint16V(v, fastpathCheckNilTrue, e)
-	case *[]uint16:
-		fastpathTV.EncSliceUint16V(*v, fastpathCheckNilTrue, e)
-
-	case []uint32:
-		fastpathTV.EncSliceUint32V(v, fastpathCheckNilTrue, e)
-	case *[]uint32:
-		fastpathTV.EncSliceUint32V(*v, fastpathCheckNilTrue, e)
-
-	case []uint64:
-		fastpathTV.EncSliceUint64V(v, fastpathCheckNilTrue, e)
-	case *[]uint64:
-		fastpathTV.EncSliceUint64V(*v, fastpathCheckNilTrue, e)
-
-	case []uintptr:
-		fastpathTV.EncSliceUintptrV(v, fastpathCheckNilTrue, e)
-	case *[]uintptr:
-		fastpathTV.EncSliceUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case []int:
-		fastpathTV.EncSliceIntV(v, fastpathCheckNilTrue, e)
-	case *[]int:
-		fastpathTV.EncSliceIntV(*v, fastpathCheckNilTrue, e)
-
-	case []int8:
-		fastpathTV.EncSliceInt8V(v, fastpathCheckNilTrue, e)
-	case *[]int8:
-		fastpathTV.EncSliceInt8V(*v, fastpathCheckNilTrue, e)
-
-	case []int16:
-		fastpathTV.EncSliceInt16V(v, fastpathCheckNilTrue, e)
-	case *[]int16:
-		fastpathTV.EncSliceInt16V(*v, fastpathCheckNilTrue, e)
-
-	case []int32:
-		fastpathTV.EncSliceInt32V(v, fastpathCheckNilTrue, e)
-	case *[]int32:
-		fastpathTV.EncSliceInt32V(*v, fastpathCheckNilTrue, e)
-
-	case []int64:
-		fastpathTV.EncSliceInt64V(v, fastpathCheckNilTrue, e)
-	case *[]int64:
-		fastpathTV.EncSliceInt64V(*v, fastpathCheckNilTrue, e)
-
-	case []bool:
-		fastpathTV.EncSliceBoolV(v, fastpathCheckNilTrue, e)
-	case *[]bool:
-		fastpathTV.EncSliceBoolV(*v, fastpathCheckNilTrue, e)
-
-	default:
-		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
-		return false
-	}
-	return true
-}
-
-func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
-	if !fastpathEnabled {
-		return false
-	}
-	switch v := iv.(type) {
-
-	case map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]interface{}:
-		fastpathTV.EncMapIntfIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]string:
-		fastpathTV.EncMapIntfStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint:
-		fastpathTV.EncMapIntfUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint8:
-		fastpathTV.EncMapIntfUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint16:
-		fastpathTV.EncMapIntfUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint32:
-		fastpathTV.EncMapIntfUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uint64:
-		fastpathTV.EncMapIntfUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]uintptr:
-		fastpathTV.EncMapIntfUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int:
-		fastpathTV.EncMapIntfIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int8:
-		fastpathTV.EncMapIntfInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int16:
-		fastpathTV.EncMapIntfInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int32:
-		fastpathTV.EncMapIntfInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]int64:
-		fastpathTV.EncMapIntfInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]float32:
-		fastpathTV.EncMapIntfFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]float64:
-		fastpathTV.EncMapIntfFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(v, fastpathCheckNilTrue, e)
-	case *map[interface{}]bool:
-		fastpathTV.EncMapIntfBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(v, fastpathCheckNilTrue, e)
-	case *map[string]interface{}:
-		fastpathTV.EncMapStringIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]string:
-		fastpathTV.EncMapStringStringV(v, fastpathCheckNilTrue, e)
-	case *map[string]string:
-		fastpathTV.EncMapStringStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint:
-		fastpathTV.EncMapStringUintV(v, fastpathCheckNilTrue, e)
-	case *map[string]uint:
-		fastpathTV.EncMapStringUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint8:
-		fastpathTV.EncMapStringUint8V(v, fastpathCheckNilTrue, e)
-	case *map[string]uint8:
-		fastpathTV.EncMapStringUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint16:
-		fastpathTV.EncMapStringUint16V(v, fastpathCheckNilTrue, e)
-	case *map[string]uint16:
-		fastpathTV.EncMapStringUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint32:
-		fastpathTV.EncMapStringUint32V(v, fastpathCheckNilTrue, e)
-	case *map[string]uint32:
-		fastpathTV.EncMapStringUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uint64:
-		fastpathTV.EncMapStringUint64V(v, fastpathCheckNilTrue, e)
-	case *map[string]uint64:
-		fastpathTV.EncMapStringUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[string]uintptr:
-		fastpathTV.EncMapStringUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int:
-		fastpathTV.EncMapStringIntV(v, fastpathCheckNilTrue, e)
-	case *map[string]int:
-		fastpathTV.EncMapStringIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int8:
-		fastpathTV.EncMapStringInt8V(v, fastpathCheckNilTrue, e)
-	case *map[string]int8:
-		fastpathTV.EncMapStringInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int16:
-		fastpathTV.EncMapStringInt16V(v, fastpathCheckNilTrue, e)
-	case *map[string]int16:
-		fastpathTV.EncMapStringInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int32:
-		fastpathTV.EncMapStringInt32V(v, fastpathCheckNilTrue, e)
-	case *map[string]int32:
-		fastpathTV.EncMapStringInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]int64:
-		fastpathTV.EncMapStringInt64V(v, fastpathCheckNilTrue, e)
-	case *map[string]int64:
-		fastpathTV.EncMapStringInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]float32:
-		fastpathTV.EncMapStringFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[string]float32:
-		fastpathTV.EncMapStringFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]float64:
-		fastpathTV.EncMapStringFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[string]float64:
-		fastpathTV.EncMapStringFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[string]bool:
-		fastpathTV.EncMapStringBoolV(v, fastpathCheckNilTrue, e)
-	case *map[string]bool:
-		fastpathTV.EncMapStringBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(v, fastpathCheckNilTrue, e)
-	case *map[float32]interface{}:
-		fastpathTV.EncMapFloat32IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]string:
-		fastpathTV.EncMapFloat32StringV(v, fastpathCheckNilTrue, e)
-	case *map[float32]string:
-		fastpathTV.EncMapFloat32StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint:
-		fastpathTV.EncMapFloat32UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint8:
-		fastpathTV.EncMapFloat32Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint16:
-		fastpathTV.EncMapFloat32Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint32:
-		fastpathTV.EncMapFloat32Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[float32]uint64:
-		fastpathTV.EncMapFloat32Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[float32]uintptr:
-		fastpathTV.EncMapFloat32UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int:
-		fastpathTV.EncMapFloat32IntV(v, fastpathCheckNilTrue, e)
-	case *map[float32]int:
-		fastpathTV.EncMapFloat32IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(v, fastpathCheckNilTrue, e)
-	case *map[float32]int8:
-		fastpathTV.EncMapFloat32Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(v, fastpathCheckNilTrue, e)
-	case *map[float32]int16:
-		fastpathTV.EncMapFloat32Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(v, fastpathCheckNilTrue, e)
-	case *map[float32]int32:
-		fastpathTV.EncMapFloat32Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(v, fastpathCheckNilTrue, e)
-	case *map[float32]int64:
-		fastpathTV.EncMapFloat32Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(v, fastpathCheckNilTrue, e)
-	case *map[float32]float32:
-		fastpathTV.EncMapFloat32Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(v, fastpathCheckNilTrue, e)
-	case *map[float32]float64:
-		fastpathTV.EncMapFloat32Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(v, fastpathCheckNilTrue, e)
-	case *map[float32]bool:
-		fastpathTV.EncMapFloat32BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(v, fastpathCheckNilTrue, e)
-	case *map[float64]interface{}:
-		fastpathTV.EncMapFloat64IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]string:
-		fastpathTV.EncMapFloat64StringV(v, fastpathCheckNilTrue, e)
-	case *map[float64]string:
-		fastpathTV.EncMapFloat64StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint:
-		fastpathTV.EncMapFloat64UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint8:
-		fastpathTV.EncMapFloat64Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint16:
-		fastpathTV.EncMapFloat64Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint32:
-		fastpathTV.EncMapFloat64Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[float64]uint64:
-		fastpathTV.EncMapFloat64Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[float64]uintptr:
-		fastpathTV.EncMapFloat64UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int:
-		fastpathTV.EncMapFloat64IntV(v, fastpathCheckNilTrue, e)
-	case *map[float64]int:
-		fastpathTV.EncMapFloat64IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(v, fastpathCheckNilTrue, e)
-	case *map[float64]int8:
-		fastpathTV.EncMapFloat64Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(v, fastpathCheckNilTrue, e)
-	case *map[float64]int16:
-		fastpathTV.EncMapFloat64Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(v, fastpathCheckNilTrue, e)
-	case *map[float64]int32:
-		fastpathTV.EncMapFloat64Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(v, fastpathCheckNilTrue, e)
-	case *map[float64]int64:
-		fastpathTV.EncMapFloat64Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(v, fastpathCheckNilTrue, e)
-	case *map[float64]float32:
-		fastpathTV.EncMapFloat64Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(v, fastpathCheckNilTrue, e)
-	case *map[float64]float64:
-		fastpathTV.EncMapFloat64Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(v, fastpathCheckNilTrue, e)
-	case *map[float64]bool:
-		fastpathTV.EncMapFloat64BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint]interface{}:
-		fastpathTV.EncMapUintIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]string:
-		fastpathTV.EncMapUintStringV(v, fastpathCheckNilTrue, e)
-	case *map[uint]string:
-		fastpathTV.EncMapUintStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint:
-		fastpathTV.EncMapUintUintV(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint:
-		fastpathTV.EncMapUintUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint8:
-		fastpathTV.EncMapUintUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint16:
-		fastpathTV.EncMapUintUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint32:
-		fastpathTV.EncMapUintUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint]uint64:
-		fastpathTV.EncMapUintUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint]uintptr:
-		fastpathTV.EncMapUintUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int:
-		fastpathTV.EncMapUintIntV(v, fastpathCheckNilTrue, e)
-	case *map[uint]int:
-		fastpathTV.EncMapUintIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int8:
-		fastpathTV.EncMapUintInt8V(v, fastpathCheckNilTrue, e)
-	case *map[uint]int8:
-		fastpathTV.EncMapUintInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int16:
-		fastpathTV.EncMapUintInt16V(v, fastpathCheckNilTrue, e)
-	case *map[uint]int16:
-		fastpathTV.EncMapUintInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int32:
-		fastpathTV.EncMapUintInt32V(v, fastpathCheckNilTrue, e)
-	case *map[uint]int32:
-		fastpathTV.EncMapUintInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]int64:
-		fastpathTV.EncMapUintInt64V(v, fastpathCheckNilTrue, e)
-	case *map[uint]int64:
-		fastpathTV.EncMapUintInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[uint]float32:
-		fastpathTV.EncMapUintFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[uint]float64:
-		fastpathTV.EncMapUintFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint]bool:
-		fastpathTV.EncMapUintBoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint]bool:
-		fastpathTV.EncMapUintBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]interface{}:
-		fastpathTV.EncMapUint8IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]string:
-		fastpathTV.EncMapUint8StringV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]string:
-		fastpathTV.EncMapUint8StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint:
-		fastpathTV.EncMapUint8UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint8:
-		fastpathTV.EncMapUint8Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint16:
-		fastpathTV.EncMapUint8Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint32:
-		fastpathTV.EncMapUint8Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uint64:
-		fastpathTV.EncMapUint8Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]uintptr:
-		fastpathTV.EncMapUint8UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int:
-		fastpathTV.EncMapUint8IntV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int:
-		fastpathTV.EncMapUint8IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int8:
-		fastpathTV.EncMapUint8Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int16:
-		fastpathTV.EncMapUint8Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int32:
-		fastpathTV.EncMapUint8Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]int64:
-		fastpathTV.EncMapUint8Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]float32:
-		fastpathTV.EncMapUint8Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(v, fastpathCheckNilTrue, e)
-	case *map[uint8]float64:
-		fastpathTV.EncMapUint8Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint8]bool:
-		fastpathTV.EncMapUint8BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]interface{}:
-		fastpathTV.EncMapUint16IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]string:
-		fastpathTV.EncMapUint16StringV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]string:
-		fastpathTV.EncMapUint16StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint:
-		fastpathTV.EncMapUint16UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint8:
-		fastpathTV.EncMapUint16Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint16:
-		fastpathTV.EncMapUint16Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint32:
-		fastpathTV.EncMapUint16Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uint64:
-		fastpathTV.EncMapUint16Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]uintptr:
-		fastpathTV.EncMapUint16UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int:
-		fastpathTV.EncMapUint16IntV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int:
-		fastpathTV.EncMapUint16IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int8:
-		fastpathTV.EncMapUint16Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int16:
-		fastpathTV.EncMapUint16Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int32:
-		fastpathTV.EncMapUint16Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]int64:
-		fastpathTV.EncMapUint16Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]float32:
-		fastpathTV.EncMapUint16Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(v, fastpathCheckNilTrue, e)
-	case *map[uint16]float64:
-		fastpathTV.EncMapUint16Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint16]bool:
-		fastpathTV.EncMapUint16BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]interface{}:
-		fastpathTV.EncMapUint32IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]string:
-		fastpathTV.EncMapUint32StringV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]string:
-		fastpathTV.EncMapUint32StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint:
-		fastpathTV.EncMapUint32UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint8:
-		fastpathTV.EncMapUint32Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint16:
-		fastpathTV.EncMapUint32Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint32:
-		fastpathTV.EncMapUint32Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uint64:
-		fastpathTV.EncMapUint32Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]uintptr:
-		fastpathTV.EncMapUint32UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int:
-		fastpathTV.EncMapUint32IntV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int:
-		fastpathTV.EncMapUint32IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int8:
-		fastpathTV.EncMapUint32Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int16:
-		fastpathTV.EncMapUint32Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int32:
-		fastpathTV.EncMapUint32Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]int64:
-		fastpathTV.EncMapUint32Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]float32:
-		fastpathTV.EncMapUint32Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(v, fastpathCheckNilTrue, e)
-	case *map[uint32]float64:
-		fastpathTV.EncMapUint32Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint32]bool:
-		fastpathTV.EncMapUint32BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]interface{}:
-		fastpathTV.EncMapUint64IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]string:
-		fastpathTV.EncMapUint64StringV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]string:
-		fastpathTV.EncMapUint64StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint:
-		fastpathTV.EncMapUint64UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint8:
-		fastpathTV.EncMapUint64Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint16:
-		fastpathTV.EncMapUint64Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint32:
-		fastpathTV.EncMapUint64Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uint64:
-		fastpathTV.EncMapUint64Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]uintptr:
-		fastpathTV.EncMapUint64UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int:
-		fastpathTV.EncMapUint64IntV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int:
-		fastpathTV.EncMapUint64IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int8:
-		fastpathTV.EncMapUint64Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int16:
-		fastpathTV.EncMapUint64Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int32:
-		fastpathTV.EncMapUint64Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]int64:
-		fastpathTV.EncMapUint64Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]float32:
-		fastpathTV.EncMapUint64Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(v, fastpathCheckNilTrue, e)
-	case *map[uint64]float64:
-		fastpathTV.EncMapUint64Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(v, fastpathCheckNilTrue, e)
-	case *map[uint64]bool:
-		fastpathTV.EncMapUint64BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]interface{}:
-		fastpathTV.EncMapUintptrIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]string:
-		fastpathTV.EncMapUintptrStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint:
-		fastpathTV.EncMapUintptrUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint8:
-		fastpathTV.EncMapUintptrUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint16:
-		fastpathTV.EncMapUintptrUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint32:
-		fastpathTV.EncMapUintptrUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uint64:
-		fastpathTV.EncMapUintptrUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]uintptr:
-		fastpathTV.EncMapUintptrUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int:
-		fastpathTV.EncMapUintptrIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int8:
-		fastpathTV.EncMapUintptrInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int16:
-		fastpathTV.EncMapUintptrInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int32:
-		fastpathTV.EncMapUintptrInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]int64:
-		fastpathTV.EncMapUintptrInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]float32:
-		fastpathTV.EncMapUintptrFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]float64:
-		fastpathTV.EncMapUintptrFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(v, fastpathCheckNilTrue, e)
-	case *map[uintptr]bool:
-		fastpathTV.EncMapUintptrBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(v, fastpathCheckNilTrue, e)
-	case *map[int]interface{}:
-		fastpathTV.EncMapIntIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]string:
-		fastpathTV.EncMapIntStringV(v, fastpathCheckNilTrue, e)
-	case *map[int]string:
-		fastpathTV.EncMapIntStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint:
-		fastpathTV.EncMapIntUintV(v, fastpathCheckNilTrue, e)
-	case *map[int]uint:
-		fastpathTV.EncMapIntUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint8:
-		fastpathTV.EncMapIntUint8V(v, fastpathCheckNilTrue, e)
-	case *map[int]uint8:
-		fastpathTV.EncMapIntUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint16:
-		fastpathTV.EncMapIntUint16V(v, fastpathCheckNilTrue, e)
-	case *map[int]uint16:
-		fastpathTV.EncMapIntUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint32:
-		fastpathTV.EncMapIntUint32V(v, fastpathCheckNilTrue, e)
-	case *map[int]uint32:
-		fastpathTV.EncMapIntUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uint64:
-		fastpathTV.EncMapIntUint64V(v, fastpathCheckNilTrue, e)
-	case *map[int]uint64:
-		fastpathTV.EncMapIntUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int]uintptr:
-		fastpathTV.EncMapIntUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int:
-		fastpathTV.EncMapIntIntV(v, fastpathCheckNilTrue, e)
-	case *map[int]int:
-		fastpathTV.EncMapIntIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int8:
-		fastpathTV.EncMapIntInt8V(v, fastpathCheckNilTrue, e)
-	case *map[int]int8:
-		fastpathTV.EncMapIntInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int16:
-		fastpathTV.EncMapIntInt16V(v, fastpathCheckNilTrue, e)
-	case *map[int]int16:
-		fastpathTV.EncMapIntInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int32:
-		fastpathTV.EncMapIntInt32V(v, fastpathCheckNilTrue, e)
-	case *map[int]int32:
-		fastpathTV.EncMapIntInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]int64:
-		fastpathTV.EncMapIntInt64V(v, fastpathCheckNilTrue, e)
-	case *map[int]int64:
-		fastpathTV.EncMapIntInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]float32:
-		fastpathTV.EncMapIntFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[int]float32:
-		fastpathTV.EncMapIntFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]float64:
-		fastpathTV.EncMapIntFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[int]float64:
-		fastpathTV.EncMapIntFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int]bool:
-		fastpathTV.EncMapIntBoolV(v, fastpathCheckNilTrue, e)
-	case *map[int]bool:
-		fastpathTV.EncMapIntBoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(v, fastpathCheckNilTrue, e)
-	case *map[int8]interface{}:
-		fastpathTV.EncMapInt8IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]string:
-		fastpathTV.EncMapInt8StringV(v, fastpathCheckNilTrue, e)
-	case *map[int8]string:
-		fastpathTV.EncMapInt8StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint:
-		fastpathTV.EncMapInt8UintV(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint:
-		fastpathTV.EncMapInt8UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint8:
-		fastpathTV.EncMapInt8Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint16:
-		fastpathTV.EncMapInt8Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint32:
-		fastpathTV.EncMapInt8Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[int8]uint64:
-		fastpathTV.EncMapInt8Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int8]uintptr:
-		fastpathTV.EncMapInt8UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int:
-		fastpathTV.EncMapInt8IntV(v, fastpathCheckNilTrue, e)
-	case *map[int8]int:
-		fastpathTV.EncMapInt8IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(v, fastpathCheckNilTrue, e)
-	case *map[int8]int8:
-		fastpathTV.EncMapInt8Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(v, fastpathCheckNilTrue, e)
-	case *map[int8]int16:
-		fastpathTV.EncMapInt8Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(v, fastpathCheckNilTrue, e)
-	case *map[int8]int32:
-		fastpathTV.EncMapInt8Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(v, fastpathCheckNilTrue, e)
-	case *map[int8]int64:
-		fastpathTV.EncMapInt8Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(v, fastpathCheckNilTrue, e)
-	case *map[int8]float32:
-		fastpathTV.EncMapInt8Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(v, fastpathCheckNilTrue, e)
-	case *map[int8]float64:
-		fastpathTV.EncMapInt8Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(v, fastpathCheckNilTrue, e)
-	case *map[int8]bool:
-		fastpathTV.EncMapInt8BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(v, fastpathCheckNilTrue, e)
-	case *map[int16]interface{}:
-		fastpathTV.EncMapInt16IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]string:
-		fastpathTV.EncMapInt16StringV(v, fastpathCheckNilTrue, e)
-	case *map[int16]string:
-		fastpathTV.EncMapInt16StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint:
-		fastpathTV.EncMapInt16UintV(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint:
-		fastpathTV.EncMapInt16UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint8:
-		fastpathTV.EncMapInt16Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint16:
-		fastpathTV.EncMapInt16Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint32:
-		fastpathTV.EncMapInt16Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[int16]uint64:
-		fastpathTV.EncMapInt16Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int16]uintptr:
-		fastpathTV.EncMapInt16UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int:
-		fastpathTV.EncMapInt16IntV(v, fastpathCheckNilTrue, e)
-	case *map[int16]int:
-		fastpathTV.EncMapInt16IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(v, fastpathCheckNilTrue, e)
-	case *map[int16]int8:
-		fastpathTV.EncMapInt16Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(v, fastpathCheckNilTrue, e)
-	case *map[int16]int16:
-		fastpathTV.EncMapInt16Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(v, fastpathCheckNilTrue, e)
-	case *map[int16]int32:
-		fastpathTV.EncMapInt16Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(v, fastpathCheckNilTrue, e)
-	case *map[int16]int64:
-		fastpathTV.EncMapInt16Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(v, fastpathCheckNilTrue, e)
-	case *map[int16]float32:
-		fastpathTV.EncMapInt16Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(v, fastpathCheckNilTrue, e)
-	case *map[int16]float64:
-		fastpathTV.EncMapInt16Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(v, fastpathCheckNilTrue, e)
-	case *map[int16]bool:
-		fastpathTV.EncMapInt16BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(v, fastpathCheckNilTrue, e)
-	case *map[int32]interface{}:
-		fastpathTV.EncMapInt32IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]string:
-		fastpathTV.EncMapInt32StringV(v, fastpathCheckNilTrue, e)
-	case *map[int32]string:
-		fastpathTV.EncMapInt32StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint:
-		fastpathTV.EncMapInt32UintV(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint:
-		fastpathTV.EncMapInt32UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint8:
-		fastpathTV.EncMapInt32Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint16:
-		fastpathTV.EncMapInt32Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint32:
-		fastpathTV.EncMapInt32Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[int32]uint64:
-		fastpathTV.EncMapInt32Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int32]uintptr:
-		fastpathTV.EncMapInt32UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int:
-		fastpathTV.EncMapInt32IntV(v, fastpathCheckNilTrue, e)
-	case *map[int32]int:
-		fastpathTV.EncMapInt32IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(v, fastpathCheckNilTrue, e)
-	case *map[int32]int8:
-		fastpathTV.EncMapInt32Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(v, fastpathCheckNilTrue, e)
-	case *map[int32]int16:
-		fastpathTV.EncMapInt32Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(v, fastpathCheckNilTrue, e)
-	case *map[int32]int32:
-		fastpathTV.EncMapInt32Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(v, fastpathCheckNilTrue, e)
-	case *map[int32]int64:
-		fastpathTV.EncMapInt32Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(v, fastpathCheckNilTrue, e)
-	case *map[int32]float32:
-		fastpathTV.EncMapInt32Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(v, fastpathCheckNilTrue, e)
-	case *map[int32]float64:
-		fastpathTV.EncMapInt32Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(v, fastpathCheckNilTrue, e)
-	case *map[int32]bool:
-		fastpathTV.EncMapInt32BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(v, fastpathCheckNilTrue, e)
-	case *map[int64]interface{}:
-		fastpathTV.EncMapInt64IntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]string:
-		fastpathTV.EncMapInt64StringV(v, fastpathCheckNilTrue, e)
-	case *map[int64]string:
-		fastpathTV.EncMapInt64StringV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint:
-		fastpathTV.EncMapInt64UintV(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint:
-		fastpathTV.EncMapInt64UintV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint8:
-		fastpathTV.EncMapInt64Uint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint16:
-		fastpathTV.EncMapInt64Uint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint32:
-		fastpathTV.EncMapInt64Uint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(v, fastpathCheckNilTrue, e)
-	case *map[int64]uint64:
-		fastpathTV.EncMapInt64Uint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(v, fastpathCheckNilTrue, e)
-	case *map[int64]uintptr:
-		fastpathTV.EncMapInt64UintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int:
-		fastpathTV.EncMapInt64IntV(v, fastpathCheckNilTrue, e)
-	case *map[int64]int:
-		fastpathTV.EncMapInt64IntV(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(v, fastpathCheckNilTrue, e)
-	case *map[int64]int8:
-		fastpathTV.EncMapInt64Int8V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(v, fastpathCheckNilTrue, e)
-	case *map[int64]int16:
-		fastpathTV.EncMapInt64Int16V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(v, fastpathCheckNilTrue, e)
-	case *map[int64]int32:
-		fastpathTV.EncMapInt64Int32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(v, fastpathCheckNilTrue, e)
-	case *map[int64]int64:
-		fastpathTV.EncMapInt64Int64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(v, fastpathCheckNilTrue, e)
-	case *map[int64]float32:
-		fastpathTV.EncMapInt64Float32V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(v, fastpathCheckNilTrue, e)
-	case *map[int64]float64:
-		fastpathTV.EncMapInt64Float64V(*v, fastpathCheckNilTrue, e)
-
-	case map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(v, fastpathCheckNilTrue, e)
-	case *map[int64]bool:
-		fastpathTV.EncMapInt64BoolV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(v, fastpathCheckNilTrue, e)
-	case *map[bool]interface{}:
-		fastpathTV.EncMapBoolIntfV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]string:
-		fastpathTV.EncMapBoolStringV(v, fastpathCheckNilTrue, e)
-	case *map[bool]string:
-		fastpathTV.EncMapBoolStringV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint:
-		fastpathTV.EncMapBoolUintV(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint:
-		fastpathTV.EncMapBoolUintV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint8:
-		fastpathTV.EncMapBoolUint8V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint16:
-		fastpathTV.EncMapBoolUint16V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint32:
-		fastpathTV.EncMapBoolUint32V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(v, fastpathCheckNilTrue, e)
-	case *map[bool]uint64:
-		fastpathTV.EncMapBoolUint64V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(v, fastpathCheckNilTrue, e)
-	case *map[bool]uintptr:
-		fastpathTV.EncMapBoolUintptrV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int:
-		fastpathTV.EncMapBoolIntV(v, fastpathCheckNilTrue, e)
-	case *map[bool]int:
-		fastpathTV.EncMapBoolIntV(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(v, fastpathCheckNilTrue, e)
-	case *map[bool]int8:
-		fastpathTV.EncMapBoolInt8V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(v, fastpathCheckNilTrue, e)
-	case *map[bool]int16:
-		fastpathTV.EncMapBoolInt16V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(v, fastpathCheckNilTrue, e)
-	case *map[bool]int32:
-		fastpathTV.EncMapBoolInt32V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(v, fastpathCheckNilTrue, e)
-	case *map[bool]int64:
-		fastpathTV.EncMapBoolInt64V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(v, fastpathCheckNilTrue, e)
-	case *map[bool]float32:
-		fastpathTV.EncMapBoolFloat32V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(v, fastpathCheckNilTrue, e)
-	case *map[bool]float64:
-		fastpathTV.EncMapBoolFloat64V(*v, fastpathCheckNilTrue, e)
-
-	case map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(v, fastpathCheckNilTrue, e)
-	case *map[bool]bool:
-		fastpathTV.EncMapBoolBoolV(*v, fastpathCheckNilTrue, e)
-
-	default:
-		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
+		_ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
 		return false
 	}
 	return true
@@ -3123,812 +1465,816 @@ 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()
+func (_ fastpathT) EncSliceIntfV(v []interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeArrayStart(len(v))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			e.encode(v2)
+		}
+	} else {
+		for _, v2 := range v {
+			e.encode(v2)
 		}
-		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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			e.encode(v2)
 		}
-		e.encode(v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceStringR(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			e.encode(v2)
 		}
-		ee.EncodeString(c_UTF8, v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceStringV(v []string, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceStringR(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceStringV(rv2i(rv).([]string), e)
+	} else {
+		fastpathTV.EncSliceStringV(rv2i(rv).([]string), e)
+	}
+}
+func (_ fastpathT) EncSliceStringV(v []string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeString(cUTF8, v2)
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeString(cUTF8, v2)
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeString(cUTF8, v2)
 		}
-		ee.EncodeString(c_UTF8, v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceFloat32R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeString(cUTF8, v2)
 		}
-		ee.EncodeFloat32(v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceFloat32V(rv2i(rv).([]float32), e)
+	} else {
+		fastpathTV.EncSliceFloat32V(rv2i(rv).([]float32), e)
+	}
+}
+func (_ fastpathT) EncSliceFloat32V(v []float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeFloat32(v2)
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeFloat32(v2)
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeFloat32(v2)
 		}
-		ee.EncodeFloat32(v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceFloat64R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeFloat32(v2)
 		}
-		ee.EncodeFloat64(v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceFloat64V(rv2i(rv).([]float64), e)
+	} else {
+		fastpathTV.EncSliceFloat64V(rv2i(rv).([]float64), e)
+	}
+}
+func (_ fastpathT) EncSliceFloat64V(v []float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeFloat64(v2)
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeFloat64(v2)
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeFloat64(v2)
 		}
-		ee.EncodeFloat64(v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceUintR(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeFloat64(v2)
 		}
-		ee.EncodeUint(uint64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUintV(v []uint, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceUintR(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceUintV(rv2i(rv).([]uint), e)
+	} else {
+		fastpathTV.EncSliceUintV(rv2i(rv).([]uint), e)
+	}
+}
+func (_ fastpathT) EncSliceUintV(v []uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeUint(uint64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeUint(uint64(v2))
 		}
-		ee.EncodeUint(uint64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceUint16R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
 		}
-		ee.EncodeUint(uint64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceUint8R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceUint8V(rv2i(rv).([]uint8), e)
+	} else {
+		fastpathTV.EncSliceUint8V(rv2i(rv).([]uint8), e)
+	}
+}
+func (_ fastpathT) EncSliceUint8V(v []uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeUint(uint64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+func (_ fastpathT) EncAsMapSliceUint8V(v []uint8, 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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeUint(uint64(v2))
 		}
-		ee.EncodeUint(uint64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceUint32R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
 		}
-		ee.EncodeUint(uint64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceUint16R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceUint16V(rv2i(rv).([]uint16), e)
+	} else {
+		fastpathTV.EncSliceUint16V(rv2i(rv).([]uint16), e)
+	}
+}
+func (_ fastpathT) EncSliceUint16V(v []uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeUint(uint64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeUint(uint64(v2))
 		}
-		ee.EncodeUint(uint64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceUint64R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
 		}
-		ee.EncodeUint(uint64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceUint32R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceUint32V(rv2i(rv).([]uint32), e)
+	} else {
+		fastpathTV.EncSliceUint32V(rv2i(rv).([]uint32), e)
+	}
+}
+func (_ fastpathT) EncSliceUint32V(v []uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeUint(uint64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeUint(uint64(v2))
 		}
-		ee.EncodeUint(uint64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceUintptrR(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
 		}
-		e.encode(v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceUint64R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceUint64V(rv2i(rv).([]uint64), e)
+	} else {
+		fastpathTV.EncSliceUint64V(rv2i(rv).([]uint64), e)
+	}
+}
+func (_ fastpathT) EncSliceUint64V(v []uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeUint(uint64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeUint(uint64(v2))
 		}
-		e.encode(v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceIntR(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeUint(uint64(v2))
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceIntV(v []int, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceUintptrV(rv2i(rv).([]uintptr), e)
+	} else {
+		fastpathTV.EncSliceUintptrV(rv2i(rv).([]uintptr), e)
+	}
+}
+func (_ fastpathT) EncSliceUintptrV(v []uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			e.encode(v2)
+		}
+	} else {
+		for _, v2 := range v {
+			e.encode(v2)
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			e.encode(v2)
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceInt8R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			e.encode(v2)
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceInt8V(v []int8, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceIntR(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceIntV(rv2i(rv).([]int), e)
+	} else {
+		fastpathTV.EncSliceIntV(rv2i(rv).([]int), e)
+	}
+}
+func (_ fastpathT) EncSliceIntV(v []int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeInt(int64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeInt(int64(v2))
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceInt16R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceInt16V(v []int16, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceInt8R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceInt8V(rv2i(rv).([]int8), e)
+	} else {
+		fastpathTV.EncSliceInt8V(rv2i(rv).([]int8), e)
+	}
+}
+func (_ fastpathT) EncSliceInt8V(v []int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeInt(int64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeInt(int64(v2))
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceInt32R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceInt32V(v []int32, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceInt16R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceInt16V(rv2i(rv).([]int16), e)
+	} else {
+		fastpathTV.EncSliceInt16V(rv2i(rv).([]int16), e)
+	}
+}
+func (_ fastpathT) EncSliceInt16V(v []int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeInt(int64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeInt(int64(v2))
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceInt64R(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceInt64V(v []int64, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceInt32R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceInt32V(rv2i(rv).([]int32), e)
+	} else {
+		fastpathTV.EncSliceInt32V(rv2i(rv).([]int32), e)
+	}
+}
+func (_ fastpathT) EncSliceInt32V(v []int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeInt(int64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeInt(int64(v2))
 		}
-		ee.EncodeInt(int64(v2))
-	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
-}
-
-func (f *encFnInfo) fastpathEncSliceBoolR(rv reflect.Value) {
-	if f.ti.mbs {
-		fastpathTV.EncAsMapSliceBoolV(rv.Interface().([]bool), fastpathCheckNilFalse, f.e)
 	} else {
-		fastpathTV.EncSliceBoolV(rv.Interface().([]bool), fastpathCheckNilFalse, f.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))
-	for _, v2 := range v {
-		if cr != nil {
-			cr.sendContainerState(containerArrayElem)
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
 		}
-		ee.EncodeBool(v2)
-	}
-	if cr != nil {
-		cr.sendContainerState(containerArrayEnd)
 	}
+	ee.WriteMapEnd()
 }
 
-func (_ fastpathT) EncAsMapSliceBoolV(v []bool, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (e *Encoder) fastpathEncSliceInt64R(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceInt64V(rv2i(rv).([]int64), e)
+	} else {
+		fastpathTV.EncSliceInt64V(rv2i(rv).([]int64), e)
+	}
+}
+func (_ fastpathT) EncSliceInt64V(v []int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeInt(int64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
 			}
+			ee.EncodeInt(int64(v2))
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeInt(int64(v2))
 		}
-		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) fastpathEncSliceBoolR(f *codecFnInfo, rv reflect.Value) {
+	if f.ti.mbs {
+		fastpathTV.EncAsMapSliceBoolV(rv2i(rv).([]bool), e)
+	} else {
+		fastpathTV.EncSliceBoolV(rv2i(rv).([]bool), e)
+	}
 }
-func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, checkNil bool, e *Encoder) {
-	ee := e.e
-	cr := e.cr
-	if checkNil && v == nil {
-		ee.EncodeNil()
+func (_ fastpathT) EncSliceBoolV(v []bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			ee.EncodeBool(v2)
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeBool(v2)
+		}
+	}
+	ee.WriteArrayEnd()
+}
+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.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
+			if j%2 == 0 {
+				ee.WriteMapElemKey()
+			} else {
+				ee.WriteMapElemValue()
+			}
+			ee.EncodeBool(v2)
+		}
+	} else {
+		for _, v2 := range v {
+			ee.EncodeBool(v2)
+		}
+	}
+	ee.WriteMapEnd()
+}
+
+func (e *Encoder) fastpathEncMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
+	fastpathTV.EncMapIntfIntfV(rv2i(rv).(map[interface{}]interface{}), e)
+}
+func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
+		return
+	}
+	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)
@@ -3944,44 +2290,47 @@ func (_ fastpathT) EncMapIntfIntfV(v map[interface{}]interface{}, checkNil bool,
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -3997,44 +2346,47 @@ func (_ fastpathT) EncMapIntfStringV(v map[interface{}]string, checkNil bool, e
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4050,44 +2402,47 @@ func (_ fastpathT) EncMapIntfUintV(v map[interface{}]uint, checkNil bool, e *Enc
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4103,44 +2458,47 @@ func (_ fastpathT) EncMapIntfUint8V(v map[interface{}]uint8, checkNil bool, e *E
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4156,44 +2514,47 @@ func (_ fastpathT) EncMapIntfUint16V(v map[interface{}]uint16, checkNil bool, e
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4209,44 +2570,47 @@ func (_ fastpathT) EncMapIntfUint32V(v map[interface{}]uint32, checkNil bool, e
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4262,44 +2626,47 @@ func (_ fastpathT) EncMapIntfUint64V(v map[interface{}]uint64, checkNil bool, e
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4315,44 +2682,47 @@ func (_ fastpathT) EncMapIntfUintptrV(v map[interface{}]uintptr, checkNil bool,
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4368,44 +2738,47 @@ func (_ fastpathT) EncMapIntfIntV(v map[interface{}]int, checkNil bool, e *Encod
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4421,44 +2794,47 @@ func (_ fastpathT) EncMapIntfInt8V(v map[interface{}]int8, checkNil bool, e *Enc
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4474,44 +2850,47 @@ func (_ fastpathT) EncMapIntfInt16V(v map[interface{}]int16, checkNil bool, e *E
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4527,44 +2906,47 @@ func (_ fastpathT) EncMapIntfInt32V(v map[interface{}]int32, checkNil bool, e *E
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4580,44 +2962,47 @@ func (_ fastpathT) EncMapIntfInt64V(v map[interface{}]int64, checkNil bool, e *E
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4633,44 +3018,47 @@ func (_ fastpathT) EncMapIntfFloat32V(v map[interface{}]float32, checkNil bool,
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4686,44 +3074,47 @@ func (_ fastpathT) EncMapIntfFloat64V(v map[interface{}]float64, checkNil bool,
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	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)
@@ -4739,45 +3130,47 @@ func (_ fastpathT) EncMapIntfBoolV(v map[interface{}]bool, checkNil bool, e *Enc
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
-		for j := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
 			}
-			e.asis(v2[j].v)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
 			}
-			e.encode(v[v2[j].i])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -4786,53 +3179,47 @@ func (_ fastpathT) EncMapStringIntfV(v map[string]interface{}, checkNil bool, e
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				e.encode(v[string(k2)])
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				e.encode(v[string(k2)])
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			e.encode(v[string(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				e.encode(v2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringStringV(v map[string]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -4841,53 +3228,47 @@ func (_ fastpathT) EncMapStringStringV(v map[string]string, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[string(k2)])
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeString(cUTF8, v[string(k2)])
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeString(c_UTF8, v[string(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeString(cUTF8, v2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringUintV(v map[string]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -4896,53 +3277,47 @@ func (_ fastpathT) EncMapStringUintV(v map[string]uint, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -4951,53 +3326,47 @@ func (_ fastpathT) EncMapStringUint8V(v map[string]uint8, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5006,53 +3375,47 @@ func (_ fastpathT) EncMapStringUint16V(v map[string]uint16, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5061,53 +3424,47 @@ func (_ fastpathT) EncMapStringUint32V(v map[string]uint32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5116,53 +3473,47 @@ func (_ fastpathT) EncMapStringUint64V(v map[string]uint64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeUint(uint64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5171,53 +3522,47 @@ func (_ fastpathT) EncMapStringUintptrV(v map[string]uintptr, checkNil bool, e *
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				e.encode(v[string(k2)])
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				e.encode(v[string(k2)])
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			e.encode(v[string(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				e.encode(v2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringIntV(v map[string]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5226,53 +3571,47 @@ func (_ fastpathT) EncMapStringIntV(v map[string]int, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringInt8V(v map[string]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5281,53 +3620,47 @@ func (_ fastpathT) EncMapStringInt8V(v map[string]int8, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringInt16V(v map[string]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5336,53 +3669,47 @@ func (_ fastpathT) EncMapStringInt16V(v map[string]int16, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringInt32V(v map[string]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5391,53 +3718,47 @@ func (_ fastpathT) EncMapStringInt32V(v map[string]int32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringInt64V(v map[string]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5446,53 +3767,47 @@ func (_ fastpathT) EncMapStringInt64V(v map[string]int64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v[string(k2)]))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeInt(int64(v[string(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeInt(int64(v2))
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5501,53 +3816,47 @@ func (_ fastpathT) EncMapStringFloat32V(v map[string]float32, checkNil bool, e *
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[string(k2)])
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeFloat32(v[string(k2)])
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeFloat32(v[string(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeFloat32(v2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5556,53 +3865,47 @@ func (_ fastpathT) EncMapStringFloat64V(v map[string]float64, checkNil bool, e *
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[string(k2)])
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeFloat64(v[string(k2)])
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeFloat64(v[string(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeFloat64(v2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapStringBoolV(v map[string]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
-	asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]string, len(v))
 		var i int
@@ -5611,52 +3914,47 @@ func (_ fastpathT) EncMapStringBoolV(v map[string]bool, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(stringSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[string(k2)])
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeBool(v[string(k2)])
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			ee.EncodeBool(v[string(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeString(cUTF8, k2)
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			if asSymbols {
-				ee.EncodeSymbol(k2)
-			} else {
-				ee.EncodeString(c_UTF8, k2)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeString(cUTF8, k2)
+				ee.EncodeBool(v2)
 			}
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
-			}
-			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()
+func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5665,44 +3963,47 @@ func (_ fastpathT) EncMapFloat32IntfV(v map[float32]interface{}, checkNil bool,
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				e.encode(v[float32(k2)])
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				e.encode(v[float32(k2)])
 			}
-			e.encode(v[float32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5711,44 +4012,47 @@ func (_ fastpathT) EncMapFloat32StringV(v map[float32]string, checkNil bool, e *
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[float32(k2)])
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeString(cUTF8, v[float32(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[float32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5757,44 +4061,47 @@ func (_ fastpathT) EncMapFloat32UintV(v map[float32]uint, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5803,44 +4110,47 @@ func (_ fastpathT) EncMapFloat32Uint8V(v map[float32]uint8, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5849,44 +4159,47 @@ func (_ fastpathT) EncMapFloat32Uint16V(v map[float32]uint16, checkNil bool, e *
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5895,44 +4208,47 @@ func (_ fastpathT) EncMapFloat32Uint32V(v map[float32]uint32, checkNil bool, e *
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5941,44 +4257,47 @@ func (_ fastpathT) EncMapFloat32Uint64V(v map[float32]uint64, checkNil bool, e *
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeUint(uint64(v[float32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -5987,44 +4306,47 @@ func (_ fastpathT) EncMapFloat32UintptrV(v map[float32]uintptr, checkNil bool, e
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				e.encode(v[float32(k2)])
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				e.encode(v[float32(k2)])
 			}
-			e.encode(v[float32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6033,44 +4355,47 @@ func (_ fastpathT) EncMapFloat32IntV(v map[float32]int, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6079,44 +4404,47 @@ func (_ fastpathT) EncMapFloat32Int8V(v map[float32]int8, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6125,44 +4453,47 @@ func (_ fastpathT) EncMapFloat32Int16V(v map[float32]int16, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6171,44 +4502,47 @@ func (_ fastpathT) EncMapFloat32Int32V(v map[float32]int32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6217,44 +4551,47 @@ func (_ fastpathT) EncMapFloat32Int64V(v map[float32]int64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeInt(int64(v[float32(k2)]))
 			}
-			ee.EncodeInt(int64(v[float32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6263,44 +4600,47 @@ func (_ fastpathT) EncMapFloat32Float32V(v map[float32]float32, checkNil bool, e
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[float32(k2)])
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeFloat32(v[float32(k2)])
 			}
-			ee.EncodeFloat32(v[float32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6309,44 +4649,47 @@ func (_ fastpathT) EncMapFloat32Float64V(v map[float32]float64, checkNil bool, e
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[float32(k2)])
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeFloat64(v[float32(k2)])
 			}
-			ee.EncodeFloat64(v[float32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6355,44 +4698,47 @@ func (_ fastpathT) EncMapFloat32BoolV(v map[float32]bool, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(float32(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[float32(k2)])
 			}
-			ee.EncodeFloat32(float32(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat32(float32(k2))
+				ee.EncodeBool(v[float32(k2)])
 			}
-			ee.EncodeBool(v[float32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat32(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeFloat32(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat32(k2)
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6401,44 +4747,47 @@ func (_ fastpathT) EncMapFloat64IntfV(v map[float64]interface{}, checkNil bool,
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v[float64(k2)])
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				e.encode(v[float64(k2)])
 			}
-			e.encode(v[float64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6447,44 +4796,47 @@ func (_ fastpathT) EncMapFloat64StringV(v map[float64]string, checkNil bool, e *
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[float64(k2)])
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeString(cUTF8, v[float64(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[float64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6493,44 +4845,47 @@ func (_ fastpathT) EncMapFloat64UintV(v map[float64]uint, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6539,44 +4894,47 @@ func (_ fastpathT) EncMapFloat64Uint8V(v map[float64]uint8, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6585,44 +4943,47 @@ func (_ fastpathT) EncMapFloat64Uint16V(v map[float64]uint16, checkNil bool, e *
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6631,44 +4992,47 @@ func (_ fastpathT) EncMapFloat64Uint32V(v map[float64]uint32, checkNil bool, e *
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6677,44 +5041,47 @@ func (_ fastpathT) EncMapFloat64Uint64V(v map[float64]uint64, checkNil bool, e *
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeUint(uint64(v[float64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6723,44 +5090,47 @@ func (_ fastpathT) EncMapFloat64UintptrV(v map[float64]uintptr, checkNil bool, e
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v[float64(k2)])
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				e.encode(v[float64(k2)])
 			}
-			e.encode(v[float64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6769,44 +5139,47 @@ func (_ fastpathT) EncMapFloat64IntV(v map[float64]int, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6815,44 +5188,47 @@ func (_ fastpathT) EncMapFloat64Int8V(v map[float64]int8, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6861,44 +5237,47 @@ func (_ fastpathT) EncMapFloat64Int16V(v map[float64]int16, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6907,44 +5286,47 @@ func (_ fastpathT) EncMapFloat64Int32V(v map[float64]int32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6953,44 +5335,47 @@ func (_ fastpathT) EncMapFloat64Int64V(v map[float64]int64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeInt(int64(v[float64(k2)]))
 			}
-			ee.EncodeInt(int64(v[float64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -6999,44 +5384,47 @@ func (_ fastpathT) EncMapFloat64Float32V(v map[float64]float32, checkNil bool, e
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[float64(k2)])
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeFloat32(v[float64(k2)])
 			}
-			ee.EncodeFloat32(v[float64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -7045,44 +5433,47 @@ func (_ fastpathT) EncMapFloat64Float64V(v map[float64]float64, checkNil bool, e
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[float64(k2)])
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeFloat64(v[float64(k2)])
 			}
-			ee.EncodeFloat64(v[float64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]float64, len(v))
 		var i int
@@ -7091,44 +5482,47 @@ func (_ fastpathT) EncMapFloat64BoolV(v map[float64]bool, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(floatSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(float64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[float64(k2)])
 			}
-			ee.EncodeFloat64(float64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeFloat64(float64(k2))
+				ee.EncodeBool(v[float64(k2)])
 			}
-			ee.EncodeBool(v[float64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeFloat64(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeFloat64(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeFloat64(k2)
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7137,44 +5531,47 @@ func (_ fastpathT) EncMapUintIntfV(v map[uint]interface{}, checkNil bool, e *Enc
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint(k2)])
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				e.encode(v[uint(k2)])
 			}
-			e.encode(v[uint(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintStringV(v map[uint]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7183,44 +5580,47 @@ func (_ fastpathT) EncMapUintStringV(v map[uint]string, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[uint(k2)])
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeString(cUTF8, v[uint(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[uint(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintUintV(v map[uint]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7229,44 +5629,47 @@ func (_ fastpathT) EncMapUintUintV(v map[uint]uint, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7275,44 +5678,47 @@ func (_ fastpathT) EncMapUintUint8V(v map[uint]uint8, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7321,44 +5727,47 @@ func (_ fastpathT) EncMapUintUint16V(v map[uint]uint16, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7367,44 +5776,47 @@ func (_ fastpathT) EncMapUintUint32V(v map[uint]uint32, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7413,44 +5825,47 @@ func (_ fastpathT) EncMapUintUint64V(v map[uint]uint64, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeUint(uint64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7459,44 +5874,47 @@ func (_ fastpathT) EncMapUintUintptrV(v map[uint]uintptr, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint(k2)])
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				e.encode(v[uint(k2)])
 			}
-			e.encode(v[uint(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintIntV(v map[uint]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7505,44 +5923,47 @@ func (_ fastpathT) EncMapUintIntV(v map[uint]int, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7551,44 +5972,47 @@ func (_ fastpathT) EncMapUintInt8V(v map[uint]int8, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7597,44 +6021,47 @@ func (_ fastpathT) EncMapUintInt16V(v map[uint]int16, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7643,44 +6070,47 @@ func (_ fastpathT) EncMapUintInt32V(v map[uint]int32, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7689,44 +6119,47 @@ func (_ fastpathT) EncMapUintInt64V(v map[uint]int64, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeInt(int64(v[uint(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7735,44 +6168,47 @@ func (_ fastpathT) EncMapUintFloat32V(v map[uint]float32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[uint(k2)])
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeFloat32(v[uint(k2)])
 			}
-			ee.EncodeFloat32(v[uint(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7781,44 +6217,47 @@ func (_ fastpathT) EncMapUintFloat64V(v map[uint]float64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[uint(k2)])
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeFloat64(v[uint(k2)])
 			}
-			ee.EncodeFloat64(v[uint(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7827,44 +6266,47 @@ func (_ fastpathT) EncMapUintBoolV(v map[uint]bool, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[uint(k2)])
 			}
-			ee.EncodeUint(uint64(uint(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint(k2)))
+				ee.EncodeBool(v[uint(k2)])
 			}
-			ee.EncodeBool(v[uint(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7873,44 +6315,47 @@ func (_ fastpathT) EncMapUint8IntfV(v map[uint8]interface{}, checkNil bool, e *E
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint8(k2)])
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				e.encode(v[uint8(k2)])
 			}
-			e.encode(v[uint8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7919,44 +6364,47 @@ func (_ fastpathT) EncMapUint8StringV(v map[uint8]string, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[uint8(k2)])
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeString(cUTF8, v[uint8(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[uint8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -7965,44 +6413,47 @@ func (_ fastpathT) EncMapUint8UintV(v map[uint8]uint, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8011,44 +6462,47 @@ func (_ fastpathT) EncMapUint8Uint8V(v map[uint8]uint8, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8057,44 +6511,47 @@ func (_ fastpathT) EncMapUint8Uint16V(v map[uint8]uint16, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8103,44 +6560,47 @@ func (_ fastpathT) EncMapUint8Uint32V(v map[uint8]uint32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8149,44 +6609,47 @@ func (_ fastpathT) EncMapUint8Uint64V(v map[uint8]uint64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeUint(uint64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8195,44 +6658,47 @@ func (_ fastpathT) EncMapUint8UintptrV(v map[uint8]uintptr, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint8(k2)])
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				e.encode(v[uint8(k2)])
 			}
-			e.encode(v[uint8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8241,44 +6707,47 @@ func (_ fastpathT) EncMapUint8IntV(v map[uint8]int, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8287,44 +6756,47 @@ func (_ fastpathT) EncMapUint8Int8V(v map[uint8]int8, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8333,44 +6805,47 @@ func (_ fastpathT) EncMapUint8Int16V(v map[uint8]int16, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8379,44 +6854,47 @@ func (_ fastpathT) EncMapUint8Int32V(v map[uint8]int32, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8425,44 +6903,47 @@ func (_ fastpathT) EncMapUint8Int64V(v map[uint8]int64, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeInt(int64(v[uint8(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8471,44 +6952,47 @@ func (_ fastpathT) EncMapUint8Float32V(v map[uint8]float32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[uint8(k2)])
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeFloat32(v[uint8(k2)])
 			}
-			ee.EncodeFloat32(v[uint8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8517,44 +7001,47 @@ func (_ fastpathT) EncMapUint8Float64V(v map[uint8]float64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[uint8(k2)])
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeFloat64(v[uint8(k2)])
 			}
-			ee.EncodeFloat64(v[uint8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8563,44 +7050,47 @@ func (_ fastpathT) EncMapUint8BoolV(v map[uint8]bool, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[uint8(k2)])
 			}
-			ee.EncodeUint(uint64(uint8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint8(k2)))
+				ee.EncodeBool(v[uint8(k2)])
 			}
-			ee.EncodeBool(v[uint8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8609,44 +7099,47 @@ func (_ fastpathT) EncMapUint16IntfV(v map[uint16]interface{}, checkNil bool, e
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint16(k2)])
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				e.encode(v[uint16(k2)])
 			}
-			e.encode(v[uint16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8655,44 +7148,47 @@ func (_ fastpathT) EncMapUint16StringV(v map[uint16]string, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[uint16(k2)])
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeString(cUTF8, v[uint16(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[uint16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8701,44 +7197,47 @@ func (_ fastpathT) EncMapUint16UintV(v map[uint16]uint, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8747,44 +7246,47 @@ func (_ fastpathT) EncMapUint16Uint8V(v map[uint16]uint8, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8793,44 +7295,47 @@ func (_ fastpathT) EncMapUint16Uint16V(v map[uint16]uint16, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8839,44 +7344,47 @@ func (_ fastpathT) EncMapUint16Uint32V(v map[uint16]uint32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8885,44 +7393,47 @@ func (_ fastpathT) EncMapUint16Uint64V(v map[uint16]uint64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeUint(uint64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8931,44 +7442,47 @@ func (_ fastpathT) EncMapUint16UintptrV(v map[uint16]uintptr, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint16(k2)])
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				e.encode(v[uint16(k2)])
 			}
-			e.encode(v[uint16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -8977,44 +7491,47 @@ func (_ fastpathT) EncMapUint16IntV(v map[uint16]int, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9023,44 +7540,47 @@ func (_ fastpathT) EncMapUint16Int8V(v map[uint16]int8, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9069,44 +7589,47 @@ func (_ fastpathT) EncMapUint16Int16V(v map[uint16]int16, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9115,44 +7638,47 @@ func (_ fastpathT) EncMapUint16Int32V(v map[uint16]int32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9161,44 +7687,47 @@ func (_ fastpathT) EncMapUint16Int64V(v map[uint16]int64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeInt(int64(v[uint16(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9207,44 +7736,47 @@ func (_ fastpathT) EncMapUint16Float32V(v map[uint16]float32, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[uint16(k2)])
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeFloat32(v[uint16(k2)])
 			}
-			ee.EncodeFloat32(v[uint16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9253,44 +7785,47 @@ func (_ fastpathT) EncMapUint16Float64V(v map[uint16]float64, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[uint16(k2)])
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeFloat64(v[uint16(k2)])
 			}
-			ee.EncodeFloat64(v[uint16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9299,44 +7834,47 @@ func (_ fastpathT) EncMapUint16BoolV(v map[uint16]bool, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[uint16(k2)])
 			}
-			ee.EncodeUint(uint64(uint16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint16(k2)))
+				ee.EncodeBool(v[uint16(k2)])
 			}
-			ee.EncodeBool(v[uint16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9345,44 +7883,47 @@ func (_ fastpathT) EncMapUint32IntfV(v map[uint32]interface{}, checkNil bool, e
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint32(k2)])
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				e.encode(v[uint32(k2)])
 			}
-			e.encode(v[uint32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9391,44 +7932,47 @@ func (_ fastpathT) EncMapUint32StringV(v map[uint32]string, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[uint32(k2)])
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeString(cUTF8, v[uint32(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[uint32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9437,44 +7981,47 @@ func (_ fastpathT) EncMapUint32UintV(v map[uint32]uint, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9483,44 +8030,47 @@ func (_ fastpathT) EncMapUint32Uint8V(v map[uint32]uint8, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9529,44 +8079,47 @@ func (_ fastpathT) EncMapUint32Uint16V(v map[uint32]uint16, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9575,44 +8128,47 @@ func (_ fastpathT) EncMapUint32Uint32V(v map[uint32]uint32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9621,44 +8177,47 @@ func (_ fastpathT) EncMapUint32Uint64V(v map[uint32]uint64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeUint(uint64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9667,44 +8226,47 @@ func (_ fastpathT) EncMapUint32UintptrV(v map[uint32]uintptr, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint32(k2)])
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				e.encode(v[uint32(k2)])
 			}
-			e.encode(v[uint32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9713,44 +8275,47 @@ func (_ fastpathT) EncMapUint32IntV(v map[uint32]int, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9759,44 +8324,47 @@ func (_ fastpathT) EncMapUint32Int8V(v map[uint32]int8, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9805,44 +8373,47 @@ func (_ fastpathT) EncMapUint32Int16V(v map[uint32]int16, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9851,44 +8422,47 @@ func (_ fastpathT) EncMapUint32Int32V(v map[uint32]int32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9897,44 +8471,47 @@ func (_ fastpathT) EncMapUint32Int64V(v map[uint32]int64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeInt(int64(v[uint32(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9943,44 +8520,47 @@ func (_ fastpathT) EncMapUint32Float32V(v map[uint32]float32, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[uint32(k2)])
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeFloat32(v[uint32(k2)])
 			}
-			ee.EncodeFloat32(v[uint32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -9989,44 +8569,47 @@ func (_ fastpathT) EncMapUint32Float64V(v map[uint32]float64, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[uint32(k2)])
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeFloat64(v[uint32(k2)])
 			}
-			ee.EncodeFloat64(v[uint32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10035,44 +8618,47 @@ func (_ fastpathT) EncMapUint32BoolV(v map[uint32]bool, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[uint32(k2)])
 			}
-			ee.EncodeUint(uint64(uint32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint32(k2)))
+				ee.EncodeBool(v[uint32(k2)])
 			}
-			ee.EncodeBool(v[uint32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10081,44 +8667,47 @@ func (_ fastpathT) EncMapUint64IntfV(v map[uint64]interface{}, checkNil bool, e
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint64(k2)])
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				e.encode(v[uint64(k2)])
 			}
-			e.encode(v[uint64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10127,44 +8716,47 @@ func (_ fastpathT) EncMapUint64StringV(v map[uint64]string, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[uint64(k2)])
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeString(cUTF8, v[uint64(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[uint64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10173,44 +8765,47 @@ func (_ fastpathT) EncMapUint64UintV(v map[uint64]uint, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10219,44 +8814,47 @@ func (_ fastpathT) EncMapUint64Uint8V(v map[uint64]uint8, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10265,44 +8863,47 @@ func (_ fastpathT) EncMapUint64Uint16V(v map[uint64]uint16, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10311,44 +8912,47 @@ func (_ fastpathT) EncMapUint64Uint32V(v map[uint64]uint32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10357,44 +8961,47 @@ func (_ fastpathT) EncMapUint64Uint64V(v map[uint64]uint64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeUint(uint64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10403,44 +9010,47 @@ func (_ fastpathT) EncMapUint64UintptrV(v map[uint64]uintptr, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[uint64(k2)])
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				e.encode(v[uint64(k2)])
 			}
-			e.encode(v[uint64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10449,44 +9059,47 @@ func (_ fastpathT) EncMapUint64IntV(v map[uint64]int, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10495,44 +9108,47 @@ func (_ fastpathT) EncMapUint64Int8V(v map[uint64]int8, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10541,44 +9157,47 @@ func (_ fastpathT) EncMapUint64Int16V(v map[uint64]int16, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10587,44 +9206,47 @@ func (_ fastpathT) EncMapUint64Int32V(v map[uint64]int32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10633,44 +9255,47 @@ func (_ fastpathT) EncMapUint64Int64V(v map[uint64]int64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeInt(int64(v[uint64(k2)]))
 			}
-			ee.EncodeInt(int64(v[uint64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10679,44 +9304,47 @@ func (_ fastpathT) EncMapUint64Float32V(v map[uint64]float32, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[uint64(k2)])
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeFloat32(v[uint64(k2)])
 			}
-			ee.EncodeFloat32(v[uint64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10725,44 +9353,47 @@ func (_ fastpathT) EncMapUint64Float64V(v map[uint64]float64, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[uint64(k2)])
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeFloat64(v[uint64(k2)])
 			}
-			ee.EncodeFloat64(v[uint64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10771,44 +9402,47 @@ func (_ fastpathT) EncMapUint64BoolV(v map[uint64]bool, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[uint64(k2)])
 			}
-			ee.EncodeUint(uint64(uint64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeUint(uint64(uint64(k2)))
+				ee.EncodeBool(v[uint64(k2)])
 			}
-			ee.EncodeBool(v[uint64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeUint(uint64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeUint(uint64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeUint(uint64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10817,44 +9451,47 @@ func (_ fastpathT) EncMapUintptrIntfV(v map[uintptr]interface{}, checkNil bool,
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				e.encode(v[uintptr(k2)])
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				e.encode(v[uintptr(k2)])
 			}
-			e.encode(v[uintptr(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10863,44 +9500,47 @@ func (_ fastpathT) EncMapUintptrStringV(v map[uintptr]string, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[uintptr(k2)])
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeString(cUTF8, v[uintptr(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[uintptr(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10909,44 +9549,47 @@ func (_ fastpathT) EncMapUintptrUintV(v map[uintptr]uint, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -10955,44 +9598,47 @@ func (_ fastpathT) EncMapUintptrUint8V(v map[uintptr]uint8, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11001,44 +9647,47 @@ func (_ fastpathT) EncMapUintptrUint16V(v map[uintptr]uint16, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11047,44 +9696,47 @@ func (_ fastpathT) EncMapUintptrUint32V(v map[uintptr]uint32, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11093,44 +9745,47 @@ func (_ fastpathT) EncMapUintptrUint64V(v map[uintptr]uint64, checkNil bool, e *
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeUint(uint64(v[uintptr(k2)]))
 			}
-			ee.EncodeUint(uint64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11139,44 +9794,47 @@ func (_ fastpathT) EncMapUintptrUintptrV(v map[uintptr]uintptr, checkNil bool, e
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				e.encode(v[uintptr(k2)])
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				e.encode(v[uintptr(k2)])
 			}
-			e.encode(v[uintptr(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11185,44 +9843,47 @@ func (_ fastpathT) EncMapUintptrIntV(v map[uintptr]int, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11231,44 +9892,47 @@ func (_ fastpathT) EncMapUintptrInt8V(v map[uintptr]int8, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11277,44 +9941,47 @@ func (_ fastpathT) EncMapUintptrInt16V(v map[uintptr]int16, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11323,44 +9990,47 @@ func (_ fastpathT) EncMapUintptrInt32V(v map[uintptr]int32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11369,44 +10039,47 @@ func (_ fastpathT) EncMapUintptrInt64V(v map[uintptr]int64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeInt(int64(v[uintptr(k2)]))
 			}
-			ee.EncodeInt(int64(v[uintptr(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11415,44 +10088,47 @@ func (_ fastpathT) EncMapUintptrFloat32V(v map[uintptr]float32, checkNil bool, e
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[uintptr(k2)])
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeFloat32(v[uintptr(k2)])
 			}
-			ee.EncodeFloat32(v[uintptr(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11461,44 +10137,47 @@ func (_ fastpathT) EncMapUintptrFloat64V(v map[uintptr]float64, checkNil bool, e
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[uintptr(k2)])
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeFloat64(v[uintptr(k2)])
 			}
-			ee.EncodeFloat64(v[uintptr(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]uint64, len(v))
 		var i int
@@ -11507,44 +10186,47 @@ func (_ fastpathT) EncMapUintptrBoolV(v map[uintptr]bool, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(uintSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				e.encode(uintptr(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[uintptr(k2)])
 			}
-			e.encode(uintptr(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				e.encode(uintptr(k2))
+				ee.EncodeBool(v[uintptr(k2)])
 			}
-			ee.EncodeBool(v[uintptr(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				e.encode(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			e.encode(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				e.encode(k2)
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11553,44 +10235,47 @@ func (_ fastpathT) EncMapIntIntfV(v map[int]interface{}, checkNil bool, e *Encod
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int(k2)])
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				e.encode(v[int(k2)])
 			}
-			e.encode(v[int(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntStringV(v map[int]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11599,44 +10284,47 @@ func (_ fastpathT) EncMapIntStringV(v map[int]string, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[int(k2)])
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeString(cUTF8, v[int(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[int(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntUintV(v map[int]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11645,44 +10333,47 @@ func (_ fastpathT) EncMapIntUintV(v map[int]uint, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11691,44 +10382,47 @@ func (_ fastpathT) EncMapIntUint8V(v map[int]uint8, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11737,44 +10431,47 @@ func (_ fastpathT) EncMapIntUint16V(v map[int]uint16, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11783,44 +10480,47 @@ func (_ fastpathT) EncMapIntUint32V(v map[int]uint32, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11829,44 +10529,47 @@ func (_ fastpathT) EncMapIntUint64V(v map[int]uint64, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeUint(uint64(v[int(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11875,44 +10578,47 @@ func (_ fastpathT) EncMapIntUintptrV(v map[int]uintptr, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int(k2)])
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				e.encode(v[int(k2)])
 			}
-			e.encode(v[int(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntIntV(v map[int]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11921,44 +10627,47 @@ func (_ fastpathT) EncMapIntIntV(v map[int]int, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntInt8V(v map[int]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -11967,44 +10676,47 @@ func (_ fastpathT) EncMapIntInt8V(v map[int]int8, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntInt16V(v map[int]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12013,44 +10725,47 @@ func (_ fastpathT) EncMapIntInt16V(v map[int]int16, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntInt32V(v map[int]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12059,44 +10774,47 @@ func (_ fastpathT) EncMapIntInt32V(v map[int]int32, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntInt64V(v map[int]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12105,44 +10823,47 @@ func (_ fastpathT) EncMapIntInt64V(v map[int]int64, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeInt(int64(v[int(k2)]))
 			}
-			ee.EncodeInt(int64(v[int(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12151,44 +10872,47 @@ func (_ fastpathT) EncMapIntFloat32V(v map[int]float32, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[int(k2)])
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeFloat32(v[int(k2)])
 			}
-			ee.EncodeFloat32(v[int(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12197,44 +10921,47 @@ func (_ fastpathT) EncMapIntFloat64V(v map[int]float64, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[int(k2)])
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeFloat64(v[int(k2)])
 			}
-			ee.EncodeFloat64(v[int(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapIntBoolV(v map[int]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12243,44 +10970,47 @@ func (_ fastpathT) EncMapIntBoolV(v map[int]bool, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[int(k2)])
 			}
-			ee.EncodeInt(int64(int(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int(k2)))
+				ee.EncodeBool(v[int(k2)])
 			}
-			ee.EncodeBool(v[int(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12289,44 +11019,47 @@ func (_ fastpathT) EncMapInt8IntfV(v map[int8]interface{}, checkNil bool, e *Enc
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int8(k2)])
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				e.encode(v[int8(k2)])
 			}
-			e.encode(v[int8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt8StringV(v map[int8]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12335,44 +11068,47 @@ func (_ fastpathT) EncMapInt8StringV(v map[int8]string, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[int8(k2)])
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeString(cUTF8, v[int8(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[int8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12381,44 +11117,47 @@ func (_ fastpathT) EncMapInt8UintV(v map[int8]uint, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12427,44 +11166,47 @@ func (_ fastpathT) EncMapInt8Uint8V(v map[int8]uint8, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12473,44 +11215,47 @@ func (_ fastpathT) EncMapInt8Uint16V(v map[int8]uint16, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12519,44 +11264,47 @@ func (_ fastpathT) EncMapInt8Uint32V(v map[int8]uint32, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12565,44 +11313,47 @@ func (_ fastpathT) EncMapInt8Uint64V(v map[int8]uint64, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeUint(uint64(v[int8(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12611,44 +11362,47 @@ func (_ fastpathT) EncMapInt8UintptrV(v map[int8]uintptr, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int8(k2)])
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				e.encode(v[int8(k2)])
 			}
-			e.encode(v[int8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt8IntV(v map[int8]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12657,44 +11411,47 @@ func (_ fastpathT) EncMapInt8IntV(v map[int8]int, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12703,44 +11460,47 @@ func (_ fastpathT) EncMapInt8Int8V(v map[int8]int8, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12749,44 +11509,47 @@ func (_ fastpathT) EncMapInt8Int16V(v map[int8]int16, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12795,44 +11558,47 @@ func (_ fastpathT) EncMapInt8Int32V(v map[int8]int32, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12841,44 +11607,47 @@ func (_ fastpathT) EncMapInt8Int64V(v map[int8]int64, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeInt(int64(v[int8(k2)]))
 			}
-			ee.EncodeInt(int64(v[int8(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12887,44 +11656,47 @@ func (_ fastpathT) EncMapInt8Float32V(v map[int8]float32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[int8(k2)])
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeFloat32(v[int8(k2)])
 			}
-			ee.EncodeFloat32(v[int8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12933,44 +11705,47 @@ func (_ fastpathT) EncMapInt8Float64V(v map[int8]float64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[int8(k2)])
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeFloat64(v[int8(k2)])
 			}
-			ee.EncodeFloat64(v[int8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -12979,44 +11754,47 @@ func (_ fastpathT) EncMapInt8BoolV(v map[int8]bool, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int8(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[int8(k2)])
 			}
-			ee.EncodeInt(int64(int8(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int8(k2)))
+				ee.EncodeBool(v[int8(k2)])
 			}
-			ee.EncodeBool(v[int8(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13025,44 +11803,47 @@ func (_ fastpathT) EncMapInt16IntfV(v map[int16]interface{}, checkNil bool, e *E
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int16(k2)])
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				e.encode(v[int16(k2)])
 			}
-			e.encode(v[int16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt16StringV(v map[int16]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13071,44 +11852,47 @@ func (_ fastpathT) EncMapInt16StringV(v map[int16]string, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[int16(k2)])
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeString(cUTF8, v[int16(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[int16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13117,44 +11901,47 @@ func (_ fastpathT) EncMapInt16UintV(v map[int16]uint, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13163,44 +11950,47 @@ func (_ fastpathT) EncMapInt16Uint8V(v map[int16]uint8, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13209,44 +11999,47 @@ func (_ fastpathT) EncMapInt16Uint16V(v map[int16]uint16, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13255,44 +12048,47 @@ func (_ fastpathT) EncMapInt16Uint32V(v map[int16]uint32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13301,44 +12097,47 @@ func (_ fastpathT) EncMapInt16Uint64V(v map[int16]uint64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeUint(uint64(v[int16(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13347,44 +12146,47 @@ func (_ fastpathT) EncMapInt16UintptrV(v map[int16]uintptr, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int16(k2)])
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				e.encode(v[int16(k2)])
 			}
-			e.encode(v[int16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt16IntV(v map[int16]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13393,44 +12195,47 @@ func (_ fastpathT) EncMapInt16IntV(v map[int16]int, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13439,44 +12244,47 @@ func (_ fastpathT) EncMapInt16Int8V(v map[int16]int8, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13485,44 +12293,47 @@ func (_ fastpathT) EncMapInt16Int16V(v map[int16]int16, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13531,44 +12342,47 @@ func (_ fastpathT) EncMapInt16Int32V(v map[int16]int32, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13577,44 +12391,47 @@ func (_ fastpathT) EncMapInt16Int64V(v map[int16]int64, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeInt(int64(v[int16(k2)]))
 			}
-			ee.EncodeInt(int64(v[int16(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13623,44 +12440,47 @@ func (_ fastpathT) EncMapInt16Float32V(v map[int16]float32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[int16(k2)])
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeFloat32(v[int16(k2)])
 			}
-			ee.EncodeFloat32(v[int16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13669,44 +12489,47 @@ func (_ fastpathT) EncMapInt16Float64V(v map[int16]float64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[int16(k2)])
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeFloat64(v[int16(k2)])
 			}
-			ee.EncodeFloat64(v[int16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13715,44 +12538,47 @@ func (_ fastpathT) EncMapInt16BoolV(v map[int16]bool, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int16(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[int16(k2)])
 			}
-			ee.EncodeInt(int64(int16(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int16(k2)))
+				ee.EncodeBool(v[int16(k2)])
 			}
-			ee.EncodeBool(v[int16(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13761,44 +12587,47 @@ func (_ fastpathT) EncMapInt32IntfV(v map[int32]interface{}, checkNil bool, e *E
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int32(k2)])
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				e.encode(v[int32(k2)])
 			}
-			e.encode(v[int32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt32StringV(v map[int32]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13807,44 +12636,47 @@ func (_ fastpathT) EncMapInt32StringV(v map[int32]string, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[int32(k2)])
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeString(cUTF8, v[int32(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[int32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13853,44 +12685,47 @@ func (_ fastpathT) EncMapInt32UintV(v map[int32]uint, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13899,44 +12734,47 @@ func (_ fastpathT) EncMapInt32Uint8V(v map[int32]uint8, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13945,44 +12783,47 @@ func (_ fastpathT) EncMapInt32Uint16V(v map[int32]uint16, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -13991,44 +12832,47 @@ func (_ fastpathT) EncMapInt32Uint32V(v map[int32]uint32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14037,44 +12881,47 @@ func (_ fastpathT) EncMapInt32Uint64V(v map[int32]uint64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeUint(uint64(v[int32(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14083,44 +12930,47 @@ func (_ fastpathT) EncMapInt32UintptrV(v map[int32]uintptr, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int32(k2)])
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				e.encode(v[int32(k2)])
 			}
-			e.encode(v[int32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt32IntV(v map[int32]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14129,44 +12979,47 @@ func (_ fastpathT) EncMapInt32IntV(v map[int32]int, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14175,44 +13028,47 @@ func (_ fastpathT) EncMapInt32Int8V(v map[int32]int8, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14221,44 +13077,47 @@ func (_ fastpathT) EncMapInt32Int16V(v map[int32]int16, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14267,44 +13126,47 @@ func (_ fastpathT) EncMapInt32Int32V(v map[int32]int32, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14313,44 +13175,47 @@ func (_ fastpathT) EncMapInt32Int64V(v map[int32]int64, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeInt(int64(v[int32(k2)]))
 			}
-			ee.EncodeInt(int64(v[int32(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14359,44 +13224,47 @@ func (_ fastpathT) EncMapInt32Float32V(v map[int32]float32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[int32(k2)])
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeFloat32(v[int32(k2)])
 			}
-			ee.EncodeFloat32(v[int32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14405,44 +13273,47 @@ func (_ fastpathT) EncMapInt32Float64V(v map[int32]float64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[int32(k2)])
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeFloat64(v[int32(k2)])
 			}
-			ee.EncodeFloat64(v[int32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14451,44 +13322,47 @@ func (_ fastpathT) EncMapInt32BoolV(v map[int32]bool, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int32(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[int32(k2)])
 			}
-			ee.EncodeInt(int64(int32(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int32(k2)))
+				ee.EncodeBool(v[int32(k2)])
 			}
-			ee.EncodeBool(v[int32(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14497,44 +13371,47 @@ func (_ fastpathT) EncMapInt64IntfV(v map[int64]interface{}, checkNil bool, e *E
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int64(k2)])
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				e.encode(v[int64(k2)])
 			}
-			e.encode(v[int64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt64StringV(v map[int64]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14543,44 +13420,47 @@ func (_ fastpathT) EncMapInt64StringV(v map[int64]string, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[int64(k2)])
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeString(cUTF8, v[int64(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[int64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14589,44 +13469,47 @@ func (_ fastpathT) EncMapInt64UintV(v map[int64]uint, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14635,44 +13518,47 @@ func (_ fastpathT) EncMapInt64Uint8V(v map[int64]uint8, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14681,44 +13567,47 @@ func (_ fastpathT) EncMapInt64Uint16V(v map[int64]uint16, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14727,44 +13616,47 @@ func (_ fastpathT) EncMapInt64Uint32V(v map[int64]uint32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14773,44 +13665,47 @@ func (_ fastpathT) EncMapInt64Uint64V(v map[int64]uint64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeUint(uint64(v[int64(k2)]))
 			}
-			ee.EncodeUint(uint64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14819,44 +13714,47 @@ func (_ fastpathT) EncMapInt64UintptrV(v map[int64]uintptr, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				e.encode(v[int64(k2)])
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				e.encode(v[int64(k2)])
 			}
-			e.encode(v[int64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt64IntV(v map[int64]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14865,44 +13763,47 @@ func (_ fastpathT) EncMapInt64IntV(v map[int64]int, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14911,44 +13812,47 @@ func (_ fastpathT) EncMapInt64Int8V(v map[int64]int8, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -14957,44 +13861,47 @@ func (_ fastpathT) EncMapInt64Int16V(v map[int64]int16, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15003,44 +13910,47 @@ func (_ fastpathT) EncMapInt64Int32V(v map[int64]int32, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15049,44 +13959,47 @@ func (_ fastpathT) EncMapInt64Int64V(v map[int64]int64, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeInt(int64(v[int64(k2)]))
 			}
-			ee.EncodeInt(int64(v[int64(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15095,44 +14008,47 @@ func (_ fastpathT) EncMapInt64Float32V(v map[int64]float32, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[int64(k2)])
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeFloat32(v[int64(k2)])
 			}
-			ee.EncodeFloat32(v[int64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15141,44 +14057,47 @@ func (_ fastpathT) EncMapInt64Float64V(v map[int64]float64, checkNil bool, e *En
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[int64(k2)])
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeFloat64(v[int64(k2)])
 			}
-			ee.EncodeFloat64(v[int64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]int64, len(v))
 		var i int
@@ -15187,44 +14106,47 @@ func (_ fastpathT) EncMapInt64BoolV(v map[int64]bool, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(intSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(int64(k2)))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[int64(k2)])
 			}
-			ee.EncodeInt(int64(int64(k2)))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeInt(int64(int64(k2)))
+				ee.EncodeBool(v[int64(k2)])
 			}
-			ee.EncodeBool(v[int64(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeInt(int64(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeInt(int64(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeInt(int64(k2))
+				ee.EncodeBool(v2)
 			}
-			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()
+func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15233,44 +14155,47 @@ func (_ fastpathT) EncMapBoolIntfV(v map[bool]interface{}, checkNil bool, e *Enc
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				e.encode(v[bool(k2)])
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				e.encode(v[bool(k2)])
 			}
-			e.encode(v[bool(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapBoolStringV(v map[bool]string, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15279,44 +14204,47 @@ func (_ fastpathT) EncMapBoolStringV(v map[bool]string, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v[bool(k2)])
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeString(cUTF8, v[bool(k2)])
 			}
-			ee.EncodeString(c_UTF8, v[bool(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeString(cUTF8, v2)
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeString(cUTF8, v2)
 			}
-			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()
+func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15325,44 +14253,47 @@ func (_ fastpathT) EncMapBoolUintV(v map[bool]uint, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15371,44 +14302,47 @@ func (_ fastpathT) EncMapBoolUint8V(v map[bool]uint8, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15417,44 +14351,47 @@ func (_ fastpathT) EncMapBoolUint16V(v map[bool]uint16, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15463,44 +14400,47 @@ func (_ fastpathT) EncMapBoolUint32V(v map[bool]uint32, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15509,44 +14449,47 @@ func (_ fastpathT) EncMapBoolUint64V(v map[bool]uint64, checkNil bool, e *Encode
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeUint(uint64(v[bool(k2)]))
 			}
-			ee.EncodeUint(uint64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeUint(uint64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeUint(uint64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15555,44 +14498,47 @@ func (_ fastpathT) EncMapBoolUintptrV(v map[bool]uintptr, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				e.encode(v[bool(k2)])
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				e.encode(v[bool(k2)])
 			}
-			e.encode(v[bool(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				e.encode(v2)
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				e.encode(v2)
 			}
-			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()
+func (_ fastpathT) EncMapBoolIntV(v map[bool]int, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15601,44 +14547,47 @@ func (_ fastpathT) EncMapBoolIntV(v map[bool]int, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15647,44 +14596,47 @@ func (_ fastpathT) EncMapBoolInt8V(v map[bool]int8, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15693,44 +14645,47 @@ func (_ fastpathT) EncMapBoolInt16V(v map[bool]int16, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15739,44 +14694,47 @@ func (_ fastpathT) EncMapBoolInt32V(v map[bool]int32, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15785,44 +14743,47 @@ func (_ fastpathT) EncMapBoolInt64V(v map[bool]int64, checkNil bool, e *Encoder)
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeInt(int64(v[bool(k2)]))
 			}
-			ee.EncodeInt(int64(v[bool(k2)]))
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeInt(int64(v2))
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeInt(int64(v2))
 			}
-			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()
+func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15831,44 +14792,47 @@ func (_ fastpathT) EncMapBoolFloat32V(v map[bool]float32, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v[bool(k2)])
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeFloat32(v[bool(k2)])
 			}
-			ee.EncodeFloat32(v[bool(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat32(v2)
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeFloat32(v2)
 			}
-			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()
+func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15877,44 +14841,47 @@ func (_ fastpathT) EncMapBoolFloat64V(v map[bool]float64, checkNil bool, e *Enco
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v[bool(k2)])
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeFloat64(v[bool(k2)])
 			}
-			ee.EncodeFloat64(v[bool(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeFloat64(v2)
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeFloat64(v2)
 			}
-			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()
+func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, e *Encoder) {
+	if v == nil {
+		e.e.EncodeNil()
 		return
 	}
-	ee.EncodeMapStart(len(v))
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteMapStart(len(v))
 	if e.h.Canonical {
 		v2 := make([]bool, len(v))
 		var i int
@@ -15923,2212 +14890,2830 @@ func (_ fastpathT) EncMapBoolBoolV(v map[bool]bool, checkNil bool, e *Encoder) {
 			i++
 		}
 		sort.Sort(boolSlice(v2))
-		for _, k2 := range v2 {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(bool(k2))
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v[bool(k2)])
 			}
-			ee.EncodeBool(bool(k2))
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for _, k2 := range v2 {
+				ee.EncodeBool(bool(k2))
+				ee.EncodeBool(v[bool(k2)])
 			}
-			ee.EncodeBool(v[bool(k2)])
 		}
 	} else {
-		for k2, v2 := range v {
-			if cr != nil {
-				cr.sendContainerState(containerMapKey)
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				ee.EncodeBool(k2)
+				ee.WriteMapElemValue()
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeBool(k2)
-			if cr != nil {
-				cr.sendContainerState(containerMapValue)
+		} else {
+			for k2, v2 := range v {
+				ee.EncodeBool(k2)
+				ee.EncodeBool(v2)
 			}
-			ee.EncodeBool(v2)
 		}
 	}
-	if cr != nil {
-		cr.sendContainerState(containerMapEnd)
-	}
+	ee.WriteMapEnd()
 }
 
 // -- decode
 
 // -- -- fast path type switch
 func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
-	if !fastpathEnabled {
-		return false
-	}
+	var changed bool
 	switch v := iv.(type) {
 
 	case []interface{}:
-		fastpathTV.DecSliceIntfV(v, fastpathCheckNilFalse, false, d)
+		var v2 []interface{}
+		v2, changed = fastpathTV.DecSliceIntfV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	case *[]interface{}:
-		v2, changed2 := fastpathTV.DecSliceIntfV(*v, fastpathCheckNilFalse, true, d)
-		if changed2 {
+		var v2 []interface{}
+		v2, changed = fastpathTV.DecSliceIntfV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []string:
+		var v2 []string
+		v2, changed = fastpathTV.DecSliceStringV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]string:
+		var v2 []string
+		v2, changed = fastpathTV.DecSliceStringV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []float32:
+		var v2 []float32
+		v2, changed = fastpathTV.DecSliceFloat32V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]float32:
+		var v2 []float32
+		v2, changed = fastpathTV.DecSliceFloat32V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []float64:
+		var v2 []float64
+		v2, changed = fastpathTV.DecSliceFloat64V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]float64:
+		var v2 []float64
+		v2, changed = fastpathTV.DecSliceFloat64V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uint:
+		var v2 []uint
+		v2, changed = fastpathTV.DecSliceUintV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uint:
+		var v2 []uint
+		v2, changed = fastpathTV.DecSliceUintV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uint16:
+		var v2 []uint16
+		v2, changed = fastpathTV.DecSliceUint16V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uint16:
+		var v2 []uint16
+		v2, changed = fastpathTV.DecSliceUint16V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uint32:
+		var v2 []uint32
+		v2, changed = fastpathTV.DecSliceUint32V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uint32:
+		var v2 []uint32
+		v2, changed = fastpathTV.DecSliceUint32V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uint64:
+		var v2 []uint64
+		v2, changed = fastpathTV.DecSliceUint64V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uint64:
+		var v2 []uint64
+		v2, changed = fastpathTV.DecSliceUint64V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []uintptr:
+		var v2 []uintptr
+		v2, changed = fastpathTV.DecSliceUintptrV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]uintptr:
+		var v2 []uintptr
+		v2, changed = fastpathTV.DecSliceUintptrV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int:
+		var v2 []int
+		v2, changed = fastpathTV.DecSliceIntV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int:
+		var v2 []int
+		v2, changed = fastpathTV.DecSliceIntV(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int8:
+		var v2 []int8
+		v2, changed = fastpathTV.DecSliceInt8V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int8:
+		var v2 []int8
+		v2, changed = fastpathTV.DecSliceInt8V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int16:
+		var v2 []int16
+		v2, changed = fastpathTV.DecSliceInt16V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int16:
+		var v2 []int16
+		v2, changed = fastpathTV.DecSliceInt16V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int32:
+		var v2 []int32
+		v2, changed = fastpathTV.DecSliceInt32V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int32:
+		var v2 []int32
+		v2, changed = fastpathTV.DecSliceInt32V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []int64:
+		var v2 []int64
+		v2, changed = fastpathTV.DecSliceInt64V(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]int64:
+		var v2 []int64
+		v2, changed = fastpathTV.DecSliceInt64V(*v, true, d)
+		if changed {
+			*v = v2
+		}
+	case []bool:
+		var v2 []bool
+		v2, changed = fastpathTV.DecSliceBoolV(v, false, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]bool:
+		var v2 []bool
+		v2, changed = fastpathTV.DecSliceBoolV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]interface{}
+		v2, changed = fastpathTV.DecMapIntfIntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]string
+		v2, changed = fastpathTV.DecMapIntfStringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]uint
+		v2, changed = fastpathTV.DecMapIntfUintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]uint8
+		v2, changed = fastpathTV.DecMapIntfUint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]uint16
+		v2, changed = fastpathTV.DecMapIntfUint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]uint32
+		v2, changed = fastpathTV.DecMapIntfUint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]uint64
+		v2, changed = fastpathTV.DecMapIntfUint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]uintptr
+		v2, changed = fastpathTV.DecMapIntfUintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]int
+		v2, changed = fastpathTV.DecMapIntfIntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]int8
+		v2, changed = fastpathTV.DecMapIntfInt8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]int16
+		v2, changed = fastpathTV.DecMapIntfInt16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]int32
+		v2, changed = fastpathTV.DecMapIntfInt32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]int64
+		v2, changed = fastpathTV.DecMapIntfInt64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]float32
+		v2, changed = fastpathTV.DecMapIntfFloat32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]float64
+		v2, changed = fastpathTV.DecMapIntfFloat64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[interface{}]bool
+		v2, changed = fastpathTV.DecMapIntfBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []string:
-		fastpathTV.DecSliceStringV(v, fastpathCheckNilFalse, false, d)
-	case *[]string:
-		v2, changed2 := fastpathTV.DecSliceStringV(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[string]interface{}
+		v2, changed = fastpathTV.DecMapStringIntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]string
+		v2, changed = fastpathTV.DecMapStringStringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]uint
+		v2, changed = fastpathTV.DecMapStringUintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]uint8
+		v2, changed = fastpathTV.DecMapStringUint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]uint16
+		v2, changed = fastpathTV.DecMapStringUint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]uint32
+		v2, changed = fastpathTV.DecMapStringUint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]uint64
+		v2, changed = fastpathTV.DecMapStringUint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]uintptr
+		v2, changed = fastpathTV.DecMapStringUintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]int
+		v2, changed = fastpathTV.DecMapStringIntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]int8
+		v2, changed = fastpathTV.DecMapStringInt8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]int16
+		v2, changed = fastpathTV.DecMapStringInt16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]int32
+		v2, changed = fastpathTV.DecMapStringInt32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]int64
+		v2, changed = fastpathTV.DecMapStringInt64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]float32
+		v2, changed = fastpathTV.DecMapStringFloat32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]float64
+		v2, changed = fastpathTV.DecMapStringFloat64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[string]bool
+		v2, changed = fastpathTV.DecMapStringBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []float32:
-		fastpathTV.DecSliceFloat32V(v, fastpathCheckNilFalse, false, d)
-	case *[]float32:
-		v2, changed2 := fastpathTV.DecSliceFloat32V(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[float32]interface{}
+		v2, changed = fastpathTV.DecMapFloat32IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]string
+		v2, changed = fastpathTV.DecMapFloat32StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]uint
+		v2, changed = fastpathTV.DecMapFloat32UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]uint8
+		v2, changed = fastpathTV.DecMapFloat32Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]uint16
+		v2, changed = fastpathTV.DecMapFloat32Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]uint32
+		v2, changed = fastpathTV.DecMapFloat32Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]uint64
+		v2, changed = fastpathTV.DecMapFloat32Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]uintptr
+		v2, changed = fastpathTV.DecMapFloat32UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]int
+		v2, changed = fastpathTV.DecMapFloat32IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]int8
+		v2, changed = fastpathTV.DecMapFloat32Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]int16
+		v2, changed = fastpathTV.DecMapFloat32Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]int32
+		v2, changed = fastpathTV.DecMapFloat32Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]int64
+		v2, changed = fastpathTV.DecMapFloat32Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]float32
+		v2, changed = fastpathTV.DecMapFloat32Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]float64
+		v2, changed = fastpathTV.DecMapFloat32Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float32]bool
+		v2, changed = fastpathTV.DecMapFloat32BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []float64:
-		fastpathTV.DecSliceFloat64V(v, fastpathCheckNilFalse, false, d)
-	case *[]float64:
-		v2, changed2 := fastpathTV.DecSliceFloat64V(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[float64]interface{}
+		v2, changed = fastpathTV.DecMapFloat64IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]string
+		v2, changed = fastpathTV.DecMapFloat64StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]uint
+		v2, changed = fastpathTV.DecMapFloat64UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]uint8
+		v2, changed = fastpathTV.DecMapFloat64Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]uint16
+		v2, changed = fastpathTV.DecMapFloat64Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]uint32
+		v2, changed = fastpathTV.DecMapFloat64Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]uint64
+		v2, changed = fastpathTV.DecMapFloat64Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]uintptr
+		v2, changed = fastpathTV.DecMapFloat64UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]int
+		v2, changed = fastpathTV.DecMapFloat64IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]int8
+		v2, changed = fastpathTV.DecMapFloat64Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]int16
+		v2, changed = fastpathTV.DecMapFloat64Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]int32
+		v2, changed = fastpathTV.DecMapFloat64Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]int64
+		v2, changed = fastpathTV.DecMapFloat64Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]float32
+		v2, changed = fastpathTV.DecMapFloat64Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]float64
+		v2, changed = fastpathTV.DecMapFloat64Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[float64]bool
+		v2, changed = fastpathTV.DecMapFloat64BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uint:
-		fastpathTV.DecSliceUintV(v, fastpathCheckNilFalse, false, d)
-	case *[]uint:
-		v2, changed2 := fastpathTV.DecSliceUintV(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[uint]interface{}
+		v2, changed = fastpathTV.DecMapUintIntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]string
+		v2, changed = fastpathTV.DecMapUintStringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]uint
+		v2, changed = fastpathTV.DecMapUintUintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]uint8
+		v2, changed = fastpathTV.DecMapUintUint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]uint16
+		v2, changed = fastpathTV.DecMapUintUint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]uint32
+		v2, changed = fastpathTV.DecMapUintUint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]uint64
+		v2, changed = fastpathTV.DecMapUintUint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]uintptr
+		v2, changed = fastpathTV.DecMapUintUintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]int
+		v2, changed = fastpathTV.DecMapUintIntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]int8
+		v2, changed = fastpathTV.DecMapUintInt8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]int16
+		v2, changed = fastpathTV.DecMapUintInt16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]int32
+		v2, changed = fastpathTV.DecMapUintInt32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]int64
+		v2, changed = fastpathTV.DecMapUintInt64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]float32
+		v2, changed = fastpathTV.DecMapUintFloat32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]float64
+		v2, changed = fastpathTV.DecMapUintFloat64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint]bool
+		v2, changed = fastpathTV.DecMapUintBoolV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]interface{}
+		v2, changed = fastpathTV.DecMapUint8IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]string
+		v2, changed = fastpathTV.DecMapUint8StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]uint
+		v2, changed = fastpathTV.DecMapUint8UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]uint8
+		v2, changed = fastpathTV.DecMapUint8Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]uint16
+		v2, changed = fastpathTV.DecMapUint8Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]uint32
+		v2, changed = fastpathTV.DecMapUint8Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]uint64
+		v2, changed = fastpathTV.DecMapUint8Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]uintptr
+		v2, changed = fastpathTV.DecMapUint8UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]int
+		v2, changed = fastpathTV.DecMapUint8IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]int8
+		v2, changed = fastpathTV.DecMapUint8Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]int16
+		v2, changed = fastpathTV.DecMapUint8Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]int32
+		v2, changed = fastpathTV.DecMapUint8Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]int64
+		v2, changed = fastpathTV.DecMapUint8Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]float32
+		v2, changed = fastpathTV.DecMapUint8Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]float64
+		v2, changed = fastpathTV.DecMapUint8Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint8]bool
+		v2, changed = fastpathTV.DecMapUint8BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uint16:
-		fastpathTV.DecSliceUint16V(v, fastpathCheckNilFalse, false, d)
-	case *[]uint16:
-		v2, changed2 := fastpathTV.DecSliceUint16V(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[uint16]interface{}
+		v2, changed = fastpathTV.DecMapUint16IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]string
+		v2, changed = fastpathTV.DecMapUint16StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]uint
+		v2, changed = fastpathTV.DecMapUint16UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]uint8
+		v2, changed = fastpathTV.DecMapUint16Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]uint16
+		v2, changed = fastpathTV.DecMapUint16Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]uint32
+		v2, changed = fastpathTV.DecMapUint16Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]uint64
+		v2, changed = fastpathTV.DecMapUint16Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]uintptr
+		v2, changed = fastpathTV.DecMapUint16UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]int
+		v2, changed = fastpathTV.DecMapUint16IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]int8
+		v2, changed = fastpathTV.DecMapUint16Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]int16
+		v2, changed = fastpathTV.DecMapUint16Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]int32
+		v2, changed = fastpathTV.DecMapUint16Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]int64
+		v2, changed = fastpathTV.DecMapUint16Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]float32
+		v2, changed = fastpathTV.DecMapUint16Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]float64
+		v2, changed = fastpathTV.DecMapUint16Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint16]bool
+		v2, changed = fastpathTV.DecMapUint16BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uint32:
-		fastpathTV.DecSliceUint32V(v, fastpathCheckNilFalse, false, d)
-	case *[]uint32:
-		v2, changed2 := fastpathTV.DecSliceUint32V(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[uint32]interface{}
+		v2, changed = fastpathTV.DecMapUint32IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]string
+		v2, changed = fastpathTV.DecMapUint32StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]uint
+		v2, changed = fastpathTV.DecMapUint32UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]uint8
+		v2, changed = fastpathTV.DecMapUint32Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]uint16
+		v2, changed = fastpathTV.DecMapUint32Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]uint32
+		v2, changed = fastpathTV.DecMapUint32Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]uint64
+		v2, changed = fastpathTV.DecMapUint32Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]uintptr
+		v2, changed = fastpathTV.DecMapUint32UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]int
+		v2, changed = fastpathTV.DecMapUint32IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]int8
+		v2, changed = fastpathTV.DecMapUint32Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]int16
+		v2, changed = fastpathTV.DecMapUint32Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]int32
+		v2, changed = fastpathTV.DecMapUint32Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]int64
+		v2, changed = fastpathTV.DecMapUint32Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]float32
+		v2, changed = fastpathTV.DecMapUint32Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]float64
+		v2, changed = fastpathTV.DecMapUint32Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint32]bool
+		v2, changed = fastpathTV.DecMapUint32BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uint64:
-		fastpathTV.DecSliceUint64V(v, fastpathCheckNilFalse, false, d)
-	case *[]uint64:
-		v2, changed2 := fastpathTV.DecSliceUint64V(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[uint64]interface{}
+		v2, changed = fastpathTV.DecMapUint64IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]string
+		v2, changed = fastpathTV.DecMapUint64StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]uint
+		v2, changed = fastpathTV.DecMapUint64UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]uint8
+		v2, changed = fastpathTV.DecMapUint64Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]uint16
+		v2, changed = fastpathTV.DecMapUint64Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]uint32
+		v2, changed = fastpathTV.DecMapUint64Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]uint64
+		v2, changed = fastpathTV.DecMapUint64Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]uintptr
+		v2, changed = fastpathTV.DecMapUint64UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]int
+		v2, changed = fastpathTV.DecMapUint64IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]int8
+		v2, changed = fastpathTV.DecMapUint64Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]int16
+		v2, changed = fastpathTV.DecMapUint64Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]int32
+		v2, changed = fastpathTV.DecMapUint64Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]int64
+		v2, changed = fastpathTV.DecMapUint64Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]float32
+		v2, changed = fastpathTV.DecMapUint64Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]float64
+		v2, changed = fastpathTV.DecMapUint64Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uint64]bool
+		v2, changed = fastpathTV.DecMapUint64BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []uintptr:
-		fastpathTV.DecSliceUintptrV(v, fastpathCheckNilFalse, false, d)
-	case *[]uintptr:
-		v2, changed2 := fastpathTV.DecSliceUintptrV(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[uintptr]interface{}
+		v2, changed = fastpathTV.DecMapUintptrIntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]string
+		v2, changed = fastpathTV.DecMapUintptrStringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]uint
+		v2, changed = fastpathTV.DecMapUintptrUintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]uint8
+		v2, changed = fastpathTV.DecMapUintptrUint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]uint16
+		v2, changed = fastpathTV.DecMapUintptrUint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]uint32
+		v2, changed = fastpathTV.DecMapUintptrUint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]uint64
+		v2, changed = fastpathTV.DecMapUintptrUint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]uintptr
+		v2, changed = fastpathTV.DecMapUintptrUintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]int
+		v2, changed = fastpathTV.DecMapUintptrIntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]int8
+		v2, changed = fastpathTV.DecMapUintptrInt8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]int16
+		v2, changed = fastpathTV.DecMapUintptrInt16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]int32
+		v2, changed = fastpathTV.DecMapUintptrInt32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]int64
+		v2, changed = fastpathTV.DecMapUintptrInt64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]float32
+		v2, changed = fastpathTV.DecMapUintptrFloat32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]float64
+		v2, changed = fastpathTV.DecMapUintptrFloat64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[uintptr]bool
+		v2, changed = fastpathTV.DecMapUintptrBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int:
-		fastpathTV.DecSliceIntV(v, fastpathCheckNilFalse, false, d)
-	case *[]int:
-		v2, changed2 := fastpathTV.DecSliceIntV(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[int]interface{}
+		v2, changed = fastpathTV.DecMapIntIntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]string
+		v2, changed = fastpathTV.DecMapIntStringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]uint
+		v2, changed = fastpathTV.DecMapIntUintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]uint8
+		v2, changed = fastpathTV.DecMapIntUint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]uint16
+		v2, changed = fastpathTV.DecMapIntUint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]uint32
+		v2, changed = fastpathTV.DecMapIntUint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]uint64
+		v2, changed = fastpathTV.DecMapIntUint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]uintptr
+		v2, changed = fastpathTV.DecMapIntUintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]int
+		v2, changed = fastpathTV.DecMapIntIntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]int8
+		v2, changed = fastpathTV.DecMapIntInt8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]int16
+		v2, changed = fastpathTV.DecMapIntInt16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]int32
+		v2, changed = fastpathTV.DecMapIntInt32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]int64
+		v2, changed = fastpathTV.DecMapIntInt64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]float32
+		v2, changed = fastpathTV.DecMapIntFloat32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]float64
+		v2, changed = fastpathTV.DecMapIntFloat64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int]bool
+		v2, changed = fastpathTV.DecMapIntBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int8:
-		fastpathTV.DecSliceInt8V(v, fastpathCheckNilFalse, false, d)
-	case *[]int8:
-		v2, changed2 := fastpathTV.DecSliceInt8V(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[int8]interface{}
+		v2, changed = fastpathTV.DecMapInt8IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]string
+		v2, changed = fastpathTV.DecMapInt8StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]uint
+		v2, changed = fastpathTV.DecMapInt8UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]uint8
+		v2, changed = fastpathTV.DecMapInt8Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]uint16
+		v2, changed = fastpathTV.DecMapInt8Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]uint32
+		v2, changed = fastpathTV.DecMapInt8Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]uint64
+		v2, changed = fastpathTV.DecMapInt8Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]uintptr
+		v2, changed = fastpathTV.DecMapInt8UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]int
+		v2, changed = fastpathTV.DecMapInt8IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]int8
+		v2, changed = fastpathTV.DecMapInt8Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]int16
+		v2, changed = fastpathTV.DecMapInt8Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]int32
+		v2, changed = fastpathTV.DecMapInt8Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]int64
+		v2, changed = fastpathTV.DecMapInt8Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]float32
+		v2, changed = fastpathTV.DecMapInt8Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]float64
+		v2, changed = fastpathTV.DecMapInt8Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int8]bool
+		v2, changed = fastpathTV.DecMapInt8BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int16:
-		fastpathTV.DecSliceInt16V(v, fastpathCheckNilFalse, false, d)
-	case *[]int16:
-		v2, changed2 := fastpathTV.DecSliceInt16V(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[int16]interface{}
+		v2, changed = fastpathTV.DecMapInt16IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]string
+		v2, changed = fastpathTV.DecMapInt16StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]uint
+		v2, changed = fastpathTV.DecMapInt16UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]uint8
+		v2, changed = fastpathTV.DecMapInt16Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]uint16
+		v2, changed = fastpathTV.DecMapInt16Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]uint32
+		v2, changed = fastpathTV.DecMapInt16Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]uint64
+		v2, changed = fastpathTV.DecMapInt16Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]uintptr
+		v2, changed = fastpathTV.DecMapInt16UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]int
+		v2, changed = fastpathTV.DecMapInt16IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]int8
+		v2, changed = fastpathTV.DecMapInt16Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]int16
+		v2, changed = fastpathTV.DecMapInt16Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]int32
+		v2, changed = fastpathTV.DecMapInt16Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]int64
+		v2, changed = fastpathTV.DecMapInt16Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]float32
+		v2, changed = fastpathTV.DecMapInt16Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]float64
+		v2, changed = fastpathTV.DecMapInt16Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int16]bool
+		v2, changed = fastpathTV.DecMapInt16BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int32:
-		fastpathTV.DecSliceInt32V(v, fastpathCheckNilFalse, false, d)
-	case *[]int32:
-		v2, changed2 := fastpathTV.DecSliceInt32V(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[int32]interface{}
+		v2, changed = fastpathTV.DecMapInt32IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]string
+		v2, changed = fastpathTV.DecMapInt32StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]uint
+		v2, changed = fastpathTV.DecMapInt32UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]uint8
+		v2, changed = fastpathTV.DecMapInt32Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]uint16
+		v2, changed = fastpathTV.DecMapInt32Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]uint32
+		v2, changed = fastpathTV.DecMapInt32Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]uint64
+		v2, changed = fastpathTV.DecMapInt32Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]uintptr
+		v2, changed = fastpathTV.DecMapInt32UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]int
+		v2, changed = fastpathTV.DecMapInt32IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]int8
+		v2, changed = fastpathTV.DecMapInt32Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]int16
+		v2, changed = fastpathTV.DecMapInt32Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]int32
+		v2, changed = fastpathTV.DecMapInt32Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]int64
+		v2, changed = fastpathTV.DecMapInt32Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]float32
+		v2, changed = fastpathTV.DecMapInt32Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]float64
+		v2, changed = fastpathTV.DecMapInt32Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int32]bool
+		v2, changed = fastpathTV.DecMapInt32BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []int64:
-		fastpathTV.DecSliceInt64V(v, fastpathCheckNilFalse, false, d)
-	case *[]int64:
-		v2, changed2 := fastpathTV.DecSliceInt64V(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[int64]interface{}
+		v2, changed = fastpathTV.DecMapInt64IntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]string
+		v2, changed = fastpathTV.DecMapInt64StringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]uint
+		v2, changed = fastpathTV.DecMapInt64UintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]uint8
+		v2, changed = fastpathTV.DecMapInt64Uint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]uint16
+		v2, changed = fastpathTV.DecMapInt64Uint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]uint32
+		v2, changed = fastpathTV.DecMapInt64Uint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]uint64
+		v2, changed = fastpathTV.DecMapInt64Uint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]uintptr
+		v2, changed = fastpathTV.DecMapInt64UintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]int
+		v2, changed = fastpathTV.DecMapInt64IntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]int8
+		v2, changed = fastpathTV.DecMapInt64Int8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]int16
+		v2, changed = fastpathTV.DecMapInt64Int16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]int32
+		v2, changed = fastpathTV.DecMapInt64Int32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]int64
+		v2, changed = fastpathTV.DecMapInt64Int64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]float32
+		v2, changed = fastpathTV.DecMapInt64Float32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]float64
+		v2, changed = fastpathTV.DecMapInt64Float64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[int64]bool
+		v2, changed = fastpathTV.DecMapInt64BoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
-	case []bool:
-		fastpathTV.DecSliceBoolV(v, fastpathCheckNilFalse, false, d)
-	case *[]bool:
-		v2, changed2 := fastpathTV.DecSliceBoolV(*v, fastpathCheckNilFalse, true, d)
-		if 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 {
+		var v2 map[bool]interface{}
+		v2, changed = fastpathTV.DecMapBoolIntfV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]string
+		v2, changed = fastpathTV.DecMapBoolStringV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]uint
+		v2, changed = fastpathTV.DecMapBoolUintV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]uint8
+		v2, changed = fastpathTV.DecMapBoolUint8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]uint16
+		v2, changed = fastpathTV.DecMapBoolUint16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]uint32
+		v2, changed = fastpathTV.DecMapBoolUint32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]uint64
+		v2, changed = fastpathTV.DecMapBoolUint64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]uintptr
+		v2, changed = fastpathTV.DecMapBoolUintptrV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]int
+		v2, changed = fastpathTV.DecMapBoolIntV(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]int8
+		v2, changed = fastpathTV.DecMapBoolInt8V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]int16
+		v2, changed = fastpathTV.DecMapBoolInt16V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]int32
+		v2, changed = fastpathTV.DecMapBoolInt32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]int64
+		v2, changed = fastpathTV.DecMapBoolInt64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]float32
+		v2, changed = fastpathTV.DecMapBoolFloat32V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]float64
+		v2, changed = fastpathTV.DecMapBoolFloat64V(*v, true, d)
+		if changed {
 			*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 {
+		var v2 map[bool]bool
+		v2, changed = fastpathTV.DecMapBoolBoolV(*v, true, d)
+		if changed {
 			*v = v2
 		}
-
 	default:
-		_ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
+		_ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
+		return false
+	}
+	return true
+}
+
+func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool {
+	switch v := iv.(type) {
+
+	case *[]interface{}:
+		*v = nil
+	case *[]string:
+		*v = nil
+	case *[]float32:
+		*v = nil
+	case *[]float64:
+		*v = nil
+	case *[]uint:
+		*v = nil
+	case *[]uint8:
+		*v = nil
+	case *[]uint16:
+		*v = nil
+	case *[]uint32:
+		*v = nil
+	case *[]uint64:
+		*v = nil
+	case *[]uintptr:
+		*v = nil
+	case *[]int:
+		*v = nil
+	case *[]int8:
+		*v = nil
+	case *[]int16:
+		*v = nil
+	case *[]int32:
+		*v = nil
+	case *[]int64:
+		*v = nil
+	case *[]bool:
+		*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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 *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 // workaround https://github.com/golang/go/issues/12927 seen in go1.4
 		return false
 	}
 	return true
@@ -18136,36 +17721,29 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
 
 // -- -- 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)
+func (d *Decoder) fastpathDecSliceIntfR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]interface{})
+		v, changed := fastpathTV.DecSliceIntfV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]interface{})
-		fastpathTV.DecSliceIntfV(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]interface{})
+		v2, changed := fastpathTV.DecSliceIntfV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceIntfX(vp *[]interface{}, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceIntfV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceIntfX(vp *[]interface{}, d *Decoder) {
+	v, changed := f.DecSliceIntfV(*vp, true, d)
 	if 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 {
@@ -18179,127 +17757,89 @@ func (_ fastpathT) DecSliceIntfV(v []interface{}, checkNil bool, canChange bool,
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = nil
+		} 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)
+func (d *Decoder) fastpathDecSliceStringR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]string)
+		v, changed := fastpathTV.DecSliceStringV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]string)
-		fastpathTV.DecSliceStringV(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]string)
+		v2, changed := fastpathTV.DecSliceStringV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceStringX(vp *[]string, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceStringV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceStringX(vp *[]string, d *Decoder) {
+	v, changed := f.DecSliceStringV(*vp, true, d)
 	if 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 {
@@ -18313,126 +17853,89 @@ func (_ fastpathT) DecSliceStringV(v []string, checkNil bool, canChange bool, d
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = ""
+		} 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)
+func (d *Decoder) fastpathDecSliceFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]float32)
+		v, changed := fastpathTV.DecSliceFloat32V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]float32)
-		fastpathTV.DecSliceFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]float32)
+		v2, changed := fastpathTV.DecSliceFloat32V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceFloat32X(vp *[]float32, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceFloat32V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceFloat32X(vp *[]float32, d *Decoder) {
+	v, changed := f.DecSliceFloat32V(*vp, true, d)
 	if 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 {
@@ -18446,126 +17949,89 @@ func (_ fastpathT) DecSliceFloat32V(v []float32, checkNil bool, canChange bool,
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		}
+	}
+	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)
+func (d *Decoder) fastpathDecSliceFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]float64)
+		v, changed := fastpathTV.DecSliceFloat64V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]float64)
-		fastpathTV.DecSliceFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]float64)
+		v2, changed := fastpathTV.DecSliceFloat64V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceFloat64X(vp *[]float64, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceFloat64V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceFloat64X(vp *[]float64, d *Decoder) {
+	v, changed := f.DecSliceFloat64V(*vp, true, d)
 	if 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 {
@@ -18579,126 +18045,89 @@ func (_ fastpathT) DecSliceFloat64V(v []float64, checkNil bool, canChange bool,
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = dd.DecodeFloat64()
+		}
+	}
+	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)
+func (d *Decoder) fastpathDecSliceUintR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint)
+		v, changed := fastpathTV.DecSliceUintV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uint)
-		fastpathTV.DecSliceUintV(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]uint)
+		v2, changed := fastpathTV.DecSliceUintV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUintX(vp *[]uint, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUintV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUintX(vp *[]uint, d *Decoder) {
+	v, changed := f.DecSliceUintV(*vp, true, d)
 	if 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 {
@@ -18712,126 +18141,185 @@ func (_ fastpathT) DecSliceUintV(v []uint, checkNil bool, canChange bool, d *Dec
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecSliceUint8R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint8)
+		v, changed := fastpathTV.DecSliceUint8V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uint16)
-		fastpathTV.DecSliceUint16V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]uint8)
+		v2, changed := fastpathTV.DecSliceUint8V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUint16X(vp *[]uint16, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUint16V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUint8X(vp *[]uint8, d *Decoder) {
+	v, changed := f.DecSliceUint8V(*vp, true, d)
 	if changed {
 		*vp = v
 	}
 }
-func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d *Decoder) (_ []uint16, changed bool) {
+func (_ fastpathT) DecSliceUint8V(v []uint8, canChange bool, d *Decoder) (_ []uint8, changed bool) {
 	dd := d.d
-
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
+	slh, containerLenS := d.decSliceHelperStart()
+	if containerLenS == 0 {
+		if canChange {
+			if v == nil {
+				v = []uint8{}
+			} else if len(v) != 0 {
+				v = v[:0]
+			}
 			changed = true
 		}
-		return nil, changed
+		slh.End()
+		return v, changed
 	}
+	hasLen := containerLenS > 0
+	var xlen int
+	if hasLen && canChange {
+		if containerLenS > cap(v) {
+			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
+			if xlen <= cap(v) {
+				v = v[:xlen]
+			} else {
+				v = make([]uint8, xlen)
+			}
+			changed = true
+		} else if containerLenS != len(v) {
+			v = v[:containerLenS]
+			changed = true
+		}
+	}
+	j := 0
+	for ; (hasLen && j < containerLenS) || !(hasLen || dd.CheckBreak()); j++ {
+		if j == 0 && len(v) == 0 && canChange {
+			if hasLen {
+				xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
+			} else {
+				xlen = 8
+			}
+			v = make([]uint8, xlen)
+			changed = true
+		}
+		// 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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = uint8(chkOvf.UintV(dd.DecodeUint64(), 8))
+		}
+	}
+	if canChange {
+		if j < len(v) {
+			v = v[:j]
+			changed = true
+		} else if j == 0 && v == nil {
+			v = make([]uint8, 0)
+			changed = true
+		}
+	}
+	slh.End()
+	return v, changed
+}
 
+func (d *Decoder) fastpathDecSliceUint16R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint16)
+		v, changed := fastpathTV.DecSliceUint16V(*vp, !array, d)
+		if changed {
+			*vp = v
+		}
+	} else {
+		v := rv2i(rv).([]uint16)
+		v2, changed := fastpathTV.DecSliceUint16V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	}
+}
+func (f fastpathT) DecSliceUint16X(vp *[]uint16, d *Decoder) {
+	v, changed := f.DecSliceUint16V(*vp, true, d)
+	if changed {
+		*vp = v
+	}
+}
+func (_ fastpathT) DecSliceUint16V(v []uint16, canChange bool, d *Decoder) (_ []uint16, changed bool) {
+	dd := d.d
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
@@ -18845,126 +18333,89 @@ func (_ fastpathT) DecSliceUint16V(v []uint16, checkNil bool, canChange bool, d
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecSliceUint32R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint32)
+		v, changed := fastpathTV.DecSliceUint32V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uint32)
-		fastpathTV.DecSliceUint32V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]uint32)
+		v2, changed := fastpathTV.DecSliceUint32V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUint32X(vp *[]uint32, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUint32V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUint32X(vp *[]uint32, d *Decoder) {
+	v, changed := f.DecSliceUint32V(*vp, true, d)
 	if 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 {
@@ -18978,126 +18429,89 @@ func (_ fastpathT) DecSliceUint32V(v []uint32, checkNil bool, canChange bool, d
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecSliceUint64R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uint64)
+		v, changed := fastpathTV.DecSliceUint64V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uint64)
-		fastpathTV.DecSliceUint64V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]uint64)
+		v2, changed := fastpathTV.DecSliceUint64V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUint64X(vp *[]uint64, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUint64V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUint64X(vp *[]uint64, d *Decoder) {
+	v, changed := f.DecSliceUint64V(*vp, true, d)
 	if 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 {
@@ -19111,126 +18525,89 @@ func (_ fastpathT) DecSliceUint64V(v []uint64, checkNil bool, canChange bool, d
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = dd.DecodeUint64()
+		}
+	}
+	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)
+func (d *Decoder) fastpathDecSliceUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]uintptr)
+		v, changed := fastpathTV.DecSliceUintptrV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]uintptr)
-		fastpathTV.DecSliceUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]uintptr)
+		v2, changed := fastpathTV.DecSliceUintptrV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceUintptrV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceUintptrX(vp *[]uintptr, d *Decoder) {
+	v, changed := f.DecSliceUintptrV(*vp, true, d)
 	if 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 {
@@ -19244,126 +18621,89 @@ func (_ fastpathT) DecSliceUintptrV(v []uintptr, checkNil bool, canChange bool,
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecSliceIntR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int)
+		v, changed := fastpathTV.DecSliceIntV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int)
-		fastpathTV.DecSliceIntV(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]int)
+		v2, changed := fastpathTV.DecSliceIntV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceIntX(vp *[]int, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceIntV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceIntX(vp *[]int, d *Decoder) {
+	v, changed := f.DecSliceIntV(*vp, true, d)
 	if 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 {
@@ -19377,126 +18717,89 @@ func (_ fastpathT) DecSliceIntV(v []int, checkNil bool, canChange bool, d *Decod
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecSliceInt8R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int8)
+		v, changed := fastpathTV.DecSliceInt8V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int8)
-		fastpathTV.DecSliceInt8V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]int8)
+		v2, changed := fastpathTV.DecSliceInt8V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceInt8X(vp *[]int8, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt8V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceInt8X(vp *[]int8, d *Decoder) {
+	v, changed := f.DecSliceInt8V(*vp, true, d)
 	if 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 {
@@ -19510,126 +18813,89 @@ func (_ fastpathT) DecSliceInt8V(v []int8, checkNil bool, canChange bool, d *Dec
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecSliceInt16R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int16)
+		v, changed := fastpathTV.DecSliceInt16V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int16)
-		fastpathTV.DecSliceInt16V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]int16)
+		v2, changed := fastpathTV.DecSliceInt16V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceInt16X(vp *[]int16, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt16V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceInt16X(vp *[]int16, d *Decoder) {
+	v, changed := f.DecSliceInt16V(*vp, true, d)
 	if 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 {
@@ -19643,126 +18909,89 @@ func (_ fastpathT) DecSliceInt16V(v []int16, checkNil bool, canChange bool, d *D
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecSliceInt32R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int32)
+		v, changed := fastpathTV.DecSliceInt32V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int32)
-		fastpathTV.DecSliceInt32V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]int32)
+		v2, changed := fastpathTV.DecSliceInt32V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceInt32X(vp *[]int32, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt32V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceInt32X(vp *[]int32, d *Decoder) {
+	v, changed := f.DecSliceInt32V(*vp, true, d)
 	if 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 {
@@ -19776,126 +19005,89 @@ func (_ fastpathT) DecSliceInt32V(v []int32, checkNil bool, canChange bool, d *D
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecSliceInt64R(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]int64)
+		v, changed := fastpathTV.DecSliceInt64V(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]int64)
-		fastpathTV.DecSliceInt64V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]int64)
+		v2, changed := fastpathTV.DecSliceInt64V(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceInt64X(vp *[]int64, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceInt64V(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceInt64X(vp *[]int64, d *Decoder) {
+	v, changed := f.DecSliceInt64V(*vp, true, d)
 	if 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 {
@@ -19909,126 +19101,89 @@ func (_ fastpathT) DecSliceInt64V(v []int64, checkNil bool, canChange bool, d *D
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = 0
+		} else {
+			v[j] = dd.DecodeInt64()
+		}
+	}
+	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)
+func (d *Decoder) fastpathDecSliceBoolR(f *codecFnInfo, rv reflect.Value) {
+	if array := f.seq == seqTypeArray; !array && rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*[]bool)
+		v, changed := fastpathTV.DecSliceBoolV(*vp, !array, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().([]bool)
-		fastpathTV.DecSliceBoolV(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]bool)
+		v2, changed := fastpathTV.DecSliceBoolV(v, !array, d)
+		if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
 	}
 }
-
-func (f fastpathT) DecSliceBoolX(vp *[]bool, checkNil bool, d *Decoder) {
-	v, changed := f.DecSliceBoolV(*vp, checkNil, true, d)
+func (f fastpathT) DecSliceBoolX(vp *[]bool, d *Decoder) {
+	v, changed := f.DecSliceBoolV(*vp, true, d)
 	if 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 {
@@ -20042,19324 +19197,15326 @@ func (_ fastpathT) DecSliceBoolV(v []bool, checkNil bool, canChange bool, d *Dec
 		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 {
-				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 && canChange {
+			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 if dd.TryDecodeAsNil() {
+			v[j] = false
+		} 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)
+func (d *Decoder) fastpathDecMapIntfIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]interface{})
+		v, changed := fastpathTV.DecMapIntfIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]interface{})
-		fastpathTV.DecMapIntfIntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfIntfX(vp *map[interface{}]interface{}, d *Decoder) {
+	v, changed := f.DecMapIntfIntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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 v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapIntfStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]string)
+		v, changed := fastpathTV.DecMapIntfStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]string)
-		fastpathTV.DecMapIntfStringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfStringX(vp *map[interface{}]string, d *Decoder) {
+	v, changed := f.DecMapIntfStringV(*vp, true, d)
 	if 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 v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapIntfUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint)
+		v, changed := fastpathTV.DecMapIntfUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]uint)
-		fastpathTV.DecMapIntfUintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfUintX(vp *map[interface{}]uint, d *Decoder) {
+	v, changed := f.DecMapIntfUintV(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntfUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint8)
+		v, changed := fastpathTV.DecMapIntfUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]uint8)
-		fastpathTV.DecMapIntfUint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfUint8X(vp *map[interface{}]uint8, d *Decoder) {
+	v, changed := f.DecMapIntfUint8V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntfUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint16)
+		v, changed := fastpathTV.DecMapIntfUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]uint16)
-		fastpathTV.DecMapIntfUint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfUint16X(vp *map[interface{}]uint16, d *Decoder) {
+	v, changed := f.DecMapIntfUint16V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntfUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint32)
+		v, changed := fastpathTV.DecMapIntfUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]uint32)
-		fastpathTV.DecMapIntfUint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfUint32X(vp *map[interface{}]uint32, d *Decoder) {
+	v, changed := f.DecMapIntfUint32V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntfUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uint64)
+		v, changed := fastpathTV.DecMapIntfUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]uint64)
-		fastpathTV.DecMapIntfUint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfUint64X(vp *map[interface{}]uint64, d *Decoder) {
+	v, changed := f.DecMapIntfUint64V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapIntfUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]uintptr)
+		v, changed := fastpathTV.DecMapIntfUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]uintptr)
-		fastpathTV.DecMapIntfUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfUintptrX(vp *map[interface{}]uintptr, d *Decoder) {
+	v, changed := f.DecMapIntfUintptrV(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntfIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int)
+		v, changed := fastpathTV.DecMapIntfIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]int)
-		fastpathTV.DecMapIntfIntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfIntX(vp *map[interface{}]int, d *Decoder) {
+	v, changed := f.DecMapIntfIntV(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapIntfInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int8)
+		v, changed := fastpathTV.DecMapIntfInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]int8)
-		fastpathTV.DecMapIntfInt8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfInt8X(vp *map[interface{}]int8, d *Decoder) {
+	v, changed := f.DecMapIntfInt8V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapIntfInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int16)
+		v, changed := fastpathTV.DecMapIntfInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]int16)
-		fastpathTV.DecMapIntfInt16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfInt16X(vp *map[interface{}]int16, d *Decoder) {
+	v, changed := f.DecMapIntfInt16V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapIntfInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int32)
+		v, changed := fastpathTV.DecMapIntfInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]int32)
-		fastpathTV.DecMapIntfInt32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfInt32X(vp *map[interface{}]int32, d *Decoder) {
+	v, changed := f.DecMapIntfInt32V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapIntfInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]int64)
+		v, changed := fastpathTV.DecMapIntfInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]int64)
-		fastpathTV.DecMapIntfInt64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfInt64X(vp *map[interface{}]int64, d *Decoder) {
+	v, changed := f.DecMapIntfInt64V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapIntfFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]float32)
+		v, changed := fastpathTV.DecMapIntfFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]float32)
-		fastpathTV.DecMapIntfFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfFloat32X(vp *map[interface{}]float32, d *Decoder) {
+	v, changed := f.DecMapIntfFloat32V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapIntfFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]float64)
+		v, changed := fastpathTV.DecMapIntfFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]float64)
-		fastpathTV.DecMapIntfFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfFloat64X(vp *map[interface{}]float64, d *Decoder) {
+	v, changed := f.DecMapIntfFloat64V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapIntfBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[interface{}]bool)
+		v, changed := fastpathTV.DecMapIntfBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[interface{}]bool)
-		fastpathTV.DecMapIntfBoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntfBoolX(vp *map[interface{}]bool, d *Decoder) {
+	v, changed := f.DecMapIntfBoolV(*vp, true, d)
 	if 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 v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapStringIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]interface{})
+		v, changed := fastpathTV.DecMapStringIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]interface{})
-		fastpathTV.DecMapStringIntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringIntfX(vp *map[string]interface{}, d *Decoder) {
+	v, changed := f.DecMapStringIntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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 v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapStringStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]string)
+		v, changed := fastpathTV.DecMapStringStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]string)
-		fastpathTV.DecMapStringStringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringStringX(vp *map[string]string, d *Decoder) {
+	v, changed := f.DecMapStringStringV(*vp, true, d)
 	if 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 v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapStringUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint)
+		v, changed := fastpathTV.DecMapStringUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]uint)
-		fastpathTV.DecMapStringUintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringUintX(vp *map[string]uint, d *Decoder) {
+	v, changed := f.DecMapStringUintV(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapStringUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint8)
+		v, changed := fastpathTV.DecMapStringUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]uint8)
-		fastpathTV.DecMapStringUint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringUint8X(vp *map[string]uint8, d *Decoder) {
+	v, changed := f.DecMapStringUint8V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapStringUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint16)
+		v, changed := fastpathTV.DecMapStringUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]uint16)
-		fastpathTV.DecMapStringUint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringUint16X(vp *map[string]uint16, d *Decoder) {
+	v, changed := f.DecMapStringUint16V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapStringUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint32)
+		v, changed := fastpathTV.DecMapStringUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]uint32)
-		fastpathTV.DecMapStringUint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringUint32X(vp *map[string]uint32, d *Decoder) {
+	v, changed := f.DecMapStringUint32V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapStringUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uint64)
+		v, changed := fastpathTV.DecMapStringUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]uint64)
-		fastpathTV.DecMapStringUint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringUint64X(vp *map[string]uint64, d *Decoder) {
+	v, changed := f.DecMapStringUint64V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapStringUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]uintptr)
+		v, changed := fastpathTV.DecMapStringUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]uintptr)
-		fastpathTV.DecMapStringUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringUintptrX(vp *map[string]uintptr, d *Decoder) {
+	v, changed := f.DecMapStringUintptrV(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapStringIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int)
+		v, changed := fastpathTV.DecMapStringIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]int)
-		fastpathTV.DecMapStringIntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringIntX(vp *map[string]int, d *Decoder) {
+	v, changed := f.DecMapStringIntV(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapStringInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int8)
+		v, changed := fastpathTV.DecMapStringInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]int8)
-		fastpathTV.DecMapStringInt8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringInt8X(vp *map[string]int8, d *Decoder) {
+	v, changed := f.DecMapStringInt8V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapStringInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int16)
+		v, changed := fastpathTV.DecMapStringInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]int16)
-		fastpathTV.DecMapStringInt16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringInt16X(vp *map[string]int16, d *Decoder) {
+	v, changed := f.DecMapStringInt16V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapStringInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int32)
+		v, changed := fastpathTV.DecMapStringInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]int32)
-		fastpathTV.DecMapStringInt32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringInt32X(vp *map[string]int32, d *Decoder) {
+	v, changed := f.DecMapStringInt32V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapStringInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]int64)
+		v, changed := fastpathTV.DecMapStringInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]int64)
-		fastpathTV.DecMapStringInt64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringInt64X(vp *map[string]int64, d *Decoder) {
+	v, changed := f.DecMapStringInt64V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapStringFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]float32)
+		v, changed := fastpathTV.DecMapStringFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]float32)
-		fastpathTV.DecMapStringFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringFloat32X(vp *map[string]float32, d *Decoder) {
+	v, changed := f.DecMapStringFloat32V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapStringFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]float64)
+		v, changed := fastpathTV.DecMapStringFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]float64)
-		fastpathTV.DecMapStringFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringFloat64X(vp *map[string]float64, d *Decoder) {
+	v, changed := f.DecMapStringFloat64V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapStringBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[string]bool)
+		v, changed := fastpathTV.DecMapStringBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[string]bool)
-		fastpathTV.DecMapStringBoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapStringBoolX(vp *map[string]bool, d *Decoder) {
+	v, changed := f.DecMapStringBoolV(*vp, true, d)
 	if 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 v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapFloat32IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]interface{})
+		v, changed := fastpathTV.DecMapFloat32IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]interface{})
-		fastpathTV.DecMapFloat32IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32IntfX(vp *map[float32]interface{}, d *Decoder) {
+	v, changed := f.DecMapFloat32IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapFloat32StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]string)
+		v, changed := fastpathTV.DecMapFloat32StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]string)
-		fastpathTV.DecMapFloat32StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32StringX(vp *map[float32]string, d *Decoder) {
+	v, changed := f.DecMapFloat32StringV(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapFloat32UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint)
+		v, changed := fastpathTV.DecMapFloat32UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]uint)
-		fastpathTV.DecMapFloat32UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32UintX(vp *map[float32]uint, d *Decoder) {
+	v, changed := f.DecMapFloat32UintV(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint8)
+		v, changed := fastpathTV.DecMapFloat32Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]uint8)
-		fastpathTV.DecMapFloat32Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Uint8X(vp *map[float32]uint8, d *Decoder) {
+	v, changed := f.DecMapFloat32Uint8V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint16)
+		v, changed := fastpathTV.DecMapFloat32Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]uint16)
-		fastpathTV.DecMapFloat32Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Uint16X(vp *map[float32]uint16, d *Decoder) {
+	v, changed := f.DecMapFloat32Uint16V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint32)
+		v, changed := fastpathTV.DecMapFloat32Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]uint32)
-		fastpathTV.DecMapFloat32Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Uint32X(vp *map[float32]uint32, d *Decoder) {
+	v, changed := f.DecMapFloat32Uint32V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uint64)
+		v, changed := fastpathTV.DecMapFloat32Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]uint64)
-		fastpathTV.DecMapFloat32Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Uint64X(vp *map[float32]uint64, d *Decoder) {
+	v, changed := f.DecMapFloat32Uint64V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapFloat32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]uintptr)
+		v, changed := fastpathTV.DecMapFloat32UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]uintptr)
-		fastpathTV.DecMapFloat32UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32UintptrX(vp *map[float32]uintptr, d *Decoder) {
+	v, changed := f.DecMapFloat32UintptrV(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat32IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int)
+		v, changed := fastpathTV.DecMapFloat32IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]int)
-		fastpathTV.DecMapFloat32IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32IntX(vp *map[float32]int, d *Decoder) {
+	v, changed := f.DecMapFloat32IntV(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapFloat32Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int8)
+		v, changed := fastpathTV.DecMapFloat32Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]int8)
-		fastpathTV.DecMapFloat32Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Int8X(vp *map[float32]int8, d *Decoder) {
+	v, changed := f.DecMapFloat32Int8V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapFloat32Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int16)
+		v, changed := fastpathTV.DecMapFloat32Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]int16)
-		fastpathTV.DecMapFloat32Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Int16X(vp *map[float32]int16, d *Decoder) {
+	v, changed := f.DecMapFloat32Int16V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapFloat32Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int32)
+		v, changed := fastpathTV.DecMapFloat32Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]int32)
-		fastpathTV.DecMapFloat32Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Int32X(vp *map[float32]int32, d *Decoder) {
+	v, changed := f.DecMapFloat32Int32V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapFloat32Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]int64)
+		v, changed := fastpathTV.DecMapFloat32Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]int64)
-		fastpathTV.DecMapFloat32Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Int64X(vp *map[float32]int64, d *Decoder) {
+	v, changed := f.DecMapFloat32Int64V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapFloat32Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]float32)
+		v, changed := fastpathTV.DecMapFloat32Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]float32)
-		fastpathTV.DecMapFloat32Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Float32X(vp *map[float32]float32, d *Decoder) {
+	v, changed := f.DecMapFloat32Float32V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapFloat32Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]float64)
+		v, changed := fastpathTV.DecMapFloat32Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]float64)
-		fastpathTV.DecMapFloat32Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32Float64X(vp *map[float32]float64, d *Decoder) {
+	v, changed := f.DecMapFloat32Float64V(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapFloat32BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float32]bool)
+		v, changed := fastpathTV.DecMapFloat32BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float32]bool)
-		fastpathTV.DecMapFloat32BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat32BoolX(vp *map[float32]bool, d *Decoder) {
+	v, changed := f.DecMapFloat32BoolV(*vp, true, d)
 	if 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(chkOvf.Float32V(dd.DecodeFloat64()))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapFloat64IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]interface{})
+		v, changed := fastpathTV.DecMapFloat64IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]interface{})
-		fastpathTV.DecMapFloat64IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64IntfX(vp *map[float64]interface{}, d *Decoder) {
+	v, changed := f.DecMapFloat64IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapFloat64StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]string)
+		v, changed := fastpathTV.DecMapFloat64StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]string)
-		fastpathTV.DecMapFloat64StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64StringX(vp *map[float64]string, d *Decoder) {
+	v, changed := f.DecMapFloat64StringV(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapFloat64UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint)
+		v, changed := fastpathTV.DecMapFloat64UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]uint)
-		fastpathTV.DecMapFloat64UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64UintX(vp *map[float64]uint, d *Decoder) {
+	v, changed := f.DecMapFloat64UintV(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint8)
+		v, changed := fastpathTV.DecMapFloat64Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]uint8)
-		fastpathTV.DecMapFloat64Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Uint8X(vp *map[float64]uint8, d *Decoder) {
+	v, changed := f.DecMapFloat64Uint8V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint16)
+		v, changed := fastpathTV.DecMapFloat64Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]uint16)
-		fastpathTV.DecMapFloat64Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Uint16X(vp *map[float64]uint16, d *Decoder) {
+	v, changed := f.DecMapFloat64Uint16V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint32)
+		v, changed := fastpathTV.DecMapFloat64Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]uint32)
-		fastpathTV.DecMapFloat64Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Uint32X(vp *map[float64]uint32, d *Decoder) {
+	v, changed := f.DecMapFloat64Uint32V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uint64)
+		v, changed := fastpathTV.DecMapFloat64Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]uint64)
-		fastpathTV.DecMapFloat64Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Uint64X(vp *map[float64]uint64, d *Decoder) {
+	v, changed := f.DecMapFloat64Uint64V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapFloat64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]uintptr)
+		v, changed := fastpathTV.DecMapFloat64UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]uintptr)
-		fastpathTV.DecMapFloat64UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64UintptrX(vp *map[float64]uintptr, d *Decoder) {
+	v, changed := f.DecMapFloat64UintptrV(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapFloat64IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int)
+		v, changed := fastpathTV.DecMapFloat64IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]int)
-		fastpathTV.DecMapFloat64IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64IntX(vp *map[float64]int, d *Decoder) {
+	v, changed := f.DecMapFloat64IntV(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapFloat64Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int8)
+		v, changed := fastpathTV.DecMapFloat64Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]int8)
-		fastpathTV.DecMapFloat64Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Int8X(vp *map[float64]int8, d *Decoder) {
+	v, changed := f.DecMapFloat64Int8V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapFloat64Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int16)
+		v, changed := fastpathTV.DecMapFloat64Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]int16)
-		fastpathTV.DecMapFloat64Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Int16X(vp *map[float64]int16, d *Decoder) {
+	v, changed := f.DecMapFloat64Int16V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapFloat64Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int32)
+		v, changed := fastpathTV.DecMapFloat64Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]int32)
-		fastpathTV.DecMapFloat64Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Int32X(vp *map[float64]int32, d *Decoder) {
+	v, changed := f.DecMapFloat64Int32V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapFloat64Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]int64)
+		v, changed := fastpathTV.DecMapFloat64Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]int64)
-		fastpathTV.DecMapFloat64Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Int64X(vp *map[float64]int64, d *Decoder) {
+	v, changed := f.DecMapFloat64Int64V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapFloat64Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]float32)
+		v, changed := fastpathTV.DecMapFloat64Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]float32)
-		fastpathTV.DecMapFloat64Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Float32X(vp *map[float64]float32, d *Decoder) {
+	v, changed := f.DecMapFloat64Float32V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapFloat64Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]float64)
+		v, changed := fastpathTV.DecMapFloat64Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]float64)
-		fastpathTV.DecMapFloat64Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64Float64X(vp *map[float64]float64, d *Decoder) {
+	v, changed := f.DecMapFloat64Float64V(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapFloat64BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[float64]bool)
+		v, changed := fastpathTV.DecMapFloat64BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[float64]bool)
-		fastpathTV.DecMapFloat64BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapFloat64BoolX(vp *map[float64]bool, d *Decoder) {
+	v, changed := f.DecMapFloat64BoolV(*vp, true, d)
 	if 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.DecodeFloat64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUintIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]interface{})
+		v, changed := fastpathTV.DecMapUintIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]interface{})
-		fastpathTV.DecMapUintIntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintIntfX(vp *map[uint]interface{}, d *Decoder) {
+	v, changed := f.DecMapUintIntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUintStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]string)
+		v, changed := fastpathTV.DecMapUintStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]string)
-		fastpathTV.DecMapUintStringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintStringX(vp *map[uint]string, d *Decoder) {
+	v, changed := f.DecMapUintStringV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUintUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint)
+		v, changed := fastpathTV.DecMapUintUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]uint)
-		fastpathTV.DecMapUintUintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintUintX(vp *map[uint]uint, d *Decoder) {
+	v, changed := f.DecMapUintUintV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint8)
+		v, changed := fastpathTV.DecMapUintUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]uint8)
-		fastpathTV.DecMapUintUint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintUint8X(vp *map[uint]uint8, d *Decoder) {
+	v, changed := f.DecMapUintUint8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint16)
+		v, changed := fastpathTV.DecMapUintUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]uint16)
-		fastpathTV.DecMapUintUint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintUint16X(vp *map[uint]uint16, d *Decoder) {
+	v, changed := f.DecMapUintUint16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint32)
+		v, changed := fastpathTV.DecMapUintUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]uint32)
-		fastpathTV.DecMapUintUint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintUint32X(vp *map[uint]uint32, d *Decoder) {
+	v, changed := f.DecMapUintUint32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uint64)
+		v, changed := fastpathTV.DecMapUintUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]uint64)
-		fastpathTV.DecMapUintUint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintUint64X(vp *map[uint]uint64, d *Decoder) {
+	v, changed := f.DecMapUintUint64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapUintUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]uintptr)
+		v, changed := fastpathTV.DecMapUintUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]uintptr)
-		fastpathTV.DecMapUintUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintUintptrX(vp *map[uint]uintptr, d *Decoder) {
+	v, changed := f.DecMapUintUintptrV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int)
+		v, changed := fastpathTV.DecMapUintIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]int)
-		fastpathTV.DecMapUintIntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintIntX(vp *map[uint]int, d *Decoder) {
+	v, changed := f.DecMapUintIntV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUintInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int8)
+		v, changed := fastpathTV.DecMapUintInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]int8)
-		fastpathTV.DecMapUintInt8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintInt8X(vp *map[uint]int8, d *Decoder) {
+	v, changed := f.DecMapUintInt8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUintInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int16)
+		v, changed := fastpathTV.DecMapUintInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]int16)
-		fastpathTV.DecMapUintInt16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintInt16X(vp *map[uint]int16, d *Decoder) {
+	v, changed := f.DecMapUintInt16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUintInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int32)
+		v, changed := fastpathTV.DecMapUintInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]int32)
-		fastpathTV.DecMapUintInt32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintInt32X(vp *map[uint]int32, d *Decoder) {
+	v, changed := f.DecMapUintInt32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUintInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]int64)
+		v, changed := fastpathTV.DecMapUintInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]int64)
-		fastpathTV.DecMapUintInt64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintInt64X(vp *map[uint]int64, d *Decoder) {
+	v, changed := f.DecMapUintInt64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapUintFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]float32)
+		v, changed := fastpathTV.DecMapUintFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]float32)
-		fastpathTV.DecMapUintFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintFloat32X(vp *map[uint]float32, d *Decoder) {
+	v, changed := f.DecMapUintFloat32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapUintFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]float64)
+		v, changed := fastpathTV.DecMapUintFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]float64)
-		fastpathTV.DecMapUintFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintFloat64X(vp *map[uint]float64, d *Decoder) {
+	v, changed := f.DecMapUintFloat64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapUintBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint]bool)
+		v, changed := fastpathTV.DecMapUintBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint]bool)
-		fastpathTV.DecMapUintBoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintBoolX(vp *map[uint]bool, d *Decoder) {
+	v, changed := f.DecMapUintBoolV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint8IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]interface{})
+		v, changed := fastpathTV.DecMapUint8IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]interface{})
-		fastpathTV.DecMapUint8IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8IntfX(vp *map[uint8]interface{}, d *Decoder) {
+	v, changed := f.DecMapUint8IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint8StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]string)
+		v, changed := fastpathTV.DecMapUint8StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]string)
-		fastpathTV.DecMapUint8StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8StringX(vp *map[uint8]string, d *Decoder) {
+	v, changed := f.DecMapUint8StringV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint8UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint)
+		v, changed := fastpathTV.DecMapUint8UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]uint)
-		fastpathTV.DecMapUint8UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8UintX(vp *map[uint8]uint, d *Decoder) {
+	v, changed := f.DecMapUint8UintV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint8)
+		v, changed := fastpathTV.DecMapUint8Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]uint8)
-		fastpathTV.DecMapUint8Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Uint8X(vp *map[uint8]uint8, d *Decoder) {
+	v, changed := f.DecMapUint8Uint8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint16)
+		v, changed := fastpathTV.DecMapUint8Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]uint16)
-		fastpathTV.DecMapUint8Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Uint16X(vp *map[uint8]uint16, d *Decoder) {
+	v, changed := f.DecMapUint8Uint16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint32)
+		v, changed := fastpathTV.DecMapUint8Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]uint32)
-		fastpathTV.DecMapUint8Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Uint32X(vp *map[uint8]uint32, d *Decoder) {
+	v, changed := f.DecMapUint8Uint32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uint64)
+		v, changed := fastpathTV.DecMapUint8Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]uint64)
-		fastpathTV.DecMapUint8Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Uint64X(vp *map[uint8]uint64, d *Decoder) {
+	v, changed := f.DecMapUint8Uint64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapUint8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]uintptr)
+		v, changed := fastpathTV.DecMapUint8UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]uintptr)
-		fastpathTV.DecMapUint8UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8UintptrX(vp *map[uint8]uintptr, d *Decoder) {
+	v, changed := f.DecMapUint8UintptrV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint8IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int)
+		v, changed := fastpathTV.DecMapUint8IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]int)
-		fastpathTV.DecMapUint8IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8IntX(vp *map[uint8]int, d *Decoder) {
+	v, changed := f.DecMapUint8IntV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint8Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int8)
+		v, changed := fastpathTV.DecMapUint8Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]int8)
-		fastpathTV.DecMapUint8Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Int8X(vp *map[uint8]int8, d *Decoder) {
+	v, changed := f.DecMapUint8Int8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint8Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int16)
+		v, changed := fastpathTV.DecMapUint8Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]int16)
-		fastpathTV.DecMapUint8Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Int16X(vp *map[uint8]int16, d *Decoder) {
+	v, changed := f.DecMapUint8Int16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint8Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int32)
+		v, changed := fastpathTV.DecMapUint8Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]int32)
-		fastpathTV.DecMapUint8Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Int32X(vp *map[uint8]int32, d *Decoder) {
+	v, changed := f.DecMapUint8Int32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint8Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]int64)
+		v, changed := fastpathTV.DecMapUint8Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]int64)
-		fastpathTV.DecMapUint8Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Int64X(vp *map[uint8]int64, d *Decoder) {
+	v, changed := f.DecMapUint8Int64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapUint8Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]float32)
+		v, changed := fastpathTV.DecMapUint8Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]float32)
-		fastpathTV.DecMapUint8Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Float32X(vp *map[uint8]float32, d *Decoder) {
+	v, changed := f.DecMapUint8Float32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapUint8Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]float64)
+		v, changed := fastpathTV.DecMapUint8Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]float64)
-		fastpathTV.DecMapUint8Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8Float64X(vp *map[uint8]float64, d *Decoder) {
+	v, changed := f.DecMapUint8Float64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapUint8BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint8]bool)
+		v, changed := fastpathTV.DecMapUint8BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint8]bool)
-		fastpathTV.DecMapUint8BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint8BoolX(vp *map[uint8]bool, d *Decoder) {
+	v, changed := f.DecMapUint8BoolV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint16IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]interface{})
+		v, changed := fastpathTV.DecMapUint16IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]interface{})
-		fastpathTV.DecMapUint16IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16IntfX(vp *map[uint16]interface{}, d *Decoder) {
+	v, changed := f.DecMapUint16IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint16StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]string)
+		v, changed := fastpathTV.DecMapUint16StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]string)
-		fastpathTV.DecMapUint16StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16StringX(vp *map[uint16]string, d *Decoder) {
+	v, changed := f.DecMapUint16StringV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint16UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint)
+		v, changed := fastpathTV.DecMapUint16UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]uint)
-		fastpathTV.DecMapUint16UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16UintX(vp *map[uint16]uint, d *Decoder) {
+	v, changed := f.DecMapUint16UintV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint8)
+		v, changed := fastpathTV.DecMapUint16Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]uint8)
-		fastpathTV.DecMapUint16Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Uint8X(vp *map[uint16]uint8, d *Decoder) {
+	v, changed := f.DecMapUint16Uint8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint16)
+		v, changed := fastpathTV.DecMapUint16Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]uint16)
-		fastpathTV.DecMapUint16Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Uint16X(vp *map[uint16]uint16, d *Decoder) {
+	v, changed := f.DecMapUint16Uint16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint32)
+		v, changed := fastpathTV.DecMapUint16Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]uint32)
-		fastpathTV.DecMapUint16Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Uint32X(vp *map[uint16]uint32, d *Decoder) {
+	v, changed := f.DecMapUint16Uint32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uint64)
+		v, changed := fastpathTV.DecMapUint16Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]uint64)
-		fastpathTV.DecMapUint16Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Uint64X(vp *map[uint16]uint64, d *Decoder) {
+	v, changed := f.DecMapUint16Uint64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapUint16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]uintptr)
+		v, changed := fastpathTV.DecMapUint16UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]uintptr)
-		fastpathTV.DecMapUint16UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16UintptrX(vp *map[uint16]uintptr, d *Decoder) {
+	v, changed := f.DecMapUint16UintptrV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint16IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int)
+		v, changed := fastpathTV.DecMapUint16IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]int)
-		fastpathTV.DecMapUint16IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16IntX(vp *map[uint16]int, d *Decoder) {
+	v, changed := f.DecMapUint16IntV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint16Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int8)
+		v, changed := fastpathTV.DecMapUint16Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]int8)
-		fastpathTV.DecMapUint16Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Int8X(vp *map[uint16]int8, d *Decoder) {
+	v, changed := f.DecMapUint16Int8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint16Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int16)
+		v, changed := fastpathTV.DecMapUint16Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]int16)
-		fastpathTV.DecMapUint16Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Int16X(vp *map[uint16]int16, d *Decoder) {
+	v, changed := f.DecMapUint16Int16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint16Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int32)
+		v, changed := fastpathTV.DecMapUint16Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]int32)
-		fastpathTV.DecMapUint16Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Int32X(vp *map[uint16]int32, d *Decoder) {
+	v, changed := f.DecMapUint16Int32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint16Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]int64)
+		v, changed := fastpathTV.DecMapUint16Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]int64)
-		fastpathTV.DecMapUint16Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Int64X(vp *map[uint16]int64, d *Decoder) {
+	v, changed := f.DecMapUint16Int64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapUint16Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]float32)
+		v, changed := fastpathTV.DecMapUint16Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]float32)
-		fastpathTV.DecMapUint16Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Float32X(vp *map[uint16]float32, d *Decoder) {
+	v, changed := f.DecMapUint16Float32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapUint16Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]float64)
+		v, changed := fastpathTV.DecMapUint16Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]float64)
-		fastpathTV.DecMapUint16Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16Float64X(vp *map[uint16]float64, d *Decoder) {
+	v, changed := f.DecMapUint16Float64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapUint16BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint16]bool)
+		v, changed := fastpathTV.DecMapUint16BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint16]bool)
-		fastpathTV.DecMapUint16BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint16BoolX(vp *map[uint16]bool, d *Decoder) {
+	v, changed := f.DecMapUint16BoolV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint32IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]interface{})
+		v, changed := fastpathTV.DecMapUint32IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]interface{})
-		fastpathTV.DecMapUint32IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32IntfX(vp *map[uint32]interface{}, d *Decoder) {
+	v, changed := f.DecMapUint32IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint32StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]string)
+		v, changed := fastpathTV.DecMapUint32StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]string)
-		fastpathTV.DecMapUint32StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32StringX(vp *map[uint32]string, d *Decoder) {
+	v, changed := f.DecMapUint32StringV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint32UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint)
+		v, changed := fastpathTV.DecMapUint32UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]uint)
-		fastpathTV.DecMapUint32UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32UintX(vp *map[uint32]uint, d *Decoder) {
+	v, changed := f.DecMapUint32UintV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint8)
+		v, changed := fastpathTV.DecMapUint32Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]uint8)
-		fastpathTV.DecMapUint32Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Uint8X(vp *map[uint32]uint8, d *Decoder) {
+	v, changed := f.DecMapUint32Uint8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint16)
+		v, changed := fastpathTV.DecMapUint32Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]uint16)
-		fastpathTV.DecMapUint32Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Uint16X(vp *map[uint32]uint16, d *Decoder) {
+	v, changed := f.DecMapUint32Uint16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint32)
+		v, changed := fastpathTV.DecMapUint32Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]uint32)
-		fastpathTV.DecMapUint32Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Uint32X(vp *map[uint32]uint32, d *Decoder) {
+	v, changed := f.DecMapUint32Uint32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uint64)
+		v, changed := fastpathTV.DecMapUint32Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]uint64)
-		fastpathTV.DecMapUint32Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Uint64X(vp *map[uint32]uint64, d *Decoder) {
+	v, changed := f.DecMapUint32Uint64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapUint32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]uintptr)
+		v, changed := fastpathTV.DecMapUint32UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]uintptr)
-		fastpathTV.DecMapUint32UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32UintptrX(vp *map[uint32]uintptr, d *Decoder) {
+	v, changed := f.DecMapUint32UintptrV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint32IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int)
+		v, changed := fastpathTV.DecMapUint32IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]int)
-		fastpathTV.DecMapUint32IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32IntX(vp *map[uint32]int, d *Decoder) {
+	v, changed := f.DecMapUint32IntV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint32Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int8)
+		v, changed := fastpathTV.DecMapUint32Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]int8)
-		fastpathTV.DecMapUint32Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Int8X(vp *map[uint32]int8, d *Decoder) {
+	v, changed := f.DecMapUint32Int8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint32Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int16)
+		v, changed := fastpathTV.DecMapUint32Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]int16)
-		fastpathTV.DecMapUint32Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Int16X(vp *map[uint32]int16, d *Decoder) {
+	v, changed := f.DecMapUint32Int16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint32Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int32)
+		v, changed := fastpathTV.DecMapUint32Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]int32)
-		fastpathTV.DecMapUint32Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Int32X(vp *map[uint32]int32, d *Decoder) {
+	v, changed := f.DecMapUint32Int32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint32Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]int64)
+		v, changed := fastpathTV.DecMapUint32Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]int64)
-		fastpathTV.DecMapUint32Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Int64X(vp *map[uint32]int64, d *Decoder) {
+	v, changed := f.DecMapUint32Int64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapUint32Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]float32)
+		v, changed := fastpathTV.DecMapUint32Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]float32)
-		fastpathTV.DecMapUint32Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Float32X(vp *map[uint32]float32, d *Decoder) {
+	v, changed := f.DecMapUint32Float32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapUint32Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]float64)
+		v, changed := fastpathTV.DecMapUint32Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]float64)
-		fastpathTV.DecMapUint32Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32Float64X(vp *map[uint32]float64, d *Decoder) {
+	v, changed := f.DecMapUint32Float64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapUint32BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint32]bool)
+		v, changed := fastpathTV.DecMapUint32BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint32]bool)
-		fastpathTV.DecMapUint32BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint32BoolX(vp *map[uint32]bool, d *Decoder) {
+	v, changed := f.DecMapUint32BoolV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint64IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]interface{})
+		v, changed := fastpathTV.DecMapUint64IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]interface{})
-		fastpathTV.DecMapUint64IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64IntfX(vp *map[uint64]interface{}, d *Decoder) {
+	v, changed := f.DecMapUint64IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint64StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]string)
+		v, changed := fastpathTV.DecMapUint64StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]string)
-		fastpathTV.DecMapUint64StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64StringX(vp *map[uint64]string, d *Decoder) {
+	v, changed := f.DecMapUint64StringV(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUint64UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint)
+		v, changed := fastpathTV.DecMapUint64UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]uint)
-		fastpathTV.DecMapUint64UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64UintX(vp *map[uint64]uint, d *Decoder) {
+	v, changed := f.DecMapUint64UintV(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint8)
+		v, changed := fastpathTV.DecMapUint64Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]uint8)
-		fastpathTV.DecMapUint64Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Uint8X(vp *map[uint64]uint8, d *Decoder) {
+	v, changed := f.DecMapUint64Uint8V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint16)
+		v, changed := fastpathTV.DecMapUint64Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]uint16)
-		fastpathTV.DecMapUint64Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Uint16X(vp *map[uint64]uint16, d *Decoder) {
+	v, changed := f.DecMapUint64Uint16V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint32)
+		v, changed := fastpathTV.DecMapUint64Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]uint32)
-		fastpathTV.DecMapUint64Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Uint32X(vp *map[uint64]uint32, d *Decoder) {
+	v, changed := f.DecMapUint64Uint32V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uint64)
+		v, changed := fastpathTV.DecMapUint64Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]uint64)
-		fastpathTV.DecMapUint64Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Uint64X(vp *map[uint64]uint64, d *Decoder) {
+	v, changed := f.DecMapUint64Uint64V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapUint64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]uintptr)
+		v, changed := fastpathTV.DecMapUint64UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]uintptr)
-		fastpathTV.DecMapUint64UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64UintptrX(vp *map[uint64]uintptr, d *Decoder) {
+	v, changed := f.DecMapUint64UintptrV(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUint64IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int)
+		v, changed := fastpathTV.DecMapUint64IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]int)
-		fastpathTV.DecMapUint64IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64IntX(vp *map[uint64]int, d *Decoder) {
+	v, changed := f.DecMapUint64IntV(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint64Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int8)
+		v, changed := fastpathTV.DecMapUint64Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]int8)
-		fastpathTV.DecMapUint64Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Int8X(vp *map[uint64]int8, d *Decoder) {
+	v, changed := f.DecMapUint64Int8V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint64Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int16)
+		v, changed := fastpathTV.DecMapUint64Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]int16)
-		fastpathTV.DecMapUint64Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Int16X(vp *map[uint64]int16, d *Decoder) {
+	v, changed := f.DecMapUint64Int16V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint64Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int32)
+		v, changed := fastpathTV.DecMapUint64Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]int32)
-		fastpathTV.DecMapUint64Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Int32X(vp *map[uint64]int32, d *Decoder) {
+	v, changed := f.DecMapUint64Int32V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUint64Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]int64)
+		v, changed := fastpathTV.DecMapUint64Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]int64)
-		fastpathTV.DecMapUint64Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Int64X(vp *map[uint64]int64, d *Decoder) {
+	v, changed := f.DecMapUint64Int64V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapUint64Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]float32)
+		v, changed := fastpathTV.DecMapUint64Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]float32)
-		fastpathTV.DecMapUint64Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Float32X(vp *map[uint64]float32, d *Decoder) {
+	v, changed := f.DecMapUint64Float32V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapUint64Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]float64)
+		v, changed := fastpathTV.DecMapUint64Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]float64)
-		fastpathTV.DecMapUint64Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64Float64X(vp *map[uint64]float64, d *Decoder) {
+	v, changed := f.DecMapUint64Float64V(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapUint64BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uint64]bool)
+		v, changed := fastpathTV.DecMapUint64BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uint64]bool)
-		fastpathTV.DecMapUint64BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUint64BoolX(vp *map[uint64]bool, d *Decoder) {
+	v, changed := f.DecMapUint64BoolV(*vp, true, d)
 	if 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.DecodeUint64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUintptrIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]interface{})
+		v, changed := fastpathTV.DecMapUintptrIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]interface{})
-		fastpathTV.DecMapUintptrIntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrIntfX(vp *map[uintptr]interface{}, d *Decoder) {
+	v, changed := f.DecMapUintptrIntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUintptrStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]string)
+		v, changed := fastpathTV.DecMapUintptrStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]string)
-		fastpathTV.DecMapUintptrStringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrStringX(vp *map[uintptr]string, d *Decoder) {
+	v, changed := f.DecMapUintptrStringV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapUintptrUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint)
+		v, changed := fastpathTV.DecMapUintptrUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]uint)
-		fastpathTV.DecMapUintptrUintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrUintX(vp *map[uintptr]uint, d *Decoder) {
+	v, changed := f.DecMapUintptrUintV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintptrUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint8)
+		v, changed := fastpathTV.DecMapUintptrUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]uint8)
-		fastpathTV.DecMapUintptrUint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrUint8X(vp *map[uintptr]uint8, d *Decoder) {
+	v, changed := f.DecMapUintptrUint8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintptrUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint16)
+		v, changed := fastpathTV.DecMapUintptrUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]uint16)
-		fastpathTV.DecMapUintptrUint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrUint16X(vp *map[uintptr]uint16, d *Decoder) {
+	v, changed := f.DecMapUintptrUint16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintptrUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint32)
+		v, changed := fastpathTV.DecMapUintptrUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]uint32)
-		fastpathTV.DecMapUintptrUint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrUint32X(vp *map[uintptr]uint32, d *Decoder) {
+	v, changed := f.DecMapUintptrUint32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintptrUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uint64)
+		v, changed := fastpathTV.DecMapUintptrUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]uint64)
-		fastpathTV.DecMapUintptrUint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrUint64X(vp *map[uintptr]uint64, d *Decoder) {
+	v, changed := f.DecMapUintptrUint64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapUintptrUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]uintptr)
+		v, changed := fastpathTV.DecMapUintptrUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]uintptr)
-		fastpathTV.DecMapUintptrUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrUintptrX(vp *map[uintptr]uintptr, d *Decoder) {
+	v, changed := f.DecMapUintptrUintptrV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapUintptrIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int)
+		v, changed := fastpathTV.DecMapUintptrIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]int)
-		fastpathTV.DecMapUintptrIntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrIntX(vp *map[uintptr]int, d *Decoder) {
+	v, changed := f.DecMapUintptrIntV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUintptrInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int8)
+		v, changed := fastpathTV.DecMapUintptrInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]int8)
-		fastpathTV.DecMapUintptrInt8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrInt8X(vp *map[uintptr]int8, d *Decoder) {
+	v, changed := f.DecMapUintptrInt8V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUintptrInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int16)
+		v, changed := fastpathTV.DecMapUintptrInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]int16)
-		fastpathTV.DecMapUintptrInt16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrInt16X(vp *map[uintptr]int16, d *Decoder) {
+	v, changed := f.DecMapUintptrInt16V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUintptrInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int32)
+		v, changed := fastpathTV.DecMapUintptrInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]int32)
-		fastpathTV.DecMapUintptrInt32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrInt32X(vp *map[uintptr]int32, d *Decoder) {
+	v, changed := f.DecMapUintptrInt32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapUintptrInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]int64)
+		v, changed := fastpathTV.DecMapUintptrInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]int64)
-		fastpathTV.DecMapUintptrInt64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrInt64X(vp *map[uintptr]int64, d *Decoder) {
+	v, changed := f.DecMapUintptrInt64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapUintptrFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]float32)
+		v, changed := fastpathTV.DecMapUintptrFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]float32)
-		fastpathTV.DecMapUintptrFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrFloat32X(vp *map[uintptr]float32, d *Decoder) {
+	v, changed := f.DecMapUintptrFloat32V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapUintptrFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]float64)
+		v, changed := fastpathTV.DecMapUintptrFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]float64)
-		fastpathTV.DecMapUintptrFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrFloat64X(vp *map[uintptr]float64, d *Decoder) {
+	v, changed := f.DecMapUintptrFloat64V(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapUintptrBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[uintptr]bool)
+		v, changed := fastpathTV.DecMapUintptrBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[uintptr]bool)
-		fastpathTV.DecMapUintptrBoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapUintptrBoolX(vp *map[uintptr]bool, d *Decoder) {
+	v, changed := f.DecMapUintptrBoolV(*vp, true, d)
 	if 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(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapIntIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]interface{})
+		v, changed := fastpathTV.DecMapIntIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]interface{})
-		fastpathTV.DecMapIntIntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntIntfX(vp *map[int]interface{}, d *Decoder) {
+	v, changed := f.DecMapIntIntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapIntStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]string)
+		v, changed := fastpathTV.DecMapIntStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]string)
-		fastpathTV.DecMapIntStringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntStringX(vp *map[int]string, d *Decoder) {
+	v, changed := f.DecMapIntStringV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapIntUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint)
+		v, changed := fastpathTV.DecMapIntUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]uint)
-		fastpathTV.DecMapIntUintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntUintX(vp *map[int]uint, d *Decoder) {
+	v, changed := f.DecMapIntUintV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint8)
+		v, changed := fastpathTV.DecMapIntUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]uint8)
-		fastpathTV.DecMapIntUint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntUint8X(vp *map[int]uint8, d *Decoder) {
+	v, changed := f.DecMapIntUint8V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint16)
+		v, changed := fastpathTV.DecMapIntUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]uint16)
-		fastpathTV.DecMapIntUint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntUint16X(vp *map[int]uint16, d *Decoder) {
+	v, changed := f.DecMapIntUint16V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint32)
+		v, changed := fastpathTV.DecMapIntUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]uint32)
-		fastpathTV.DecMapIntUint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntUint32X(vp *map[int]uint32, d *Decoder) {
+	v, changed := f.DecMapIntUint32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uint64)
+		v, changed := fastpathTV.DecMapIntUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]uint64)
-		fastpathTV.DecMapIntUint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntUint64X(vp *map[int]uint64, d *Decoder) {
+	v, changed := f.DecMapIntUint64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapIntUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]uintptr)
+		v, changed := fastpathTV.DecMapIntUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]uintptr)
-		fastpathTV.DecMapIntUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntUintptrX(vp *map[int]uintptr, d *Decoder) {
+	v, changed := f.DecMapIntUintptrV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapIntIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int)
+		v, changed := fastpathTV.DecMapIntIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]int)
-		fastpathTV.DecMapIntIntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntIntX(vp *map[int]int, d *Decoder) {
+	v, changed := f.DecMapIntIntV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapIntInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int8)
+		v, changed := fastpathTV.DecMapIntInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]int8)
-		fastpathTV.DecMapIntInt8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntInt8X(vp *map[int]int8, d *Decoder) {
+	v, changed := f.DecMapIntInt8V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapIntInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int16)
+		v, changed := fastpathTV.DecMapIntInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]int16)
-		fastpathTV.DecMapIntInt16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntInt16X(vp *map[int]int16, d *Decoder) {
+	v, changed := f.DecMapIntInt16V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapIntInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int32)
+		v, changed := fastpathTV.DecMapIntInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]int32)
-		fastpathTV.DecMapIntInt32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntInt32X(vp *map[int]int32, d *Decoder) {
+	v, changed := f.DecMapIntInt32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapIntInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]int64)
+		v, changed := fastpathTV.DecMapIntInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]int64)
-		fastpathTV.DecMapIntInt64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntInt64X(vp *map[int]int64, d *Decoder) {
+	v, changed := f.DecMapIntInt64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapIntFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]float32)
+		v, changed := fastpathTV.DecMapIntFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]float32)
-		fastpathTV.DecMapIntFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntFloat32X(vp *map[int]float32, d *Decoder) {
+	v, changed := f.DecMapIntFloat32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapIntFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]float64)
+		v, changed := fastpathTV.DecMapIntFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]float64)
-		fastpathTV.DecMapIntFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntFloat64X(vp *map[int]float64, d *Decoder) {
+	v, changed := f.DecMapIntFloat64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapIntBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int]bool)
+		v, changed := fastpathTV.DecMapIntBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int]bool)
-		fastpathTV.DecMapIntBoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapIntBoolX(vp *map[int]bool, d *Decoder) {
+	v, changed := f.DecMapIntBoolV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), intBitsize))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt8IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]interface{})
+		v, changed := fastpathTV.DecMapInt8IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]interface{})
-		fastpathTV.DecMapInt8IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8IntfX(vp *map[int8]interface{}, d *Decoder) {
+	v, changed := f.DecMapInt8IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt8StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]string)
+		v, changed := fastpathTV.DecMapInt8StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]string)
-		fastpathTV.DecMapInt8StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8StringX(vp *map[int8]string, d *Decoder) {
+	v, changed := f.DecMapInt8StringV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt8UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint)
+		v, changed := fastpathTV.DecMapInt8UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]uint)
-		fastpathTV.DecMapInt8UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8UintX(vp *map[int8]uint, d *Decoder) {
+	v, changed := f.DecMapInt8UintV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt8Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint8)
+		v, changed := fastpathTV.DecMapInt8Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]uint8)
-		fastpathTV.DecMapInt8Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Uint8X(vp *map[int8]uint8, d *Decoder) {
+	v, changed := f.DecMapInt8Uint8V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt8Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint16)
+		v, changed := fastpathTV.DecMapInt8Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]uint16)
-		fastpathTV.DecMapInt8Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Uint16X(vp *map[int8]uint16, d *Decoder) {
+	v, changed := f.DecMapInt8Uint16V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt8Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint32)
+		v, changed := fastpathTV.DecMapInt8Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]uint32)
-		fastpathTV.DecMapInt8Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Uint32X(vp *map[int8]uint32, d *Decoder) {
+	v, changed := f.DecMapInt8Uint32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt8Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uint64)
+		v, changed := fastpathTV.DecMapInt8Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]uint64)
-		fastpathTV.DecMapInt8Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Uint64X(vp *map[int8]uint64, d *Decoder) {
+	v, changed := f.DecMapInt8Uint64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapInt8UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]uintptr)
+		v, changed := fastpathTV.DecMapInt8UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]uintptr)
-		fastpathTV.DecMapInt8UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8UintptrX(vp *map[int8]uintptr, d *Decoder) {
+	v, changed := f.DecMapInt8UintptrV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt8IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int)
+		v, changed := fastpathTV.DecMapInt8IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]int)
-		fastpathTV.DecMapInt8IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8IntX(vp *map[int8]int, d *Decoder) {
+	v, changed := f.DecMapInt8IntV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt8Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int8)
+		v, changed := fastpathTV.DecMapInt8Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]int8)
-		fastpathTV.DecMapInt8Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Int8X(vp *map[int8]int8, d *Decoder) {
+	v, changed := f.DecMapInt8Int8V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt8Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int16)
+		v, changed := fastpathTV.DecMapInt8Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]int16)
-		fastpathTV.DecMapInt8Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Int16X(vp *map[int8]int16, d *Decoder) {
+	v, changed := f.DecMapInt8Int16V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt8Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int32)
+		v, changed := fastpathTV.DecMapInt8Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]int32)
-		fastpathTV.DecMapInt8Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Int32X(vp *map[int8]int32, d *Decoder) {
+	v, changed := f.DecMapInt8Int32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt8Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]int64)
+		v, changed := fastpathTV.DecMapInt8Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]int64)
-		fastpathTV.DecMapInt8Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Int64X(vp *map[int8]int64, d *Decoder) {
+	v, changed := f.DecMapInt8Int64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapInt8Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]float32)
+		v, changed := fastpathTV.DecMapInt8Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]float32)
-		fastpathTV.DecMapInt8Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Float32X(vp *map[int8]float32, d *Decoder) {
+	v, changed := f.DecMapInt8Float32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapInt8Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]float64)
+		v, changed := fastpathTV.DecMapInt8Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]float64)
-		fastpathTV.DecMapInt8Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8Float64X(vp *map[int8]float64, d *Decoder) {
+	v, changed := f.DecMapInt8Float64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapInt8BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int8]bool)
+		v, changed := fastpathTV.DecMapInt8BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int8]bool)
-		fastpathTV.DecMapInt8BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt8BoolX(vp *map[int8]bool, d *Decoder) {
+	v, changed := f.DecMapInt8BoolV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 8))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt16IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]interface{})
+		v, changed := fastpathTV.DecMapInt16IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]interface{})
-		fastpathTV.DecMapInt16IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16IntfX(vp *map[int16]interface{}, d *Decoder) {
+	v, changed := f.DecMapInt16IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt16StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]string)
+		v, changed := fastpathTV.DecMapInt16StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]string)
-		fastpathTV.DecMapInt16StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16StringX(vp *map[int16]string, d *Decoder) {
+	v, changed := f.DecMapInt16StringV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt16UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint)
+		v, changed := fastpathTV.DecMapInt16UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]uint)
-		fastpathTV.DecMapInt16UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16UintX(vp *map[int16]uint, d *Decoder) {
+	v, changed := f.DecMapInt16UintV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt16Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint8)
+		v, changed := fastpathTV.DecMapInt16Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]uint8)
-		fastpathTV.DecMapInt16Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Uint8X(vp *map[int16]uint8, d *Decoder) {
+	v, changed := f.DecMapInt16Uint8V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt16Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint16)
+		v, changed := fastpathTV.DecMapInt16Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]uint16)
-		fastpathTV.DecMapInt16Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Uint16X(vp *map[int16]uint16, d *Decoder) {
+	v, changed := f.DecMapInt16Uint16V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt16Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint32)
+		v, changed := fastpathTV.DecMapInt16Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]uint32)
-		fastpathTV.DecMapInt16Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Uint32X(vp *map[int16]uint32, d *Decoder) {
+	v, changed := f.DecMapInt16Uint32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt16Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uint64)
+		v, changed := fastpathTV.DecMapInt16Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]uint64)
-		fastpathTV.DecMapInt16Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Uint64X(vp *map[int16]uint64, d *Decoder) {
+	v, changed := f.DecMapInt16Uint64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapInt16UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]uintptr)
+		v, changed := fastpathTV.DecMapInt16UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]uintptr)
-		fastpathTV.DecMapInt16UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16UintptrX(vp *map[int16]uintptr, d *Decoder) {
+	v, changed := f.DecMapInt16UintptrV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt16IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int)
+		v, changed := fastpathTV.DecMapInt16IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]int)
-		fastpathTV.DecMapInt16IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16IntX(vp *map[int16]int, d *Decoder) {
+	v, changed := f.DecMapInt16IntV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt16Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int8)
+		v, changed := fastpathTV.DecMapInt16Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]int8)
-		fastpathTV.DecMapInt16Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Int8X(vp *map[int16]int8, d *Decoder) {
+	v, changed := f.DecMapInt16Int8V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt16Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int16)
+		v, changed := fastpathTV.DecMapInt16Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]int16)
-		fastpathTV.DecMapInt16Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Int16X(vp *map[int16]int16, d *Decoder) {
+	v, changed := f.DecMapInt16Int16V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt16Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int32)
+		v, changed := fastpathTV.DecMapInt16Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]int32)
-		fastpathTV.DecMapInt16Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Int32X(vp *map[int16]int32, d *Decoder) {
+	v, changed := f.DecMapInt16Int32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt16Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]int64)
+		v, changed := fastpathTV.DecMapInt16Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]int64)
-		fastpathTV.DecMapInt16Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Int64X(vp *map[int16]int64, d *Decoder) {
+	v, changed := f.DecMapInt16Int64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapInt16Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]float32)
+		v, changed := fastpathTV.DecMapInt16Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]float32)
-		fastpathTV.DecMapInt16Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Float32X(vp *map[int16]float32, d *Decoder) {
+	v, changed := f.DecMapInt16Float32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapInt16Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]float64)
+		v, changed := fastpathTV.DecMapInt16Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]float64)
-		fastpathTV.DecMapInt16Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16Float64X(vp *map[int16]float64, d *Decoder) {
+	v, changed := f.DecMapInt16Float64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapInt16BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int16]bool)
+		v, changed := fastpathTV.DecMapInt16BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int16]bool)
-		fastpathTV.DecMapInt16BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt16BoolX(vp *map[int16]bool, d *Decoder) {
+	v, changed := f.DecMapInt16BoolV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 16))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt32IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]interface{})
+		v, changed := fastpathTV.DecMapInt32IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]interface{})
-		fastpathTV.DecMapInt32IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32IntfX(vp *map[int32]interface{}, d *Decoder) {
+	v, changed := f.DecMapInt32IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt32StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]string)
+		v, changed := fastpathTV.DecMapInt32StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]string)
-		fastpathTV.DecMapInt32StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32StringX(vp *map[int32]string, d *Decoder) {
+	v, changed := f.DecMapInt32StringV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt32UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint)
+		v, changed := fastpathTV.DecMapInt32UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]uint)
-		fastpathTV.DecMapInt32UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32UintX(vp *map[int32]uint, d *Decoder) {
+	v, changed := f.DecMapInt32UintV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt32Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint8)
+		v, changed := fastpathTV.DecMapInt32Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]uint8)
-		fastpathTV.DecMapInt32Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Uint8X(vp *map[int32]uint8, d *Decoder) {
+	v, changed := f.DecMapInt32Uint8V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt32Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint16)
+		v, changed := fastpathTV.DecMapInt32Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]uint16)
-		fastpathTV.DecMapInt32Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Uint16X(vp *map[int32]uint16, d *Decoder) {
+	v, changed := f.DecMapInt32Uint16V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt32Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint32)
+		v, changed := fastpathTV.DecMapInt32Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]uint32)
-		fastpathTV.DecMapInt32Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Uint32X(vp *map[int32]uint32, d *Decoder) {
+	v, changed := f.DecMapInt32Uint32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt32Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uint64)
+		v, changed := fastpathTV.DecMapInt32Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]uint64)
-		fastpathTV.DecMapInt32Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Uint64X(vp *map[int32]uint64, d *Decoder) {
+	v, changed := f.DecMapInt32Uint64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapInt32UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]uintptr)
+		v, changed := fastpathTV.DecMapInt32UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]uintptr)
-		fastpathTV.DecMapInt32UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32UintptrX(vp *map[int32]uintptr, d *Decoder) {
+	v, changed := f.DecMapInt32UintptrV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt32IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int)
+		v, changed := fastpathTV.DecMapInt32IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]int)
-		fastpathTV.DecMapInt32IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32IntX(vp *map[int32]int, d *Decoder) {
+	v, changed := f.DecMapInt32IntV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt32Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int8)
+		v, changed := fastpathTV.DecMapInt32Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]int8)
-		fastpathTV.DecMapInt32Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Int8X(vp *map[int32]int8, d *Decoder) {
+	v, changed := f.DecMapInt32Int8V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt32Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int16)
+		v, changed := fastpathTV.DecMapInt32Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]int16)
-		fastpathTV.DecMapInt32Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Int16X(vp *map[int32]int16, d *Decoder) {
+	v, changed := f.DecMapInt32Int16V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt32Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int32)
+		v, changed := fastpathTV.DecMapInt32Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]int32)
-		fastpathTV.DecMapInt32Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Int32X(vp *map[int32]int32, d *Decoder) {
+	v, changed := f.DecMapInt32Int32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt32Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]int64)
+		v, changed := fastpathTV.DecMapInt32Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]int64)
-		fastpathTV.DecMapInt32Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Int64X(vp *map[int32]int64, d *Decoder) {
+	v, changed := f.DecMapInt32Int64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapInt32Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]float32)
+		v, changed := fastpathTV.DecMapInt32Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]float32)
-		fastpathTV.DecMapInt32Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Float32X(vp *map[int32]float32, d *Decoder) {
+	v, changed := f.DecMapInt32Float32V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapInt32Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]float64)
+		v, changed := fastpathTV.DecMapInt32Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]float64)
-		fastpathTV.DecMapInt32Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32Float64X(vp *map[int32]float64, d *Decoder) {
+	v, changed := f.DecMapInt32Float64V(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapInt32BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int32]bool)
+		v, changed := fastpathTV.DecMapInt32BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int32]bool)
-		fastpathTV.DecMapInt32BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt32BoolX(vp *map[int32]bool, d *Decoder) {
+	v, changed := f.DecMapInt32BoolV(*vp, true, d)
 	if 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(chkOvf.IntV(dd.DecodeInt64(), 32))
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt64IntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]interface{})
+		v, changed := fastpathTV.DecMapInt64IntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]interface{})
-		fastpathTV.DecMapInt64IntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64IntfX(vp *map[int64]interface{}, d *Decoder) {
+	v, changed := f.DecMapInt64IntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt64StringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]string)
+		v, changed := fastpathTV.DecMapInt64StringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]string)
-		fastpathTV.DecMapInt64StringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64StringX(vp *map[int64]string, d *Decoder) {
+	v, changed := f.DecMapInt64StringV(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapInt64UintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint)
+		v, changed := fastpathTV.DecMapInt64UintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]uint)
-		fastpathTV.DecMapInt64UintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64UintX(vp *map[int64]uint, d *Decoder) {
+	v, changed := f.DecMapInt64UintV(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt64Uint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint8)
+		v, changed := fastpathTV.DecMapInt64Uint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]uint8)
-		fastpathTV.DecMapInt64Uint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Uint8X(vp *map[int64]uint8, d *Decoder) {
+	v, changed := f.DecMapInt64Uint8V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt64Uint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint16)
+		v, changed := fastpathTV.DecMapInt64Uint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]uint16)
-		fastpathTV.DecMapInt64Uint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Uint16X(vp *map[int64]uint16, d *Decoder) {
+	v, changed := f.DecMapInt64Uint16V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt64Uint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint32)
+		v, changed := fastpathTV.DecMapInt64Uint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]uint32)
-		fastpathTV.DecMapInt64Uint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Uint32X(vp *map[int64]uint32, d *Decoder) {
+	v, changed := f.DecMapInt64Uint32V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt64Uint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uint64)
+		v, changed := fastpathTV.DecMapInt64Uint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]uint64)
-		fastpathTV.DecMapInt64Uint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Uint64X(vp *map[int64]uint64, d *Decoder) {
+	v, changed := f.DecMapInt64Uint64V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapInt64UintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]uintptr)
+		v, changed := fastpathTV.DecMapInt64UintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]uintptr)
-		fastpathTV.DecMapInt64UintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64UintptrX(vp *map[int64]uintptr, d *Decoder) {
+	v, changed := f.DecMapInt64UintptrV(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapInt64IntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int)
+		v, changed := fastpathTV.DecMapInt64IntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]int)
-		fastpathTV.DecMapInt64IntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64IntX(vp *map[int64]int, d *Decoder) {
+	v, changed := f.DecMapInt64IntV(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt64Int8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int8)
+		v, changed := fastpathTV.DecMapInt64Int8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]int8)
-		fastpathTV.DecMapInt64Int8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Int8X(vp *map[int64]int8, d *Decoder) {
+	v, changed := f.DecMapInt64Int8V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt64Int16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int16)
+		v, changed := fastpathTV.DecMapInt64Int16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]int16)
-		fastpathTV.DecMapInt64Int16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Int16X(vp *map[int64]int16, d *Decoder) {
+	v, changed := f.DecMapInt64Int16V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt64Int32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int32)
+		v, changed := fastpathTV.DecMapInt64Int32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]int32)
-		fastpathTV.DecMapInt64Int32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Int32X(vp *map[int64]int32, d *Decoder) {
+	v, changed := f.DecMapInt64Int32V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapInt64Int64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]int64)
+		v, changed := fastpathTV.DecMapInt64Int64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]int64)
-		fastpathTV.DecMapInt64Int64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Int64X(vp *map[int64]int64, d *Decoder) {
+	v, changed := f.DecMapInt64Int64V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapInt64Float32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]float32)
+		v, changed := fastpathTV.DecMapInt64Float32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]float32)
-		fastpathTV.DecMapInt64Float32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Float32X(vp *map[int64]float32, d *Decoder) {
+	v, changed := f.DecMapInt64Float32V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapInt64Float64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]float64)
+		v, changed := fastpathTV.DecMapInt64Float64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]float64)
-		fastpathTV.DecMapInt64Float64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64Float64X(vp *map[int64]float64, d *Decoder) {
+	v, changed := f.DecMapInt64Float64V(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapInt64BoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[int64]bool)
+		v, changed := fastpathTV.DecMapInt64BoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[int64]bool)
-		fastpathTV.DecMapInt64BoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapInt64BoolX(vp *map[int64]bool, d *Decoder) {
+	v, changed := f.DecMapInt64BoolV(*vp, true, d)
 	if 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.DecodeInt64()
+		if esep {
+			dd.ReadMapElemValue()
+		}
+		if dd.TryDecodeAsNil() {
+			if v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapBoolIntfR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]interface{})
+		v, changed := fastpathTV.DecMapBoolIntfV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]interface{})
-		fastpathTV.DecMapBoolIntfV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolIntfX(vp *map[bool]interface{}, d *Decoder) {
+	v, changed := f.DecMapBoolIntfV(*vp, true, d)
 	if 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
 	}
-	mapGet := !d.h.MapValueReset && !d.h.InterfaceReset
+	if containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
+	}
+	mapGet := v != nil && !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 v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapBoolStringR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]string)
+		v, changed := fastpathTV.DecMapBoolStringV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]string)
-		fastpathTV.DecMapBoolStringV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolStringX(vp *map[bool]string, d *Decoder) {
+	v, changed := f.DecMapBoolStringV(*vp, true, d)
 	if 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 v == nil {
+			} else 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)
+func (d *Decoder) fastpathDecMapBoolUintR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint)
+		v, changed := fastpathTV.DecMapBoolUintV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]uint)
-		fastpathTV.DecMapBoolUintV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolUintX(vp *map[bool]uint, d *Decoder) {
+	v, changed := f.DecMapBoolUintV(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapBoolUint8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint8)
+		v, changed := fastpathTV.DecMapBoolUint8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]uint8)
-		fastpathTV.DecMapBoolUint8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolUint8X(vp *map[bool]uint8, d *Decoder) {
+	v, changed := f.DecMapBoolUint8V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint8(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapBoolUint16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint16)
+		v, changed := fastpathTV.DecMapBoolUint16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]uint16)
-		fastpathTV.DecMapBoolUint16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolUint16X(vp *map[bool]uint16, d *Decoder) {
+	v, changed := f.DecMapBoolUint16V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint16(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapBoolUint32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint32)
+		v, changed := fastpathTV.DecMapBoolUint32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]uint32)
-		fastpathTV.DecMapBoolUint32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolUint32X(vp *map[bool]uint32, d *Decoder) {
+	v, changed := f.DecMapBoolUint32V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uint32(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapBoolUint64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uint64)
+		v, changed := fastpathTV.DecMapBoolUint64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]uint64)
-		fastpathTV.DecMapBoolUint64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolUint64X(vp *map[bool]uint64, d *Decoder) {
+	v, changed := f.DecMapBoolUint64V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeUint64()
+		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)
+func (d *Decoder) fastpathDecMapBoolUintptrR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]uintptr)
+		v, changed := fastpathTV.DecMapBoolUintptrV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]uintptr)
-		fastpathTV.DecMapBoolUintptrV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolUintptrX(vp *map[bool]uintptr, d *Decoder) {
+	v, changed := f.DecMapBoolUintptrV(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = uintptr(chkOvf.UintV(dd.DecodeUint64(), 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)
+func (d *Decoder) fastpathDecMapBoolIntR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int)
+		v, changed := fastpathTV.DecMapBoolIntV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]int)
-		fastpathTV.DecMapBoolIntV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolIntX(vp *map[bool]int, d *Decoder) {
+	v, changed := f.DecMapBoolIntV(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapBoolInt8R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int8)
+		v, changed := fastpathTV.DecMapBoolInt8V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]int8)
-		fastpathTV.DecMapBoolInt8V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolInt8X(vp *map[bool]int8, d *Decoder) {
+	v, changed := f.DecMapBoolInt8V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int8(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapBoolInt16R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int16)
+		v, changed := fastpathTV.DecMapBoolInt16V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]int16)
-		fastpathTV.DecMapBoolInt16V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolInt16X(vp *map[bool]int16, d *Decoder) {
+	v, changed := f.DecMapBoolInt16V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int16(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapBoolInt32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int32)
+		v, changed := fastpathTV.DecMapBoolInt32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]int32)
-		fastpathTV.DecMapBoolInt32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolInt32X(vp *map[bool]int32, d *Decoder) {
+	v, changed := f.DecMapBoolInt32V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = int32(chkOvf.IntV(dd.DecodeInt64(), 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)
+func (d *Decoder) fastpathDecMapBoolInt64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]int64)
+		v, changed := fastpathTV.DecMapBoolInt64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]int64)
-		fastpathTV.DecMapBoolInt64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolInt64X(vp *map[bool]int64, d *Decoder) {
+	v, changed := f.DecMapBoolInt64V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeInt64()
+		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)
+func (d *Decoder) fastpathDecMapBoolFloat32R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]float32)
+		v, changed := fastpathTV.DecMapBoolFloat32V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]float32)
-		fastpathTV.DecMapBoolFloat32V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolFloat32X(vp *map[bool]float32, d *Decoder) {
+	v, changed := f.DecMapBoolFloat32V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = float32(chkOvf.Float32V(dd.DecodeFloat64()))
+		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)
+func (d *Decoder) fastpathDecMapBoolFloat64R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]float64)
+		v, changed := fastpathTV.DecMapBoolFloat64V(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]float64)
-		fastpathTV.DecMapBoolFloat64V(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolFloat64X(vp *map[bool]float64, d *Decoder) {
+	v, changed := f.DecMapBoolFloat64V(*vp, true, d)
 	if 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 v == nil {
+			} else if d.h.DeleteOnNilMapValue {
+				delete(v, mk)
+			} else {
+				v[mk] = 0
 			}
+			continue
+		}
+		mv = dd.DecodeFloat64()
+		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)
+func (d *Decoder) fastpathDecMapBoolBoolR(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[bool]bool)
+		v, changed := fastpathTV.DecMapBoolBoolV(*vp, true, d)
 		if changed {
 			*vp = v
 		}
 	} else {
-		v := rv.Interface().(map[bool]bool)
-		fastpathTV.DecMapBoolBoolV(v, fastpathCheckNilFalse, false, f.d)
+		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)
+func (f fastpathT) DecMapBoolBoolX(vp *map[bool]bool, d *Decoder) {
+	v, changed := f.DecMapBoolBoolV(*vp, true, d)
 	if 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 v == nil {
+			} else 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 04c173fba..2023e05d3 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
@@ -3,10 +3,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.
 
-// ************************************************************
-// DO NOT EDIT. 
-// THIS FILE IS AUTO-GENERATED from fast-path.go.tmpl
-// ************************************************************
+// Code generated from fast-path.go.tmpl - DO NOT EDIT.
 
 package codec
 
@@ -18,19 +15,19 @@ package codec
 // This file can be omitted without causing a build failure.
 //
 // The advantage of fast paths is:
-//    - Many calls bypass reflection altogether
+//	  - Many calls bypass reflection altogether
 // 
 // Currently support
-//    - slice of all builtin types,
-//    - map of all builtin types to string or interface value
-//    - symetrical maps of all builtin types (e.g. str-str, uint8-uint8)
+//	  - slice of all builtin types,
+//	  - map of all builtin types to string or interface value
+//	  - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
 // This should provide adequate "typical" implementations.
 // 
 // Note that fast track decode functions must handle values for which an address cannot be obtained.
 // For example: 
-//   m2 := map[string]int{}
-//   p2 := []interface{}{m2}
-//   // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
+//	 m2 := map[string]int{}
+//	 p2 := []interface{}{m2}
+//	 // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
 // 
 
 import (
@@ -38,8 +35,7 @@ import (
 	"sort"
 )
 
-const fastpathCheckNilFalse = false // for reflect
-const fastpathCheckNilTrue = true // for type switch
+const fastpathEnabled = true
 
 type fastpathT struct {}
 
@@ -48,8 +44,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
@@ -81,23 +77,22 @@ var fastpathAV fastpathA
 
 // due to possible initialization loop error, make fastpath in an init()
 func init() {
-	if !fastpathEnabled {
-		return
-	}
 	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)
 		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}}
+	{{/* do not register []uint8 in fast-path */}}
+	{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}{{if ne .Elem "uint8"}}
+	fn([]{{ .Elem }}(nil), (*Encoder).{{ .MethodNamePfx "fastpathEnc" false }}R, (*Decoder).{{ .MethodNamePfx "fastpathDec" false }}R){{end}}{{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[:]))
 }
@@ -106,128 +101,150 @@ func init() {
 
 // -- -- fast path type switch
 func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
-	if !fastpathEnabled {
-		return false
-	}
 	switch v := iv.(type) {
-{{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 }}
-	case *[]{{ .Elem }}:{{else}}
-	case *map[{{ .MapKey }}]{{ .Elem }}:{{end}}
-		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
-{{end}}{{end}}
+
+{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}{{if ne .Elem "uint8"}}
+	case []{{ .Elem }}:
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e)
+	case *[]{{ .Elem }}:
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, e){{/*
+*/}}{{end}}{{end}}{{end}}{{end}}
+
+{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
+	case map[{{ .MapKey }}]{{ .Elem }}:
+		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e)
+	case *map[{{ .MapKey }}]{{ .Elem }}:
+		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)
+        _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
 		return false
 	}
 	return true
 }
 
+{{/*
+**** removing this block, as they are never called directly ****
+
+
+
+**** removing this block, as they are never called directly ****
+
+
+
 func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
-	if !fastpathEnabled {
-		return false
-	}
 	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)
+        _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
 		return false
 	}
 	return true
 }
 
 func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
-	if !fastpathEnabled {
-		return false
-	}
 	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)
+        _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
 		return false
 	}
 	return true
 }
 
+
+
+**** removing this block, as they are never called directly ****
+
+
+
+**** removing this block, as they are never called directly ****
+*/}}
+
 // -- -- 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) {
+	if v == nil { e.e.EncodeNil(); return }
+	ee, esep := e.e, e.hh.hasElemSeparators()
+	ee.WriteArrayStart(len(v))
+	if esep {
+		for _, v2 := range v {
+			ee.WriteArrayElem()
+			{{ encmd .Elem "v2"}}
+		}
+	} else {
+		for _, v2 := range v {
+			{{ encmd .Elem "v2"}}
+		}
+	} {{/*
 	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)
-	for j, v2 := range v {
-		if cr != nil {
+	ee.WriteMapStart(len(v) / 2)
+	if esep {
+		for j, v2 := range v {
 			if j%2 == 0 {
-				cr.sendContainerState(containerMapKey)
+				ee.WriteMapElemKey()
 			} else {
-				cr.sendContainerState(containerMapValue)
+				ee.WriteMapElemValue()
+			}
+			{{ encmd .Elem "v2"}}
+		}
+	} else {
+		for _, v2 := range v {
+			{{ encmd .Elem "v2"}}
+		}
+	} {{/*
+	for j, v2 := range v {
+		if esep {
+			if j%2 == 0 {
+				ee.WriteMapElemKey()
+			} else {
+				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))
-	{{if eq .MapKey "string"}}asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
-	{{end}}if e.h.Canonical {
+func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, e *Encoder) {
+	if v == nil { e.e.EncodeNil(); return }
+	ee, esep := e.e, e.hh.hasElemSeparators() 
+	ee.WriteMapStart(len(v))
+	if e.h.Canonical {
 		{{if eq .MapKey "interface{}"}}{{/* out of band 
 		*/}}var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
 		e2 := NewEncoderBytes(&mksv, e.hh)
@@ -243,66 +260,126 @@ func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Ele
 			i++
 		}
 		sort.Sort(bytesISlice(v2))
+		if esep {
+			for j := range v2 {
+				ee.WriteMapElemKey()
+				e.asis(v2[j].v)
+				ee.WriteMapElemValue()
+				e.encode(v[v2[j].i])
+			}
+		} else {
+			for j := range v2 {
+				e.asis(v2[j].v)
+				e.encode(v[v2[j].i])
+			}
+		} {{/*
 		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))
+		} */}} {{else}}{{ $x := sorttype .MapKey true}}v2 := make([]{{ $x }}, len(v))
 		var i int 
 		for k, _ := range v {
 			v2[i] = {{ $x }}(k)
 			i++
 		}
 		sort.Sort({{ sorttype .MapKey false}}(v2))
+		if esep {
+			for _, k2 := range v2 {
+				ee.WriteMapElemKey()
+				{{if eq .MapKey "string"}}ee.EncodeString(cUTF8, k2){{else}}{{ $y := printf "%s(k2)" .MapKey }}{{ encmd .MapKey $y }}{{end}}
+				ee.WriteMapElemValue()
+				{{ $y := printf "v[%s(k2)]" .MapKey }}{{ encmd .Elem $y }}
+			} 
+		} else {
+			for _, k2 := range v2 {
+				{{if eq .MapKey "string"}}ee.EncodeString(cUTF8, k2){{else}}{{ $y := printf "%s(k2)" .MapKey }}{{ encmd .MapKey $y }}{{end}}
+				{{ $y := printf "v[%s(k2)]" .MapKey }}{{ encmd .Elem $y }}
+			} 
+		} {{/*
 		for _, k2 := range v2 {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
-			{{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.WriteMapElemKey() }
+			{{if eq .MapKey "string"}}ee.EncodeString(cUTF8, k2){{else}}{{ $y := printf "%s(k2)" .MapKey }}{{ encmd .MapKey $y }}{{end}}
+			if esep { ee.WriteMapElemValue() }
 			{{ $y := printf "v[%s(k2)]" .MapKey }}{{ encmd .Elem $y }}
-		} {{end}}
+		} */}} {{end}}
 	} else {
+		if esep {
+			for k2, v2 := range v {
+				ee.WriteMapElemKey()
+				{{if eq .MapKey "string"}}ee.EncodeString(cUTF8, k2){{else}}{{ encmd .MapKey "k2"}}{{end}}
+				ee.WriteMapElemValue()
+				{{ encmd .Elem "v2"}}
+			}
+		} else {
+			for k2, v2 := range v {
+				{{if eq .MapKey "string"}}ee.EncodeString(cUTF8, k2){{else}}{{ encmd .MapKey "k2"}}{{end}}
+				{{ encmd .Elem "v2"}}
+			}
+		} {{/*
 		for k2, v2 := range v {
-			if cr != nil { cr.sendContainerState(containerMapKey) }
-			{{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.WriteMapElemKey() }
+			{{if eq .MapKey "string"}}ee.EncodeString(cUTF8, k2){{else}}{{ encmd .MapKey "k2"}}{{end}}
+			if esep { ee.WriteMapElemValue() }
 			{{ encmd .Elem "v2"}}
-		}
+		} */}}
 	}
-	if cr != nil { cr.sendContainerState(containerMapEnd) }{{/* ee.EncodeEnd() */}}
+	ee.WriteMapEnd()
 }
-
 {{end}}{{end}}{{end}}
 
 // -- decode
 
 // -- -- fast path type switch
 func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
-	if !fastpathEnabled {
+     var changed bool
+	switch v := iv.(type) {
+{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}{{if ne .Elem "uint8"}}
+	case []{{ .Elem }}:
+        var v2 []{{ .Elem }}
+		v2, changed = fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, false, d)
+        if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+			copy(v, v2)
+		}
+	case *[]{{ .Elem }}:
+        var v2 []{{ .Elem }}
+		v2, changed = fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*v, true, d)
+        if changed {
+			*v = v2 
+		}{{/*
+*/}}{{end}}{{end}}{{end}}{{end}}
+{{range .Values}}{{if not .Primitive}}{{if .MapKey }}{{/*
+// maps only change if nil, and in that case, there's no point copying
+*/}}
+	case map[{{ .MapKey }}]{{ .Elem }}:
+		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, false, d)
+	case *map[{{ .MapKey }}]{{ .Elem }}:
+         var v2 map[{{ .MapKey }}]{{ .Elem }}
+		v2, changed = fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*v, true, d)
+        if changed {
+			*v = v2 
+		}{{/*
+*/}}{{end}}{{end}}{{end}}
+	default:
+        _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
 		return false
 	}
+	return true
+}
+
+func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool {
 	switch v := iv.(type) {
 {{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 {
-			*v = v2 
-		}
-{{end}}{{end}}
+	case *[]{{ .Elem }}: 
+		*v = nil {{/*
+*/}}{{end}}{{end}}{{end}}
+{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
+	case *map[{{ .MapKey }}]{{ .Elem }}: 
+		*v = nil {{/*
+*/}}{{end}}{{end}}{{end}}
 	default:
-        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
+        _ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
 		return false
 	}
 	return true
@@ -316,225 +393,152 @@ 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 {
+		vp := rv2i(rv).(*[]{{ .Elem }})
+		v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, !array, d)
+        if changed { *vp = v }
 	} else {
-		v := rv.Interface().([]{{ .Elem }})
-		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, f.d)
+		v := rv2i(rv).([]{{ .Elem }})
+        v2, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, !array, d)
+        if changed && len(v) > 0 && len(v2) > 0 && !(len(v2) == len(v) && &v2[0] == &v[0]) {
+           copy(v, v2)
+        }
 	}
 }
-
-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 {
-		*vp = v 
-	}
+func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *[]{{ .Elem }}, d *Decoder) {
+	v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, true, d)
+    if changed { *vp = v }
 }
-func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil bool, 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 
-	}
-
+func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, canChange bool, d *Decoder) (_ []{{ .Elem }}, changed bool) {
+	dd := d.d{{/*
+	    // if dd.isContainerType(valueTypeNil) { dd.TryDecodeAsNil()
+    */}}
 	slh, containerLenS := d.decSliceHelperStart()
 	if containerLenS == 0 {
 		if canChange {
-			if v == nil {
-				v = []{{ .Elem }}{}
-			} else if len(v) != 0 {
-				v = v[:0]
-			}
+			if v == nil { v = []{{ .Elem }}{} } else if len(v) != 0 { v = v[:0] }
 			changed = true
 		}
 		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 && canChange {
+			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 dd.TryDecodeAsNil() {
+			v[j] = {{ zerocmd .Elem }}
+		} 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 
 }
-
 {{end}}{{end}}{{end}}
 
-
 {{range .Values}}{{if not .Primitive}}{{if .MapKey }}
 {{/*
 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 {
-			*vp = v
-		}
+func (d *Decoder) {{ .MethodNamePfx "fastpathDec" false }}R(f *codecFnInfo, rv reflect.Value) {
+	if rv.Kind() == reflect.Ptr {
+		vp := rv2i(rv).(*map[{{ .MapKey }}]{{ .Elem }})
+		v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, true, d);
+		if changed { *vp = v }
 	} else {
-		v := rv.Interface().(map[{{ .MapKey }}]{{ .Elem }})
-		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, f.d)
-	}
+	    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 {
-		*vp = v 
-	}
+func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *map[{{ .MapKey }}]{{ .Elem }}, d *Decoder) {
+	v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, true, d)
+	if 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
-	{{/* // if dd.isContainerType(valueTypeNil) {dd.TryDecodeAsNil() */}}
-	if checkNil && dd.TryDecodeAsNil() {
-		if v != nil {
-			changed = true
-		} 
-		return nil, changed
-	}
-
+	dd, esep := d.d, d.hh.hasElemSeparators(){{/*
+	    // if dd.isContainerType(valueTypeNil) {dd.TryDecodeAsNil()
+    */}}
 	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 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
-			}
-		}
-	} 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 containerLen == 0 {
+		dd.ReadMapEnd()
+		return v, changed
 	}
-	if cr != nil { cr.sendContainerState(containerMapEnd) }
+	{{ if eq .Elem "interface{}" }}mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
+    {{end}}var mk {{ .MapKey }}
+	var mv {{ .Elem }}
+	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 v == nil {} else if d.h.DeleteOnNilMapValue { delete(v, mk) } else { v[mk] = {{ zerocmd .Elem }} }
+			continue 
+		}
+		{{ 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 }
+	}
+	dd.ReadMapEnd()
 	return v, changed
 }
-
 {{end}}{{end}}{{end}}
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 d6f5f0c91..f11b4674f 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.not.go
+++ b/vendor/github.com/ugorji/go/codec/fast-path.not.go
@@ -1,9 +1,14 @@
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
 // +build notfastpath
 
 package codec
 
 import "reflect"
 
+const fastpathEnabled = false
+
 // The generated fast-path code is very large, and adds a few seconds to the build time.
 // This causes test execution, execution of small tools which use codec, etc
 // to take a long time.
@@ -16,17 +21,27 @@ func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool      { return fal
 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{}) 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
 
 func (x fastpathA) index(rtid uintptr) int { return -1 }
 
+func (_ fastpathT) DecSliceUint8V(v []uint8, canChange bool, d *Decoder) (_ []uint8, changed bool) {
+	fn := d.cfer().get(uint8SliceTyp, true, true)
+	d.kSlice(&fn.i, reflect.ValueOf(&v).Elem())
+	return v, true
+}
+
 var fastpathAV fastpathA
 var fastpathTV fastpathT
+
+// ----
+type TestMammoth2Wrapper struct{} // to allow testMammoth work in notfastpath mode
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 32df54144..59c598369 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
@@ -9,94 +9,68 @@ if {{var "l"}} == 0 {
 	} else if len({{var "v"}}) != 0 {
 		{{var "v"}} = {{var "v"}}[:0]
 		{{var "c"}} = true
-	} {{end}} {{if isChan }}if {{var "v"}} == nil {
+	} {{else if isChan }}if {{var "v"}} == nil {
 		{{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 && {{var "v"}} == nil {
+			if {{var "hl"}} {
+				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+			} else {
+				{{var "rl"}} = {{if isSlice}}8{{else if isChan}}64{{end}}
+			}
+			{{var "v"}} = make({{if isSlice}}[]{{ .Typ }}{{else if isChan}}{{.CTyp}}{{end}}, {{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() */}}{{/* commented out, as decLineVar handles this already each time */}}
+        {{if isChan}}{{ $x := printf "%[1]vvcx%[2]v" .TempVar .Rand }}var {{$x}} {{ .Typ }}
+		{{ decLineVar $x }}
+		{{var "v"}} <- {{ $x }}
+        // println(">>>> sending ", {{ $x }}, " into ", {{var "v"}}) // TODO: remove this
+        {{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"}} { 
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 77400e0a1..8323b5494 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-enc-chan.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-enc-chan.go.tmpl
new file mode 100644
index 000000000..4249588a3
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/gen-enc-chan.go.tmpl
@@ -0,0 +1,27 @@
+{{.Label}}:
+switch timeout{{.Sfx}} :=  z.EncBasicHandle().ChanRecvTimeout; {
+case timeout{{.Sfx}} == 0: // only consume available
+	for {
+		select {
+		case b{{.Sfx}} := <-{{.Chan}}:
+			{{ .Slice }} = append({{.Slice}}, b{{.Sfx}})
+		default:
+			break {{.Label}}
+		}
+	}
+case timeout{{.Sfx}} > 0: // consume until timeout
+	tt{{.Sfx}} := time.NewTimer(timeout{{.Sfx}})
+	for {
+		select {
+		case b{{.Sfx}} := <-{{.Chan}}:
+			{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
+		case <-tt{{.Sfx}}.C:
+			// close(tt.C)
+			break {{.Label}}
+		}
+	}
+default: // consume until close
+	for b{{.Sfx}} := range {{.Chan}} {
+		{{.Slice}} = append({{.Slice}}, b{{.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 22bce776b..900281f06 100644
--- a/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
+++ b/vendor/github.com/ugorji/go/codec/gen-helper.generated.go
@@ -1,23 +1,24 @@
-// //+build ignore
+/* // +build ignore */
 
 // 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 gen-helper.go.tmpl
-// ************************************************************
+// Code generated from gen-helper.go.tmpl - DO NOT EDIT.
 
 package codec
 
 import (
 	"encoding"
 	"reflect"
+	"strconv"
 )
 
+// 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 continously and without notice.
+// library users. They WILL change continuously and without notice.
 //
 // To help enforce this, we create an unexported type with exported members.
 // The only way to get the type is via the one exported type that we control (somewhat).
@@ -26,25 +27,85 @@ 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
+func GenHelperEncoder(e *Encoder) (ge genHelperEncoder, ee genHelperEncDriver) {
+	ge = genHelperEncoder{e: e}
+	ee = genHelperEncDriver{encDriver: e.e}
+	return
 }
 
 // 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
+func GenHelperDecoder(d *Decoder) (gd genHelperDecoder, dd genHelperDecDriver) {
+	gd = genHelperDecoder{d: d}
+	dd = genHelperDecDriver{decDriver: d.d}
+	return
+}
+
+type genHelperEncDriver struct {
+	encDriver
+}
+
+func (x genHelperEncDriver) EncodeBuiltin(rt uintptr, v interface{}) {}
+func (x genHelperEncDriver) EncStructFieldKey(keyType valueType, s string) {
+	var m must
+	if keyType == valueTypeString {
+		x.encDriver.EncodeString(cUTF8, s)
+	} else if keyType == valueTypeInt {
+		x.encDriver.EncodeInt(m.Int(strconv.ParseInt(s, 10, 64)))
+	} else if keyType == valueTypeUint {
+		x.encDriver.EncodeUint(m.Uint(strconv.ParseUint(s, 10, 64)))
+	} else if keyType == valueTypeFloat {
+		x.encDriver.EncodeFloat64(m.Float(strconv.ParseFloat(s, 64)))
+	}
+	// encStructFieldKey(x.encDriver, keyType, s)
+}
+func (x genHelperEncDriver) EncodeSymbol(s string) {
+	x.encDriver.EncodeString(cUTF8, s)
+}
+
+type genHelperDecDriver struct {
+	decDriver
+	C checkOverflow
+}
+
+func (x genHelperDecDriver) DecodeBuiltin(rt uintptr, v interface{}) {}
+func (x genHelperDecDriver) DecStructFieldKey(keyType valueType, buf *[decScratchByteArrayLen]byte) []byte {
+	return decStructFieldKey(x.decDriver, keyType, buf)
+}
+func (x genHelperDecDriver) DecodeInt(bitsize uint8) (i int64) {
+	return x.C.IntV(x.decDriver.DecodeInt64(), bitsize)
+}
+func (x genHelperDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
+	return x.C.UintV(x.decDriver.DecodeUint64(), bitsize)
+}
+func (x genHelperDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+	f = x.DecodeFloat64()
+	if chkOverflow32 && chkOvf.Float32(f) {
+		panicv.errorf("float32 overflow: %v", f)
+	}
+	return
+}
+func (x genHelperDecDriver) DecodeFloat32As64() (f float64) {
+	f = x.DecodeFloat64()
+	if chkOvf.Float32(f) {
+		panicv.errorf("float32 overflow: %v", f)
+	}
+	return
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 type genHelperEncoder struct {
+	M must
 	e *Encoder
 	F fastpathT
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 type genHelperDecoder struct {
+	C checkOverflow
 	d *Decoder
 	F fastpathT
 }
@@ -59,69 +120,91 @@ func (f genHelperEncoder) EncBinary() bool {
 	return f.e.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)
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) {
-	bs, fnerr := iv.MarshalText()
-	f.e.marshal(bs, fnerr, false, c_UTF8)
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
-	bs, fnerr := iv.MarshalJSON()
-	f.e.marshal(bs, fnerr, true, c_UTF8)
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
-	bs, fnerr := iv.MarshalBinary()
-	f.e.marshal(bs, fnerr, false, c_RAW)
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
-	if _, ok := f.e.hh.(*BincHandle); ok {
-		return timeTypId
-	}
-	return 0
-}
-
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) IsJSONHandle() bool {
 	return f.e.js
 }
 
 // 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.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) {
+	bs, fnerr := iv.MarshalText()
+	f.e.marshal(bs, fnerr, false, cUTF8)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
+	bs, fnerr := iv.MarshalJSON()
+	f.e.marshal(bs, fnerr, true, cUTF8)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
+	bs, fnerr := iv.MarshalBinary()
+	f.e.marshal(bs, fnerr, false, cRAW)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncRaw(iv Raw) { f.e.rawBytes(iv) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: builtin no longer supported - so we make this method a no-op,
+// but leave in-place so that old generated files continue to work without regeneration.
+func (f genHelperEncoder) TimeRtidIfBinc() (v uintptr) { return }
+
+// func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
+// 	if _, ok := f.e.hh.(*BincHandle); ok {
+// 		return timeTypId
+// 	}
+// }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) I2Rtid(v interface{}) uintptr {
+	return i2rtid(v)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) Extension(rtid uintptr) (xfn *extTypeTagFn) {
+	return f.e.h.getExt(rtid)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext, f.e)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) WriteStr(s string) {
+	f.e.w.writestr(s)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperEncoder) HasExtensions() bool {
 	return len(f.e.h.extHandle) != 0
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperEncoder) EncExt(v interface{}) (r bool) {
-	rt := reflect.TypeOf(v)
-	if rt.Kind() == reflect.Ptr {
-		rt = rt.Elem()
-	}
-	rtid := reflect.ValueOf(rt).Pointer()
-	if xfFn := f.e.h.getExt(rtid); xfFn != nil {
+	if xfFn := f.e.h.getExt(i2rtid(v)); 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 -----------------
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -135,19 +218,27 @@ func (f genHelperDecoder) DecBinary() bool {
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecSwallow() {
-	f.d.swallow()
-}
+func (f genHelperDecoder) DecSwallow() { f.d.swallow() }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecScratchBuffer() []byte {
 	return f.d.b[:]
 }
 
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecScratchArrayBuffer() *[decScratchByteArrayLen]byte {
+	return &f.d.b
+}
+
 // 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)
+	// f.d.decodeValueFallback(rv)
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -167,7 +258,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)
 	}
@@ -175,7 +266,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 {
@@ -185,19 +276,28 @@ 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) TimeRtidIfBinc() uintptr {
-	if _, ok := f.d.hh.(*BincHandle); ok {
-		return timeTypId
-	}
-	return 0
-}
+func (f genHelperDecoder) DecRaw() []byte { return f.d.rawBytes() }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: builtin no longer supported - so we make this method a no-op,
+// but leave in-place so that old generated files continue to work without regeneration.
+func (f genHelperDecoder) TimeRtidIfBinc() (v uintptr) { return }
+
+// func (f genHelperDecoder) TimeRtidIfBinc() uintptr {
+// 	// Note: builtin is no longer supported - so make this a no-op
+// 	if _, ok := f.d.hh.(*BincHandle); ok {
+// 		return timeTypId
+// 	}
+// 	return 0
+// }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) IsJSONHandle() bool {
@@ -205,15 +305,34 @@ func (f genHelperDecoder) IsJSONHandle() bool {
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) I2Rtid(v interface{}) uintptr {
+	return i2rtid(v)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) Extension(rtid uintptr) (xfn *extTypeTagFn) {
+	return f.d.h.getExt(rtid)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperDecoder) HasExtensions() bool {
 	return len(f.d.h.extHandle) != 0
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperDecoder) DecExt(v interface{}) (r bool) {
-	rt := reflect.TypeOf(v).Elem()
-	rtid := reflect.ValueOf(rt).Pointer()
-	if xfFn := f.d.h.getExt(rtid); xfFn != nil {
+	if xfFn := f.d.h.getExt(i2rtid(v)); xfFn != nil {
 		f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
 		return true
 	}
@@ -221,13 +340,12 @@ 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)
-	}
-}
+//
+// Deprecated: no longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
+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 31958574f..c30da85b3 100644
--- a/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
@@ -1,50 +1,111 @@
-// //+build ignore
+/* // +build ignore */
 
 // 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 gen-helper.go.tmpl
-// ************************************************************
+// Code generated from gen-helper.go.tmpl - DO NOT EDIT.
 
 package codec
 
 import (
 	"encoding"
 	"reflect"
+	"strconv"
 )
 
+// 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 continously and without notice.
-// 
+// library users. They WILL change continuously and without notice.
+//
 // To help enforce this, we create an unexported type with exported members.
 // The only way to get the type is via the one exported type that we control (somewhat).
-// 
+//
 // When static codecs are created for types, they will use this value
 // 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 
+func GenHelperEncoder(e *Encoder) (ge genHelperEncoder, ee genHelperEncDriver) {
+	ge = genHelperEncoder{e: e}
+	ee = genHelperEncDriver{encDriver: e.e}
+	return 
 }
 
 // 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 
+func GenHelperDecoder(d *Decoder) (gd genHelperDecoder, dd genHelperDecDriver) {
+	gd = genHelperDecoder{d: d}
+	dd = genHelperDecDriver{decDriver: d.d}
+	return
+}
+
+type genHelperEncDriver struct {
+	encDriver
+}
+
+func (x genHelperEncDriver) EncodeBuiltin(rt uintptr, v interface{}) {}
+func (x genHelperEncDriver) EncStructFieldKey(keyType valueType, s string) {
+	var m must
+	if keyType == valueTypeString {
+		x.encDriver.EncodeString(cUTF8, s)
+	} else if keyType == valueTypeInt {
+		x.encDriver.EncodeInt(m.Int(strconv.ParseInt(s, 10, 64)))
+	} else if keyType == valueTypeUint {
+		x.encDriver.EncodeUint(m.Uint(strconv.ParseUint(s, 10, 64)))
+	} else if keyType == valueTypeFloat {
+		x.encDriver.EncodeFloat64(m.Float(strconv.ParseFloat(s, 64)))
+	} 
+	// encStructFieldKey(x.encDriver, keyType, s)
+}
+func (x genHelperEncDriver) EncodeSymbol(s string) {
+	x.encDriver.EncodeString(cUTF8, s)
+}
+
+type genHelperDecDriver struct {
+	decDriver
+	C checkOverflow
+}
+
+func (x genHelperDecDriver) DecodeBuiltin(rt uintptr, v interface{}) {}
+func (x genHelperDecDriver) DecStructFieldKey(keyType valueType, buf *[decScratchByteArrayLen]byte) []byte {
+	return decStructFieldKey(x.decDriver, keyType, buf)
+}
+func (x genHelperDecDriver) DecodeInt(bitsize uint8) (i int64) {
+	return x.C.IntV(x.decDriver.DecodeInt64(), bitsize)
+}
+func (x genHelperDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
+	return x.C.UintV(x.decDriver.DecodeUint64(), bitsize)
+}
+func (x genHelperDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+	f = x.DecodeFloat64()
+	if chkOverflow32 && chkOvf.Float32(f) {
+		panicv.errorf("float32 overflow: %v", f)
+	}
+	return
+}
+func (x genHelperDecDriver) DecodeFloat32As64() (f float64) {
+	f = x.DecodeFloat64()
+	if chkOvf.Float32(f) {
+		panicv.errorf("float32 overflow: %v", f)
+	}
+	return
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 type genHelperEncoder struct {
+	M must
 	e *Encoder
 	F fastpathT 
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 type genHelperDecoder struct {
+	C checkOverflow
 	d *Decoder
 	F fastpathT 
 }
@@ -53,65 +114,82 @@ type genHelperDecoder struct {
 func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
 	return f.e.h
 }
-
 // 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()
 }
 // 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)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) {
-	bs, fnerr := iv.MarshalText()
-	f.e.marshal(bs, fnerr, false, c_UTF8)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
-	bs, fnerr := iv.MarshalJSON()
-	f.e.marshal(bs, fnerr, true, c_UTF8)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
-	bs, fnerr := iv.MarshalBinary()
-	f.e.marshal(bs, fnerr, false, c_RAW)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
-	if _, ok := f.e.hh.(*BincHandle); ok {
-		return timeTypId 
-	}
-	return 0
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) IsJSONHandle() bool {
 	return f.e.js
 }
 // 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.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) {
+	bs, fnerr := iv.MarshalText()
+	f.e.marshal(bs, fnerr, false, cUTF8)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
+	bs, fnerr := iv.MarshalJSON()
+	f.e.marshal(bs, fnerr, true, cUTF8)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
+	bs, fnerr := iv.MarshalBinary()
+	f.e.marshal(bs, fnerr, false, cRAW)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncRaw(iv Raw) { f.e.rawBytes(iv) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: builtin no longer supported - so we make this method a no-op, 
+// but leave in-place so that old generated files continue to work without regeneration.
+func (f genHelperEncoder) TimeRtidIfBinc() (v uintptr) { return }
+// func (f genHelperEncoder) TimeRtidIfBinc() uintptr {
+// 	if _, ok := f.e.hh.(*BincHandle); ok {
+// 		return timeTypId
+// 	}
+// }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) I2Rtid(v interface{}) uintptr {
+	return i2rtid(v)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) Extension(rtid uintptr) (xfn *extTypeTagFn) {
+	return f.e.h.getExt(rtid)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext, f.e)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) WriteStr(s string) {
+	f.e.w.writestr(s)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperEncoder) HasExtensions() bool {
 	return len(f.e.h.extHandle) != 0
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperEncoder) EncExt(v interface{}) (r bool) {
-	rt := reflect.TypeOf(v)
-	if rt.Kind() == reflect.Ptr {
-		rt = rt.Elem()
-	}
-	rtid := reflect.ValueOf(rt).Pointer()
-	if xfFn := f.e.h.getExt(rtid); xfFn != nil {
+	if xfFn := f.e.h.getExt(i2rtid(v)); 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 -----------------
 
@@ -124,17 +202,24 @@ func (f genHelperDecoder) DecBinary() bool {
      return f.d.be // f.d.hh.isBinaryEncoding()
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecSwallow() {
-	f.d.swallow()
-}
+func (f genHelperDecoder) DecSwallow() { f.d.swallow() }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecScratchBuffer() []byte {
 	return f.d.b[:]
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecScratchArrayBuffer() *[decScratchByteArrayLen]byte {
+	return &f.d.b
+}
+// 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)
+	// f.d.decodeValueFallback(rv)
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecSliceHelperStart() (decSliceHelper, int) {
@@ -150,14 +235,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 {
@@ -166,199 +251,67 @@ 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) TimeRtidIfBinc() uintptr {
-	if _, ok := f.d.hh.(*BincHandle); ok {
-		return timeTypId 
-	}
-	return 0
-}
+func (f genHelperDecoder) DecRaw() []byte {	return f.d.rawBytes() }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: builtin no longer supported - so we make this method a no-op, 
+// but leave in-place so that old generated files continue to work without regeneration.
+func (f genHelperDecoder) TimeRtidIfBinc() (v uintptr) { return }
+// func (f genHelperDecoder) TimeRtidIfBinc() uintptr {
+// 	// Note: builtin is no longer supported - so make this a no-op
+// 	if _, ok := f.d.hh.(*BincHandle); ok {
+// 		return timeTypId
+// 	}
+// 	return 0
+// }
+
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) IsJSONHandle() bool {
 	return f.d.js 
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) I2Rtid(v interface{}) uintptr {
+	return i2rtid(v)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) Extension(rtid uintptr) (xfn *extTypeTagFn) {
+	return f.d.h.getExt(rtid)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecExtension(v interface{}, xfFn *extTypeTagFn) {
+	f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperDecoder) HasExtensions() bool {
 	return len(f.d.h.extHandle) != 0
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+//
+// Deprecated: No longer used,
+// but leave in-place so that old generated files continue to work without regeneration.
 func (f genHelperDecoder) DecExt(v interface{}) (r bool) {
-	rt := reflect.TypeOf(v).Elem()
-	rtid := reflect.ValueOf(rt).Pointer()
-	if xfFn := f.d.h.getExt(rtid); xfFn != nil {
+	if xfFn := f.d.h.getExt(i2rtid(v)); xfFn != nil {
 		f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
 		return true
 	}
 	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) DecSendContainerState(c containerState) {
-	if f.d.cr != nil {
-		f.d.cr.sendContainerState(c)
-	}
-}
+//
+// Deprecated: no longer used, 
+// but leave in-place so that old generated files continue to work without regeneration.
+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 genHelperEncoder) EncDriver() encDriver {
-	return f.e.e
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecDriver() decDriver {
-     return f.d.d
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncNil() {
-	f.e.e.EncodeNil()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncBytes(v []byte) {
-	f.e.e.EncodeStringBytes(c_RAW, v)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncArrayStart(length int) {
-	f.e.e.EncodeArrayStart(length)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncArrayEnd() {
-	f.e.e.EncodeArrayEnd()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncArrayEntrySeparator() {
-	f.e.e.EncodeArrayEntrySeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncMapStart(length int) {
-	f.e.e.EncodeMapStart(length)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncMapEnd() {
-	f.e.e.EncodeMapEnd()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncMapEntrySeparator() {
-	f.e.e.EncodeMapEntrySeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) EncMapKVSeparator() {
-	f.e.e.EncodeMapKVSeparator()
-}
-
-// ---------
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecBytes(v *[]byte) {
-	*v = f.d.d.DecodeBytes(*v)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecTryNil() bool {
-	return f.d.d.TryDecodeAsNil()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecContainerIsNil() (b bool) {
-	return f.d.d.IsContainerType(valueTypeNil)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecContainerIsMap() (b bool) {
-	return f.d.d.IsContainerType(valueTypeMap)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecContainerIsArray() (b bool) {
-	return f.d.d.IsContainerType(valueTypeArray)
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecCheckBreak() bool {
-	return f.d.d.CheckBreak()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecMapStart() int {
-	return f.d.d.ReadMapStart()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecArrayStart() int {
-	return f.d.d.ReadArrayStart()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecMapEnd() {
-	f.d.d.ReadMapEnd()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecArrayEnd() {
-	f.d.d.ReadArrayEnd()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecArrayEntrySeparator() {
-	f.d.d.ReadArrayEntrySeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecMapEntrySeparator() {
-	f.d.d.ReadMapEntrySeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecMapKVSeparator() {
-	f.d.d.ReadMapKVSeparator()
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) ReadStringAsBytes(bs []byte) []byte {
-	return f.d.d.DecodeStringAsBytes(bs)
-}
-
-
-// -- encode calls (primitives)
-{{range .Values}}{{if .Primitive }}{{if ne .Primitive "interface{}" }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) {{ .MethodNamePfx "Enc" true }}(v {{ .Primitive }}) {
-	ee := f.e.e
-	{{ encmd .Primitive "v" }}
-}
-{{ end }}{{ end }}{{ end }}
-
-// -- decode calls (primitives)
-{{range .Values}}{{if .Primitive }}{{if ne .Primitive "interface{}" }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) {{ .MethodNamePfx "Dec" true }}(vp *{{ .Primitive }}) {
-	dd := f.d.d
-	*vp = {{ decmd .Primitive }}
-}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) {{ .MethodNamePfx "Read" true }}() (v {{ .Primitive }}) {
-	dd := f.d.d
-	v = {{ decmd .Primitive }}
-	return
-}
-{{ end }}{{ end }}{{ end }}
-
-
-// -- encode calls (slices/maps)
-{{range .Values}}{{if not .Primitive }}{{if .Slice }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) {{ .MethodNamePfx "Enc" false }}(v []{{ .Elem }}) { {{ else }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) {{ .MethodNamePfx "Enc" false }}(v map[{{ .MapKey }}]{{ .Elem }}) { {{end}}
-	f.F.{{ .MethodNamePfx "Enc" false }}V(v, false, f.e)
-}
-{{ end }}{{ end }}
-
-// -- decode calls (slices/maps) 
-{{range .Values}}{{if not .Primitive }}
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-{{if .Slice }}func (f genHelperDecoder) {{ .MethodNamePfx "Dec" false }}(vp *[]{{ .Elem }}) { 
-{{else}}func (f genHelperDecoder) {{ .MethodNamePfx "Dec" false }}(vp *map[{{ .MapKey }}]{{ .Elem }}) { {{end}}
-	v, changed := f.F.{{ .MethodNamePfx "Dec" false }}V(*vp, false, true, f.d)
-	if changed {
-		*vp = v 
-	}
-}
-{{ end }}{{ end }}
-*/}}
diff --git a/vendor/github.com/ugorji/go/codec/gen.generated.go b/vendor/github.com/ugorji/go/codec/gen.generated.go
index 2ace97b78..240ba9f8c 100644
--- a/vendor/github.com/ugorji/go/codec/gen.generated.go
+++ b/vendor/github.com/ugorji/go/codec/gen.generated.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.
 
@@ -10,21 +12,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 +39,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 = `
@@ -78,94 +64,68 @@ if {{var "l"}} == 0 {
 	} else if len({{var "v"}}) != 0 {
 		{{var "v"}} = {{var "v"}}[:0]
 		{{var "c"}} = true
-	} {{end}} {{if isChan }}if {{var "v"}} == nil {
+	} {{else if isChan }}if {{var "v"}} == nil {
 		{{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 && {{var "v"}} == nil {
+			if {{var "hl"}} {
+				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
+			} else {
+				{{var "rl"}} = {{if isSlice}}8{{else if isChan}}64{{end}}
+			}
+			{{var "v"}} = make({{if isSlice}}[]{{ .Typ }}{{else if isChan}}{{.CTyp}}{{end}}, {{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() */}}{{/* commented out, as decLineVar handles this already each time */}}
+        {{if isChan}}{{ $x := printf "%[1]vvcx%[2]v" .TempVar .Rand }}var {{$x}} {{ .Typ }}
+		{{ decLineVar $x }}
+		{{var "v"}} <- {{ $x }}
+        // println(">>>> sending ", {{ $x }}, " into ", {{var "v"}}) // TODO: remove this
+        {{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"}} { 
@@ -173,3 +133,32 @@ if {{var "l"}} == 0 {
 }{{end}}
 `
 
+const genEncChanTmpl = `
+{{.Label}}:
+switch timeout{{.Sfx}} :=  z.EncBasicHandle().ChanRecvTimeout; {
+case timeout{{.Sfx}} == 0: // only consume available
+	for {
+		select {
+		case b{{.Sfx}} := <-{{.Chan}}:
+			{{ .Slice }} = append({{.Slice}}, b{{.Sfx}})
+		default:
+			break {{.Label}}
+		}
+	}
+case timeout{{.Sfx}} > 0: // consume until timeout
+	tt{{.Sfx}} := time.NewTimer(timeout{{.Sfx}})
+	for {
+		select {
+		case b{{.Sfx}} := <-{{.Chan}}:
+			{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
+		case <-tt{{.Sfx}}.C:
+			// close(tt.C)
+			break {{.Label}}
+		}
+	}
+default: // consume until close
+	for b{{.Sfx}} := range {{.Chan}} {
+		{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
+	}
+}
+`
diff --git a/vendor/github.com/ugorji/go/codec/gen.go b/vendor/github.com/ugorji/go/codec/gen.go
index d4dcbdcc0..575e89c98 100644
--- a/vendor/github.com/ugorji/go/codec/gen.go
+++ b/vendor/github.com/ugorji/go/codec/gen.go
@@ -1,4 +1,6 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// +build codecgen.exec
+
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 package codec
@@ -12,7 +14,6 @@ import (
 	"io"
 	"io/ioutil"
 	"math/rand"
-	"os"
 	"reflect"
 	"regexp"
 	"sort"
@@ -28,7 +29,7 @@ import (
 // ---------------------------------------------------
 // codecgen supports the full cycle of reflection-based codec:
 //    - RawExt
-//    - Builtins
+//    - Raw
 //    - Extensions
 //    - (Binary|Text|JSON)(Unm|M)arshal
 //    - generic by-kind
@@ -78,8 +79,12 @@ import (
 // codecgen will panic if the file was generated with an old version of the library in use.
 //
 // Note:
-//   It was a concious decision to have gen.go always explicitly call EncodeNil or TryDecodeAsNil.
+//   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 +99,10 @@ 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
+// v7:
+// v8: current - we now maintain compatibility with old generated code.
+const genVersion = 8
 
 const (
 	genCodecPkg        = "codec1978"
@@ -122,12 +130,27 @@ const (
 )
 
 var (
-	genAllTypesSamePkgErr  = errors.New("All types must be in the same package")
-	genExpectArrayOrMapErr = errors.New("unexpected type. Expecting array/map/slice")
-	genBase64enc           = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789__")
-	genQNameRegex          = regexp.MustCompile(`[A-Za-z_.]+`)
+	errGenAllTypesSamePkg  = errors.New("All types must be in the same package")
+	errGenExpectArrayOrMap = errors.New("unexpected type. Expecting array/map/slice")
+
+	genBase64enc  = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789__")
+	genQNameRegex = regexp.MustCompile(`[A-Za-z_.]+`)
 )
 
+type genBuf struct {
+	buf []byte
+}
+
+func (x *genBuf) s(s string) *genBuf              { x.buf = append(x.buf, s...); return x }
+func (x *genBuf) b(s []byte) *genBuf              { x.buf = append(x.buf, s...); return x }
+func (x *genBuf) v() string                       { return string(x.buf) }
+func (x *genBuf) f(s string, args ...interface{}) { x.s(fmt.Sprintf(s, args...)) }
+func (x *genBuf) reset() {
+	if x.buf != nil {
+		x.buf = x.buf[:0]
+	}
+}
+
 // genRunner holds some state used during a Gen run.
 type genRunner struct {
 	w io.Writer      // output
@@ -146,8 +169,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
@@ -157,30 +179,37 @@ 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 CONTINUOUSLY 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
+
 	if len(typ) == 0 {
 		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
@@ -196,20 +225,17 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 	for _, t := range typ {
 		// fmt.Printf("###########: PkgPath: '%v', Name: '%s'\n", genImportPath(t), t.Name())
 		if genImportPath(t) != x.bp {
-			panic(genAllTypesSamePkgErr)
+			panic(errGenAllTypesSamePkg)
 		}
 		x.genRefPkgs(t)
 	}
 	if buildTags != "" {
-		x.line("//+build " + buildTags)
+		x.line("// +build " + buildTags)
 		x.line("")
 	}
 	x.line(`
 
-// ************************************************************
-// DO NOT EDIT.
-// THIS FILE IS AUTO-GENERATED BY codecgen.
-// ************************************************************
+// Code generated by codecgen - DO NOT EDIT.
 
 `)
 	x.line("package " + pkgName)
@@ -221,19 +247,20 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 	}
 	// use a sorted set of im keys, so that we can get consistent output
 	imKeys := make([]string, 0, len(x.im))
-	for k, _ := range x.im {
+	for k := range x.im {
 		imKeys = append(imKeys, k)
 	}
 	sort.Strings(imKeys)
 	for _, k := range imKeys { // for k, _ := range x.im {
-		x.linef("%s \"%s\"", x.imn[k], k)
+		if k == x.imn[k] {
+			x.linef("\"%s\"", k)
+		} else {
+			x.linef("%s \"%s\"", x.imn[k], k)
+		}
 	}
 	// add required packages
-	for _, k := range [...]string{"reflect", "unsafe", "runtime", "fmt", "errors"} {
+	for _, k := range [...]string{"runtime", "errors", "strconv"} { // "reflect", "fmt"
 		if _, ok := x.im[k]; !ok {
-			if k == "unsafe" && !x.unsafe {
-				continue
-			}
 			x.line("\"" + k + "\"")
 		}
 	}
@@ -242,40 +269,36 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 
 	x.line("const (")
 	x.linef("// ----- content types ----")
-	x.linef("codecSelferC_UTF8%s = %v", x.xs, int64(c_UTF8))
-	x.linef("codecSelferC_RAW%s = %v", x.xs, int64(c_RAW))
+	x.linef("codecSelferCcUTF8%s = %v", x.xs, int64(cUTF8))
+	x.linef("codecSelferCcRAW%s = %v", x.xs, int64(cRAW))
 	x.linef("// ----- value types used ----")
-	x.linef("codecSelferValueTypeArray%s = %v", x.xs, int64(valueTypeArray))
-	x.linef("codecSelferValueTypeMap%s = %v", x.xs, int64(valueTypeMap))
-	x.linef("// ----- containerStateValues ----")
-	x.linef("codecSelfer_containerMapKey%s = %v", x.xs, int64(containerMapKey))
-	x.linef("codecSelfer_containerMapValue%s = %v", x.xs, int64(containerMapValue))
-	x.linef("codecSelfer_containerMapEnd%s = %v", x.xs, int64(containerMapEnd))
-	x.linef("codecSelfer_containerArrayElem%s = %v", x.xs, int64(containerArrayElem))
-	x.linef("codecSelfer_containerArrayEnd%s = %v", x.xs, int64(containerArrayEnd))
+	for _, vt := range [...]valueType{
+		valueTypeArray, valueTypeMap, valueTypeString,
+		valueTypeInt, valueTypeUint, valueTypeFloat} {
+		x.linef("codecSelferValueType%s%s = %v", vt.String(), x.xs, int64(vt))
+	}
+
+	x.linef("codecSelferBitsize%s = uint8(32 << (^uint(0) >> 63))", x.xs)
 	x.line(")")
 	x.line("var (")
-	x.line("codecSelferBitsize" + x.xs + " = uint8(reflect.TypeOf(uint(0)).Bits())")
-	x.line("codecSelferOnlyMapOrArrayEncodeToStructErr" + x.xs + " = errors.New(`only encoded map or array can be decoded into a struct`)")
+	x.line("errCodecSelferOnlyMapOrArrayEncodeToStruct" + x.xs + " = errors.New(`only encoded map or array can be decoded into a struct`)")
 	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.line("panic(err)")
+	x.outf(`panic("codecgen version mismatch: current: %v, need " + strconv.FormatInt(int64(%sGenVersion), 10) + ". Re-generate file: " + file)`, genVersion, x.cpfx)
+	// x.out(`panic(fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v", `)
+	// x.linef(`%v, %sGenVersion, file))`, genVersion, x.cpfx)
 	x.linef("}")
 	x.line("if false { // reference the types, but skip this branch at build/run time")
+	// x.line("_ = strconv.ParseInt")
 	var n int
 	// for k, t := range x.im {
 	for _, k := range imKeys {
@@ -283,10 +306,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++ {
@@ -309,8 +328,9 @@ 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)
 		x.genRequiredMethodVars(true)
 		switch t.Kind() {
@@ -319,12 +339,13 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 		case reflect.Map:
 			x.encMapFallback("v", t)
 		default:
-			panic(genExpectArrayOrMapErr)
+			panic(errGenExpectArrayOrMap)
 		}
 		x.line("}")
 		x.line("")
 
 		// generate dec functions for all these slice/map types.
+		x.varsfxreset()
 		x.linef("func (x %s) dec%s(v *%s, d *%sDecoder) {", x.hn, x.genMethodNameT(t), x.genTypeName(t), x.cpfx)
 		x.genRequiredMethodVars(false)
 		switch t.Kind() {
@@ -333,7 +354,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
 		case reflect.Map:
 			x.decMapFallback("v", rtid, t)
 		default:
-			panic(genExpectArrayOrMapErr)
+			panic(errGenExpectArrayOrMap)
 		}
 		x.line("}")
 		x.line("")
@@ -369,7 +390,6 @@ func (x *genRunner) genRefPkgs(t reflect.Type) {
 	if _, ok := x.is[t]; ok {
 		return
 	}
-	// fmt.Printf(">>>>>>: PkgPath: '%v', Name: '%s'\n", genImportPath(t), t.Name())
 	x.is[t] = struct{}{}
 	tpkg, tname := genImportPath(t), t.Name()
 	if tpkg != "" && tpkg != x.bp && tpkg != x.cp && tname != "" && tname[0] >= 'A' && tname[0] <= 'Z' {
@@ -398,6 +418,29 @@ func (x *genRunner) genRefPkgs(t reflect.Type) {
 	}
 }
 
+func (x *genRunner) varsfx() string {
+	x.c++
+	return strconv.FormatUint(x.c, 10)
+}
+
+func (x *genRunner) varsfxreset() {
+	x.c = 0
+}
+
+func (x *genRunner) out(s string) {
+	_, err := io.WriteString(x.w, s)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (x *genRunner) outf(s string, params ...interface{}) {
+	_, err := fmt.Fprintf(x.w, s, params...)
+	if err != nil {
+		panic(err)
+	}
+}
+
 func (x *genRunner) line(s string) {
 	x.out(s)
 	if len(s) == 0 || s[len(s)-1] != '\n' {
@@ -405,23 +448,11 @@ func (x *genRunner) line(s string) {
 	}
 }
 
-func (x *genRunner) varsfx() string {
-	x.c++
-	return strconv.FormatUint(x.c, 10)
-}
-
-func (x *genRunner) out(s string) {
-	if _, err := io.WriteString(x.w, s); err != nil {
-		panic(err)
-	}
-}
-
 func (x *genRunner) linef(s string, params ...interface{}) {
-	x.line(fmt.Sprintf(s, params...))
-}
-
-func (x *genRunner) outf(s string, params ...interface{}) {
-	x.out(fmt.Sprintf(s, params...))
+	x.outf(s, params...)
+	if len(s) == 0 || s[len(s)-1] != '\n' {
+		x.out("\n")
+	}
 }
 
 func (x *genRunner) genTypeName(t reflect.Type) (n string) {
@@ -494,22 +525,23 @@ func (x *genRunner) selfer(encode bool) {
 	t := x.tc
 	t0 := t
 	// always make decode use a pointer receiver,
-	// and structs always use a ptr receiver (encode|decode)
-	isptr := !encode || t.Kind() == reflect.Struct
-	fnSigPfx := "func (x "
+	// and structs/arrays always use a ptr receiver (encode|decode)
+	isptr := !encode || t.Kind() == reflect.Array || (t.Kind() == reflect.Struct && t != timeTyp)
+	x.varsfxreset()
+
+	fnSigPfx := "func (" + genTopLevelVarName + " "
 	if isptr {
 		fnSigPfx += "*"
 	}
 	fnSigPfx += x.genTypeName(t)
-
 	x.out(fnSigPfx)
+
 	if isptr {
 		t = reflect.PtrTo(t)
 	}
 	if encode {
 		x.line(") CodecEncodeSelf(e *" + x.cpfx + "Encoder) {")
 		x.genRequiredMethodVars(true)
-		// x.enc(genTopLevelVarName, t)
 		x.encVar(genTopLevelVarName, t)
 	} else {
 		x.line(") CodecDecodeSelf(d *" + x.cpfx + "Decoder) {")
@@ -518,7 +550,7 @@ func (x *genRunner) selfer(encode bool) {
 		// or way to elegantly handle that, and also setting it to a
 		// non-nil value doesn't affect the pointer passed.
 		// x.decVar(genTopLevelVarName, t, false)
-		x.dec(genTopLevelVarName, t0)
+		x.dec(genTopLevelVarName, t0, true)
 	}
 	x.line("}")
 	x.line("")
@@ -532,21 +564,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("")
 	}
@@ -555,18 +587,24 @@ 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("")
 
 }
 
 // used for chan, array, slice, map
-func (x *genRunner) xtraSM(varname string, encode bool, t reflect.Type) {
-	if encode {
-		x.linef("h.enc%s((%s%s)(%s), e)", x.genMethodNameT(t), x.arr2str(t, "*"), x.genTypeName(t), varname)
+func (x *genRunner) xtraSM(varname string, t reflect.Type, encode, isptr bool) {
+	var ptrPfx, addrPfx string
+	if isptr {
+		ptrPfx = "*"
 	} else {
-		x.linef("h.dec%s((*%s)(%s), d)", x.genMethodNameT(t), x.genTypeName(t), varname)
+		addrPfx = "&"
+	}
+	if encode {
+		x.linef("h.enc%s((%s%s)(%s), e)", x.genMethodNameT(t), ptrPfx, x.genTypeName(t), varname)
+	} else {
+		x.linef("h.dec%s((*%s)(%s%s), d)", x.genMethodNameT(t), x.genTypeName(t), addrPfx, varname)
 	}
 	x.registerXtraT(t)
 }
@@ -605,17 +643,23 @@ func (x *genRunner) encVar(varname string, t reflect.Type) {
 	if checkNil {
 		x.linef("if %s == nil { r.EncodeNil() } else { ", varname)
 	}
+
 	switch t.Kind() {
 	case reflect.Ptr:
-		switch t.Elem().Kind() {
-		case reflect.Struct, reflect.Array:
+		telem := t.Elem()
+		tek := telem.Kind()
+		if tek == reflect.Array || (tek == reflect.Struct && telem != timeTyp) {
 			x.enc(varname, genNonPtr(t))
-		default:
-			i := x.varsfx()
-			x.line(genTempVarPfx + i + " := *" + varname)
-			x.enc(genTempVarPfx+i, genNonPtr(t))
+			break
 		}
+		i := x.varsfx()
+		x.line(genTempVarPfx + i + " := *" + varname)
+		x.enc(genTempVarPfx+i, genNonPtr(t))
 	case reflect.Struct, reflect.Array:
+		if t == timeTyp {
+			x.enc(varname, t)
+			break
+		}
 		i := x.varsfx()
 		x.line(genTempVarPfx + i + " := &" + varname)
 		x.enc(genTempVarPfx+i, t)
@@ -629,29 +673,33 @@ 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)
+// enc will encode a variable (varname) of type t, where t represents T.
+// if t is !time.Time and t is of kind reflect.Struct or reflect.Array, varname is of type *T
+// (to prevent copying),
+// else t is of type T
 func (x *genRunner) enc(varname string, t reflect.Type) {
-	rtid := reflect.ValueOf(t).Pointer()
+	rtid := rt2id(t)
+	ti2 := x.ti.get(rtid, 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
 	//   - the type is in the list of the ones we will generate for, but it is not currently being generated
 
 	mi := x.varsfx()
-	tptr := reflect.PtrTo(t)
+	// tptr := reflect.PtrTo(t)
 	tk := t.Kind()
 	if x.checkForSelfer(t, varname) {
-		if tk == reflect.Array || tk == reflect.Struct { // varname is of type *T
-			if tptr.Implements(selferTyp) || t.Implements(selferTyp) {
+		if tk == reflect.Array || (tk == reflect.Struct && rtid != timeTypId) { // varname is of type *T
+			// if tptr.Implements(selferTyp) || t.Implements(selferTyp) {
+			if ti2.isFlag(typeInfoFlagIsZeroerPtr) || ti2.isFlag(typeInfoFlagIsZeroer) {
 				x.line(varname + ".CodecEncodeSelf(e)")
 				return
 			}
 		} else { // varname is of type T
-			if t.Implements(selferTyp) {
+			if ti2.cs { // t.Implements(selferTyp) {
 				x.line(varname + ".CodecEncodeSelf(e)")
 				return
-			} else if tptr.Implements(selferTyp) {
+			} else if ti2.csp { // tptr.Implements(selferTyp) {
 				x.linef("%ssf%s := &%s", genTempVarPfx, mi, varname)
 				x.linef("%ssf%s.CodecEncodeSelf(e)", genTempVarPfx, mi)
 				return
@@ -683,53 +731,53 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 	}
 
 	// check if
-	//   - type is RawExt
+	//   - type is time.Time, RawExt, Raw
 	//   - the type implements (Text|JSON|Binary)(Unm|M)arshal
-	x.linef("%sm%s := z.EncBinary()", genTempVarPfx, mi)
-	x.linef("_ = %sm%s", genTempVarPfx, mi)
+
 	x.line("if false {")           //start if block
 	defer func() { x.line("}") }() //end if block
 
-	if t == rawExtTyp {
-		x.linef("} else { r.EncodeRawExt(%v, e)", varname)
+	if t == timeTyp {
+		x.linef("} else { r.EncodeTime(%s)", varname)
 		return
 	}
-	// HACK: Support for Builtins.
-	//       Currently, only Binc supports builtins, and the only builtin type is time.Time.
-	//       Have a method that returns the rtid for time.Time if Handle is Binc.
-	if t == timeTyp {
-		vrtid := genTempVarPfx + "m" + x.varsfx()
-		x.linef("} else if %s := z.TimeRtidIfBinc(); %s != 0 { ", vrtid, vrtid)
-		x.linef("r.EncodeBuiltin(%s, %s)", vrtid, varname)
+	if t == rawTyp {
+		x.linef("} else { z.EncRaw(%s)", varname)
+		return
+	}
+	if t == rawExtTyp {
+		x.linef("} else { r.EncodeRawExt(%s, e)", varname)
+		return
 	}
 	// only check for extensions if the type is named, and has a packagePath.
-	if 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)
+	var arrayOrStruct = tk == reflect.Array || tk == reflect.Struct // meaning varname if of type *T
+	if !x.nx && genImportPath(t) != "" && t.Name() != "" {
+		yy := fmt.Sprintf("%sxt%s", genTempVarPfx, mi)
+		x.linef("} else if %s := z.Extension(z.I2Rtid(%s)); %s != nil { z.EncExtension(%s, %s) ", yy, varname, yy, varname, yy)
 	}
-	if tk == reflect.Array || tk == reflect.Struct { // varname is of type *T
-		if t.Implements(binaryMarshalerTyp) || tptr.Implements(binaryMarshalerTyp) {
-			x.linef("} else if %sm%s { z.EncBinaryMarshal(%v) ", genTempVarPfx, mi, varname)
+	if arrayOrStruct { // varname is of type *T
+		if ti2.bm || ti2.bmp { // t.Implements(binaryMarshalerTyp) || tptr.Implements(binaryMarshalerTyp) {
+			x.linef("} else if z.EncBinary() { z.EncBinaryMarshal(%v) ", varname)
 		}
-		if t.Implements(jsonMarshalerTyp) || tptr.Implements(jsonMarshalerTyp) {
-			x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(%v) ", genTempVarPfx, mi, varname)
-		} else if t.Implements(textMarshalerTyp) || tptr.Implements(textMarshalerTyp) {
-			x.linef("} else if !%sm%s { z.EncTextMarshal(%v) ", genTempVarPfx, mi, varname)
+		if ti2.jm || ti2.jmp { // t.Implements(jsonMarshalerTyp) || tptr.Implements(jsonMarshalerTyp) {
+			x.linef("} else if !z.EncBinary() && z.IsJSONHandle() { z.EncJSONMarshal(%v) ", varname)
+		} else if ti2.tm || ti2.tmp { // t.Implements(textMarshalerTyp) || tptr.Implements(textMarshalerTyp) {
+			x.linef("} else if !z.EncBinary() { z.EncTextMarshal(%v) ", varname)
 		}
 	} else { // varname is of type T
-		if t.Implements(binaryMarshalerTyp) {
-			x.linef("} else if %sm%s { z.EncBinaryMarshal(%v) ", genTempVarPfx, mi, varname)
-		} else if tptr.Implements(binaryMarshalerTyp) {
-			x.linef("} else if %sm%s { z.EncBinaryMarshal(&%v) ", genTempVarPfx, mi, varname)
+		if ti2.bm { // t.Implements(binaryMarshalerTyp) {
+			x.linef("} else if z.EncBinary() { z.EncBinaryMarshal(%v) ", varname)
+		} else if ti2.bmp { // tptr.Implements(binaryMarshalerTyp) {
+			x.linef("} else if z.EncBinary() { z.EncBinaryMarshal(&%v) ", varname)
 		}
-		if t.Implements(jsonMarshalerTyp) {
-			x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(%v) ", genTempVarPfx, mi, varname)
-		} else if tptr.Implements(jsonMarshalerTyp) {
-			x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(&%v) ", genTempVarPfx, mi, varname)
-		} else if t.Implements(textMarshalerTyp) {
-			x.linef("} else if !%sm%s { z.EncTextMarshal(%v) ", genTempVarPfx, mi, varname)
-		} else if tptr.Implements(textMarshalerTyp) {
-			x.linef("} else if !%sm%s { z.EncTextMarshal(&%v) ", genTempVarPfx, mi, varname)
+		if ti2.jm { // t.Implements(jsonMarshalerTyp) {
+			x.linef("} else if !z.EncBinary() && z.IsJSONHandle() { z.EncJSONMarshal(%v) ", varname)
+		} else if ti2.jmp { // tptr.Implements(jsonMarshalerTyp) {
+			x.linef("} else if !z.EncBinary() && z.IsJSONHandle() { z.EncJSONMarshal(&%v) ", varname)
+		} else if ti2.tm { // t.Implements(textMarshalerTyp) {
+			x.linef("} else if !z.EncBinary() { z.EncTextMarshal(%v) ", varname)
+		} else if ti2.tmp { // tptr.Implements(textMarshalerTyp) {
+			x.linef("} else if !z.EncBinary() { z.EncTextMarshal(&%v) ", varname)
 		}
 	}
 	x.line("} else {")
@@ -746,12 +794,12 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 	case reflect.Bool:
 		x.line("r.EncodeBool(bool(" + varname + "))")
 	case reflect.String:
-		x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + ", string(" + varname + "))")
+		x.line("r.EncodeString(codecSelferCcUTF8" + x.xs + ", string(" + varname + "))")
 	case reflect.Chan:
-		x.xtraSM(varname, true, t)
+		x.xtraSM(varname, t, true, false)
 		// x.encListFallback(varname, rtid, t)
 	case reflect.Array:
-		x.xtraSM(varname, true, t)
+		x.xtraSM(varname, t, true, true)
 	case reflect.Slice:
 		// if nil, call dedicated function
 		// if a []uint8, call dedicated function
@@ -760,12 +808,12 @@ func (x *genRunner) enc(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("r.EncodeStringBytes(codecSelferC_RAW" + x.xs + ", []byte(" + varname + "))")
+			x.line("r.EncodeStringBytes(codecSelferCcRAW" + 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.xtraSM(varname, t, true, false)
 			// x.encListFallback(varname, rtid, t)
 		}
 	case reflect.Map:
@@ -777,9 +825,9 @@ 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.xtraSM(varname, t, true, false)
 			// x.encMapFallback(varname, rtid, t)
 		}
 	case reflect.Struct:
@@ -810,12 +858,53 @@ func (x *genRunner) encZero(t reflect.Type) {
 	case reflect.Bool:
 		x.line("r.EncodeBool(false)")
 	case reflect.String:
-		x.line("r.EncodeString(codecSelferC_UTF8" + x.xs + `, "")`)
+		x.line("r.EncodeString(codecSelferCcUTF8" + x.xs + `, "")`)
 	default:
 		x.line("r.EncodeNil()")
 	}
 }
 
+func (x *genRunner) encOmitEmptyLine(t2 reflect.StructField, varname string, buf *genBuf) {
+	// smartly 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)
+	varname2 := varname + "." + t2.Name
+	switch t2.Type.Kind() {
+	case reflect.Struct:
+		rtid2 := rt2id(t2.Type)
+		ti2 := x.ti.get(rtid2, t2.Type)
+		// fmt.Printf(">>>> structfield: omitempty: type: %s, field: %s\n", t2.Type.Name(), t2.Name)
+		if ti2.rtid == timeTypId {
+			buf.s("!(").s(varname2).s(".IsZero())")
+			break
+		}
+		if ti2.isFlag(typeInfoFlagIsZeroerPtr) || ti2.isFlag(typeInfoFlagIsZeroer) {
+			buf.s("!(").s(varname2).s(".IsZero())")
+			break
+		}
+		if ti2.isFlag(typeInfoFlagComparable) {
+			buf.s(varname2).s(" != ").s(x.genZeroValueR(t2.Type))
+			break
+		}
+		// buf.s("(")
+		buf.s("false")
+		for i, n := 0, t2.Type.NumField(); i < n; i++ {
+			f := t2.Type.Field(i)
+			if f.PkgPath != "" { // unexported
+				continue
+			}
+			buf.s(" || ")
+			x.encOmitEmptyLine(f, varname2, buf)
+		}
+		//buf.s(")")
+	case reflect.Bool:
+		buf.s(varname2)
+	case reflect.Map, reflect.Slice, reflect.Array, reflect.Chan:
+		buf.s("len(").s(varname2).s(") != 0")
+	default:
+		buf.s(varname2).s(" != ").s(x.genZeroValueR(t2.Type))
+	}
+}
+
 func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 	// Use knowledge from structfieldinfo (mbs, encodable fields. Ignore omitempty. )
 	// replicate code in kStruct i.e. for each field, deref type to non-pointer, and call x.enc on it
@@ -830,60 +919,71 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 
 	x.line(sepVarname + " := !z.EncBinary()")
 	x.linef("%s := z.EncBasicHandle().StructToArray", struct2arrvar)
-	tisfi := ti.sfip // always use sequence from file. decStruct expects same thing.
+	x.linef("_, _ = %s, %s", sepVarname, struct2arrvar)
+	x.linef("const %s bool = %v // struct tag has 'toArray'", ti2arrayvar, ti.toArray)
+
+	tisfi := ti.sfiSrc // always use sequence from file. decStruct expects same thing.
+
+	// var nn int
 	// due to omitEmpty, we need to calculate the
 	// 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)
-	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 && "
+	if ti.anyOmitEmpty {
+		x.linef("var %s = [%v]bool{ // should field at this index be written?", numfieldsvar, len(tisfi))
+
+		for j, si := range tisfi {
+			_ = j
+			if !si.omitEmpty() {
+				// x.linef("%s[%v] = true // %s", numfieldsvar, j, si.fieldName)
+				x.linef("true, // %s", si.fieldName)
+				// nn++
+				continue
+			}
+			var t2 reflect.StructField
+			var omitline genBuf
+			{
+				t2typ := t
+				varname3 := varname
+				// go through the loop, record the t2 field explicitly,
+				// and gather the omit line if embedded in pointers.
+				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
+					// do not include actual field in the omit line.
+					// that is done subsequently (right after - below).
+					if uint8(ij+1) < si.nis && t2typ.Kind() == reflect.Ptr {
+						omitline.s(varname3).s(" != nil && ")
+					}
 				}
 			}
+			x.encOmitEmptyLine(t2, varname, &omitline)
+			x.linef("%s, // %s", omitline.v(), si.fieldName)
 		}
-		// 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.line("}")
+		x.linef("_ = %s", numfieldsvar)
 	}
-	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 {
+		// nn = 0
+		// x.linef("var %snn%s = %v", genTempVarPfx, i, nn)
+		x.linef("var %snn%s int", genTempVarPfx, i)
+		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 {
@@ -891,17 +991,17 @@ 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 {
-				// fmt.Printf("%%%% %v, ix: %v\n", t2typ, ix)
+			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 {
@@ -924,14 +1024,14 @@ 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("z.EncSendContainerState(codecSelfer_containerArrayElem%s)", x.xs)
-		if si.omitEmpty {
+		x.line("r.WriteArrayElem()")
+		if si.omitEmpty() {
 			x.linef("if %s[%v] {", numfieldsvar, j)
 		}
 		x.encVar(varname+"."+t2.Name, t2.Type)
-		if si.omitEmpty {
+		if si.omitEmpty() {
 			x.linef("} else {")
 			x.encZero(t2.Type)
 			x.linef("}")
@@ -942,12 +1042,31 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 
 		x.linef("} else {") // if not ti.toArray
 
-		if si.omitEmpty {
+		if si.omitEmpty() {
 			x.linef("if %s[%v] {", numfieldsvar, j)
 		}
-		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.WriteMapElemKey()")
+
+		// x.line("r.EncodeString(codecSelferCcUTF8" + x.xs + ", `" + si.encName + "`)")
+		// emulate EncStructFieldKey
+		switch ti.keyType {
+		case valueTypeInt:
+			x.linef("r.EncodeInt(z.M.Int(strconv.ParseInt(`%s`, 10, 64)))", si.encName)
+		case valueTypeUint:
+			x.linef("r.EncodeUint(z.M.Uint(strconv.ParseUint(`%s`, 10, 64)))", si.encName)
+		case valueTypeFloat:
+			x.linef("r.EncodeFloat64(z.M.Float(strconv.ParseFloat(`%s`, 64)))", si.encName)
+		default: // string
+			if si.encNameAsciiAlphaNum {
+				x.linef(`if z.IsJSONHandle() { z.WriteStr("\"%s\"") } else { `, si.encName)
+			}
+			x.linef("r.EncodeString(codecSelferCcUTF8%s, `%s`)", x.xs, si.encName)
+			if si.encNameAsciiAlphaNum {
+				x.linef("}")
+			}
+		}
+		// x.linef("r.EncStructFieldKey(codecSelferValueType%s%s, `%s`)", ti.keyType.String(), x.xs, si.encName)
+		x.line("r.WriteMapElemValue()")
 		if labelUsed {
 			x.line("if " + isNilVarName + " { r.EncodeNil() } else { ")
 			x.encVar(varname+"."+t2.Name, t2.Type)
@@ -955,128 +1074,218 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 		} else {
 			x.encVar(varname+"."+t2.Name, t2.Type)
 		}
-		if si.omitEmpty {
+		if si.omitEmpty() {
 			x.line("}")
 		}
 		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.line("} else {")
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.WriteMapEnd()")
 	x.line("}")
 
 }
 
 func (x *genRunner) encListFallback(varname string, t reflect.Type) {
-	i := x.varsfx()
-	g := genTempVarPfx
-	x.line("r.EncodeArrayStart(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.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)
+	elemBytes := t.Elem().Kind() == reflect.Uint8
+	if t.AssignableTo(uint8SliceTyp) {
+		x.linef("r.EncodeStringBytes(codecSelferCcRAW%s, []byte(%s))", x.xs, varname)
+		return
 	}
+	if t.Kind() == reflect.Array && elemBytes {
+		x.linef("r.EncodeStringBytes(codecSelferCcRAW%s, ((*[%d]byte)(%s))[:])", x.xs, t.Len(), varname)
+		return
+	}
+	i := x.varsfx()
+	if t.Kind() == reflect.Chan {
+		type ts struct {
+			Label, Chan, Slice, Sfx string
+		}
+		tm, err := template.New("").Parse(genEncChanTmpl)
+		if err != nil {
+			panic(err)
+		}
+		x.linef("if %s == nil { r.EncodeNil() } else { ", varname)
+		x.linef("var sch%s []%s", i, x.genTypeName(t.Elem()))
+		err = tm.Execute(x.w, &ts{"Lsch" + i, varname, "sch" + i, i})
+		if err != nil {
+			panic(err)
+		}
+		// x.linef("%s = sch%s", varname, i)
+		if elemBytes {
+			x.linef("r.EncodeStringBytes(codecSelferCcRAW%s, []byte(%s))", x.xs, "sch"+i)
+			x.line("}")
+			return
+		}
+		varname = "sch" + i
+	}
+
+	x.line("r.WriteArrayStart(len(" + varname + "))")
+	x.linef("for _, %sv%s := range %s {", genTempVarPfx, i, varname)
+	x.line("r.WriteArrayElem()")
+
 	x.encVar(genTempVarPfx+"v"+i, t.Elem())
 	x.line("}")
-	x.linef("z.EncSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.WriteArrayEnd()")
+	if t.Kind() == reflect.Chan {
+		x.line("}")
+	}
 }
 
 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()")
 	x.encVar(genTempVarPfx+"k"+i, t.Key())
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
+	x.line("r.WriteMapElemValue()")
 	x.encVar(genTempVarPfx+"v"+i, t.Elem())
 	x.line("}")
-	x.linef("z.EncSendContainerState(codecSelfer_containerMapEnd%s)", x.xs)
+	x.line("r.WriteMapEnd()")
 }
 
-func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) {
+func (x *genRunner) decVarInitPtr(varname, nilvar string, t reflect.Type, si *structFieldInfo,
+	newbuf, nilbuf *genBuf) (t2 reflect.StructField) {
+	//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
+	t2kind := t2typ.Kind()
+	var nilbufed bool
+	if si != nil {
+		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
+			t2kind = t2typ.Kind()
+			if t2kind != reflect.Ptr {
+				continue
+			}
+			if newbuf != nil {
+				newbuf.f("if %s == nil { %s = new(%s) }\n", varname3, varname3, x.genTypeName(t2typ.Elem()))
+			}
+			if nilbuf != nil {
+				if !nilbufed {
+					nilbuf.s("if true")
+					nilbufed = true
+				}
+				nilbuf.s(" && ").s(varname3).s(" != nil")
+			}
+		}
+	}
+	// if t2typ.Kind() == reflect.Ptr {
+	// 	varname3 = varname3 + t2.Name
+	// }
+	if nilbuf != nil {
+		if nilbufed {
+			nilbuf.s(" { ")
+		}
+		if nilvar != "" {
+			nilbuf.s(nilvar).s(" = true")
+		} else if tk := t2typ.Kind(); tk == reflect.Ptr {
+			if strings.IndexByte(varname3, '.') != -1 || strings.IndexByte(varname3, '[') != -1 {
+				nilbuf.s(varname3).s(" = nil")
+			} else {
+				nilbuf.s("*").s(varname3).s(" = ").s(x.genZeroValueR(t2typ.Elem()))
+			}
+		} else {
+			nilbuf.s(varname3).s(" = ").s(x.genZeroValueR(t2typ))
+		}
+		if nilbufed {
+			nilbuf.s("}")
+		}
+	}
+	return t2
+}
+
+// decVar takes a variable called varname, of type t
+func (x *genRunner) decVarMain(varname, rand string, t reflect.Type, checkNotNil 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
 	// cause a nil value to be stored when something is expected.
 	// This could happen when decoding from a struct encoded as an array.
 	// For that, decVar should be called with canNil=true, to force true as its value.
-	i := x.varsfx()
-	if !canBeNil {
-		canBeNil = genAnythingCanBeNil || !genIsImmutable(t)
-	}
-	if canBeNil {
-		x.line("if r.TryDecodeAsNil() {")
-		if t.Kind() == reflect.Ptr {
-			x.line("if " + varname + " != nil { ")
-
-			// if varname is a field of a struct (has a dot in it),
-			// then just set it to nil
-			if strings.IndexByte(varname, '.') != -1 {
-				x.line(varname + " = nil")
-			} else {
-				x.line("*" + varname + " = " + x.genZeroValueR(t.Elem()))
-			}
-			x.line("}")
-		} else {
-			x.line(varname + " = " + x.genZeroValueR(t))
-		}
-		x.line("} else {")
-	} else {
-		x.line("// cannot be nil")
-	}
+	var varname2 string
 	if t.Kind() != reflect.Ptr {
-		if x.decTryAssignPrimitive(varname, t) {
-			x.line(genTempVarPfx + "v" + i + " := &" + varname)
-			x.dec(genTempVarPfx+"v"+i, t)
+		if t.PkgPath() != "" || !x.decTryAssignPrimitive(varname, t, false) {
+			x.dec(varname, t, false)
 		}
 	} else {
-		x.linef("if %s == nil { %s = new(%s) }", varname, varname, x.genTypeName(t.Elem()))
+		if checkNotNil {
+			x.linef("if %s == nil { %s = new(%s) }", varname, varname, x.genTypeName(t.Elem()))
+		}
 		// Ensure we set underlying ptr to a non-nil value (so we can deref to it later).
 		// There's a chance of a **T in here which is nil.
 		var ptrPfx string
 		for t = t.Elem(); t.Kind() == reflect.Ptr; t = t.Elem() {
 			ptrPfx += "*"
-			x.linef("if %s%s == nil { %s%s = new(%s)}",
-				ptrPfx, varname, ptrPfx, varname, x.genTypeName(t))
-		}
-		// if varname has [ in it, then create temp variable for this ptr thingie
-		if strings.Index(varname, "[") >= 0 {
-			varname2 := genTempVarPfx + "w" + i
-			x.line(varname2 + " := " + varname)
-			varname = varname2
+			if checkNotNil {
+				x.linef("if %s%s == nil { %s%s = new(%s)}",
+					ptrPfx, varname, ptrPfx, varname, x.genTypeName(t))
+			}
 		}
+		// Should we create temp var if a slice/map indexing? No. dec(...) can now handle it.
 
 		if ptrPfx == "" {
-			x.dec(varname, t)
+			x.dec(varname, t, true)
 		} else {
-			x.line(genTempVarPfx + "z" + i + " := " + ptrPfx + varname)
-			x.dec(genTempVarPfx+"z"+i, t)
+			varname2 = genTempVarPfx + "z" + rand
+			x.line(varname2 + " := " + ptrPfx + varname)
+			x.dec(varname2, t, true)
 		}
-
 	}
+}
+
+// decVar takes a variable called varname, of type t
+func (x *genRunner) decVar(varname, nilvar string, t reflect.Type, canBeNil, checkNotNil bool) {
+	i := x.varsfx()
+
+	// 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
+	// cause a nil value to be stored when something is expected.
+	// This could happen when decoding from a struct encoded as an array.
+	// For that, decVar should be called with canNil=true, to force true as its value.
+
+	if !canBeNil {
+		canBeNil = genAnythingCanBeNil || !genIsImmutable(t)
+	}
+
+	if canBeNil {
+		var buf genBuf
+		x.decVarInitPtr(varname, nilvar, t, nil, nil, &buf)
+		x.linef("if r.TryDecodeAsNil() { %s } else {", buf.buf)
+	} else {
+		x.line("// cannot be nil")
+	}
+
+	x.decVarMain(varname, i, t, checkNotNil)
 
 	if canBeNil {
 		x.line("} ")
 	}
 }
 
-// dec will decode a variable (varname) of type ptrTo(t).
+// dec will decode a variable (varname) of type t or ptrTo(t) if isptr==true.
 // t is always a basetype (i.e. not of kind reflect.Ptr).
-func (x *genRunner) dec(varname string, t reflect.Type) {
+func (x *genRunner) dec(varname string, t reflect.Type, isptr bool) {
 	// 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()
-	tptr := reflect.PtrTo(t)
+	rtid := rt2id(t)
+	ti2 := x.ti.get(rtid, t)
+	// tptr := reflect.PtrTo(t)
 	if x.checkForSelfer(t, varname) {
-		if t.Implements(selferTyp) || tptr.Implements(selferTyp) {
+		if ti2.cs || ti2.csp { // t.Implements(selferTyp) || tptr.Implements(selferTyp) {
 			x.line(varname + ".CodecDecodeSelf(d)")
 			return
 		}
@@ -1105,96 +1314,61 @@ func (x *genRunner) dec(varname string, t reflect.Type) {
 	}
 
 	// check if
-	//   - type is RawExt
+	//   - type is time.Time, Raw, RawExt
 	//   - the type implements (Text|JSON|Binary)(Unm|M)arshal
+
 	mi := x.varsfx()
-	x.linef("%sm%s := z.DecBinary()", genTempVarPfx, mi)
-	x.linef("_ = %sm%s", genTempVarPfx, mi)
+	// x.linef("%sm%s := z.DecBinary()", genTempVarPfx, mi)
+	// x.linef("_ = %sm%s", genTempVarPfx, mi)
 	x.line("if false {")           //start if block
 	defer func() { x.line("}") }() //end if block
 
-	if t == rawExtTyp {
-		x.linef("} else { r.DecodeExt(%v, 0, nil)", varname)
+	var ptrPfx, addrPfx string
+	if isptr {
+		ptrPfx = "*"
+	} else {
+		addrPfx = "&"
+	}
+	if t == timeTyp {
+		x.linef("} else { %s%v = r.DecodeTime()", ptrPfx, varname)
+		return
+	}
+	if t == rawTyp {
+		x.linef("} else { %s%v = z.DecRaw()", ptrPfx, varname)
 		return
 	}
 
-	// HACK: Support for Builtins.
-	//       Currently, only Binc supports builtins, and the only builtin type is time.Time.
-	//       Have a method that returns the rtid for time.Time if Handle is Binc.
-	if t == timeTyp {
-		vrtid := genTempVarPfx + "m" + x.varsfx()
-		x.linef("} else if %s := z.TimeRtidIfBinc(); %s != 0 { ", vrtid, vrtid)
-		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() != "" {
-		// first check if extensions are configued, before doing the interface conversion
-		x.linef("} else if z.HasExtensions() && z.DecExt(%s) {", varname)
+	if t == rawExtTyp {
+		x.linef("} else { r.DecodeExt(%s%v, 0, nil)", addrPfx, varname)
+		return
 	}
 
-	if t.Implements(binaryUnmarshalerTyp) || tptr.Implements(binaryUnmarshalerTyp) {
-		x.linef("} else if %sm%s { z.DecBinaryUnmarshal(%v) ", genTempVarPfx, mi, varname)
+	// only check for extensions if the type is named, and has a packagePath.
+	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)
+		yy := fmt.Sprintf("%sxt%s", genTempVarPfx, mi)
+		x.linef("} else if %s := z.Extension(z.I2Rtid(%s)); %s != nil { z.DecExtension(%s, %s) ", yy, varname, yy, varname, yy)
 	}
-	if t.Implements(jsonUnmarshalerTyp) || tptr.Implements(jsonUnmarshalerTyp) {
-		x.linef("} else if !%sm%s && z.IsJSONHandle() { z.DecJSONUnmarshal(%v)", genTempVarPfx, mi, varname)
-	} else if t.Implements(textUnmarshalerTyp) || tptr.Implements(textUnmarshalerTyp) {
-		x.linef("} else if !%sm%s { z.DecTextUnmarshal(%v)", genTempVarPfx, mi, varname)
+
+	if ti2.bu || ti2.bup { // t.Implements(binaryUnmarshalerTyp) || tptr.Implements(binaryUnmarshalerTyp) {
+		x.linef("} else if z.DecBinary() { z.DecBinaryUnmarshal(%s%v) ", addrPfx, varname)
+	}
+	if ti2.ju || ti2.jup { // t.Implements(jsonUnmarshalerTyp) || tptr.Implements(jsonUnmarshalerTyp) {
+		x.linef("} else if !z.DecBinary() && z.IsJSONHandle() { z.DecJSONUnmarshal(%s%v)", addrPfx, varname)
+	} else if ti2.tu || ti2.tup { // t.Implements(textUnmarshalerTyp) || tptr.Implements(textUnmarshalerTyp) {
+		x.linef("} else if !z.DecBinary() { z.DecTextUnmarshal(%s%v)", addrPfx, varname)
 	}
 
 	x.line("} else {")
 
-	// Since these are pointers, we cannot share, and have to use them one by one
+	if x.decTryAssignPrimitive(varname, t, isptr) {
+		return
+	}
+
 	switch t.Kind() {
-	case reflect.Int:
-		x.line("*((*int)(" + varname + ")) = int(r.DecodeInt(codecSelferBitsize" + x.xs + "))")
-		// x.line("z.DecInt((*int)(" + varname + "))")
-	case reflect.Int8:
-		x.line("*((*int8)(" + varname + ")) = int8(r.DecodeInt(8))")
-		// x.line("z.DecInt8((*int8)(" + varname + "))")
-	case reflect.Int16:
-		x.line("*((*int16)(" + varname + ")) = int16(r.DecodeInt(16))")
-		// x.line("z.DecInt16((*int16)(" + varname + "))")
-	case reflect.Int32:
-		x.line("*((*int32)(" + varname + ")) = int32(r.DecodeInt(32))")
-		// x.line("z.DecInt32((*int32)(" + varname + "))")
-	case reflect.Int64:
-		x.line("*((*int64)(" + varname + ")) = int64(r.DecodeInt(64))")
-		// x.line("z.DecInt64((*int64)(" + varname + "))")
-
-	case reflect.Uint:
-		x.line("*((*uint)(" + varname + ")) = uint(r.DecodeUint(codecSelferBitsize" + x.xs + "))")
-		// x.line("z.DecUint((*uint)(" + varname + "))")
-	case reflect.Uint8:
-		x.line("*((*uint8)(" + varname + ")) = uint8(r.DecodeUint(8))")
-		// x.line("z.DecUint8((*uint8)(" + varname + "))")
-	case reflect.Uint16:
-		x.line("*((*uint16)(" + varname + ")) = uint16(r.DecodeUint(16))")
-		//x.line("z.DecUint16((*uint16)(" + varname + "))")
-	case reflect.Uint32:
-		x.line("*((*uint32)(" + varname + ")) = uint32(r.DecodeUint(32))")
-		//x.line("z.DecUint32((*uint32)(" + varname + "))")
-	case reflect.Uint64:
-		x.line("*((*uint64)(" + varname + ")) = uint64(r.DecodeUint(64))")
-		//x.line("z.DecUint64((*uint64)(" + varname + "))")
-	case reflect.Uintptr:
-		x.line("*((*uintptr)(" + varname + ")) = uintptr(r.DecodeUint(codecSelferBitsize" + x.xs + "))")
-
-	case reflect.Float32:
-		x.line("*((*float32)(" + varname + ")) = float32(r.DecodeFloat(true))")
-		//x.line("z.DecFloat32((*float32)(" + varname + "))")
-	case reflect.Float64:
-		x.line("*((*float64)(" + varname + ")) = float64(r.DecodeFloat(false))")
-		// x.line("z.DecFloat64((*float64)(" + varname + "))")
-
-	case reflect.Bool:
-		x.line("*((*bool)(" + varname + ")) = r.DecodeBool()")
-		// x.line("z.DecBool((*bool)(" + varname + "))")
-	case reflect.String:
-		x.line("*((*string)(" + varname + ")) = r.DecodeString()")
-		// x.line("z.DecString((*string)(" + varname + "))")
 	case reflect.Array, reflect.Chan:
-		x.xtraSM(varname, false, t)
-		// x.decListFallback(varname, rtid, true, t)
+		x.xtraSM(varname, t, false, isptr)
 	case reflect.Slice:
 		// if a []uint8, call dedicated function
 		// if a known fastpath slice, call dedicated function
@@ -1202,12 +1376,13 @@ 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.linef("%s%s = r.DecodeBytes(%s(%s[]byte)(%s), false)",
+				ptrPfx, varname, ptrPfx, ptrPfx, varname)
 		} else if fastpathAV.index(rtid) != -1 {
 			g := x.newGenV(t)
-			x.line("z.F." + g.MethodNamePfx("Dec", false) + "X(" + varname + ", false, d)")
+			x.linef("z.F.%sX(%s%s, d)", g.MethodNamePfx("Dec", false), addrPfx, varname)
 		} else {
-			x.xtraSM(varname, false, t)
+			x.xtraSM(varname, t, false, isptr)
 			// x.decListFallback(varname, rtid, false, t)
 		}
 	case reflect.Map:
@@ -1217,87 +1392,91 @@ 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.linef("z.F.%sX(%s%s, d)", g.MethodNamePfx("Dec", false), addrPfx, varname)
 		} else {
-			x.xtraSM(varname, false, t)
+			x.xtraSM(varname, t, false, isptr)
 			// x.decMapFallback(varname, rtid, t)
 		}
 	case reflect.Struct:
 		if inlist {
-			x.decStruct(varname, rtid, t)
+			// no need to create temp variable if isptr, or x.F or x[F]
+			if isptr || strings.IndexByte(varname, '.') != -1 || strings.IndexByte(varname, '[') != -1 {
+				x.decStruct(varname, rtid, t)
+			} else {
+				varname2 := genTempVarPfx + "j" + mi
+				x.line(varname2 + " := &" + varname)
+				x.decStruct(varname2, rtid, t)
+			}
 		} else {
 			// delete(x.td, rtid)
-			x.line("z.DecFallback(" + varname + ", false)")
+			x.line("z.DecFallback(" + addrPfx + varname + ", false)")
 		}
 	default:
 		if rtidAdded {
 			delete(x.te, rtid)
 		}
-		x.line("z.DecFallback(" + varname + ", true)")
+		x.line("z.DecFallback(" + addrPfx + varname + ", true)")
 	}
 }
 
-func (x *genRunner) decTryAssignPrimitive(varname string, t reflect.Type) (tryAsPtr bool) {
-	// We have to use the actual type name when doing a direct assignment.
-	// We don't have the luxury of casting the pointer to the underlying type.
-	//
-	// Consequently, in the situation of a
-	//     type Message int32
-	//     var x Message
-	//     var i int32 = 32
-	//     x = i // this will bomb
-	//     x = Message(i) // this will work
-	//     *((*int32)(&x)) = i // this will work
-	//
-	// Consequently, we replace:
-	//      case reflect.Uint32: x.line(varname + " = uint32(r.DecodeUint(32))")
-	// with:
-	//      case reflect.Uint32: x.line(varname + " = " + genTypeNamePrim(t, x.tc) + "(r.DecodeUint(32))")
+func (x *genRunner) decTryAssignPrimitive(varname string, t reflect.Type, isptr bool) (done bool) {
+	// This should only be used for exact primitives (ie un-named types).
+	// Named types may be implementations of Selfer, Unmarshaler, etc.
+	// They should be handled by dec(...)
 
-	xfn := func(t reflect.Type) string {
-		return x.genTypeNamePrim(t)
+	var ptr string
+	if isptr {
+		ptr = "*"
 	}
 	switch t.Kind() {
 	case reflect.Int:
-		x.linef("%s = %s(r.DecodeInt(codecSelferBitsize%s))", varname, xfn(t), x.xs)
+		x.linef("%s%s = (%s)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize%s))", ptr, varname, x.genTypeName(t), x.xs)
 	case reflect.Int8:
-		x.linef("%s = %s(r.DecodeInt(8))", varname, xfn(t))
+		x.linef("%s%s = (%s)(z.C.IntV(r.DecodeInt64(), 8))", ptr, varname, x.genTypeName(t))
 	case reflect.Int16:
-		x.linef("%s = %s(r.DecodeInt(16))", varname, xfn(t))
+		x.linef("%s%s = (%s)(z.C.IntV(r.DecodeInt64(), 16))", ptr, varname, x.genTypeName(t))
 	case reflect.Int32:
-		x.linef("%s = %s(r.DecodeInt(32))", varname, xfn(t))
+		x.linef("%s%s = (%s)(z.C.IntV(r.DecodeInt64(), 32))", ptr, varname, x.genTypeName(t))
 	case reflect.Int64:
-		x.linef("%s = %s(r.DecodeInt(64))", varname, xfn(t))
+		x.linef("%s%s = (%s)(r.DecodeInt64())", ptr, varname, x.genTypeName(t))
 
 	case reflect.Uint:
-		x.linef("%s = %s(r.DecodeUint(codecSelferBitsize%s))", varname, xfn(t), x.xs)
+		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), codecSelferBitsize%s))", ptr, varname, x.genTypeName(t), x.xs)
 	case reflect.Uint8:
-		x.linef("%s = %s(r.DecodeUint(8))", varname, xfn(t))
+		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), 8))", ptr, varname, x.genTypeName(t))
 	case reflect.Uint16:
-		x.linef("%s = %s(r.DecodeUint(16))", varname, xfn(t))
+		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), 16))", ptr, varname, x.genTypeName(t))
 	case reflect.Uint32:
-		x.linef("%s = %s(r.DecodeUint(32))", varname, xfn(t))
+		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), 32))", ptr, varname, x.genTypeName(t))
 	case reflect.Uint64:
-		x.linef("%s = %s(r.DecodeUint(64))", varname, xfn(t))
+		x.linef("%s%s = (%s)(r.DecodeUint64())", ptr, varname, x.genTypeName(t))
 	case reflect.Uintptr:
-		x.linef("%s = %s(r.DecodeUint(codecSelferBitsize%s))", varname, xfn(t), x.xs)
+		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), codecSelferBitsize%s))", ptr, varname, x.genTypeName(t), x.xs)
 
 	case reflect.Float32:
-		x.linef("%s = %s(r.DecodeFloat(true))", varname, xfn(t))
+		x.linef("%s%s = (%s)(r.DecodeFloat32As64())", ptr, varname, x.genTypeName(t))
 	case reflect.Float64:
-		x.linef("%s = %s(r.DecodeFloat(false))", varname, xfn(t))
+		x.linef("%s%s = (%s)(r.DecodeFloat64())", ptr, varname, x.genTypeName(t))
 
 	case reflect.Bool:
-		x.linef("%s = %s(r.DecodeBool())", varname, xfn(t))
+		x.linef("%s%s = (%s)(r.DecodeBool())", ptr, varname, x.genTypeName(t))
 	case reflect.String:
-		x.linef("%s = %s(r.DecodeString())", varname, xfn(t))
+		x.linef("%s%s = (%s)(r.DecodeString())", ptr, varname, x.genTypeName(t))
 	default:
-		tryAsPtr = true
+		return false
 	}
-	return
+	return true
 }
 
 func (x *genRunner) decListFallback(varname string, rtid uintptr, t reflect.Type) {
+	if t.AssignableTo(uint8SliceTyp) {
+		x.line("*" + varname + " = r.DecodeBytes(*((*[]byte)(" + varname + ")), false)")
+		return
+	}
+	if t.Kind() == reflect.Array && t.Elem().Kind() == reflect.Uint8 {
+		x.linef("r.DecodeBytes( ((*[%d]byte)(%s))[:], true)", t.Len(), varname)
+		return
+	}
 	type tstruc struct {
 		TempVar   string
 		Rand      string
@@ -1313,11 +1492,7 @@ 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, true)
 		return ""
 	}
 	funcs["var"] = func(s string) string {
@@ -1375,19 +1550,11 @@ 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, true)
 		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, true)
 		return ""
 	}
 	funcs["var"] = func(s string) string {
@@ -1405,31 +1572,17 @@ func (x *genRunner) decMapFallback(varname string, rtid uintptr, t reflect.Type)
 
 func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintptr, t reflect.Type) {
 	ti := x.ti.get(rtid, t)
-	tisfi := ti.sfip // always use sequence from file. decStruct expects same thing.
+	tisfi := ti.sfiSrc // always use sequence from file. decStruct expects same thing.
 	x.line("switch (" + kName + ") {")
+	var newbuf, nilbuf genBuf
 	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 accomodate 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 t2typ.Kind() == reflect.Ptr {
-					t2typ = t2typ.Elem()
-				}
-				t2 = t2typ.Field(ix)
-				t2typ = t2.Type
-				varname3 = varname3 + "." + t2.Name
-				if t2typ.Kind() == reflect.Ptr {
-					x.linef("if %s == nil { %s = new(%s) }", varname3, varname3, x.genTypeName(t2typ.Elem()))
-				}
-			}
-		}
-		x.decVar(varname+"."+t2.Name, t2.Type, false)
+		newbuf.reset()
+		nilbuf.reset()
+		t2 := x.decVarInitPtr(varname, "", t, si, &newbuf, &nilbuf)
+		x.linef("if r.TryDecodeAsNil() { %s } else { %s", nilbuf.buf, newbuf.buf)
+		x.decVarMain(varname+"."+t2.Name, x.varsfx(), t2.Type, false)
+		x.line("}")
 	}
 	x.line("default:")
 	// pass the slice here, so that the string will not escape, and maybe save allocation
@@ -1439,27 +1592,10 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt
 
 func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t reflect.Type, style genStructMapStyle) {
 	tpfx := genTempVarPfx
+	ti := x.ti.get(rtid, t)
 	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).
-
-	x.line("var " + kName + "Slc = z.DecScratchBuffer() // default slice to decode into")
-
-	x.line("_ = " + kName + "Slc")
 	switch style {
 	case genStructMapStyleLenPrefix:
 		x.linef("for %sj%s := 0; %sj%s < %s; %sj%s++ {", tpfx, i, tpfx, i, lenvarname, tpfx, i)
@@ -1471,60 +1607,49 @@ 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)")
-	// 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.line("r.ReadMapElemKey()")
+
+	// emulate decstructfieldkey
+	switch ti.keyType {
+	case valueTypeInt:
+		x.linef("%s := z.StringView(strconv.AppendInt(z.DecScratchArrayBuffer()[:0], r.DecodeInt64(), 10))", kName)
+	case valueTypeUint:
+		x.linef("%s := z.StringView(strconv.AppendUint(z.DecScratchArrayBuffer()[:0], r.DecodeUint64(), 10))", kName)
+	case valueTypeFloat:
+		x.linef("%s := z.StringView(strconv.AppendFloat(z.DecScratchArrayBuffer()[:0], r.DecodeFloat64(), 'f', -1, 64))", kName)
+	default: // string
+		x.linef("%s := z.StringView(r.DecodeStringAsBytes())", kName)
 	}
-	x.linef("z.DecSendContainerState(codecSelfer_containerMapValue%s)", x.xs)
+	// x.linef("%s := z.StringView(r.DecStructFieldKey(codecSelferValueType%s%s, z.DecScratchArrayBuffer()))", kName, ti.keyType.String(), x.xs)
+
+	x.line("r.ReadMapElemValue()")
 	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()")
 }
 
 func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid uintptr, t reflect.Type) {
 	tpfx := genTempVarPfx
 	i := x.varsfx()
 	ti := x.ti.get(rtid, t)
-	tisfi := ti.sfip // always use sequence from file. decStruct expects same thing.
+	tisfi := ti.sfiSrc // always use sequence from file. decStruct expects same thing.
 	x.linef("var %sj%s int", tpfx, i)
 	x.linef("var %sb%s bool", tpfx, i)                        // break
 	x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
+	var newbuf, nilbuf genBuf
 	for _, si := range tisfi {
-		var t2 reflect.StructField
-		if si.i != -1 {
-			t2 = t.Field(int(si.i))
-		} else {
-			//we must accomodate 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 t2typ.Kind() == reflect.Ptr {
-					t2typ = t2typ.Elem()
-				}
-				t2 = t2typ.Field(ix)
-				t2typ = t2.Type
-				varname3 = varname3 + "." + t2.Name
-				if t2typ.Kind() == reflect.Ptr {
-					x.linef("if %s == nil { %s = new(%s) }", varname3, varname3, x.genTypeName(t2typ.Elem()))
-				}
-			}
-		}
-
 		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.line("r.ReadArrayElem()")
+		newbuf.reset()
+		nilbuf.reset()
+		t2 := x.decVarInitPtr(varname, "", t, si, &newbuf, &nilbuf)
+		x.linef("if r.TryDecodeAsNil() { %s } else { %s", nilbuf.buf, newbuf.buf)
+		x.decVarMain(varname+"."+t2.Name, x.varsfx(), t2.Type, false)
+		x.line("}")
 	}
 	// read remaining values and throw away.
 	x.line("for {")
@@ -1532,28 +1657,28 @@ 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()")
 	x.linef(`z.DecStructFieldNotFound(%sj%s - 1, "")`, tpfx, i)
 	x.line("}")
-	x.linef("z.DecSendContainerState(codecSelfer_containerArrayEnd%s)", x.xs)
+	x.line("r.ReadArrayEnd()")
 }
 
 func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) {
-	// if container is map
+	// varname MUST be a ptr, or a struct field or a slice element.
 	i := x.varsfx()
 	x.linef("%sct%s := r.ContainerType()", genTempVarPfx, i)
 	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()")
 	if genUseOneFunctionForDecStructMap {
 		x.line("} else { ")
-		x.linef("x.codecDecodeSelfFromMap(%sl%s, d)", genTempVarPfx, i)
+		x.linef("%s.codecDecodeSelfFromMap(%sl%s, d)", varname, genTempVarPfx, i)
 	} else {
 		x.line("} else if " + genTempVarPfx + "l" + i + " > 0 { ")
-		x.line("x.codecDecodeSelfFromMapLenPrefix(" + genTempVarPfx + "l" + i + ", d)")
+		x.line(varname + ".codecDecodeSelfFromMapLenPrefix(" + genTempVarPfx + "l" + i + ", d)")
 		x.line("} else {")
-		x.line("x.codecDecodeSelfFromMapCheckBreak(" + genTempVarPfx + "l" + i + ", d)")
+		x.line(varname + ".codecDecodeSelfFromMapCheckBreak(" + genTempVarPfx + "l" + i + ", d)")
 	}
 	x.line("}")
 
@@ -1561,13 +1686,13 @@ 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()")
 	x.line("} else { ")
-	x.linef("x.codecDecodeSelfFromArray(%sl%s, d)", genTempVarPfx, i)
+	x.linef("%s.codecDecodeSelfFromArray(%sl%s, d)", varname, genTempVarPfx, i)
 	x.line("}")
 	// else panic
 	x.line("} else { ")
-	x.line("panic(codecSelferOnlyMapOrArrayEncodeToStructErr" + x.xs + ")")
+	x.line("panic(errCodecSelferOnlyMapOrArrayEncodeToStruct" + x.xs + ")")
 	x.line("} ")
 }
 
@@ -1618,8 +1743,6 @@ func (x *genV) MethodNamePfx(prefix string, prim bool) string {
 
 }
 
-var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") == "1"
-
 // genImportPath returns import path of a non-predeclared named typed, or an empty string otherwise.
 //
 // This handles the misbehaviour that occurs when 1.5-style vendoring is enabled,
@@ -1628,15 +1751,8 @@ var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") == "1"
 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 = genStripVendor(s)
 	}
 	return
 }
@@ -1670,7 +1786,7 @@ func genNonPtr(t reflect.Type) reflect.Type {
 
 func genTitleCaseName(s string) string {
 	switch s {
-	case "interface{}":
+	case "interface{}", "interface {}":
 		return "Intf"
 	default:
 		return strings.ToUpper(s[0:1]) + s[1:]
@@ -1758,13 +1874,13 @@ func genIsImmutable(t reflect.Type) (v bool) {
 }
 
 type genInternal struct {
-	Values []genV
-	Unsafe bool
+	Version int
+	Values  []genV
 }
 
 func (x genInternal) FastpathLen() (l int) {
 	for _, v := range x.Values {
-		if v.Primitive == "" {
+		if v.Primitive == "" && !(v.MapKey == "" && v.Elem == "uint8") {
 			l++
 		}
 	}
@@ -1773,7 +1889,7 @@ func (x genInternal) FastpathLen() (l int) {
 
 func genInternalZeroValue(s string) string {
 	switch s {
-	case "interface{}":
+	case "interface{}", "interface {}":
 		return "nil"
 	case "bool":
 		return "false"
@@ -1784,6 +1900,32 @@ func genInternalZeroValue(s string) string {
 	}
 }
 
+var genInternalNonZeroValueIdx [5]uint64
+var genInternalNonZeroValueStrs = [2][5]string{
+	{`"string-is-an-interface"`, "true", `"some-string"`, "11.1", "33"},
+	{`"string-is-an-interface-2"`, "true", `"some-string-2"`, "22.2", "44"},
+}
+
+func genInternalNonZeroValue(s string) string {
+	switch s {
+	case "interface{}", "interface {}":
+		genInternalNonZeroValueIdx[0]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[0]%2][0] // return string, to remove ambiguity
+	case "bool":
+		genInternalNonZeroValueIdx[1]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[1]%2][1]
+	case "string":
+		genInternalNonZeroValueIdx[2]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[2]%2][2]
+	case "float32", "float64", "float", "double":
+		genInternalNonZeroValueIdx[3]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[3]%2][3]
+	default:
+		genInternalNonZeroValueIdx[4]++
+		return genInternalNonZeroValueStrs[genInternalNonZeroValueIdx[4]%2][4]
+	}
+}
+
 func genInternalEncCommandAsString(s string, vname string) string {
 	switch s {
 	case "uint", "uint8", "uint16", "uint32", "uint64":
@@ -1791,15 +1933,15 @@ func genInternalEncCommandAsString(s string, vname string) string {
 	case "int", "int8", "int16", "int32", "int64":
 		return "ee.EncodeInt(int64(" + vname + "))"
 	case "string":
-		return "ee.EncodeString(c_UTF8, " + vname + ")"
+		return "ee.EncodeString(cUTF8, " + vname + ")"
 	case "float32":
 		return "ee.EncodeFloat32(" + vname + ")"
 	case "float64":
 		return "ee.EncodeFloat64(" + vname + ")"
 	case "bool":
 		return "ee.EncodeBool(" + vname + ")"
-	case "symbol":
-		return "ee.EncodeSymbol(" + vname + ")"
+	// case "symbol":
+	// 	return "ee.EncodeSymbol(" + vname + ")"
 	default:
 		return "e.encode(" + vname + ")"
 	}
@@ -1808,34 +1950,34 @@ func genInternalEncCommandAsString(s string, vname string) string {
 func genInternalDecCommandAsString(s string) string {
 	switch s {
 	case "uint":
-		return "uint(dd.DecodeUint(uintBitsize))"
+		return "uint(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))"
 	case "uint8":
-		return "uint8(dd.DecodeUint(8))"
+		return "uint8(chkOvf.UintV(dd.DecodeUint64(), 8))"
 	case "uint16":
-		return "uint16(dd.DecodeUint(16))"
+		return "uint16(chkOvf.UintV(dd.DecodeUint64(), 16))"
 	case "uint32":
-		return "uint32(dd.DecodeUint(32))"
+		return "uint32(chkOvf.UintV(dd.DecodeUint64(), 32))"
 	case "uint64":
-		return "dd.DecodeUint(64)"
+		return "dd.DecodeUint64()"
 	case "uintptr":
-		return "uintptr(dd.DecodeUint(uintBitsize))"
+		return "uintptr(chkOvf.UintV(dd.DecodeUint64(), uintBitsize))"
 	case "int":
-		return "int(dd.DecodeInt(intBitsize))"
+		return "int(chkOvf.IntV(dd.DecodeInt64(), intBitsize))"
 	case "int8":
-		return "int8(dd.DecodeInt(8))"
+		return "int8(chkOvf.IntV(dd.DecodeInt64(), 8))"
 	case "int16":
-		return "int16(dd.DecodeInt(16))"
+		return "int16(chkOvf.IntV(dd.DecodeInt64(), 16))"
 	case "int32":
-		return "int32(dd.DecodeInt(32))"
+		return "int32(chkOvf.IntV(dd.DecodeInt64(), 32))"
 	case "int64":
-		return "dd.DecodeInt(64)"
+		return "dd.DecodeInt64()"
 
 	case "string":
 		return "dd.DecodeString()"
 	case "float32":
-		return "float32(dd.DecodeFloat(true))"
+		return "float32(chkOvf.Float32V(dd.DecodeFloat64()))"
 	case "float64":
-		return "dd.DecodeFloat(false)"
+		return "dd.DecodeFloat64()"
 	case "bool":
 		return "dd.DecodeBool()"
 	default:
@@ -1859,8 +2001,21 @@ func genInternalSortType(s string, elem bool) string {
 	panic("sorttype: unexpected type: " + s)
 }
 
+func genStripVendor(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
 
@@ -1923,14 +2078,15 @@ func genInternalInit() {
 		"float64":     8,
 		"bool":        1,
 	}
-	var gt genInternal
+	var gt = genInternal{Version: genVersion}
 
-	// For each slice or map type, there must be a (symetrical) Encode and Decode fast-path function
+	// For each slice or map type, there must be a (symmetrical) Encode and Decode fast-path function
 	for _, s := range types {
 		gt.Values = append(gt.Values, genV{Primitive: s, Size: mapvaltypes2[s]})
-		if s != "uint8" { // do not generate fast path for slice of bytes. Treat specially already.
-			gt.Values = append(gt.Values, genV{Elem: s, Size: mapvaltypes2[s]})
-		}
+		// if s != "uint8" { // do not generate fast path for slice of bytes. Treat specially already.
+		// 	gt.Values = append(gt.Values, genV{Elem: s, Size: mapvaltypes2[s]})
+		// }
+		gt.Values = append(gt.Values, genV{Elem: s, Size: mapvaltypes2[s]})
 		if _, ok := mapvaltypes2[s]; !ok {
 			gt.Values = append(gt.Values, genV{MapKey: s, Elem: s, Size: 2 * mapvaltypes2[s]})
 		}
@@ -1944,6 +2100,7 @@ func genInternalInit() {
 	funcs["encmd"] = genInternalEncCommandAsString
 	funcs["decmd"] = genInternalDecCommandAsString
 	funcs["zerocmd"] = genInternalZeroValue
+	funcs["nonzerocmd"] = genInternalNonZeroValue
 	funcs["hasprefix"] = strings.HasPrefix
 	funcs["sorttype"] = genInternalSortType
 
@@ -1955,11 +2112,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/goversion_arrayof_gte_go15.go b/vendor/github.com/ugorji/go/codec/goversion_arrayof_gte_go15.go
new file mode 100644
index 000000000..9ddbe2059
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_arrayof_gte_go15.go
@@ -0,0 +1,14 @@
+// Copyright (c) 2012-2018 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
+
+import "reflect"
+
+const reflectArrayOfSupported = true
+
+func reflectArrayOf(count int, elem reflect.Type) reflect.Type {
+	return reflect.ArrayOf(count, elem)
+}
diff --git a/vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go b/vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go
new file mode 100644
index 000000000..c5fcd6697
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go
@@ -0,0 +1,14 @@
+// Copyright (c) 2012-2018 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
+
+import "reflect"
+
+const reflectArrayOfSupported = false
+
+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 000000000..bc39d6b71
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_makemap_gte_go19.go
@@ -0,0 +1,15 @@
+// Copyright (c) 2012-2018 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 000000000..cde4cd372
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_makemap_lt_go19.go
@@ -0,0 +1,12 @@
+// Copyright (c) 2012-2018 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_unexportedembeddedptr_gte_go110.go b/vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_gte_go110.go
new file mode 100644
index 000000000..794133a3c
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_gte_go110.go
@@ -0,0 +1,8 @@
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// +build go1.10
+
+package codec
+
+const allowSetUnexportedEmbeddedPtr = false
diff --git a/vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_lt_go110.go b/vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_lt_go110.go
new file mode 100644
index 000000000..fd92ede35
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_lt_go110.go
@@ -0,0 +1,8 @@
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// +build !go1.10
+
+package codec
+
+const allowSetUnexportedEmbeddedPtr = true
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 000000000..8debfa613
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_unsupported_lt_go14.go
@@ -0,0 +1,17 @@
+// Copyright (c) 2012-2018 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/goversion_vendor_eq_go15.go b/vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go15.go
new file mode 100644
index 000000000..0f1bb01e5
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go15.go
@@ -0,0 +1,10 @@
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// +build go1.5,!go1.6
+
+package codec
+
+import "os"
+
+var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") == "1"
diff --git a/vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go b/vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go
new file mode 100644
index 000000000..2fb4b057d
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go
@@ -0,0 +1,10 @@
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// +build go1.6,!go1.7
+
+package codec
+
+import "os"
+
+var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") != "0"
diff --git a/vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go b/vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go
new file mode 100644
index 000000000..c5b815505
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go
@@ -0,0 +1,8 @@
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+// +build go1.7
+
+package codec
+
+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 000000000..837cf240b
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_vendor_lt_go15.go
@@ -0,0 +1,8 @@
+// Copyright (c) 2012-2018 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 40065a01c..8a946f4e4 100644
--- a/vendor/github.com/ugorji/go/codec/helper.go
+++ b/vendor/github.com/ugorji/go/codec/helper.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 package codec
@@ -38,10 +38,6 @@ package codec
 // a length prefix, or if it used explicit breaks. If length-prefixed, we assume that
 // it has to be binary, and we do not even try to read separators.
 //
-// The only codec that may suffer (slightly) is cbor, and only when decoding indefinite-length.
-// It may suffer because we treat it like a text-based codec, and read separators.
-// However, this read is a no-op and the cost is insignificant.
-//
 // Philosophy
 // ------------
 // On decode, this codec will update containers appropriately:
@@ -106,9 +102,11 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	"io"
 	"math"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -116,43 +114,28 @@ 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
 
-	// Fast path functions try to create a fast path encode or decode implementation
-	// for common maps and slices, by by-passing reflection altogether.
-	fastpathEnabled = true
+	// arrayCacheLen is the length of the cache used in encoder or decoder for
+	// allowing zero-alloc initialization.
+	arrayCacheLen = 8
 
-	// if checkStructForEmptyValue, check structs fields to see if an empty value.
-	// This could be an expensive call, so possibly disable it.
-	checkStructForEmptyValue = false
+	// size of the cacheline: defaulting to value for archs: amd64, arm64, 386
+	// should use "runtime/internal/sys".CacheLineSize, but that is not exposed.
+	cacheLineSize = 64
 
-	// if derefForIsEmptyValue, deref pointers and interfaces when checking isEmptyValue
-	derefForIsEmptyValue = false
+	wordSizeBits = 32 << (^uint(0) >> 63) // strconv.IntSize
+	wordSize     = wordSizeBits / 8
 
-	// 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
+	maxLevelsEmbedding = 14 // use this, so structFieldInfo fits into 8 bytes
 )
 
 var (
@@ -160,15 +143,28 @@ var (
 	zeroByteSlice = oneByteArr[:0:0]
 )
 
+var refBitset bitset32
+var pool pooler
+var panicv panicHdl
+
+func init() {
+	pool.init()
+
+	refBitset.set(byte(reflect.Map))
+	refBitset.set(byte(reflect.Ptr))
+	refBitset.set(byte(reflect.Func))
+	refBitset.set(byte(reflect.Chan))
+}
+
 type charEncoding uint8
 
 const (
-	c_RAW charEncoding = iota
-	c_UTF8
-	c_UTF16LE
-	c_UTF16BE
-	c_UTF32LE
-	c_UTF32BE
+	cRAW charEncoding = iota
+	cUTF8
+	cUTF16LE
+	cUTF16BE
+	cUTF32LE
+	cUTF32BE
 )
 
 // valueType is the stream type
@@ -186,12 +182,35 @@ const (
 	valueTypeBytes
 	valueTypeMap
 	valueTypeArray
-	valueTypeTimestamp
+	valueTypeTime
 	valueTypeExt
 
 	// valueTypeInvalid = 0xff
 )
 
+var valueTypeStrings = [...]string{
+	"Unset",
+	"Nil",
+	"Int",
+	"Uint",
+	"Float",
+	"Bool",
+	"String",
+	"Symbol",
+	"Bytes",
+	"Map",
+	"Array",
+	"Timestamp",
+	"Ext",
+}
+
+func (x valueType) String() string {
+	if int(x) < len(valueTypeStrings) {
+		return valueTypeStrings[x]
+	}
+	return strconv.FormatInt(int64(x), 10)
+}
+
 type seqType uint8
 
 const (
@@ -217,30 +236,52 @@ const (
 	containerArrayEnd
 )
 
-type rgetPoolT struct {
-	encNames [8]string
-	fNames   [8]string
-	etypes   [8]uintptr
-	sfis     [8]*structFieldInfo
+// // sfiIdx used for tracking where a (field/enc)Name is seen in a []*structFieldInfo
+// type sfiIdx struct {
+// 	name  string
+// 	index int
+// }
+
+// do not recurse if a containing type refers to an embedded type
+// which refers back to its containing type (via a pointer).
+// The second time this back-reference happens, break out,
+// so as not to cause an infinite loop.
+const rgetMaxRecursion = 2
+
+// Anecdotally, we believe most types have <= 12 fields.
+// - even Java's PMD rules set TooManyFields threshold to 15.
+// However, go has embedded fields, which should be regarded as
+// top level, allowing structs to possibly double or triple.
+// In addition, we don't want to keep creating transient arrays,
+// especially for the sfi index tracking, and the evtypes tracking.
+//
+// So - try to keep typeInfoLoadArray within 2K bytes
+const (
+	typeInfoLoadArraySfisLen   = 16
+	typeInfoLoadArraySfiidxLen = 8 * 112
+	typeInfoLoadArrayEtypesLen = 12
+	typeInfoLoadArrayBLen      = 8 * 4
+)
+
+type typeInfoLoad struct {
+	// fNames   []string
+	// encNames []string
+	etypes []uintptr
+	sfis   []structFieldInfo
 }
 
-var rgetPool = sync.Pool{
-	New: func() interface{} { return new(rgetPoolT) },
-}
-
-type rgetT struct {
-	fNames   []string
-	encNames []string
-	etypes   []uintptr
-	sfis     []*structFieldInfo
-}
-
-type containerStateRecv interface {
-	sendContainerState(containerState)
+type typeInfoLoadArray struct {
+	// fNames   [typeInfoLoadArrayLen]string
+	// encNames [typeInfoLoadArrayLen]string
+	sfis   [typeInfoLoadArraySfisLen]structFieldInfo
+	sfiidx [typeInfoLoadArraySfiidxLen]byte
+	etypes [typeInfoLoadArrayEtypesLen]uintptr
+	b      [typeInfoLoadArrayBLen]byte // scratch - used for struct field names
 }
 
 // mirror json.Marshaler and json.Unmarshaler here,
 // so we don't import the encoding/json package
+
 type jsonMarshaler interface {
 	MarshalJSON() ([]byte, error)
 }
@@ -248,6 +289,12 @@ type jsonUnmarshaler interface {
 	UnmarshalJSON([]byte) error
 }
 
+type isZeroer interface {
+	IsZero() bool
+}
+
+// type byteAccepter func(byte) bool
+
 var (
 	bigen               = binary.BigEndian
 	structInfoFieldName = "_struct"
@@ -257,10 +304,17 @@ var (
 	intfSliceTyp   = reflect.TypeOf([]interface{}(nil))
 	intfTyp        = intfSliceTyp.Elem()
 
+	reflectValTyp = reflect.TypeOf((*reflect.Value)(nil)).Elem()
+
 	stringTyp     = reflect.TypeOf("")
 	timeTyp       = reflect.TypeOf(time.Time{})
 	rawExtTyp     = reflect.TypeOf(RawExt{})
+	rawTyp        = reflect.TypeOf(Raw{})
+	uintptrTyp    = reflect.TypeOf(uintptr(0))
+	uint8Typ      = reflect.TypeOf(uint8(0))
 	uint8SliceTyp = reflect.TypeOf([]uint8(nil))
+	uintTyp       = reflect.TypeOf(uint(0))
+	intTyp        = reflect.TypeOf(int(0))
 
 	mapBySliceTyp = reflect.TypeOf((*MapBySlice)(nil)).Elem()
 
@@ -274,64 +328,130 @@ var (
 	jsonUnmarshalerTyp = reflect.TypeOf((*jsonUnmarshaler)(nil)).Elem()
 
 	selferTyp = reflect.TypeOf((*Selfer)(nil)).Elem()
+	iszeroTyp = reflect.TypeOf((*isZeroer)(nil)).Elem()
 
-	uint8SliceTypId = reflect.ValueOf(uint8SliceTyp).Pointer()
-	rawExtTypId     = reflect.ValueOf(rawExtTyp).Pointer()
-	intfTypId       = reflect.ValueOf(intfTyp).Pointer()
-	timeTypId       = reflect.ValueOf(timeTyp).Pointer()
-	stringTypId     = reflect.ValueOf(stringTyp).Pointer()
+	uint8TypId      = rt2id(uint8Typ)
+	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())
+	intBitsize  = uint8(intTyp.Bits())
+	uintBitsize = uint8(uintTyp.Bits())
 
 	bsAll0x00 = []byte{0, 0, 0, 0, 0, 0, 0, 0}
 	bsAll0xff = []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
 
 	chkOvf checkOverflow
 
-	noFieldNameToStructFieldInfoErr = errors.New("no field name passed to parseStructFieldInfo")
+	errNoFieldNameToStructFieldInfo = errors.New("no field name passed to parseStructFieldInfo")
 )
 
 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
+}
+
 // 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.
 // Consequently, during (en|de)code, this takes precedence over
 // (text|binary)(M|Unm)arshal or extension support.
+//
+// Note: *the first set of bytes of any value MUST NOT represent nil in the format*.
+// This is because, during each decode, we first check the the next set of bytes
+// represent nil, and if so, we just set the value to nil.
 type Selfer interface {
 	CodecEncodeSelf(*Encoder)
 	CodecDecodeSelf(*Decoder)
 }
 
-// MapBySlice represents a slice which should be encoded as a map in the stream.
+// MapBySlice is a tag interface that denotes wrapped slice should encode as a map in the stream.
 // The slice contains a sequence of key-value pairs.
 // This affords storing a map in a specific sequence in the stream.
 //
+// Example usage:
+//    type T1 []string         // or []int or []Point or any other "slice" type
+//    func (_ T1) MapBySlice{} // T1 now implements MapBySlice, and will be encoded as a map
+//    type T2 struct { KeyValues T1 }
+//
+//    var kvs = []string{"one", "1", "two", "2", "three", "3"}
+//    var v2 = T2{ KeyValues: T1(kvs) }
+//    // v2 will be encoded like the map: {"KeyValues": {"one": "1", "two": "2", "three": "3"} }
+//
 // The support of MapBySlice affords the following:
 //   - A slice type which implements MapBySlice will be encoded as a map
 //   - A slice can be decoded from a map in the stream
+//   - It MUST be a slice type (not a pointer receiver) that implements MapBySlice
 type MapBySlice interface {
 	MapBySlice()
 }
 
-// WARNING: DO NOT USE DIRECTLY. EXPORTED FOR GODOC BENEFIT. WILL BE REMOVED.
-//
 // BasicHandle encapsulates the common options and extension functions.
+//
+// Deprecated: DO NOT USE DIRECTLY. EXPORTED FOR GODOC BENEFIT. WILL BE REMOVED.
 type BasicHandle struct {
+	// BasicHandle is always a part of a different type.
+	// It doesn't have to fit into it own cache lines.
+
 	// TypeInfos is used to get the type info for any type.
 	//
 	// If not configured, the default TypeInfos is used, which uses struct tag keys: codec, json
 	TypeInfos *TypeInfos
 
+	// Note: BasicHandle is not comparable, due to these slices here (extHandle, intf2impls).
+	// If *[]T is used instead, this becomes comparable, at the cost of extra indirection.
+	// Thses slices are used all the time, so keep as slices (not pointers).
+
 	extHandle
-	EncodeOptions
+
+	intf2impls
+
+	RPCOptions
+
+	// ---- cache line
+
 	DecodeOptions
+
+	// ---- cache line
+
+	EncodeOptions
+
+	// noBuiltInTypeChecker
 }
 
 func (x *BasicHandle) getBasicHandle() *BasicHandle {
@@ -339,10 +459,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.
@@ -351,23 +471,36 @@ func (x *BasicHandle) getTypeInfo(rtid uintptr, rt reflect.Type) (pti *typeInfo)
 // and not modified while in use. Such a pre-configured Handle
 // is safe for concurrent access.
 type Handle interface {
+	Name() string
 	getBasicHandle() *BasicHandle
+	recreateEncDriver(encDriver) bool
 	newEncDriver(w *Encoder) encDriver
 	newDecDriver(r *Decoder) decDriver
 	isBinary() bool
+	hasElemSeparators() bool
+	// IsBuiltinType(rtid uintptr) bool
 }
 
+// Raw represents raw formatted bytes.
+// We "blindly" store it during encode and retrieve the raw bytes during decode.
+// Note: it is dangerous during encode, so we may gate the behaviour
+// behind an Encode flag which must be explicitly set.
+type Raw []byte
+
 // RawExt represents raw unprocessed extension data.
-// Some codecs will decode extension data as a *RawExt if there is no registered extension for the tag.
+// Some codecs will decode extension data as a *RawExt
+// if there is no registered extension for the tag.
 //
-// Only one of Data or Value is nil. If Data is nil, then the content of the RawExt is in the Value.
+// Only one of Data or Value is nil.
+// If Data is nil, then the content of the RawExt is in the Value.
 type RawExt struct {
 	Tag uint64
-	// Data is the []byte which represents the raw ext. If Data is nil, ext is exposed in Value.
-	// Data is used by codecs (e.g. binc, msgpack, simple) which do custom serialization of the types
+	// Data is the []byte which represents the raw ext. If nil, ext is exposed in Value.
+	// Data is used by codecs (e.g. binc, msgpack, simple) which do custom serialization of types
 	Data []byte
 	// Value represents the extension, if Data is nil.
-	// Value is used by codecs (e.g. cbor) which use the format to do custom serialization of the types.
+	// Value is used by codecs (e.g. cbor, json) which leverage the format to do
+	// custom serialization of the types.
 	Value interface{}
 }
 
@@ -376,24 +509,30 @@ type RawExt struct {
 type BytesExt interface {
 	// WriteExt converts a value to a []byte.
 	//
-	// Note: v *may* be a pointer to the extension type, if the extension type was a struct or array.
+	// Note: v is a pointer iff the registered extension type is a struct or array kind.
 	WriteExt(v interface{}) []byte
 
 	// ReadExt updates a value from a []byte.
+	//
+	// Note: dst is always a pointer kind to the registered extension type.
 	ReadExt(dst interface{}, src []byte)
 }
 
 // InterfaceExt handles custom (de)serialization of types to/from another interface{} value.
 // The Encoder or Decoder will then handle the further (de)serialization of that known type.
 //
-// It is used by codecs (e.g. cbor, json) which use the format to do custom serialization of the types.
+// It is used by codecs (e.g. cbor, json) which use the format to do custom serialization of types.
 type InterfaceExt interface {
-	// ConvertExt converts a value into a simpler interface for easy encoding e.g. convert time.Time to int64.
+	// ConvertExt converts a value into a simpler interface for easy encoding
+	// e.g. convert time.Time to int64.
 	//
-	// Note: v *may* be a pointer to the extension type, if the extension type was a struct or array.
+	// Note: v is a pointer iff the registered extension type is a struct or array kind.
 	ConvertExt(v interface{}) interface{}
 
-	// UpdateExt updates a value from a simpler interface for easy decoding e.g. convert int64 to time.Time.
+	// UpdateExt updates a value from a simpler interface for easy decoding
+	// e.g. convert int64 to time.Time.
+	//
+	// Note: dst is always a pointer kind to the registered extension type.
 	UpdateExt(dst interface{}, src interface{})
 }
 
@@ -431,64 +570,59 @@ func (x addExtWrapper) UpdateExt(dest interface{}, v interface{}) {
 	x.ReadExt(dest, v.([]byte))
 }
 
-type setExtWrapper struct {
-	b BytesExt
-	i InterfaceExt
+type extWrapper struct {
+	BytesExt
+	InterfaceExt
 }
 
-func (x *setExtWrapper) WriteExt(v interface{}) []byte {
-	if x.b == nil {
-		panic("BytesExt.WriteExt is not supported")
-	}
-	return x.b.WriteExt(v)
+type bytesExtFailer struct{}
+
+func (bytesExtFailer) WriteExt(v interface{}) []byte {
+	panicv.errorstr("BytesExt.WriteExt is not supported")
+	return nil
+}
+func (bytesExtFailer) ReadExt(v interface{}, bs []byte) {
+	panicv.errorstr("BytesExt.ReadExt is not supported")
 }
 
-func (x *setExtWrapper) ReadExt(v interface{}, bs []byte) {
-	if x.b == nil {
-		panic("BytesExt.WriteExt is not supported")
+type interfaceExtFailer struct{}
 
-	}
-	x.b.ReadExt(v, bs)
+func (interfaceExtFailer) ConvertExt(v interface{}) interface{} {
+	panicv.errorstr("InterfaceExt.ConvertExt is not supported")
+	return nil
 }
-
-func (x *setExtWrapper) ConvertExt(v interface{}) interface{} {
-	if x.i == nil {
-		panic("InterfaceExt.ConvertExt is not supported")
-
-	}
-	return x.i.ConvertExt(v)
+func (interfaceExtFailer) UpdateExt(dest interface{}, v interface{}) {
+	panicv.errorstr("InterfaceExt.UpdateExt is not supported")
 }
 
-func (x *setExtWrapper) UpdateExt(dest interface{}, v interface{}) {
-	if x.i == nil {
-		panic("InterfaceExxt.UpdateExt is not supported")
-
-	}
-	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 }
+func (binaryEncodingType) isBinary() bool { return true }
 
 type textEncodingType struct{}
 
-func (_ textEncodingType) isBinary() bool { return false }
+func (textEncodingType) isBinary() bool { return false }
 
 // noBuiltInTypes is embedded into many types which do not support builtins
 // e.g. msgpack, simple, cbor.
+
+// type noBuiltInTypeChecker struct{}
+// func (noBuiltInTypeChecker) IsBuiltinType(rt uintptr) bool { return false }
+// type noBuiltInTypes struct{ noBuiltInTypeChecker }
+
 type noBuiltInTypes struct{}
 
-func (_ noBuiltInTypes) IsBuiltinType(rt uintptr) bool           { return false }
-func (_ noBuiltInTypes) EncodeBuiltin(rt uintptr, v interface{}) {}
-func (_ noBuiltInTypes) DecodeBuiltin(rt uintptr, v interface{}) {}
+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 }
+func (noElemSeparators) recreateEncDriver(e encDriver) (v bool) { return }
 
 // bigenHelper.
 // Users must already slice the x completely, because we will not reslice.
@@ -513,164 +647,259 @@ func (z bigenHelper) writeUint64(v uint64) {
 }
 
 type extTypeTagFn struct {
-	rtid uintptr
-	rt   reflect.Type
-	tag  uint64
-	ext  Ext
+	rtid    uintptr
+	rtidptr uintptr
+	rt      reflect.Type
+	tag     uint64
+	ext     Ext
+	_       [1]uint64 // padding
 }
 
 type extHandle []extTypeTagFn
 
-// DEPRECATED: Use SetBytesExt or SetInterfaceExt on the Handle instead.
-//
 // AddExt registes an encode and decode function for a reflect.Type.
-// AddExt internally calls SetExt.
 // To deregister an Ext, call AddExt with nil encfn and/or nil decfn.
-func (o *extHandle) AddExt(
-	rt reflect.Type, tag byte,
-	encfn func(reflect.Value) ([]byte, error), decfn func(reflect.Value, []byte) error,
-) (err error) {
+//
+// Deprecated: Use SetBytesExt or SetInterfaceExt on the Handle instead.
+func (o *extHandle) AddExt(rt reflect.Type, tag byte,
+	encfn func(reflect.Value) ([]byte, error),
+	decfn func(reflect.Value, []byte) error) (err error) {
 	if encfn == nil || decfn == nil {
 		return o.SetExt(rt, uint64(tag), nil)
 	}
 	return o.SetExt(rt, uint64(tag), addExtWrapper{encfn, decfn})
 }
 
-// DEPRECATED: Use SetBytesExt or SetInterfaceExt on the Handle instead.
+// SetExt will set the extension for a tag and reflect.Type.
+// Note that the type must be a named type, and specifically not a pointer or Interface.
+// An error is returned if that is not honored.
+// To Deregister an ext, call SetExt with nil Ext.
 //
-// Note that the type must be a named type, and specifically not
-// a pointer or Interface. An error is returned if that is not honored.
-//
-// To Deregister an ext, call SetExt with nil Ext
+// Deprecated: Use SetBytesExt or SetInterfaceExt on the Handle instead.
 func (o *extHandle) SetExt(rt reflect.Type, tag uint64, ext Ext) (err error) {
 	// o is a pointer, because we may need to initialize it
-	if rt.PkgPath() == "" || rt.Kind() == reflect.Interface {
-		err = fmt.Errorf("codec.Handle.AddExt: Takes named type, especially not a pointer or interface: %T",
-			reflect.Zero(rt).Interface())
-		return
+	rk := rt.Kind()
+	for rk == reflect.Ptr {
+		rt = rt.Elem()
+		rk = rt.Kind()
 	}
 
-	rtid := reflect.ValueOf(rt).Pointer()
-	for _, v := range *o {
+	if rt.PkgPath() == "" || rk == reflect.Interface { // || rk == reflect.Ptr {
+		return fmt.Errorf("codec.Handle.SetExt: Takes named type, not a pointer or interface: %v", rt)
+	}
+
+	rtid := rt2id(rt)
+	switch rtid {
+	case timeTypId, rawTypId, rawExtTypId:
+		// all natively supported type, so cannot have an extension
+		return // TODO: should we silently ignore, or return an error???
+	}
+	// if o == nil {
+	// 	return errors.New("codec.Handle.SetExt: extHandle not initialized")
+	// }
+	o2 := *o
+	// if o2 == nil {
+	// 	return errors.New("codec.Handle.SetExt: extHandle not initialized")
+	// }
+	for i := range o2 {
+		v := &o2[i]
 		if v.rtid == rtid {
 			v.tag, v.ext = tag, ext
 			return
 		}
 	}
-
-	if *o == nil {
-		*o = make([]extTypeTagFn, 0, 4)
-	}
-	*o = append(*o, extTypeTagFn{rtid, rt, tag, ext})
+	rtidptr := rt2id(reflect.PtrTo(rt))
+	*o = append(o2, extTypeTagFn{rtid, rtidptr, rt, tag, ext, [1]uint64{}})
 	return
 }
 
-func (o extHandle) getExt(rtid uintptr) *extTypeTagFn {
-	var v *extTypeTagFn
+func (o extHandle) getExt(rtid uintptr) (v *extTypeTagFn) {
 	for i := range o {
 		v = &o[i]
-		if v.rtid == rtid {
-			return v
+		if v.rtid == rtid || v.rtidptr == rtid {
+			return
 		}
 	}
 	return nil
 }
 
-func (o extHandle) getExtForTag(tag uint64) *extTypeTagFn {
-	var v *extTypeTagFn
+func (o extHandle) getExtForTag(tag uint64) (v *extTypeTagFn) {
 	for i := range o {
 		v = &o[i]
 		if v.tag == tag {
-			return v
+			return
 		}
 	}
 	return nil
 }
 
-type structFieldInfo struct {
-	encName string // encode 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
-	omitEmpty bool
-	toArray   bool // if field is _struct, is the toArray set?
+type intf2impl struct {
+	rtid uintptr // for intf
+	impl reflect.Type
+	// _    [1]uint64 // padding // not-needed, as *intf2impl is never returned.
 }
 
-// func (si *structFieldInfo) isZero() bool {
-// 	return si.encName == "" && len(si.is) == 0 && si.i == 0 && !si.omitEmpty && !si.toArray
-// }
+type intf2impls []intf2impl
 
-// 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
+// Intf2Impl maps an interface to an implementing type.
+// This allows us support infering the concrete type
+// and populating it when passed an interface.
+// e.g. var v io.Reader can be decoded as a bytes.Buffer, etc.
+//
+// Passing a nil impl will clear the mapping.
+func (o *intf2impls) Intf2Impl(intf, impl reflect.Type) (err error) {
+	if impl != nil && !impl.Implements(intf) {
+		return fmt.Errorf("Intf2Impl: %v does not implement %v", impl, intf)
 	}
-	// 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()
+	rtid := rt2id(intf)
+	o2 := *o
+	for i := range o2 {
+		v := &o2[i]
+		if v.rtid == rtid {
+			v.impl = impl
+			return
 		}
-		v = v.Field(x)
 	}
-	return v
+	*o = append(o2, intf2impl{rtid, impl})
+	return
+}
+
+func (o intf2impls) intf2impl(rtid uintptr) (rv reflect.Value) {
+	for i := range o {
+		v := &o[i]
+		if v.rtid == rtid {
+			if v.impl == nil {
+				return
+			}
+			if v.impl.Kind() == reflect.Ptr {
+				return reflect.New(v.impl.Elem())
+			}
+			return reflect.New(v.impl).Elem()
+		}
+	}
+	return
+}
+
+type structFieldInfoFlag uint8
+
+const (
+	_ structFieldInfoFlag = 1 << iota
+	structFieldInfoFlagReady
+	structFieldInfoFlagOmitEmpty
+)
+
+func (x *structFieldInfoFlag) flagSet(f structFieldInfoFlag) {
+	*x = *x | f
+}
+
+func (x *structFieldInfoFlag) flagClr(f structFieldInfoFlag) {
+	*x = *x &^ f
+}
+
+func (x structFieldInfoFlag) flagGet(f structFieldInfoFlag) bool {
+	return x&f != 0
+}
+
+func (x structFieldInfoFlag) omitEmpty() bool {
+	return x.flagGet(structFieldInfoFlagOmitEmpty)
+}
+
+func (x structFieldInfoFlag) ready() bool {
+	return x.flagGet(structFieldInfoFlagReady)
+}
+
+type structFieldInfo struct {
+	encName   string // encode name
+	fieldName string // field name
+
+	is  [maxLevelsEmbedding]uint16 // (recursive/embedded) field index in struct
+	nis uint8                      // num levels of embedding. if 1, then it's not embedded.
+
+	encNameAsciiAlphaNum bool // the encName only contains ascii alphabet and numbers
+	structFieldInfoFlag
+	_ [1]byte // padding
 }
 
 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)
-		}
+	if v, valid := si.field(v, false); valid {
 		v.Set(reflect.Zero(v.Type()))
 	}
 }
 
-func parseStructFieldInfo(fname string, stag string) *structFieldInfo {
-	// if fname == "" {
-	// 	panic(noFieldNameToStructFieldInfoErr)
-	// }
-	si := structFieldInfo{
-		encName: fname,
+// 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, valid bool) {
+	// replicate FieldByIndex
+	for i, x := range si.is {
+		if uint8(i) == si.nis {
+			break
+		}
+		if v, valid = baseStructRv(v, update); !valid {
+			return
+		}
+		v = v.Field(int(x))
 	}
 
-	if stag != "" {
-		for i, s := range strings.Split(stag, ",") {
-			if i == 0 {
-				if s != "" {
-					si.encName = s
-				}
-			} else {
-				if s == "omitempty" {
-					si.omitEmpty = true
-				} else if s == "toarray" {
-					si.toArray = true
-				}
+	return v, true
+}
+
+// func (si *structFieldInfo) fieldval(v reflect.Value, update bool) reflect.Value {
+// 	v, _ = si.field(v, update)
+// 	return v
+// }
+
+func parseStructInfo(stag string) (toArray, omitEmpty bool, keytype valueType) {
+	keytype = valueTypeString // default
+	if stag == "" {
+		return
+	}
+	for i, s := range strings.Split(stag, ",") {
+		if i == 0 {
+		} else {
+			switch s {
+			case "omitempty":
+				omitEmpty = true
+			case "toarray":
+				toArray = true
+			case "int":
+				keytype = valueTypeInt
+			case "uint":
+				keytype = valueTypeUint
+			case "float":
+				keytype = valueTypeFloat
+				// case "bool":
+				// 	keytype = valueTypeBool
+			case "string":
+				keytype = valueTypeString
+			}
+		}
+	}
+	return
+}
+
+func (si *structFieldInfo) parseTag(stag string) {
+	// if fname == "" {
+	// 	panic(errNoFieldNameToStructFieldInfo)
+	// }
+
+	if stag == "" {
+		return
+	}
+	for i, s := range strings.Split(stag, ",") {
+		if i == 0 {
+			if s != "" {
+				si.encName = s
+			}
+		} else {
+			switch s {
+			case "omitempty":
+				si.flagSet(structFieldInfoFlagOmitEmpty)
+				// si.omitEmpty = true
+				// case "toarray":
+				// 	si.toArray = true
 			}
 		}
 	}
-	// si.encNameBs = []byte(si.encName)
-	return &si
 }
 
 type sfiSortedByEncName []*structFieldInfo
@@ -687,7 +916,105 @@ func (p sfiSortedByEncName) Swap(i, j int) {
 	p[i], p[j] = p[j], p[i]
 }
 
-// typeInfo keeps information about each type referenced in the encode/decode sequence.
+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) {
+	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
+}
+
+type typeInfoFlag uint8
+
+const (
+	typeInfoFlagComparable = 1 << iota
+	typeInfoFlagIsZeroer
+	typeInfoFlagIsZeroerPtr
+)
+
+// typeInfo keeps information about each (non-ptr) type referenced in the encode/decode sequence.
 //
 // During an encode/decode sequence, we work as below:
 //   - If base is a built in type, en/decode base value
@@ -696,69 +1023,82 @@ func (p sfiSortedByEncName) Swap(i, j int) {
 //   - If type is text(M/Unm)arshaler, call Text(M/Unm)arshal method
 //   - Else decode appropriately based on the reflect.Kind
 type typeInfo struct {
-	sfi  []*structFieldInfo // sorted. Used when enc/dec struct to map.
-	sfip []*structFieldInfo // unsorted. Used when enc/dec struct to array.
+	rt      reflect.Type
+	elem    reflect.Type
+	pkgpath string
 
-	rt   reflect.Type
 	rtid uintptr
+	// rv0  reflect.Value // saved zero value, used if immutableKind
 
 	numMeth uint16 // number of methods
+	kind    uint8
+	chandir uint8
 
-	// baseId gives pointer to the base reflect.Type, after deferencing
-	// the pointers. E.g. base type of ***time.Time is time.Time.
-	base      reflect.Type
-	baseId    uintptr
-	baseIndir int8 // number of indirections to get to base
+	anyOmitEmpty bool      // true if a struct, and any of the fields are tagged "omitempty"
+	toArray      bool      // whether this (struct) type should be encoded as an array
+	keyType      valueType // if struct, how is the field name stored in a stream? default is string
+	mbs          bool      // base type (T or *T) is a MapBySlice
 
-	mbs bool // base type (T or *T) is a MapBySlice
+	// ---- cpu cache line boundary?
+	sfiSort []*structFieldInfo // sorted. Used when enc/dec struct to map.
+	sfiSrc  []*structFieldInfo // unsorted. Used when enc/dec struct to array.
 
-	bm        bool // base type (T or *T) is a binaryMarshaler
-	bunm      bool // base type (T or *T) is a binaryUnmarshaler
-	bmIndir   int8 // number of indirections to get to binaryMarshaler type
-	bunmIndir int8 // number of indirections to get to binaryUnmarshaler type
+	key reflect.Type
 
-	tm        bool // base type (T or *T) is a textMarshaler
-	tunm      bool // base type (T or *T) is a textUnmarshaler
-	tmIndir   int8 // number of indirections to get to textMarshaler type
-	tunmIndir int8 // number of indirections to get to textUnmarshaler type
+	// ---- cpu cache line boundary?
+	// sfis         []structFieldInfo // all sfi, in src order, as created.
+	sfiNamesSort []byte // all names, with indexes into the sfiSort
 
-	jm        bool // base type (T or *T) is a jsonMarshaler
-	junm      bool // base type (T or *T) is a jsonUnmarshaler
-	jmIndir   int8 // number of indirections to get to jsonMarshaler type
-	junmIndir int8 // number of indirections to get to jsonUnmarshaler type
+	// format of marshal type fields below: [btj][mu]p? OR csp?
 
-	cs      bool // base type (T or *T) is a Selfer
-	csIndir int8 // number of indirections to get to Selfer type
+	bm  bool // T is a binaryMarshaler
+	bmp bool // *T is a binaryMarshaler
+	bu  bool // T is a binaryUnmarshaler
+	bup bool // *T is a binaryUnmarshaler
+	tm  bool // T is a textMarshaler
+	tmp bool // *T is a textMarshaler
+	tu  bool // T is a textUnmarshaler
+	tup bool // *T is a textUnmarshaler
 
-	toArray bool // whether this (struct) type should be encoded as an array
+	jm  bool // T is a jsonMarshaler
+	jmp bool // *T is a jsonMarshaler
+	ju  bool // T is a jsonUnmarshaler
+	jup bool // *T is a jsonUnmarshaler
+	cs  bool // T is a Selfer
+	csp bool // *T is a Selfer
+
+	// other flags, with individual bits representing if set.
+	flags typeInfoFlag
+
+	// _ [2]byte   // padding
+	_ [3]uint64 // padding
 }
 
-func (ti *typeInfo) indexForEncName(name string) int {
-	//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.
-		for i, si := range ti.sfi {
-			if si.encName == name {
-				return i
-			}
-		}
+func (ti *typeInfo) isFlag(f typeInfoFlag) bool {
+	return ti.flags&f != 0
+}
+
+func (ti *typeInfo) indexForEncName(name []byte) (index int16) {
+	var sn []byte
+	if len(name)+2 <= 32 {
+		var buf [32]byte // should not escape
+		sn = buf[:len(name)+2]
 	} 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
-		}
+		sn = make([]byte, len(name)+2)
 	}
-	return -1
+	copy(sn[1:], name)
+	sn[0], sn[len(sn)-1] = tiSep2(name), 0xff
+	j := bytes.Index(ti.sfiNamesSort, sn)
+	if j < 0 {
+		return -1
+	}
+	index = int16(uint16(ti.sfiNamesSort[j+len(sn)+1]) | uint16(ti.sfiNamesSort[j+len(sn)])<<8)
+	return
+}
+
+type rtid2ti struct {
+	rtid uintptr
+	ti   *typeInfo
 }
 
 // TypeInfos caches typeInfo for each type on first inspection.
@@ -766,9 +1106,11 @@ func (ti *typeInfo) indexForEncName(name string) int {
 // 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: formerly map[uintptr]*typeInfo, now *[]rtid2ti, 2 words expected
+	infos atomicTypeInfoSlice
+	mu    sync.Mutex
 	tags  []string
+	_     [2]uint64 // padding
 }
 
 // NewTypeInfos creates a TypeInfos given a set of struct tags keys.
@@ -776,7 +1118,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) {
@@ -791,115 +1133,147 @@ func (x *TypeInfos) structTag(t reflect.StructTag) (s string) {
 	return
 }
 
+func (x *TypeInfos) find(s []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
+		}
+	}
+
+	rk := rt.Kind()
+
+	if rk == reflect.Ptr { // || (rk == reflect.Interface && rtid != intfTypId) {
+		panicv.errorf("invalid kind passed to TypeInfos.get: %v - %v", rk, rt)
 	}
 
 	// do not hold lock while computing this.
 	// it may lead to duplication, but that's ok.
-	ti := typeInfo{rt: rt, rtid: rtid}
+	ti := typeInfo{
+		rt:      rt,
+		rtid:    rtid,
+		kind:    uint8(rk),
+		pkgpath: rt.PkgPath(),
+		keyType: valueTypeString, // default it - so it's never 0
+	}
+	// ti.rv0 = reflect.Zero(rt)
+
+	// ti.comparable = rt.Comparable()
 	ti.numMeth = uint16(rt.NumMethod())
 
-	var indir int8
-	if ok, indir = implementsIntf(rt, binaryMarshalerTyp); ok {
-		ti.bm, ti.bmIndir = true, indir
+	ti.bm, ti.bmp = implIntf(rt, binaryMarshalerTyp)
+	ti.bu, ti.bup = implIntf(rt, binaryUnmarshalerTyp)
+	ti.tm, ti.tmp = implIntf(rt, textMarshalerTyp)
+	ti.tu, ti.tup = implIntf(rt, textUnmarshalerTyp)
+	ti.jm, ti.jmp = implIntf(rt, jsonMarshalerTyp)
+	ti.ju, ti.jup = implIntf(rt, jsonUnmarshalerTyp)
+	ti.cs, ti.csp = implIntf(rt, selferTyp)
+
+	b1, b2 := implIntf(rt, iszeroTyp)
+	if b1 {
+		ti.flags |= typeInfoFlagIsZeroer
 	}
-	if ok, indir = implementsIntf(rt, binaryUnmarshalerTyp); ok {
-		ti.bunm, ti.bunmIndir = true, indir
+	if b2 {
+		ti.flags |= typeInfoFlagIsZeroerPtr
 	}
-	if ok, indir = implementsIntf(rt, textMarshalerTyp); ok {
-		ti.tm, ti.tmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, textUnmarshalerTyp); ok {
-		ti.tunm, ti.tunmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, jsonMarshalerTyp); ok {
-		ti.jm, ti.jmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, jsonUnmarshalerTyp); ok {
-		ti.junm, ti.junmIndir = true, indir
-	}
-	if ok, indir = implementsIntf(rt, selferTyp); ok {
-		ti.cs, ti.csIndir = true, indir
-	}
-	if ok, _ = implementsIntf(rt, mapBySliceTyp); ok {
-		ti.mbs = true
+	if rt.Comparable() {
+		ti.flags |= typeInfoFlagComparable
 	}
 
-	pt := rt
-	var ptIndir int8
-	// for ; pt.Kind() == reflect.Ptr; pt, ptIndir = pt.Elem(), ptIndir+1 { }
-	for pt.Kind() == reflect.Ptr {
-		pt = pt.Elem()
-		ptIndir++
-	}
-	if ptIndir == 0 {
-		ti.base = rt
-		ti.baseId = rtid
-	} else {
-		ti.base = pt
-		ti.baseId = reflect.ValueOf(pt).Pointer()
-		ti.baseIndir = ptIndir
-	}
-
-	if rt.Kind() == reflect.Struct {
-		var siInfo *structFieldInfo
+	switch rk {
+	case reflect.Struct:
+		var omitEmpty bool
 		if f, ok := rt.FieldByName(structInfoFieldName); ok {
-			siInfo = parseStructFieldInfo(structInfoFieldName, x.structTag(f.Tag))
-			ti.toArray = siInfo.toArray
+			ti.toArray, omitEmpty, ti.keyType = parseStructInfo(x.structTag(f.Tag))
+		} else {
+			ti.keyType = valueTypeString
 		}
-		pi := rgetPool.Get()
-		pv := pi.(*rgetPoolT)
-		pv.etypes[0] = ti.baseId
-		vv := rgetT{pv.fNames[:0], pv.encNames[:0], pv.etypes[:1], pv.sfis[:0]}
-		x.rget(rt, rtid, nil, &vv, siInfo)
-		ti.sfip = make([]*structFieldInfo, len(vv.sfis))
-		ti.sfi = make([]*structFieldInfo, len(vv.sfis))
-		copy(ti.sfip, vv.sfis)
-		sort.Sort(sfiSortedByEncName(vv.sfis))
-		copy(ti.sfi, vv.sfis)
-		rgetPool.Put(pi)
+		pp, pi := pool.tiLoad()
+		pv := pi.(*typeInfoLoadArray)
+		pv.etypes[0] = ti.rtid
+		// vv := typeInfoLoad{pv.fNames[:0], pv.encNames[:0], pv.etypes[:1], pv.sfis[:0]}
+		vv := typeInfoLoad{pv.etypes[:1], pv.sfis[:0]}
+		x.rget(rt, rtid, omitEmpty, nil, &vv)
+		// ti.sfis = vv.sfis
+		ti.sfiSrc, ti.sfiSort, ti.sfiNamesSort, ti.anyOmitEmpty = rgetResolveSFI(rt, vv.sfis, pv)
+		pp.Put(pi)
+	case reflect.Map:
+		ti.elem = rt.Elem()
+		ti.key = rt.Key()
+	case reflect.Slice:
+		ti.mbs, _ = implIntf(rt, mapBySliceTyp)
+		ti.elem = rt.Elem()
+	case reflect.Chan:
+		ti.elem = rt.Elem()
+		ti.chandir = uint8(rt.ChanDir())
+	case reflect.Array, reflect.Ptr:
+		ti.elem = rt.Elem()
 	}
-	// sfi = sfip
+	// sfi = sfiSrc
 
 	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 {
+			pti = &ti
+			vs := make([]rtid2ti, len(sp)+1)
+			copy(vs, sp[:idx])
+			copy(vs[idx+1:], sp[idx:])
+			vs[idx] = rtid2ti{rtid, pti}
+			x.infos.store(vs)
+		}
 	}
 	x.mu.Unlock()
 	return
 }
 
-func (x *TypeInfos) rget(rt reflect.Type, rtid uintptr,
-	indexstack []int, pv *rgetT, siInfo *structFieldInfo,
-) {
-	// This will read up the fields and store how to access the value.
-	// It uses the go language's rules for embedding, as below:
-	//   - if a field has been seen while traversing, skip it
-	//   - if an encName has been seen while traversing, skip it
-	//   - if an embedded type has been seen, skip it
+func (x *TypeInfos) rget(rt reflect.Type, rtid uintptr, omitEmpty bool,
+	indexstack []uint16, pv *typeInfoLoad) {
+	// Read up fields and store how to access the value.
 	//
-	// Also, per Go's rules, embedded fields must be analyzed AFTER all top-level fields.
+	// It uses go's rules for message selectors,
+	// which say that the field with the shallowest depth is selected.
 	//
 	// 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
-
-	type anonField struct {
-		ft  reflect.Type
-		idx int
+	//       Typically, types have < 16 fields,
+	//       and iteration using equals is faster than maps there
+	flen := rt.NumField()
+	if flen > (1<<maxLevelsEmbedding - 1) {
+		panicv.errorf("codec: types with > %v fields are not supported - has %v fields",
+			(1<<maxLevelsEmbedding - 1), flen)
 	}
-
-	var anonFields []anonField
-
+	// pv.sfis = make([]structFieldInfo, 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 {
@@ -907,150 +1281,647 @@ LOOP:
 			continue LOOP
 		}
 
-		// if r1, _ := utf8.DecodeRuneInString(f.Name); r1 == utf8.RuneError || !unicode.IsUpper(r1) {
-		if f.PkgPath != "" && !f.Anonymous { // unexported, not embedded
+		isUnexported := f.PkgPath != ""
+		if isUnexported && !f.Anonymous {
 			continue
 		}
 		stag := x.structTag(f.Tag)
 		if stag == "-" {
 			continue
 		}
-		var si *structFieldInfo
-		// if anonymous and no struct tag (or it's blank), and a struct (or pointer to struct), inline it.
+		var si structFieldInfo
+		var parsed bool
+		// if anonymous and no struct tag (or it's blank),
+		// and a struct (or pointer to struct), inline it.
 		if f.Anonymous && fkind != reflect.Interface {
+			// ^^ redundant but ok: per go spec, an embedded pointer type cannot be to an interface
+			ft := f.Type
+			isPtr := ft.Kind() == reflect.Ptr
+			for ft.Kind() == reflect.Ptr {
+				ft = ft.Elem()
+			}
+			isStruct := ft.Kind() == reflect.Struct
+
+			// Ignore embedded fields of unexported non-struct types.
+			// Also, from go1.10, ignore pointers to unexported struct types
+			// because unmarshal cannot assign a new struct to an unexported field.
+			// See https://golang.org/issue/21357
+			if (isUnexported && !isStruct) || (!allowSetUnexportedEmbeddedPtr && isUnexported && isPtr) {
+				continue
+			}
 			doInline := stag == ""
 			if !doInline {
-				si = parseStructFieldInfo("", stag)
+				si.parseTag(stag)
+				parsed = true
 				doInline = si.encName == ""
 				// doInline = si.isZero()
 			}
-			if doInline {
-				ft := f.Type
-				for ft.Kind() == reflect.Ptr {
-					ft = ft.Elem()
+			if doInline && isStruct {
+				// if etypes contains this, don't call rget again (as fields are already seen here)
+				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
+				// owning type, which then refers to its embedded type.
+				processIt := true
+				numk := 0
+				for _, k := range pv.etypes {
+					if k == ftid {
+						numk++
+						if numk == rgetMaxRecursion {
+							processIt = false
+							break
+						}
+					}
 				}
-				if ft.Kind() == reflect.Struct {
-					// handle anonymous fields after handling all the non-anon fields
-					anonFields = append(anonFields, anonField{ft, j})
-					continue
+				if processIt {
+					pv.etypes = append(pv.etypes, ftid)
+					indexstack2 := make([]uint16, len(indexstack)+1)
+					copy(indexstack2, indexstack)
+					indexstack2[len(indexstack)] = j
+					// indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
+					x.rget(ft, ftid, omitEmpty, indexstack2, pv)
 				}
+				continue
 			}
 		}
 
 		// after the anonymous dance: if an unexported field, skip
-		if f.PkgPath != "" { // unexported
+		if isUnexported {
 			continue
 		}
 
 		if f.Name == "" {
-			panic(noFieldNameToStructFieldInfoErr)
+			panic(errNoFieldNameToStructFieldInfo)
 		}
 
-		for _, k := range pv.fNames {
-			if k == f.Name {
-				continue LOOP
-			}
-		}
-		pv.fNames = append(pv.fNames, f.Name)
+		// pv.fNames = append(pv.fNames, f.Name)
+		// if si.encName == "" {
 
-		if si == nil {
-			si = parseStructFieldInfo(f.Name, stag)
+		if !parsed {
+			si.encName = f.Name
+			si.parseTag(stag)
+			parsed = true
 		} else if si.encName == "" {
 			si.encName = f.Name
 		}
-
-		for _, k := range pv.encNames {
-			if k == si.encName {
-				continue LOOP
+		si.encNameAsciiAlphaNum = true
+		for i := len(si.encName) - 1; i >= 0; i-- {
+			b := si.encName[i]
+			if (b >= '0' && b <= '9') || (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') {
+				continue
 			}
+			si.encNameAsciiAlphaNum = false
+			break
 		}
-		pv.encNames = append(pv.encNames, si.encName)
+		si.fieldName = f.Name
+		si.flagSet(structFieldInfoFlagReady)
+
+		// 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 {
+			panicv.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 siInfo != nil {
-			if siInfo.omitEmpty {
-				si.omitEmpty = true
-			}
+		if omitEmpty {
+			si.flagSet(structFieldInfoFlagOmitEmpty)
 		}
 		pv.sfis = append(pv.sfis, si)
 	}
+}
 
-	// now handle anonymous fields
-LOOP2:
-	for _, af := range anonFields {
-		// if etypes contains this, then do not call rget again (as the fields are already seen here)
-		ftid := reflect.ValueOf(af.ft).Pointer()
-		for _, k := range pv.etypes {
-			if k == ftid {
-				continue LOOP2
+func tiSep(name string) uint8 {
+	// (xn[0]%64) // (between 192-255 - outside ascii BMP)
+	// return 0xfe - (name[0] & 63)
+	// return 0xfe - (name[0] & 63) - uint8(len(name))
+	// return 0xfe - (name[0] & 63) - uint8(len(name)&63)
+	// return ((0xfe - (name[0] & 63)) & 0xf8) | (uint8(len(name) & 0x07))
+	return 0xfe - (name[0] & 63) - uint8(len(name)&63)
+}
+
+func tiSep2(name []byte) uint8 {
+	return 0xfe - (name[0] & 63) - uint8(len(name)&63)
+}
+
+// resolves the struct field info got from a call to rget.
+// Returns a trimmed, unsorted and sorted []*structFieldInfo.
+func rgetResolveSFI(rt reflect.Type, x []structFieldInfo, pv *typeInfoLoadArray) (
+	y, z []*structFieldInfo, ss []byte, anyOmitEmpty bool) {
+	sa := pv.sfiidx[:0]
+	sn := pv.b[:]
+	n := len(x)
+
+	var xn string
+	var ui uint16
+	var sep byte
+
+	for i := range x {
+		ui = uint16(i)
+		xn = x[i].encName // fieldName or encName? use encName for now.
+		if len(xn)+2 > cap(pv.b) {
+			sn = make([]byte, len(xn)+2)
+		} else {
+			sn = sn[:len(xn)+2]
+		}
+		// use a custom sep, so that misses are less frequent,
+		// since the sep (first char in search) is as unique as first char in field name.
+		sep = tiSep(xn)
+		sn[0], sn[len(sn)-1] = sep, 0xff
+		copy(sn[1:], xn)
+		j := bytes.Index(sa, sn)
+		if j == -1 {
+			sa = append(sa, sep)
+			sa = append(sa, xn...)
+			sa = append(sa, 0xff, byte(ui>>8), byte(ui))
+		} else {
+			index := uint16(sa[j+len(sn)+1]) | uint16(sa[j+len(sn)])<<8
+			// one of them must be reset to nil,
+			// and the index updated appropriately to the other one
+			if x[i].nis == x[index].nis {
+			} else if x[i].nis < x[index].nis {
+				sa[j+len(sn)], sa[j+len(sn)+1] = byte(ui>>8), byte(ui)
+				if x[index].ready() {
+					x[index].flagClr(structFieldInfoFlagReady)
+					n--
+				}
+			} else {
+				if x[i].ready() {
+					x[i].flagClr(structFieldInfoFlagReady)
+					n--
+				}
 			}
 		}
-		pv.etypes = append(pv.etypes, ftid)
 
-		indexstack2 := make([]int, len(indexstack)+1)
-		copy(indexstack2, indexstack)
-		indexstack2[len(indexstack)] = af.idx
-		// indexstack2 := append(append(make([]int, 0, len(indexstack)+4), indexstack...), j)
-		x.rget(af.ft, ftid, indexstack2, pv, siInfo)
 	}
+	var w []structFieldInfo
+	sharingArray := len(x) <= typeInfoLoadArraySfisLen // sharing array with typeInfoLoadArray
+	if sharingArray {
+		w = make([]structFieldInfo, n)
+	}
+
+	// remove all the nils (non-ready)
+	y = make([]*structFieldInfo, n)
+	n = 0
+	var sslen int
+	for i := range x {
+		if !x[i].ready() {
+			continue
+		}
+		if !anyOmitEmpty && x[i].omitEmpty() {
+			anyOmitEmpty = true
+		}
+		if sharingArray {
+			w[n] = x[i]
+			y[n] = &w[n]
+		} else {
+			y[n] = &x[i]
+		}
+		sslen = sslen + len(x[i].encName) + 4
+		n++
+	}
+	if n != len(y) {
+		panicv.errorf("failure reading struct %v - expecting %d of %d valid fields, got %d",
+			rt, len(y), len(x), n)
+	}
+
+	z = make([]*structFieldInfo, len(y))
+	copy(z, y)
+	sort.Sort(sfiSortedByEncName(z))
+
+	sharingArray = len(sa) <= typeInfoLoadArraySfiidxLen
+	if sharingArray {
+		ss = make([]byte, 0, sslen)
+	} else {
+		ss = sa[:0] // reuse the newly made sa array if necessary
+	}
+	for i := range z {
+		xn = z[i].encName
+		sep = tiSep(xn)
+		ui = uint16(i)
+		ss = append(ss, sep)
+		ss = append(ss, xn...)
+		ss = append(ss, 0xff, byte(ui>>8), byte(ui))
+	}
+	return
 }
 
-func panicToErr(err *error) {
+func implIntf(rt, iTyp reflect.Type) (base bool, indir bool) {
+	return rt.Implements(iTyp), reflect.PtrTo(rt).Implements(iTyp)
+}
+
+// isEmptyStruct is only called from isEmptyValue, and checks if a struct is empty:
+//    - does it implement IsZero() bool
+//    - is it comparable, and can i compare directly using ==
+//    - if checkStruct, then walk through the encodable fields
+//      and check if they are empty or not.
+func isEmptyStruct(v reflect.Value, tinfos *TypeInfos, deref, checkStruct bool) bool {
+	// v is a struct kind - no need to check again.
+	// We only check isZero on a struct kind, to reduce the amount of times
+	// that we lookup the rtid and typeInfo for each type as we walk the tree.
+
+	vt := v.Type()
+	rtid := rt2id(vt)
+	if tinfos == nil {
+		tinfos = defTypeInfos
+	}
+	ti := tinfos.get(rtid, vt)
+	if ti.rtid == timeTypId {
+		return rv2i(v).(time.Time).IsZero()
+	}
+	if ti.isFlag(typeInfoFlagIsZeroerPtr) && v.CanAddr() {
+		return rv2i(v.Addr()).(isZeroer).IsZero()
+	}
+	if ti.isFlag(typeInfoFlagIsZeroer) {
+		return rv2i(v).(isZeroer).IsZero()
+	}
+	if ti.isFlag(typeInfoFlagComparable) {
+		return rv2i(v) == rv2i(reflect.Zero(vt))
+	}
+	if !checkStruct {
+		return false
+	}
+	// We only care about what we can encode/decode,
+	// so that is what we use to check omitEmpty.
+	for _, si := range ti.sfiSrc {
+		sfv, valid := si.field(v, false)
+		if valid && !isEmptyValue(sfv, tinfos, deref, checkStruct) {
+			return false
+		}
+	}
+	return true
+}
+
+// func roundFloat(x float64) float64 {
+// 	t := math.Trunc(x)
+// 	if math.Abs(x-t) >= 0.5 {
+// 		return t + math.Copysign(1, x)
+// 	}
+// 	return t
+// }
+
+func panicToErr(h errstrDecorator, err *error) {
+	// Note: This method MUST be called directly from defer i.e. defer panicToErr ...
+	// else it seems the recover is not fully handled
 	if recoverPanicToErr {
 		if x := recover(); x != nil {
-			//debug.PrintStack()
-			panicValToErr(x, err)
+			// fmt.Printf("panic'ing with: %v\n", x)
+			// debug.PrintStack()
+			panicValToErr(h, x, err)
 		}
 	}
 }
 
-// func doPanic(tag string, format string, params ...interface{}) {
-// 	params2 := make([]interface{}, len(params)+1)
-// 	params2[0] = tag
-// 	copy(params2[1:], params)
-// 	panic(fmt.Errorf("%s: "+format, params2...))
-// }
+func panicValToErr(h errstrDecorator, v interface{}, err *error) {
+	switch xerr := v.(type) {
+	case nil:
+	case error:
+		switch xerr {
+		case nil:
+		case io.EOF, io.ErrUnexpectedEOF, errEncoderNotInitialized, errDecoderNotInitialized:
+			// treat as special (bubble up)
+			*err = xerr
+		default:
+			h.wrapErrstr(xerr.Error(), err)
+		}
+	case string:
+		if xerr != "" {
+			h.wrapErrstr(xerr, err)
+		}
+	case fmt.Stringer:
+		if xerr != nil {
+			h.wrapErrstr(xerr.String(), err)
+		}
+	default:
+		h.wrapErrstr(v, err)
+	}
+}
 
 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]
 }
 
-// these functions must be inlinable, and not call anybody
+// ----
+
+type codecFnInfo struct {
+	ti    *typeInfo
+	xfFn  Ext
+	xfTag uint64
+	seq   seqType
+	addrD bool
+	addrF bool // if addrD, this says whether decode function can take a value or a ptr
+	addrE bool
+	ready bool // ready to use
+}
+
+// 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)
+	_  [1]uint64 // padding
+}
+
+type codecRtidFn struct {
+	rtid uintptr
+	fn   *codecFn
+}
+
+type codecFner struct {
+	// hh Handle
+	h  *BasicHandle
+	s  []codecRtidFn
+	be bool
+	js bool
+	_  [6]byte   // padding
+	_  [3]uint64 // padding
+}
+
+func (c *codecFner) reset(hh Handle) {
+	bh := hh.getBasicHandle()
+	// only reset iff extensions changed or *TypeInfos changed
+	var hhSame = true &&
+		c.h == bh && c.h.TypeInfos == bh.TypeInfos &&
+		len(c.h.extHandle) == len(bh.extHandle) &&
+		(len(c.h.extHandle) == 0 || &c.h.extHandle[0] == &bh.extHandle[0])
+	if !hhSame {
+		// c.hh = hh
+		c.h, bh = bh, c.h // swap both
+		_, c.js = hh.(*JsonHandle)
+		c.be = hh.isBinary()
+		if len(c.s) > 0 {
+			c.s = c.s[:0]
+		}
+		// for i := range c.s {
+		// 	c.s[i].fn.i.ready = false
+		// }
+	}
+}
+
+func (c *codecFner) get(rt reflect.Type, checkFastpath, checkCodecSelfer bool) (fn *codecFn) {
+	rtid := rt2id(rt)
+
+	for _, x := range c.s {
+		if x.rtid == rtid {
+			// if rtid exists, then there's a *codenFn attached (non-nil)
+			fn = x.fn
+			if fn.i.ready {
+				return
+			}
+			break
+		}
+	}
+	var ti *typeInfo
+	if fn == nil {
+		fn = new(codecFn)
+		if c.s == nil {
+			c.s = make([]codecRtidFn, 0, 8)
+		}
+		c.s = append(c.s, codecRtidFn{rtid, fn})
+	} else {
+		ti = fn.i.ti
+		*fn = codecFn{}
+		fn.i.ti = ti
+		// fn.fe, fn.fd = nil, nil
+	}
+	fi := &(fn.i)
+	fi.ready = true
+	if ti == nil {
+		ti = c.h.getTypeInfo(rtid, rt)
+		fi.ti = ti
+	}
+
+	rk := reflect.Kind(ti.kind)
+
+	if checkCodecSelfer && (ti.cs || ti.csp) {
+		fn.fe = (*Encoder).selferMarshal
+		fn.fd = (*Decoder).selferUnmarshal
+		fi.addrF = true
+		fi.addrD = ti.csp
+		fi.addrE = ti.csp
+	} else if rtid == timeTypId {
+		fn.fe = (*Encoder).kTime
+		fn.fd = (*Decoder).kTime
+	} else if rtid == rawTypId {
+		fn.fe = (*Encoder).raw
+		fn.fd = (*Decoder).raw
+	} else if rtid == rawExtTypId {
+		fn.fe = (*Encoder).rawExt
+		fn.fd = (*Decoder).rawExt
+		fi.addrF = true
+		fi.addrD = true
+		fi.addrE = 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
+		fi.addrF = true
+		fi.addrD = true
+		if rk == reflect.Struct || rk == reflect.Array {
+			fi.addrE = true
+		}
+	} else if supportMarshalInterfaces && c.be && (ti.bm || ti.bmp) && (ti.bu || ti.bup) {
+		fn.fe = (*Encoder).binaryMarshal
+		fn.fd = (*Decoder).binaryUnmarshal
+		fi.addrF = true
+		fi.addrD = ti.bup
+		fi.addrE = ti.bmp
+	} else if supportMarshalInterfaces && !c.be && c.js && (ti.jm || ti.jmp) && (ti.ju || ti.jup) {
+		//If JSON, we should check JSONMarshal before textMarshal
+		fn.fe = (*Encoder).jsonMarshal
+		fn.fd = (*Decoder).jsonUnmarshal
+		fi.addrF = true
+		fi.addrD = ti.jup
+		fi.addrE = ti.jmp
+	} else if supportMarshalInterfaces && !c.be && (ti.tm || ti.tmp) && (ti.tu || ti.tup) {
+		fn.fe = (*Encoder).textMarshal
+		fn.fd = (*Decoder).textUnmarshal
+		fi.addrF = true
+		fi.addrD = ti.tup
+		fi.addrE = ti.tmp
+	} else {
+		if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) {
+			if ti.pkgpath == "" { // un-named slice or map
+				if idx := fastpathAV.index(rtid); idx != -1 {
+					fn.fe = fastpathAV[idx].encfn
+					fn.fd = fastpathAV[idx].decfn
+					fi.addrD = true
+					fi.addrF = false
+				}
+			} else {
+				// use mapping for underlying type if there
+				var rtu reflect.Type
+				if rk == reflect.Map {
+					rtu = reflect.MapOf(ti.key, ti.elem)
+				} else {
+					rtu = reflect.SliceOf(ti.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))
+					}
+					fi.addrD = true
+					fi.addrF = false // meaning it can be an address(ptr) or a value
+					xfnf2 := fastpathAV[idx].decfn
+					fn.fd = func(d *Decoder, xf *codecFnInfo, xrv reflect.Value) {
+						if xrv.Kind() == reflect.Ptr {
+							xfnf2(d, xf, xrv.Convert(reflect.PtrTo(xrt)))
+						} else {
+							xfnf2(d, xf, xrv.Convert(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).kInt8
+				fn.fd = (*Decoder).kInt8
+			case reflect.Int16:
+				fn.fe = (*Encoder).kInt16
+				fn.fd = (*Decoder).kInt16
+			case reflect.Int32:
+				fn.fe = (*Encoder).kInt32
+				fn.fd = (*Decoder).kInt32
+			case reflect.Int64:
+				fn.fe = (*Encoder).kInt64
+				fn.fd = (*Decoder).kInt64
+			case reflect.Uint:
+				fn.fd = (*Decoder).kUint
+				fn.fe = (*Encoder).kUint
+			case reflect.Uint8:
+				fn.fe = (*Encoder).kUint8
+				fn.fd = (*Decoder).kUint8
+			case reflect.Uint16:
+				fn.fe = (*Encoder).kUint16
+				fn.fd = (*Decoder).kUint16
+			case reflect.Uint32:
+				fn.fe = (*Encoder).kUint32
+				fn.fd = (*Decoder).kUint32
+			case reflect.Uint64:
+				fn.fe = (*Encoder).kUint64
+				fn.fd = (*Decoder).kUint64
+			case reflect.Uintptr:
+				fn.fe = (*Encoder).kUintptr
+				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
+				fn.fd = (*Decoder).kErr
+			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.addrF = false
+				fi.addrD = false
+				rt2 := reflect.SliceOf(ti.elem)
+				fn.fd = func(d *Decoder, xf *codecFnInfo, xrv reflect.Value) {
+					d.cfer().get(rt2, true, false).fd(d, xf, xrv.Slice(0, xrv.Len()))
+				}
+				// fn.fd = (*Decoder).kArray
+			case reflect.Struct:
+				if ti.anyOmitEmpty {
+					fn.fe = (*Encoder).kStruct
+				} else {
+					fn.fe = (*Encoder).kStructNoOmitempty
+				}
+				fn.fd = (*Decoder).kStruct
+			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
+				fn.fe = (*Encoder).kErr
+			default:
+				// reflect.Ptr and reflect.Interface are handled already by preEncodeValue
+				fn.fe = (*Encoder).kErr
+				fn.fd = (*Decoder).kErr
+			}
+		}
+	}
+	return
+}
+
+type codecFnPooler struct {
+	cf  *codecFner
+	cfp *sync.Pool
+	hh  Handle
+}
+
+func (d *codecFnPooler) cfer() *codecFner {
+	if d.cf == nil {
+		var v interface{}
+		d.cfp, v = pool.codecFner()
+		d.cf = v.(*codecFner)
+		d.cf.reset(d.hh)
+	}
+	return d.cf
+}
+
+func (d *codecFnPooler) alwaysAtEnd() {
+	if d.cf != nil {
+		d.cfp.Put(d.cf)
+		d.cf, d.cfp = nil, nil
+	}
+}
+
+// ----
+
+// these "checkOverflow" functions must be inlinable, and not call anybody.
+// Overflow means that the value cannot be represented without wrapping/overflow.
+// Overflow=false does not mean that the value can be represented without losing precision
+// (especially for floating point).
+
 type checkOverflow struct{}
 
-func (_ checkOverflow) Float32(f float64) (overflow bool) {
-	if f < 0 {
-		f = -f
-	}
-	return math.MaxFloat32 < f && f <= math.MaxFloat64
-}
+// func (checkOverflow) Float16(f float64) (overflow bool) {
+// 	panicv.errorf("unimplemented")
+// 	if f < 0 {
+// 		f = -f
+// 	}
+// 	return math.MaxFloat32 < f && f <= math.MaxFloat64
+// }
 
-func (_ checkOverflow) Uint(v uint64, bitsize uint8) (overflow bool) {
+func (checkOverflow) Float32(v float64) (overflow bool) {
+	if v < 0 {
+		v = -v
+	}
+	return math.MaxFloat32 < v && v <= math.MaxFloat64
+}
+func (checkOverflow) Uint(v uint64, bitsize uint8) (overflow bool) {
 	if bitsize == 0 || bitsize >= 64 || v == 0 {
 		return
 	}
@@ -1059,8 +1930,7 @@ func (_ checkOverflow) Uint(v uint64, bitsize uint8) (overflow bool) {
 	}
 	return
 }
-
-func (_ checkOverflow) Int(v int64, bitsize uint8) (overflow bool) {
+func (checkOverflow) Int(v int64, bitsize uint8) (overflow bool) {
 	if bitsize == 0 || bitsize >= 64 || v == 0 {
 		return
 	}
@@ -1069,38 +1939,76 @@ func (_ checkOverflow) Int(v int64, bitsize uint8) (overflow bool) {
 	}
 	return
 }
-
-func (_ checkOverflow) SignedInt(v uint64) (i int64, overflow bool) {
+func (checkOverflow) SignedInt(v uint64) (overflow bool) {
 	//e.g. -127 to 128 for int8
 	pos := (v >> 63) == 0
 	ui2 := v & 0x7fffffffffffffff
 	if pos {
 		if ui2 > math.MaxInt64 {
 			overflow = true
-			return
 		}
 	} else {
 		if ui2 > math.MaxInt64-1 {
 			overflow = true
-			return
 		}
 	}
-	i = int64(v)
 	return
 }
 
+func (x checkOverflow) Float32V(v float64) float64 {
+	if x.Float32(v) {
+		panicv.errorf("float32 overflow: %v", v)
+	}
+	return v
+}
+func (x checkOverflow) UintV(v uint64, bitsize uint8) uint64 {
+	if x.Uint(v, bitsize) {
+		panicv.errorf("uint64 overflow: %v", v)
+	}
+	return v
+}
+func (x checkOverflow) IntV(v int64, bitsize uint8) int64 {
+	if x.Int(v, bitsize) {
+		panicv.errorf("int64 overflow: %v", v)
+	}
+	return v
+}
+func (x checkOverflow) SignedIntV(v uint64) int64 {
+	if x.SignedInt(v) {
+		panicv.errorf("uint64 to int64 overflow: %v", v)
+	}
+	return int64(v)
+}
+
 // ------------------ SORT -----------------
 
 func isNaN(f float64) bool { return f != f }
 
 // -----------------------
 
+type ioFlusher interface {
+	Flush() error
+}
+
+type ioPeeker interface {
+	Peek(int) ([]byte, error)
+}
+
+type ioBuffered interface {
+	Buffered() int
+}
+
+// -----------------------
+
 type intSlice []int64
 type uintSlice []uint64
+
+// type uintptrSlice []uintptr
 type floatSlice []float64
 type boolSlice []bool
 type stringSlice []string
-type bytesSlice [][]byte
+
+// type bytesSlice [][]byte
 
 func (p intSlice) Len() int           { return len(p) }
 func (p intSlice) Less(i, j int) bool { return p[i] < p[j] }
@@ -1110,6 +2018,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])
@@ -1120,9 +2032,9 @@ func (p stringSlice) Len() int           { return len(p) }
 func (p stringSlice) Less(i, j int) bool { return p[i] < p[j] }
 func (p stringSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
-func (p bytesSlice) Len() int           { return len(p) }
-func (p bytesSlice) Less(i, j int) bool { return bytes.Compare(p[i], p[j]) == -1 }
-func (p bytesSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+// func (p bytesSlice) Len() int           { return len(p) }
+// func (p bytesSlice) Less(i, j int) bool { return bytes.Compare(p[i], p[j]) == -1 }
+// func (p bytesSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
 func (p boolSlice) Len() int           { return len(p) }
 func (p boolSlice) Less(i, j int) bool { return !p[i] && p[j] }
@@ -1130,6 +2042,11 @@ func (p boolSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
 // ---------------------
 
+type sfiRv struct {
+	v *structFieldInfo
+	r reflect.Value
+}
+
 type intRv struct {
 	v int64
 	r reflect.Value
@@ -1160,6 +2077,11 @@ type bytesRv struct {
 	r reflect.Value
 }
 type bytesRvSlice []bytesRv
+type timeRv struct {
+	v time.Time
+	r reflect.Value
+}
+type timeRvSlice []timeRv
 
 func (p intRvSlice) Len() int           { return len(p) }
 func (p intRvSlice) Less(i, j int) bool { return p[i].v < p[j].v }
@@ -1187,6 +2109,10 @@ func (p boolRvSlice) Len() int           { return len(p) }
 func (p boolRvSlice) Less(i, j int) bool { return !p[i].v && p[j].v }
 func (p boolRvSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 
+func (p timeRvSlice) Len() int           { return len(p) }
+func (p timeRvSlice) Less(i, j int) bool { return p[i].v.Before(p[j].v) }
+func (p timeRvSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
 // -----------------
 
 type bytesI struct {
@@ -1206,7 +2132,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)
@@ -1247,7 +2172,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
@@ -1269,3 +2193,248 @@ 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) isset(pos byte) bool {
+	return x[pos>>3]&(1<<(pos&7)) != 0
+}
+func (x *bitset256) issetv(pos byte) byte {
+	return x[pos>>3] & (1 << (pos & 7))
+}
+func (x *bitset256) set(pos byte) {
+	x[pos>>3] |= (1 << (pos & 7))
+}
+
+// func (x *bitset256) unset(pos byte) {
+// 	x[pos>>3] &^= (1 << (pos & 7))
+// }
+
+type bitset128 [16]byte
+
+func (x *bitset128) isset(pos byte) bool {
+	return x[pos>>3]&(1<<(pos&7)) != 0
+}
+func (x *bitset128) set(pos byte) {
+	x[pos>>3] |= (1 << (pos & 7))
+}
+
+// func (x *bitset128) unset(pos byte) {
+// 	x[pos>>3] &^= (1 << (pos & 7))
+// }
+
+type bitset32 [4]byte
+
+func (x *bitset32) isset(pos byte) bool {
+	return x[pos>>3]&(1<<(pos&7)) != 0
+}
+func (x *bitset32) set(pos byte) {
+	x[pos>>3] |= (1 << (pos & 7))
+}
+
+// func (x *bitset32) unset(pos byte) {
+// 	x[pos>>3] &^= (1 << (pos & 7))
+// }
+
+// type bit2set256 [64]byte
+
+// func (x *bit2set256) set(pos byte, v1, v2 bool) {
+// 	var pos2 uint8 = (pos & 3) << 1 // returning 0, 2, 4 or 6
+// 	if v1 {
+// 		x[pos>>2] |= 1 << (pos2 + 1)
+// 	}
+// 	if v2 {
+// 		x[pos>>2] |= 1 << pos2
+// 	}
+// }
+// func (x *bit2set256) get(pos byte) uint8 {
+// 	var pos2 uint8 = (pos & 3) << 1     // returning 0, 2, 4 or 6
+// 	return x[pos>>2] << (6 - pos2) >> 6 // 11000000 -> 00000011
+// }
+
+// ------------
+
+type pooler struct {
+	dn                                          sync.Pool // for decNaked
+	cfn                                         sync.Pool // for codecFner
+	tiload                                      sync.Pool
+	strRv8, strRv16, strRv32, strRv64, strRv128 sync.Pool // for stringRV
+}
+
+func (p *pooler) init() {
+	p.strRv8.New = func() interface{} { return new([8]sfiRv) }
+	p.strRv16.New = func() interface{} { return new([16]sfiRv) }
+	p.strRv32.New = func() interface{} { return new([32]sfiRv) }
+	p.strRv64.New = func() interface{} { return new([64]sfiRv) }
+	p.strRv128.New = func() interface{} { return new([128]sfiRv) }
+	p.dn.New = func() interface{} { x := new(decNaked); x.init(); return x }
+	p.tiload.New = func() interface{} { return new(typeInfoLoadArray) }
+	p.cfn.New = func() interface{} { return new(codecFner) }
+}
+
+func (p *pooler) sfiRv8() (sp *sync.Pool, v interface{}) {
+	return &p.strRv8, p.strRv8.Get()
+}
+func (p *pooler) sfiRv16() (sp *sync.Pool, v interface{}) {
+	return &p.strRv16, p.strRv16.Get()
+}
+func (p *pooler) sfiRv32() (sp *sync.Pool, v interface{}) {
+	return &p.strRv32, p.strRv32.Get()
+}
+func (p *pooler) sfiRv64() (sp *sync.Pool, v interface{}) {
+	return &p.strRv64, p.strRv64.Get()
+}
+func (p *pooler) sfiRv128() (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) codecFner() (sp *sync.Pool, v interface{}) {
+	return &p.cfn, p.cfn.Get()
+}
+func (p *pooler) tiLoad() (sp *sync.Pool, v interface{}) {
+	return &p.tiload, p.tiload.Get()
+}
+
+// func (p *pooler) decNaked() (v *decNaked, f func(*decNaked) ) {
+// 	sp := &(p.dn)
+// 	vv := sp.Get()
+// 	return vv.(*decNaked), func(x *decNaked) { sp.Put(vv) }
+// }
+// func (p *pooler) decNakedGet() (v interface{}) {
+// 	return p.dn.Get()
+// }
+// func (p *pooler) codecFnerGet() (v interface{}) {
+// 	return p.cfn.Get()
+// }
+// func (p *pooler) tiLoadGet() (v interface{}) {
+// 	return p.tiload.Get()
+// }
+// func (p *pooler) decNakedPut(v interface{}) {
+// 	p.dn.Put(v)
+// }
+// func (p *pooler) codecFnerPut(v interface{}) {
+// 	p.cfn.Put(v)
+// }
+// func (p *pooler) tiLoadPut(v interface{}) {
+// 	p.tiload.Put(v)
+// }
+
+type panicHdl struct{}
+
+func (panicHdl) errorv(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (panicHdl) errorstr(message string) {
+	if message != "" {
+		panic(message)
+	}
+}
+
+func (panicHdl) errorf(format string, params ...interface{}) {
+	if format != "" {
+		if len(params) == 0 {
+			panic(format)
+		} else {
+			panic(fmt.Sprintf(format, params...))
+		}
+	}
+}
+
+type errstrDecorator interface {
+	wrapErrstr(interface{}, *error)
+}
+
+type errstrDecoratorDef struct{}
+
+func (errstrDecoratorDef) wrapErrstr(v interface{}, e *error) { *e = fmt.Errorf("%v", v) }
+
+type must struct{}
+
+func (must) String(s string, err error) string {
+	if err != nil {
+		panicv.errorv(err)
+	}
+	return s
+}
+func (must) Int(s int64, err error) int64 {
+	if err != nil {
+		panicv.errorv(err)
+	}
+	return s
+}
+func (must) Uint(s uint64, err error) uint64 {
+	if err != nil {
+		panicv.errorv(err)
+	}
+	return s
+}
+func (must) Float(s float64, err error) float64 {
+	if err != nil {
+		panicv.errorv(err)
+	}
+	return s
+}
+
+// xdebugf prints the message in red on the terminal.
+// Use it in place of fmt.Printf (which it calls internally)
+func xdebugf(pattern string, args ...interface{}) {
+	var delim string
+	if len(pattern) > 0 && pattern[len(pattern)-1] != '\n' {
+		delim = "\n"
+	}
+	fmt.Printf("\033[1;31m"+pattern+delim+"\033[0m", args...)
+}
+
+// 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
+// }
+
+// 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/helper_internal.go b/vendor/github.com/ugorji/go/codec/helper_internal.go
index dea981fbb..0cbd665e2 100644
--- a/vendor/github.com/ugorji/go/codec/helper_internal.go
+++ b/vendor/github.com/ugorji/go/codec/helper_internal.go
@@ -6,74 +6,6 @@ package codec
 // All non-std package dependencies live in this file,
 // so porting to different environment is easy (just update functions).
 
-import (
-	"errors"
-	"fmt"
-	"math"
-	"reflect"
-)
-
-func panicValToErr(panicVal interface{}, err *error) {
-	if panicVal == nil {
-		return
-	}
-	// case nil
-	switch xerr := panicVal.(type) {
-	case error:
-		*err = xerr
-	case string:
-		*err = errors.New(xerr)
-	default:
-		*err = fmt.Errorf("%v", panicVal)
-	}
-	return
-}
-
-func hIsEmptyValue(v reflect.Value, deref, checkStruct bool) bool {
-	switch v.Kind() {
-	case reflect.Invalid:
-		return true
-	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
-		return v.Len() == 0
-	case reflect.Bool:
-		return !v.Bool()
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return v.Int() == 0
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		return v.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return v.Float() == 0
-	case reflect.Interface, reflect.Ptr:
-		if deref {
-			if v.IsNil() {
-				return true
-			}
-			return hIsEmptyValue(v.Elem(), deref, checkStruct)
-		} else {
-			return v.IsNil()
-		}
-	case reflect.Struct:
-		if !checkStruct {
-			return false
-		}
-		// return true if all fields are empty. else return false.
-		// we cannot use equality check, because some fields may be maps/slices/etc
-		// and consequently the structs are not comparable.
-		// return v.Interface() == reflect.Zero(v.Type()).Interface()
-		for i, n := 0, v.NumField(); i < n; i++ {
-			if !hIsEmptyValue(v.Field(i), deref, checkStruct) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
-}
-
-func isEmptyValue(v reflect.Value) bool {
-	return hIsEmptyValue(v, derefForIsEmptyValue, checkStructForEmptyValue)
-}
-
 func pruneSignExt(v []byte, pos bool) (n int) {
 	if len(v) < 2 {
 	} else if pos && v[0] == 0 {
@@ -86,37 +18,6 @@ func pruneSignExt(v []byte, pos bool) (n int) {
 	return
 }
 
-func implementsIntf(typ, iTyp reflect.Type) (success bool, indir int8) {
-	if typ == nil {
-		return
-	}
-	rt := typ
-	// The type might be a pointer and we need to keep
-	// dereferencing to the base type until we find an implementation.
-	for {
-		if rt.Implements(iTyp) {
-			return true, indir
-		}
-		if p := rt; p.Kind() == reflect.Ptr {
-			indir++
-			if indir >= math.MaxInt8 { // insane number of indirections
-				return false, 0
-			}
-			rt = p.Elem()
-			continue
-		}
-		break
-	}
-	// No luck yet, but if this is a base type (non-pointer), the pointer might satisfy.
-	if typ.Kind() != reflect.Ptr {
-		// Not a pointer, but does the pointer work?
-		if reflect.PtrTo(typ).Implements(iTyp) {
-			return true, -1
-		}
-	}
-	return false, 0
-}
-
 // validate that this function is correct ...
 // culled from OGRE (Object-Oriented Graphics Rendering Engine)
 // function: halfToFloatI (http://stderr.org/doc/ogre-doc/api/OgreBitwise_8h-source.html)
@@ -129,21 +30,20 @@ func halfFloatToFloatBits(yy uint16) (d uint32) {
 	if e == 0 {
 		if m == 0 { // plu or minus 0
 			return s << 31
-		} else { // Denormalized number -- renormalize it
-			for (m & 0x00000400) == 0 {
-				m <<= 1
-				e -= 1
-			}
-			e += 1
-			const zz uint32 = 0x0400
-			m &= ^zz
 		}
+		// Denormalized number -- renormalize it
+		for (m & 0x00000400) == 0 {
+			m <<= 1
+			e -= 1
+		}
+		e += 1
+		const zz uint32 = 0x0400
+		m &= ^zz
 	} else if e == 31 {
 		if m == 0 { // Inf
 			return (s << 31) | 0x7f800000
-		} else { // NaN
-			return (s << 31) | 0x7f800000 | (m << 13)
 		}
+		return (s << 31) | 0x7f800000 | (m << 13) // NaN
 	}
 	e = e + (127 - 15)
 	m = m << 13
@@ -219,24 +119,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 7c2ffc0fd..fd52690c9 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,24 @@
-//+build !unsafe
+// +build !go1.7 safe appengine
 
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 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"
+	"time"
+)
+
+const safeMode = true
+
 // 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 +26,247 @@ 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 {
+	// this is a best-effort option.
+	// We just return false, so we don't unnecessarily incur the cost of reflection this early.
+	return false
+}
+
+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()
+}
+
+func i2rtid(i interface{}) uintptr {
+	return reflect.ValueOf(reflect.TypeOf(i)).Pointer()
+}
+
+// --------------------------
+
+func isEmptyValue(v reflect.Value, tinfos *TypeInfos, deref, checkStruct bool) bool {
+	switch v.Kind() {
+	case reflect.Invalid:
+		return true
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		return v.Len() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Interface, reflect.Ptr:
+		if deref {
+			if v.IsNil() {
+				return true
+			}
+			return isEmptyValue(v.Elem(), tinfos, deref, checkStruct)
+		}
+		return v.IsNil()
+	case reflect.Struct:
+		return isEmptyStruct(v, tinfos, deref, checkStruct)
+	}
+	return false
+}
+
+// --------------------------
+// type ptrToRvMap struct{}
+
+// func (*ptrToRvMap) init() {}
+// func (*ptrToRvMap) get(i interface{}) reflect.Value {
+// 	return reflect.ValueOf(i).Elem()
+// }
+
+// --------------------------
+type atomicTypeInfoSlice struct { // expected to be 2 words
+	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) kTime(f *codecFnInfo, rv reflect.Value) {
+	rv.Set(reflect.ValueOf(d.d.DecodeTime()))
+}
+
+func (d *Decoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	fv := d.d.DecodeFloat64()
+	if chkOvf.Float32(fv) {
+		d.errorf("float32 overflow: %v", fv)
+	}
+	rv.SetFloat(fv)
+}
+
+func (d *Decoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	rv.SetFloat(d.d.DecodeFloat64())
+}
+
+func (d *Decoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
+}
+
+func (d *Decoder) kInt8(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(chkOvf.IntV(d.d.DecodeInt64(), 8))
+}
+
+func (d *Decoder) kInt16(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(chkOvf.IntV(d.d.DecodeInt64(), 16))
+}
+
+func (d *Decoder) kInt32(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(chkOvf.IntV(d.d.DecodeInt64(), 32))
+}
+
+func (d *Decoder) kInt64(f *codecFnInfo, rv reflect.Value) {
+	rv.SetInt(d.d.DecodeInt64())
+}
+
+func (d *Decoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
+}
+
+func (d *Decoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
+}
+
+func (d *Decoder) kUint8(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(chkOvf.UintV(d.d.DecodeUint64(), 8))
+}
+
+func (d *Decoder) kUint16(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(chkOvf.UintV(d.d.DecodeUint64(), 16))
+}
+
+func (d *Decoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(chkOvf.UintV(d.d.DecodeUint64(), 32))
+}
+
+func (d *Decoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	rv.SetUint(d.d.DecodeUint64())
+}
+
+// ----------------
+
+func (e *Encoder) kBool(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeBool(rv.Bool())
+}
+
+func (e *Encoder) kTime(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeTime(rv2i(rv).(time.Time))
+}
+
+func (e *Encoder) kString(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeString(cUTF8, rv.String())
+}
+
+func (e *Encoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeFloat64(rv.Float())
+}
+
+func (e *Encoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeFloat32(float32(rv.Float()))
+}
+
+func (e *Encoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kInt8(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kInt16(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kInt32(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kInt64(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeInt(rv.Int())
+}
+
+func (e *Encoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUint8(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUint16(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+func (e *Encoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
+	e.e.EncodeUint(rv.Uint())
+}
+
+// // 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 definitelyNil(v interface{}) bool {
+// 	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
+// 	}
+// }
diff --git a/vendor/github.com/ugorji/go/codec/helper_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_unsafe.go
index 373b2b102..e3df60abe 100644
--- a/vendor/github.com/ugorji/go/codec/helper_unsafe.go
+++ b/vendor/github.com/ugorji/go/codec/helper_unsafe.go
@@ -1,45 +1,639 @@
-//+build unsafe
+// +build !safe
+// +build !appengine
+// +build go1.7
 
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 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"
+	"time"
 	"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 safeMode = false
+const unsafeFlagIndir = 1 << 7 // keep in sync with GO_ROOT/src/reflect/value.go
 
 type unsafeString struct {
-	Data uintptr
+	Data unsafe.Pointer
 	Len  int
 }
 
-type unsafeBytes struct {
-	Data uintptr
+type unsafeSlice struct {
+	Data unsafe.Pointer
 	Len  int
 	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 ""
 	}
-	x := unsafeString{uintptr(unsafe.Pointer(&v[0])), len(v)}
-	return *(*string)(unsafe.Pointer(&x))
+	bx := (*unsafeSlice)(unsafe.Pointer(&v))
+	return *(*string)(unsafe.Pointer(&unsafeString{bx.Data, bx.Len}))
 }
 
-// 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
 	}
-	x := unsafeBytes{uintptr(unsafe.Pointer(&v)), len(v), len(v)}
-	return *(*[]byte)(unsafe.Pointer(&x))
+	sx := (*unsafeString)(unsafe.Pointer(&v))
+	return *(*[]byte)(unsafe.Pointer(&unsafeSlice{sx.Data, sx.Len, sx.Len}))
 }
+
+func definitelyNil(v interface{}) bool {
+	// There is no global way of checking if an interface is nil.
+	// For true references (map, ptr, func, chan), you can just look
+	// at the word of the interface. However, for slices, you have to dereference
+	// the word, and get a pointer to the 3-word interface value.
+	//
+	// However, the following are cheap calls
+	// - TypeOf(interface): cheap 2-line call.
+	// - ValueOf(interface{}): expensive
+	// - type.Kind: cheap call through an interface
+	// - Value.Type(): cheap call
+	//                 except it's a method value (e.g. r.Read, which implies that it is a Func)
+
+	return ((*unsafeIntf)(unsafe.Pointer(&v))).word == nil
+}
+
+func rv2i(rv reflect.Value) interface{} {
+	// 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.
+
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	// true references (map, func, chan, ptr - NOT slice) may be double-referenced as flagIndir
+	var ptr unsafe.Pointer
+	if refBitset.isset(byte(urv.flag&(1<<5-1))) && urv.flag&unsafeFlagIndir != 0 {
+		ptr = *(*unsafe.Pointer)(urv.ptr)
+	} else {
+		ptr = urv.ptr
+	}
+	return *(*interface{})(unsafe.Pointer(&unsafeIntf{typ: urv.typ, word: ptr}))
+}
+
+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 i2rtid(i interface{}) uintptr {
+	return uintptr(((*unsafeIntf)(unsafe.Pointer(&i))).typ)
+}
+
+// --------------------------
+
+func isEmptyValue(v reflect.Value, tinfos *TypeInfos, deref, checkStruct bool) bool {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&v))
+	if urv.flag == 0 {
+		return true
+	}
+	switch v.Kind() {
+	case reflect.Invalid:
+		return true
+	case reflect.String:
+		return (*unsafeString)(urv.ptr).Len == 0
+	case reflect.Slice:
+		return (*unsafeSlice)(urv.ptr).Len == 0
+	case reflect.Bool:
+		return !*(*bool)(urv.ptr)
+	case reflect.Int:
+		return *(*int)(urv.ptr) == 0
+	case reflect.Int8:
+		return *(*int8)(urv.ptr) == 0
+	case reflect.Int16:
+		return *(*int16)(urv.ptr) == 0
+	case reflect.Int32:
+		return *(*int32)(urv.ptr) == 0
+	case reflect.Int64:
+		return *(*int64)(urv.ptr) == 0
+	case reflect.Uint:
+		return *(*uint)(urv.ptr) == 0
+	case reflect.Uint8:
+		return *(*uint8)(urv.ptr) == 0
+	case reflect.Uint16:
+		return *(*uint16)(urv.ptr) == 0
+	case reflect.Uint32:
+		return *(*uint32)(urv.ptr) == 0
+	case reflect.Uint64:
+		return *(*uint64)(urv.ptr) == 0
+	case reflect.Uintptr:
+		return *(*uintptr)(urv.ptr) == 0
+	case reflect.Float32:
+		return *(*float32)(urv.ptr) == 0
+	case reflect.Float64:
+		return *(*float64)(urv.ptr) == 0
+	case reflect.Interface:
+		isnil := urv.ptr == nil || *(*unsafe.Pointer)(urv.ptr) == nil
+		if deref {
+			if isnil {
+				return true
+			}
+			return isEmptyValue(v.Elem(), tinfos, deref, checkStruct)
+		}
+		return isnil
+	case reflect.Ptr:
+		// isnil := urv.ptr == nil (not sufficient, as a pointer value encodes the type)
+		isnil := urv.ptr == nil || *(*unsafe.Pointer)(urv.ptr) == nil
+		if deref {
+			if isnil {
+				return true
+			}
+			return isEmptyValue(v.Elem(), tinfos, deref, checkStruct)
+		}
+		return isnil
+	case reflect.Struct:
+		return isEmptyStruct(v, tinfos, deref, checkStruct)
+	case reflect.Map, reflect.Array, reflect.Chan:
+		return v.Len() == 0
+	}
+	return false
+}
+
+// --------------------------
+
+// atomicTypeInfoSlice contains length and pointer to the array for a slice.
+// It is expected to be 2 words.
+//
+// Previously, we atomically loaded and stored the length and array pointer separately,
+// which could lead to some races.
+// We now just atomically store and load the pointer to the value directly.
+
+type atomicTypeInfoSlice struct { // expected to be 2 words
+	l int            // length of the data array (must be first in struct, for 64-bit alignment necessary for 386)
+	v unsafe.Pointer // data array - Pointer (not uintptr) to maintain GC reference
+}
+
+func (x *atomicTypeInfoSlice) load() []rtid2ti {
+	xp := unsafe.Pointer(x)
+	x2 := *(*atomicTypeInfoSlice)(atomic.LoadPointer(&xp))
+	if x2.l == 0 {
+		return nil
+	}
+	return *(*[]rtid2ti)(unsafe.Pointer(&unsafeSlice{Data: x2.v, Len: x2.l, Cap: x2.l}))
+}
+
+func (x *atomicTypeInfoSlice) store(p []rtid2ti) {
+	s := (*unsafeSlice)(unsafe.Pointer(&p))
+	xp := unsafe.Pointer(x)
+	atomic.StorePointer(&xp, unsafe.Pointer(&atomicTypeInfoSlice{l: s.Len, v: s.Data}))
+}
+
+// --------------------------
+func (d *Decoder) raw(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*[]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) kTime(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*time.Time)(urv.ptr) = d.d.DecodeTime()
+}
+
+func (d *Decoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	fv := d.d.DecodeFloat64()
+	if chkOvf.Float32(fv) {
+		d.errorf("float32 overflow: %v", fv)
+	}
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*float32)(urv.ptr) = float32(fv)
+}
+
+func (d *Decoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*float64)(urv.ptr) = d.d.DecodeFloat64()
+}
+
+func (d *Decoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int)(urv.ptr) = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
+}
+
+func (d *Decoder) kInt8(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int8)(urv.ptr) = int8(chkOvf.IntV(d.d.DecodeInt64(), 8))
+}
+
+func (d *Decoder) kInt16(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int16)(urv.ptr) = int16(chkOvf.IntV(d.d.DecodeInt64(), 16))
+}
+
+func (d *Decoder) kInt32(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int32)(urv.ptr) = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
+}
+
+func (d *Decoder) kInt64(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*int64)(urv.ptr) = d.d.DecodeInt64()
+}
+
+func (d *Decoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint)(urv.ptr) = uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
+}
+
+func (d *Decoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uintptr)(urv.ptr) = uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))
+}
+
+func (d *Decoder) kUint8(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint8)(urv.ptr) = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
+}
+
+func (d *Decoder) kUint16(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint16)(urv.ptr) = uint16(chkOvf.UintV(d.d.DecodeUint64(), 16))
+}
+
+func (d *Decoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint32)(urv.ptr) = uint32(chkOvf.UintV(d.d.DecodeUint64(), 32))
+}
+
+func (d *Decoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	*(*uint64)(urv.ptr) = d.d.DecodeUint64()
+}
+
+// ------------
+
+func (e *Encoder) kBool(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeBool(*(*bool)(v.ptr))
+}
+
+func (e *Encoder) kTime(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeTime(*(*time.Time)(v.ptr))
+}
+
+func (e *Encoder) kString(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeString(cUTF8, *(*string)(v.ptr))
+}
+
+func (e *Encoder) kFloat64(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeFloat64(*(*float64)(v.ptr))
+}
+
+func (e *Encoder) kFloat32(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeFloat32(*(*float32)(v.ptr))
+}
+
+func (e *Encoder) kInt(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int)(v.ptr)))
+}
+
+func (e *Encoder) kInt8(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int8)(v.ptr)))
+}
+
+func (e *Encoder) kInt16(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int16)(v.ptr)))
+}
+
+func (e *Encoder) kInt32(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int32)(v.ptr)))
+}
+
+func (e *Encoder) kInt64(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeInt(int64(*(*int64)(v.ptr)))
+}
+
+func (e *Encoder) kUint(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint)(v.ptr)))
+}
+
+func (e *Encoder) kUint8(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint8)(v.ptr)))
+}
+
+func (e *Encoder) kUint16(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint16)(v.ptr)))
+}
+
+func (e *Encoder) kUint32(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint32)(v.ptr)))
+}
+
+func (e *Encoder) kUint64(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uint64)(v.ptr)))
+}
+
+func (e *Encoder) kUintptr(f *codecFnInfo, rv reflect.Value) {
+	v := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+	e.e.EncodeUint(uint64(*(*uintptr)(v.ptr)))
+}
+
+// ------------
+
+// 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 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})
+// }
+
+// func rv2i(rv reflect.Value) interface{} {
+// 	urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
+// 	// true references (map, func, chan, ptr - NOT slice) may be double-referenced as flagIndir
+// 	var ptr unsafe.Pointer
+// 	// kk := reflect.Kind(urv.flag & (1<<5 - 1))
+// 	// if (kk == reflect.Map || kk == reflect.Ptr || kk == reflect.Chan || kk == reflect.Func) && urv.flag&unsafeFlagIndir != 0 {
+// 	if refBitset.isset(byte(urv.flag&(1<<5-1))) && urv.flag&unsafeFlagIndir != 0 {
+// 		ptr = *(*unsafe.Pointer)(urv.ptr)
+// 	} else {
+// 		ptr = urv.ptr
+// 	}
+// 	return *(*interface{})(unsafe.Pointer(&unsafeIntf{typ: urv.typ, word: ptr}))
+// 	// 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 definitelyNil(v interface{}) bool {
+// 	var ui *unsafeIntf = (*unsafeIntf)(unsafe.Pointer(&v))
+// 	if ui.word == nil {
+// 		return true
+// 	}
+// 	var tk = reflect.TypeOf(v).Kind()
+// 	return (tk == reflect.Interface || tk == reflect.Slice) && *(*unsafe.Pointer)(ui.word) == nil
+// 	fmt.Printf(">>>> definitely nil: isnil: %v, TYPE: \t%T, word: %v, *word: %v, type: %v, nil: %v\n",
+// 	v == nil, v, word, *((*unsafe.Pointer)(word)), ui.typ, nil)
+// }
+
+// func keepAlive4BytesView(v string) {
+// 	runtime.KeepAlive(v)
+// }
+
+// func keepAlive4StringView(v []byte) {
+// 	runtime.KeepAlive(v)
+// }
+
+// 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 a04dfcb9d..7c3b76055 100644
--- a/vendor/github.com/ugorji/go/codec/json.go
+++ b/vendor/github.com/ugorji/go/codec/json.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 package codec
@@ -17,16 +17,6 @@ package codec
 // Note:
 //   - we cannot use strconv.Quote and strconv.Unquote because json quotes/unquotes differently.
 //     We implement it here.
-//   - Also, strconv.ParseXXX for floats and integers
-//     - only works on strings resulting in unnecessary allocation and []byte-string conversion.
-//     - it does a lot of redundant checks, because json numbers are simpler that what it supports.
-//   - We parse numbers (floats and integers) directly here.
-//     We only delegate parsing floats if it is a hairy float which could cause a loss of precision.
-//     In that case, we delegate to strconv.ParseFloat.
-//
-// Note:
-//   - encode does not beautify. There is no whitespace when encoding.
-//   - rpc calls which take single integer arguments or write single numeric arguments will need care.
 
 // Top-level methods of json(End|Dec)Driver (which are implementations of (en|de)cDriver
 // MUST not call one-another.
@@ -34,42 +24,41 @@ package codec
 import (
 	"bytes"
 	"encoding/base64"
-	"fmt"
+	"math"
 	"reflect"
 	"strconv"
+	"time"
+	"unicode"
 	"unicode/utf16"
 	"unicode/utf8"
 )
 
 //--------------------------------
 
-var (
-	jsonLiterals = [...]byte{'t', 'r', 'u', 'e', 'f', 'a', 'l', 's', 'e', 'n', 'u', 'l', 'l'}
+var 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,
-	}
-
-	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
+const (
+	jsonLitTrueQ  = 0
+	jsonLitTrue   = 1
+	jsonLitFalseQ = 6
+	jsonLitFalse  = 7
+	jsonLitNullQ  = 13
+	jsonLitNull   = 14
 )
 
 const (
-	// jsonUnreadAfterDecNum controls whether we unread after decoding a number.
-	//
-	// instead of unreading, just update d.tok (iff it's not a whitespace char)
-	// However, doing this means that we may HOLD onto some data which belongs to another stream.
-	// Thus, it is safest to unread the data when done.
-	// keep behind a constant flag for now.
-	jsonUnreadAfterDecNum = true
+	jsonU4Chk2 = '0'
+	jsonU4Chk1 = 'a' - 10
+	jsonU4Chk0 = 'A' - 10
 
+	jsonScratchArrayLen = 64
+)
+
+const (
 	// If !jsonValidateSymbols, decoding will be faster, by skipping some checks:
 	//   - If we see first character of null, false or true,
 	//     do not validate subsequent characters.
@@ -78,48 +67,154 @@ 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
+
+	jsonAlwaysReturnInternString = false
+)
+
+var (
+	// jsonTabs and jsonSpaces are used as caches for indents
+	jsonTabs, jsonSpaces [jsonSpacesOrTabsLen]byte
+
+	jsonCharHtmlSafeSet   bitset128
+	jsonCharSafeSet       bitset128
+	jsonCharWhitespaceSet bitset256
+	jsonNumSet            bitset256
 )
 
 func init() {
-	var bs [jsonSpacesOrTabsLen]byte
 	for i := 0; i < jsonSpacesOrTabsLen; i++ {
-		bs[i] = ' '
+		jsonSpaces[i] = ' '
+		jsonTabs[i] = '\t'
 	}
-	jsonSpaces = string(bs[:])
 
-	for i := 0; i < jsonSpacesOrTabsLen; i++ {
-		bs[i] = '\t'
+	// 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)
+		}
 	}
-	jsonTabs = string(bs[:])
 }
 
-type jsonEncDriver struct {
-	e  *Encoder
+// ----------------
+
+type jsonEncDriverTypical struct {
 	w  encWriter
-	h  *JsonHandle
-	b  [64]byte // scratch
-	bs []byte   // scratch
-	se setExtWrapper
-	ds string // indent string
-	dl uint16 // indent level
-	dt bool   // indent using tabs
-	d  bool   // indent
+	b  *[jsonScratchArrayLen]byte
+	tw bool // term white space
 	c  containerState
-	noBuiltInTypes
+}
+
+func (e *jsonEncDriverTypical) typical() {}
+
+func (e *jsonEncDriverTypical) reset(ee *jsonEncDriver) {
+	e.w = ee.ew
+	e.b = &ee.b
+	e.tw = ee.h.TermWhitespace
+	e.c = 0
+}
+
+func (e *jsonEncDriverTypical) WriteArrayStart(length int) {
+	e.w.writen1('[')
+	e.c = containerArrayStart
+}
+
+func (e *jsonEncDriverTypical) WriteArrayElem() {
+	if e.c != containerArrayStart {
+		e.w.writen1(',')
+	}
+	e.c = containerArrayElem
+}
+
+func (e *jsonEncDriverTypical) WriteArrayEnd() {
+	e.w.writen1(']')
+	e.c = containerArrayEnd
+}
+
+func (e *jsonEncDriverTypical) WriteMapStart(length int) {
+	e.w.writen1('{')
+	e.c = containerMapStart
+}
+
+func (e *jsonEncDriverTypical) WriteMapElemKey() {
+	if e.c != containerMapStart {
+		e.w.writen1(',')
+	}
+	e.c = containerMapKey
+}
+
+func (e *jsonEncDriverTypical) WriteMapElemValue() {
+	e.w.writen1(':')
+	e.c = containerMapValue
+}
+
+func (e *jsonEncDriverTypical) WriteMapEnd() {
+	e.w.writen1('}')
+	e.c = containerMapEnd
+}
+
+func (e *jsonEncDriverTypical) EncodeBool(b bool) {
+	if b {
+		e.w.writeb(jsonLiterals[jsonLitTrue : jsonLitTrue+4])
+	} else {
+		e.w.writeb(jsonLiterals[jsonLitFalse : jsonLitFalse+5])
+	}
+}
+
+func (e *jsonEncDriverTypical) EncodeFloat64(f float64) {
+	fmt, prec := jsonFloatStrconvFmtPrec(f)
+	e.w.writeb(strconv.AppendFloat(e.b[:0], f, fmt, prec, 64))
+}
+
+func (e *jsonEncDriverTypical) EncodeInt(v int64) {
+	e.w.writeb(strconv.AppendInt(e.b[:0], v, 10))
+}
+
+func (e *jsonEncDriverTypical) EncodeUint(v uint64) {
+	e.w.writeb(strconv.AppendUint(e.b[:0], v, 10))
+}
+
+func (e *jsonEncDriverTypical) EncodeFloat32(f float32) {
+	e.EncodeFloat64(float64(f))
+}
+
+func (e *jsonEncDriverTypical) atEndOfEncode() {
+	if e.tw {
+		e.w.writen1(' ')
+	}
+}
+
+// ----------------
+
+type jsonEncDriverGeneric struct {
+	w encWriter
+	b *[jsonScratchArrayLen]byte
+	c containerState
+	// ds string // indent string
+	di int8    // indent per
+	d  bool    // indenting?
+	dt bool    // indent using tabs
+	dl uint16  // indent level
+	ks bool    // map key as string
+	is byte    // integer as string
+	tw bool    // term white space
+	_  [7]byte // padding
 }
 
 // indent is done as below:
@@ -127,107 +222,228 @@ 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 {
+func (e *jsonEncDriverGeneric) reset(ee *jsonEncDriver) {
+	e.w = ee.ew
+	e.b = &ee.b
+	e.tw = ee.h.TermWhitespace
+	e.c = 0
+	e.d, e.dt, e.dl, e.di = false, false, 0, 0
+	h := ee.h
+	if h.Indent > 0 {
+		e.d = true
+		e.di = int8(h.Indent)
+	} else if h.Indent < 0 {
+		e.d = true
+		e.dt = true
+		e.di = int8(-h.Indent)
+	}
+	e.ks = h.MapKeyAsString
+	e.is = h.IntegerAsString
+}
+
+func (e *jsonEncDriverGeneric) WriteArrayStart(length int) {
+	if e.d {
+		e.dl++
+	}
+	e.w.writen1('[')
+	e.c = containerArrayStart
+}
+
+func (e *jsonEncDriverGeneric) WriteArrayElem() {
+	if e.c != containerArrayStart {
+		e.w.writen1(',')
+	}
+	if e.d {
+		e.writeIndent()
+	}
+	e.c = containerArrayElem
+}
+
+func (e *jsonEncDriverGeneric) WriteArrayEnd() {
+	if e.d {
+		e.dl--
 		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(']')
 	}
-	e.c = c
+	e.w.writen1(']')
+	e.c = containerArrayEnd
 }
 
-func (e *jsonEncDriver) writeIndent() {
+func (e *jsonEncDriverGeneric) WriteMapStart(length int) {
+	if e.d {
+		e.dl++
+	}
+	e.w.writen1('{')
+	e.c = containerMapStart
+}
+
+func (e *jsonEncDriverGeneric) WriteMapElemKey() {
+	if e.c != containerMapStart {
+		e.w.writen1(',')
+	}
+	if e.d {
+		e.writeIndent()
+	}
+	e.c = containerMapKey
+}
+
+func (e *jsonEncDriverGeneric) WriteMapElemValue() {
+	if e.d {
+		e.w.writen2(':', ' ')
+	} else {
+		e.w.writen1(':')
+	}
+	e.c = containerMapValue
+}
+
+func (e *jsonEncDriverGeneric) WriteMapEnd() {
+	if e.d {
+		e.dl--
+		if e.c != containerMapStart {
+			e.writeIndent()
+		}
+	}
+	e.w.writen1('}')
+	e.c = containerMapEnd
+}
+
+func (e *jsonEncDriverGeneric) writeIndent() {
 	e.w.writen1('\n')
-	if x := len(e.ds) * int(e.dl); x <= jsonSpacesOrTabsLen {
-		if e.dt {
-			e.w.writestr(jsonTabs[:x])
+	x := int(e.di) * int(e.dl)
+	if e.dt {
+		for x > jsonSpacesOrTabsLen {
+			e.w.writeb(jsonTabs[:])
+			x -= jsonSpacesOrTabsLen
+		}
+		e.w.writeb(jsonTabs[:x])
+	} else {
+		for x > jsonSpacesOrTabsLen {
+			e.w.writeb(jsonSpaces[:])
+			x -= jsonSpacesOrTabsLen
+		}
+		e.w.writeb(jsonSpaces[:x])
+	}
+}
+
+func (e *jsonEncDriverGeneric) EncodeBool(b bool) {
+	if e.ks && e.c == containerMapKey {
+		if b {
+			e.w.writeb(jsonLiterals[jsonLitTrueQ : jsonLitTrueQ+6])
 		} else {
-			e.w.writestr(jsonSpaces[:x])
+			e.w.writeb(jsonLiterals[jsonLitFalseQ : jsonLitFalseQ+7])
 		}
 	} else {
-		for i := uint16(0); i < e.dl; i++ {
-			e.w.writestr(e.ds)
+		if b {
+			e.w.writeb(jsonLiterals[jsonLitTrue : jsonLitTrue+4])
+		} else {
+			e.w.writeb(jsonLiterals[jsonLitFalse : jsonLitFalse+5])
 		}
 	}
 }
 
-func (e *jsonEncDriver) EncodeNil() {
-	e.w.writeb(jsonLiterals[9:13]) // null
-}
+func (e *jsonEncDriverGeneric) EncodeFloat64(f float64) {
+	// instead of using 'g', specify whether to use 'e' or 'f'
+	fmt, prec := jsonFloatStrconvFmtPrec(f)
 
-func (e *jsonEncDriver) EncodeBool(b bool) {
-	if b {
-		e.w.writeb(jsonLiterals[0:4]) // true
+	var blen int
+	if e.ks && e.c == containerMapKey {
+		blen = 2 + len(strconv.AppendFloat(e.b[1:1], f, fmt, prec, 64))
+		e.b[0] = '"'
+		e.b[blen-1] = '"'
 	} else {
-		e.w.writeb(jsonLiterals[4:9]) // false
+		blen = len(strconv.AppendFloat(e.b[:0], f, fmt, prec, 64))
 	}
+	e.w.writeb(e.b[:blen])
 }
 
-func (e *jsonEncDriver) EncodeFloat32(f float32) {
-	e.w.writeb(strconv.AppendFloat(e.b[:0], float64(f), 'E', -1, 32))
-}
-
-func (e *jsonEncDriver) EncodeFloat64(f float64) {
-	// e.w.writestr(strconv.FormatFloat(f, 'E', -1, 64))
-	e.w.writeb(strconv.AppendFloat(e.b[:0], f, 'E', -1, 64))
-}
-
-func (e *jsonEncDriver) EncodeInt(v int64) {
-	if x := e.h.IntegerAsString; x == 'A' || x == 'L' && (v > 1<<53 || v < -(1<<53)) {
-		e.w.writen1('"')
-		e.w.writeb(strconv.AppendInt(e.b[:0], v, 10))
-		e.w.writen1('"')
+func (e *jsonEncDriverGeneric) EncodeInt(v int64) {
+	x := e.is
+	if x == 'A' || x == 'L' && (v > 1<<53 || v < -(1<<53)) || (e.ks && e.c == containerMapKey) {
+		blen := 2 + len(strconv.AppendInt(e.b[1:1], v, 10))
+		e.b[0] = '"'
+		e.b[blen-1] = '"'
+		e.w.writeb(e.b[:blen])
 		return
 	}
 	e.w.writeb(strconv.AppendInt(e.b[:0], v, 10))
 }
 
-func (e *jsonEncDriver) EncodeUint(v uint64) {
-	if x := e.h.IntegerAsString; x == 'A' || x == 'L' && v > 1<<53 {
-		e.w.writen1('"')
-		e.w.writeb(strconv.AppendUint(e.b[:0], v, 10))
-		e.w.writen1('"')
+func (e *jsonEncDriverGeneric) EncodeUint(v uint64) {
+	x := e.is
+	if x == 'A' || x == 'L' && v > 1<<53 || (e.ks && e.c == containerMapKey) {
+		blen := 2 + len(strconv.AppendUint(e.b[1:1], v, 10))
+		e.b[0] = '"'
+		e.b[blen-1] = '"'
+		e.w.writeb(e.b[:blen])
 		return
 	}
 	e.w.writeb(strconv.AppendUint(e.b[:0], v, 10))
 }
 
+func (e *jsonEncDriverGeneric) EncodeFloat32(f float32) {
+	// e.encodeFloat(float64(f), 32)
+	// always encode all floats as IEEE 64-bit floating point.
+	// It also ensures that we can decode in full precision even if into a float32,
+	// as what is written is always to float64 precision.
+	e.EncodeFloat64(float64(f))
+}
+
+func (e *jsonEncDriverGeneric) atEndOfEncode() {
+	if e.tw {
+		if e.d {
+			e.w.writen1('\n')
+		} else {
+			e.w.writen1(' ')
+		}
+	}
+}
+
+// --------------------
+
+type jsonEncDriver struct {
+	noBuiltInTypes
+	e  *Encoder
+	h  *JsonHandle
+	ew encWriter
+	se extWrapper
+	// ---- cpu cache line boundary?
+	bs []byte // scratch
+	// ---- cpu cache line boundary?
+	b [jsonScratchArrayLen]byte // scratch (encode time,
+	_ [2]uint64                 // padding
+}
+
+func (e *jsonEncDriver) EncodeNil() {
+	// We always encode nil as just null (never in quotes)
+	// This allows us to easily decode if a nil in the json stream
+	// ie if initial token is n.
+	e.ew.writeb(jsonLiterals[jsonLitNull : jsonLitNull+4])
+
+	// if e.h.MapKeyAsString && e.c == containerMapKey {
+	// 	e.ew.writeb(jsonLiterals[jsonLitNullQ : jsonLitNullQ+6])
+	// } else {
+	// 	e.ew.writeb(jsonLiterals[jsonLitNull : jsonLitNull+4])
+	// }
+}
+
+func (e *jsonEncDriver) EncodeTime(t time.Time) {
+	// Do NOT use MarshalJSON, as it allocates internally.
+	// instead, we call AppendFormat directly, using our scratch buffer (e.b)
+	if t.IsZero() {
+		e.EncodeNil()
+	} else {
+		e.b[0] = '"'
+		b := t.AppendFormat(e.b[1:1], time.RFC3339Nano)
+		e.b[len(b)+1] = '"'
+		e.ew.writeb(e.b[:len(b)+2])
+	}
+	// v, err := t.MarshalJSON(); if err != nil { e.e.error(err) } e.ew.writeb(v)
+}
+
 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.EncodeNil()
 	} else {
 		en.encode(v)
 	}
@@ -236,74 +452,61 @@ 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.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)
 }
 
 func (e *jsonEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
 	// if encoding raw bytes and RawBytesExt is configured, use it to encode
-	if c == c_RAW && e.se.i != nil {
-		e.EncodeExt(v, 0, &e.se, e.e)
+	if v == nil {
+		e.EncodeNil()
 		return
 	}
-	if c == c_RAW {
-		slen := base64.StdEncoding.EncodedLen(len(v))
-		if cap(e.bs) >= slen {
-			e.bs = e.bs[:slen]
-		} else {
-			e.bs = make([]byte, slen)
+	if c == cRAW {
+		if e.se.InterfaceExt != nil {
+			e.EncodeExt(v, 0, &e.se, e.e)
+			return
 		}
-		base64.StdEncoding.Encode(e.bs, v)
-		e.w.writen1('"')
-		e.w.writeb(e.bs)
-		e.w.writen1('"')
+
+		slen := base64.StdEncoding.EncodedLen(len(v))
+		if cap(e.bs) >= slen+2 {
+			e.bs = e.bs[:slen+2]
+		} else {
+			e.bs = make([]byte, slen+2)
+		}
+		e.bs[0] = '"'
+		base64.StdEncoding.Encode(e.bs[1:], v)
+		e.bs[slen+1] = '"'
+		e.ew.writeb(e.bs)
 	} else {
-		// e.EncodeString(c, string(v))
 		e.quoteStr(stringView(v))
 	}
 }
 
 func (e *jsonEncDriver) EncodeAsis(v []byte) {
-	e.w.writeb(v)
+	e.ew.writeb(v)
 }
 
 func (e *jsonEncDriver) quoteStr(s string) {
 	// adapted from std pkg encoding/json
 	const hex = "0123456789abcdef"
-	w := e.w
+	w := e.ew
+	htmlasis := e.h.HTMLCharsAsIs
 	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 (htmlasis && jsonCharSafeSet.isset(b)) || jsonCharHtmlSafeSet.isset(b) {
+			if jsonCharHtmlSafeSet.isset(b) || (htmlasis && jsonCharSafeSet.isset(b)) {
 				i++
 				continue
 			}
@@ -324,8 +527,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])
 			}
@@ -344,7 +545,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])
@@ -363,123 +564,32 @@ 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
-	}
-	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 {
 	noBuiltInTypes
-	d *Decoder
-	h *JsonHandle
-	r decReader
+	d  *Decoder
+	h  *JsonHandle
+	r  decReader
+	se extWrapper
+
+	// ---- writable fields during execution --- *try* to keep in sep cache line
 
 	c containerState
 	// tok is used to store the token read right after skipWhiteSpace.
-	tok uint8
+	tok   uint8
+	fnull bool    // found null from appendStringAsBytes
+	bs    []byte  // scratch. Initialized from b. Used for parsing strings or numbers.
+	bstr  [8]byte // scratch used for string \UXXX parsing
+	// ---- cpu cache line boundary?
+	b  [jsonScratchArrayLen]byte // scratch 1, used for parsing strings or numbers or time.Time
+	b2 [jsonScratchArrayLen]byte // scratch 2, used only for readUntil, decNumBytes
 
-	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)
-	bs   []byte   // scratch. Initialized from b. Used for parsing strings or numbers.
-
-	se setExtWrapper
-
-	n jsonNum
+	_ [3]uint64 // padding
+	// n jsonNum
 }
 
-func jsonIsWS(b byte) bool {
-	return b == ' ' || b == '\t' || b == '\r' || b == '\n'
-}
-
-// // 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 jsonIsWS(b byte) bool {
+// 	// return b == ' ' || b == '\t' || b == '\r' || b == '\n'
+// 	return jsonCharWhitespaceSet.isset(b)
 // }
 
 func (d *jsonDecDriver) uncacheRead() {
@@ -489,110 +599,13 @@ 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)
+	const xc uint8 = '{'
+	if d.tok != xc {
+		d.d.errorf("read map - expect char '%c' but got char '%c'", xc, d.tok)
 	}
 	d.tok = 0
 	d.c = containerMapStart
@@ -601,29 +614,169 @@ 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)
+	const xc uint8 = '['
+	if d.tok != xc {
+		d.d.errorf("read array - expect char '%c' but got char '%c'", xc, d.tok)
 	}
 	d.tok = 0
 	d.c = containerArrayStart
 	return -1
 }
 
+func (d *jsonDecDriver) CheckBreak() bool {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	return d.tok == '}' || d.tok == ']'
+}
+
+// For the ReadXXX methods below, we could just delegate to helper functions
+// readContainerState(c containerState, xc uint8, check bool)
+// - ReadArrayElem would become:
+//   readContainerState(containerArrayElem, ',', d.c != containerArrayStart)
+//
+// However, until mid-stack inlining comes in go1.11 which supports inlining of
+// one-liners, we explicitly write them all 5 out to elide the extra func call.
+//
+// TODO: For Go 1.11, if inlined, consider consolidating these.
+
+func (d *jsonDecDriver) ReadArrayElem() {
+	const xc uint8 = ','
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.c != containerArrayStart {
+		if d.tok != xc {
+			d.d.errorf("read array element - expect char '%c' but got char '%c'", xc, d.tok)
+		}
+		d.tok = 0
+	}
+	d.c = containerArrayElem
+}
+
+func (d *jsonDecDriver) ReadArrayEnd() {
+	const xc uint8 = ']'
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.tok != xc {
+		d.d.errorf("read array end - expect char '%c' but got char '%c'", xc, d.tok)
+	}
+	d.tok = 0
+	d.c = containerArrayEnd
+}
+
+func (d *jsonDecDriver) ReadMapElemKey() {
+	const xc uint8 = ','
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.c != containerMapStart {
+		if d.tok != xc {
+			d.d.errorf("read map key - expect char '%c' but got char '%c'", xc, d.tok)
+		}
+		d.tok = 0
+	}
+	d.c = containerMapKey
+}
+
+func (d *jsonDecDriver) ReadMapElemValue() {
+	const xc uint8 = ':'
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.tok != xc {
+		d.d.errorf("read map value - expect char '%c' but got char '%c'", xc, d.tok)
+	}
+	d.tok = 0
+	d.c = containerMapValue
+}
+
+func (d *jsonDecDriver) ReadMapEnd() {
+	const xc uint8 = '}'
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	if d.tok != xc {
+		d.d.errorf("read map end - expect char '%c' but got char '%c'", xc, d.tok)
+	}
+	d.tok = 0
+	d.c = containerMapEnd
+}
+
+func (d *jsonDecDriver) readLit(length, fromIdx uint8) {
+	bs := d.r.readx(int(length))
+	d.tok = 0
+	if jsonValidateSymbols && !bytes.Equal(bs, jsonLiterals[fromIdx:fromIdx+length]) {
+		d.d.errorf("expecting %s: got %s", jsonLiterals[fromIdx:fromIdx+length], bs)
+		return
+	}
+}
+
+func (d *jsonDecDriver) TryDecodeAsNil() bool {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	// we shouldn't try to see if "null" was here, right?
+	// only the plain string: `null` denotes a nil (ie not quotes)
+	if d.tok == 'n' {
+		d.readLit(3, jsonLitNull+1) // (n)ull
+		return true
+	}
+	return false
+}
+
+func (d *jsonDecDriver) DecodeBool() (v bool) {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	fquot := d.c == containerMapKey && d.tok == '"'
+	if fquot {
+		d.tok = d.r.readn1()
+	}
+	switch d.tok {
+	case 'f':
+		d.readLit(4, jsonLitFalse+1) // (f)alse
+		// v = false
+	case 't':
+		d.readLit(3, jsonLitTrue+1) // (t)rue
+		v = true
+	default:
+		d.d.errorf("decode bool: got first char %c", d.tok)
+		// v = false // "unreachable"
+	}
+	if fquot {
+		d.r.readn1()
+	}
+	return
+}
+
+func (d *jsonDecDriver) DecodeTime() (t time.Time) {
+	// read string, and pass the string into json.unmarshal
+	d.appendStringAsBytes()
+	if d.fnull {
+		return
+	}
+	t, err := time.Parse(time.RFC3339, stringView(d.bs))
+	if err != nil {
+		d.d.errorv(err)
+	}
+	return
+}
+
 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)
 	}
+
+	// optimize this, so we don't do 4 checks but do one computation.
+	// return jsonContainerSet[d.tok]
+
+	// ContainerType is mostly called for Map and Array,
+	// so this conditional is good enough (max 2 checks typically)
 	if b := d.tok; b == '{' {
 		return valueTypeMap
 	} else if b == '[' {
@@ -634,266 +787,100 @@ func (d *jsonDecDriver) ContainerType() (vt valueType) {
 		return valueTypeString
 	}
 	return valueTypeUnset
-	// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
-	// 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) DecodeUint64() (u uint64) {
+	bs := d.decNumBytes()
+	if len(bs) == 0 {
+		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()
+	n, neg, badsyntax, overflow := jsonParseInteger(bs)
+	if overflow {
+		d.d.errorf("overflow parsing unsigned integer: %s", bs)
+	} else if neg {
+		d.d.errorf("minus found parsing unsigned integer: %s", bs)
+	} else if badsyntax {
+		// fallback: try to decode as float, and cast
+		n = d.decUint64ViaFloat(stringView(bs))
 	}
+	return n
+}
 
-	if jsonTruncateMantissa && n.mantissa != 0 {
-		for n.mantissa%10 == 0 {
-			n.mantissa /= 10
-			n.exponent++
-		}
+func (d *jsonDecDriver) DecodeInt64() (i int64) {
+	const cutoff = uint64(1 << uint(64-1))
+	bs := d.decNumBytes()
+	if len(bs) == 0 {
+		return
 	}
-
-	if e != 0 {
-		if eNeg {
-			n.exponent -= e
+	n, neg, badsyntax, overflow := jsonParseInteger(bs)
+	if overflow {
+		d.d.errorf("overflow parsing integer: %s", bs)
+	} else if badsyntax {
+		// d.d.errorf("invalid syntax for integer: %s", bs)
+		// fallback: try to decode as float, and cast
+		if neg {
+			n = d.decUint64ViaFloat(stringView(bs[1:]))
 		} else {
-			n.exponent += e
+			n = d.decUint64ViaFloat(stringView(bs))
 		}
 	}
-
-	// d.n = n
-
-	if !eof {
-		if jsonUnreadAfterDecNum {
-			r.unreadn1()
-		} else {
-			if !jsonIsWS(b) {
-				d.tok = b
-			}
+	if neg {
+		if n > cutoff {
+			d.d.errorf("overflow parsing integer: %s", bs)
 		}
-	}
-	// 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)
-		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
+		i = -(int64(n))
+	} else {
+		if n >= cutoff {
+			d.d.errorf("overflow parsing integer: %s", bs)
 		}
+		i = int64(n)
 	}
 	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")
+func (d *jsonDecDriver) decUint64ViaFloat(s string) (u uint64) {
+	if len(s) == 0 {
 		return
 	}
-	if n.manOverflow {
-		d.d.errorf("json: overflow integer after: %v", n.mantissa)
-		return
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		d.d.errorf("invalid syntax for integer: %s", s)
+		// d.d.errorv(err)
 	}
-	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
-		}
+	fi, ff := math.Modf(f)
+	if ff > 0 {
+		d.d.errorf("fractional part found parsing integer: %s", s)
+	} else if fi > float64(math.MaxUint64) {
+		d.d.errorf("overflow parsing integer: %s", s)
 	}
-	if chkOvf.Uint(u, bitsize) {
-		d.d.errorf("json: overflow %v bits: %s", bitsize, d.bs)
-		return
-	}
-	// fmt.Printf("DecodeUint: %v\n", u)
-	return
+	return uint64(fi)
 }
 
-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)
+func (d *jsonDecDriver) DecodeFloat64() (f float64) {
+	bs := d.decNumBytes()
+	if len(bs) == 0 {
 		return
 	}
+	f, err := strconv.ParseFloat(stringView(bs), 64)
+	if err != nil {
+		d.d.errorv(err)
+	}
 	return
 }
 
@@ -910,18 +897,31 @@ 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.InterfaceExt != nil {
 		bsOut = bs
 		d.DecodeExt(&bsOut, 0, &d.se)
 		return
 	}
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	if d.tok == '[' {
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		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
+	// 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 {
+		if d.fnull {
+			return nil
+		}
+		return []byte{}
 	}
 	bs0 := d.bs
 	slen := base64.StdEncoding.DecodedLen(len(bs0))
@@ -934,7 +934,7 @@ func (d *jsonDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut [
 	}
 	slen2, err := base64.StdEncoding.Decode(bsOut, bs0)
 	if err != nil {
-		d.d.errorf("json: error decoding base64 binary '%s': %v", bs0, err)
+		d.d.errorf("error decoding base64 binary '%s': %v", bs0, err)
 		return nil
 	}
 	if slen != slen2 {
@@ -945,164 +945,270 @@ func (d *jsonDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut [
 
 func (d *jsonDecDriver) DecodeString() (s string) {
 	d.appendStringAsBytes()
+	return d.bsToString()
+}
+
+func (d *jsonDecDriver) DecodeStringAsBytes() (s []byte) {
+	d.appendStringAsBytes()
+	return d.bs
+}
+
+func (d *jsonDecDriver) appendStringAsBytes() {
+	if d.tok == 0 {
+		d.tok = d.r.skip(&jsonCharWhitespaceSet)
+	}
+
+	d.fnull = false
+	if d.tok != '"' {
+		// d.d.errorf("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.readLit(3, jsonLitNull+1) // (n)ull
+			d.bs = d.bs[:0]
+			d.fnull = true
+		case 'f':
+			d.readLit(4, jsonLitFalse+1) // (f)alse
+			d.bs = d.bs[:5]
+			copy(d.bs, "false")
+		case 't':
+			d.readLit(3, jsonLitTrue+1) // (t)rue
+			d.bs = d.bs[:4]
+			copy(d.bs, "true")
+		default:
+			// try to parse a valid number
+			bs := d.decNumBytes()
+			if len(bs) <= cap(d.bs) {
+				d.bs = d.bs[:len(bs)]
+			} else {
+				d.bs = make([]byte, len(bs))
+			}
+			copy(d.bs, bs)
+		}
+		return
+	}
+
+	d.tok = 0
+	r := d.r
+	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
+			if len(cs) < i+4 { // may help reduce bounds-checking
+				d.d.errorf("need at least 4 more bytes for unicode sequence")
+			}
+			// c = cs[i+4] // may help reduce bounds-checking
+			for j := 1; j < 5; j++ {
+				// best to use explicit if-else
+				// - not a table, etc which involve memory loads, array lookup with bounds checks, etc
+				c = cs[i+j]
+				if c >= '0' && c <= '9' {
+					rr = rr*16 + uint32(c-jsonU4Chk2)
+				} else if c >= 'a' && c <= 'f' {
+					rr = rr*16 + uint32(c-jsonU4Chk1)
+				} else if c >= 'A' && c <= 'F' {
+					rr = rr*16 + uint32(c-jsonU4Chk0)
+				} else {
+					r = unicode.ReplacementChar
+					i += 4
+					goto encode_rune
+				}
+			}
+			r = rune(rr)
+			i += 4
+			if utf16.IsSurrogate(r) {
+				if len(cs) >= i+6 && cs[i+2] == 'u' && cs[i+1] == '\\' {
+					i += 2
+					// c = cs[i+4] // may help reduce bounds-checking
+					var rr1 uint32
+					for j := 1; j < 5; j++ {
+						c = cs[i+j]
+						if c >= '0' && c <= '9' {
+							rr = rr*16 + uint32(c-jsonU4Chk2)
+						} else if c >= 'a' && c <= 'f' {
+							rr = rr*16 + uint32(c-jsonU4Chk1)
+						} else if c >= 'A' && c <= 'F' {
+							rr = rr*16 + uint32(c-jsonU4Chk0)
+						} else {
+							r = unicode.ReplacementChar
+							i += 4
+							goto encode_rune
+						}
+					}
+					r = utf16.DecodeRune(r, rune(rr1))
+					i += 4
+				} else {
+					r = unicode.ReplacementChar
+					goto encode_rune
+				}
+			}
+		encode_rune:
+			w2 := utf8.EncodeRune(d.bstr[:], r)
+			v = append(v, d.bstr[:w2]...)
+		default:
+			d.d.errorf("unsupported escaped value: %c", c)
+		}
+		i++
+		cursor = i
+	}
+	d.bs = v
+}
+
+func (d *jsonDecDriver) nakedNum(z *decNaked, bs []byte) (err error) {
+	const cutoff = uint64(1 << uint(64-1))
+
+	var n uint64
+	var neg, badsyntax, overflow bool
+
+	if len(bs) == 0 {
+		if d.h.PreferFloat {
+			z.v = valueTypeFloat
+			z.f = 0
+		} else if d.h.SignedInteger {
+			z.v = valueTypeInt
+			z.i = 0
+		} else {
+			z.v = valueTypeUint
+			z.u = 0
+		}
+		return
+	}
+	if d.h.PreferFloat {
+		goto F
+	}
+	n, neg, badsyntax, overflow = jsonParseInteger(bs)
+	if badsyntax || overflow {
+		goto F
+	}
+	if neg {
+		if n > cutoff {
+			goto F
+		}
+		z.v = valueTypeInt
+		z.i = -(int64(n))
+	} else if d.h.SignedInteger {
+		if n >= cutoff {
+			goto F
+		}
+		z.v = valueTypeInt
+		z.i = int64(n)
+	} else {
+		z.v = valueTypeUint
+		z.u = n
+	}
+	return
+F:
+	z.v = valueTypeFloat
+	z.f, err = strconv.ParseFloat(stringView(bs), 64)
+	return
+}
+
+func (d *jsonDecDriver) bsToString() string {
 	// 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) appendStringAsBytes() {
-	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.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)
-		}
-	}
-	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) 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.readLit(3, jsonLitNull+1) // (n)ull
 		z.v = valueTypeNil
 	case 'f':
-		d.readStrIdx(5, 9) // alse
+		d.readLit(4, jsonLitFalse+1) // (f)alse
 		z.v = valueTypeBool
 		z.b = false
 	case 't':
-		d.readStrIdx(1, 4) // rue
+		d.readLit(3, jsonLitTrue+1) // (t)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:
-			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)
+		// if a string, and MapKeyAsString, then try to decode it as a nil, bool or number first
+		d.appendStringAsBytes()
+		if len(d.bs) > 0 && d.c == containerMapKey && d.h.MapKeyAsString {
+			switch stringView(d.bs) {
+			case "null":
+				z.v = valueTypeNil
+			case "true":
+				z.v = valueTypeBool
+				z.b = true
+			case "false":
+				z.v = valueTypeBool
+				z.b = false
 			default:
-				z.v = valueTypeUint
-				z.u = u
-			}
-		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
+				// check if a number: float, int or uint
+				if err := d.nakedNum(z, d.bs); err != nil {
+					z.v = valueTypeString
+					z.s = d.bsToString()
+				}
 			}
+		} else {
+			z.v = valueTypeString
+			z.s = d.bsToString()
+		}
+	default: // number
+		bs := d.decNumBytes()
+		if len(bs) == 0 {
+			d.d.errorf("decode number from empty string")
+			return
+		}
+		if err := d.nakedNum(z, bs); err != nil {
+			d.d.errorf("decode number from %s: %v", bs, err)
+			return
 		}
-		// fmt.Printf("DecodeNaked: Number: %T, %v\n", v, v)
 	}
 	// if decodeFurther {
 	// 	d.s.sc.retryRead()
@@ -1116,24 +1222,26 @@ func (d *jsonDecDriver) DecodeNaked() {
 //
 // Json is comprehensively supported:
 //    - decodes numbers into interface{} as int, uint or float64
+//      based on how the number looks and some config parameters e.g. PreferFloat, SignedInt, etc.
+//    - decode integers from float formatted numbers e.g. 1.27e+8
+//    - decode any json value (numbers, bool, etc) from quoted strings
 //    - configurable way to encode/decode []byte .
 //      by default, encodes and decodes []byte using base64 Std Encoding
 //    - UTF-8 support for encoding and decoding
 //
 // It has better performance than the json library in the standard library,
-// by leveraging the performance improvements of the codec library and
-// minimizing allocations.
+// by leveraging the performance improvements of the codec library.
 //
 // In addition, it doesn't read more bytes than necessary during a decode, which allows
 // reading multiple values from a stream containing json and non-json content.
 // For example, a user can read a json value, then a cbor value, then a msgpack value,
 // all from the same stream in sequence.
+//
+// Note that, when decoding quoted strings, invalid UTF-8 or invalid UTF-16 surrogate pairs are
+// not treated as an error. Instead, they are replaced by the Unicode replacement character U+FFFD.
 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
 
 	// Indent indicates how a value is encoded.
 	//   - If positive, indent by that number of spaces.
@@ -1151,63 +1259,193 @@ type JsonHandle struct {
 	//   - if 'A', then encode all integers as a json string
 	//             containing the exact integer representation as a decimal.
 	//   - else    encode all integers as a json number (default)
-	IntegerAsString uint8
+	IntegerAsString byte
+
+	// 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
+
+	// MapKeyAsString says to encode all map keys as strings.
+	//
+	// Use this to enforce strict json output.
+	// The only caveat is that nil value is ALWAYS written as null (never as "null")
+	MapKeyAsString bool
+
+	// _ [2]byte // padding
+
+	// Note: below, we store hardly-used items e.g. RawBytesExt is cached in the (en|de)cDriver.
+
+	// 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
+
+	_ [2]uint64 // padding
 }
 
+// Name returns the name of the handle: json
+func (h *JsonHandle) Name() string            { return "json" }
+func (h *JsonHandle) hasElemSeparators() bool { return true }
+func (h *JsonHandle) typical() bool {
+	return h.Indent == 0 && !h.MapKeyAsString && h.IntegerAsString != 'A' && h.IntegerAsString != 'L'
+}
+
+type jsonTypical interface {
+	typical()
+}
+
+func (h *JsonHandle) recreateEncDriver(ed encDriver) (v bool) {
+	_, v = ed.(jsonTypical)
+	return v != h.typical()
+}
+
+// SetInterfaceExt sets an extension
 func (h *JsonHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
-	return h.SetExt(rt, tag, &setExtWrapper{i: ext})
+	return h.SetExt(rt, tag, &extWrapper{bytesExtFailer{}, ext})
 }
 
-func (h *JsonHandle) newEncDriver(e *Encoder) encDriver {
-	hd := jsonEncDriver{e: e, h: h}
-	hd.bs = hd.b[:0]
+type jsonEncDriverTypicalImpl struct {
+	jsonEncDriver
+	jsonEncDriverTypical
+	_ [3]uint64 // padding
+}
 
-	hd.reset()
+func (x *jsonEncDriverTypicalImpl) reset() {
+	x.jsonEncDriver.reset()
+	x.jsonEncDriverTypical.reset(&x.jsonEncDriver)
+}
 
-	return &hd
+type jsonEncDriverGenericImpl struct {
+	jsonEncDriver
+	jsonEncDriverGeneric
+	_ [2]uint64 // padding
+}
+
+func (x *jsonEncDriverGenericImpl) reset() {
+	x.jsonEncDriver.reset()
+	x.jsonEncDriverGeneric.reset(&x.jsonEncDriver)
+}
+
+func (h *JsonHandle) newEncDriver(e *Encoder) (ee encDriver) {
+	var hd *jsonEncDriver
+	if h.typical() {
+		var v jsonEncDriverTypicalImpl
+		ee = &v
+		hd = &v.jsonEncDriver
+	} else {
+		var v jsonEncDriverGenericImpl
+		ee = &v
+		hd = &v.jsonEncDriver
+	}
+	hd.e, hd.h, hd.bs = e, h, hd.b[:0]
+	hd.se.BytesExt = bytesExtFailer{}
+	ee.reset()
+	return
 }
 
 func (h *JsonHandle) newDecDriver(d *Decoder) decDriver {
 	// d := jsonDecDriver{r: r.(*bytesDecReader), h: h}
 	hd := jsonDecDriver{d: d, h: h}
+	hd.se.BytesExt = bytesExtFailer{}
 	hd.bs = hd.b[:0]
 	hd.reset()
 	return &hd
 }
 
 func (e *jsonEncDriver) reset() {
-	e.w = e.e.w
-	e.se.i = e.h.RawBytesExt
+	e.ew = e.e.w
+	e.se.InterfaceExt = e.h.RawBytesExt
 	if e.bs != nil {
 		e.bs = e.bs[:0]
 	}
-	e.d, e.dt, e.dl, e.ds = false, false, 0, ""
-	e.c = 0
-	if e.h.Indent > 0 {
-		e.d = true
-		e.ds = jsonSpaces[:e.h.Indent]
-	} else if e.h.Indent < 0 {
-		e.d = true
-		e.dt = true
-		e.ds = jsonTabs[:-(e.h.Indent)]
-	}
 }
 
 func (d *jsonDecDriver) reset() {
 	d.r = d.d.r
-	d.se.i = d.h.RawBytesExt
+	d.se.InterfaceExt = d.h.RawBytesExt
 	if d.bs != nil {
 		d.bs = d.bs[:0]
 	}
 	d.c, d.tok = 0, 0
-	d.n.reset()
+	// d.n.reset()
 }
 
-var jsonEncodeTerminate = []byte{' '}
+func jsonFloatStrconvFmtPrec(f float64) (fmt byte, prec int) {
+	prec = -1
+	var abs = math.Abs(f)
+	if abs != 0 && (abs < 1e-6 || abs >= 1e21) {
+		fmt = 'e'
+	} else {
+		fmt = 'f'
+		// set prec to 1 iff mod is 0.
+		//     better than using jsonIsFloatBytesB2 to check if a . or E in the float bytes.
+		// this ensures that every float has an e or .0 in it.
+		if abs <= 1 {
+			if abs == 0 || abs == 1 {
+				prec = 1
+			}
+		} else if _, mod := math.Modf(abs); mod == 0 {
+			prec = 1
+		}
+	}
+	return
+}
 
-func (h *JsonHandle) rpcEncodeTerminate() []byte {
-	return jsonEncodeTerminate
+// custom-fitted version of strconv.Parse(Ui|I)nt.
+// Also ensures we don't have to search for .eE to determine if a float or not.
+// Note: s CANNOT be a zero-length slice.
+func jsonParseInteger(s []byte) (n uint64, neg, badSyntax, overflow bool) {
+	const maxUint64 = (1<<64 - 1)
+	const cutoff = maxUint64/10 + 1
+
+	// if len(s) == 0 {
+	// 	// treat empty string as zero value
+	// 	// badSyntax = true
+	// 	return
+	// }
+	switch s[0] {
+	case '+':
+		s = s[1:]
+	case '-':
+		s = s[1:]
+		neg = true
+	}
+	for _, c := range s {
+		if c < '0' || c > '9' {
+			badSyntax = true
+			return
+		}
+		// unsigned integers don't overflow well on multiplication, so check cutoff here
+		// e.g. (maxUint64-5)*10 doesn't overflow well ...
+		if n >= cutoff {
+			overflow = true
+			return
+		}
+		n *= 10
+		n1 := n + uint64(c-'0')
+		if n1 < n || n1 > maxUint64 {
+			overflow = true
+			return
+		}
+		n = n1
+	}
+	return
 }
 
 var _ decDriver = (*jsonDecDriver)(nil)
-var _ encDriver = (*jsonEncDriver)(nil)
+var _ encDriver = (*jsonEncDriverGenericImpl)(nil)
+var _ encDriver = (*jsonEncDriverTypicalImpl)(nil)
+var _ jsonTypical = (*jsonEncDriverTypical)(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 000000000..90d758ce4
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl
@@ -0,0 +1,154 @@
+// 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.
+
+// Code generated from mammoth-test.go.tmpl - DO NOT EDIT.
+
+package codec
+
+import "testing"
+import "fmt"
+import "reflect"
+
+// 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.
+
+func init() { _ = fmt.Printf } // so we can include fmt as needed
+
+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}}
+
+}
+
+{{range .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
+*/}} type {{ .MethodNamePfx "typMbs" false }} []{{ .Elem }}
+func (_ {{ .MethodNamePfx "typMbs" false }}) MapBySlice() { }
+{{end}}{{end}}{{end}}
+
+{{range .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
+*/}} type {{ .MethodNamePfx "typMap" false }} map[{{ .MapKey }}]{{ .Elem }}
+{{end}}{{end}}{{end}}
+
+func doTestMammothSlices(t *testing.T, h Handle) {
+{{range $i, $e := .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
+*/}}
+    var v{{$i}}va [8]{{ .Elem }}
+    for _, v := range [][]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .Elem }}, {{ zerocmd .Elem }}, {{ zerocmd .Elem }}, {{ nonzerocmd .Elem }} } } { {{/*
+    // fmt.Printf(">>>> running mammoth slice v{{$i}}: %v\n", v)
+    //   - encode value to some []byte
+    //   - decode into a length-wise-equal []byte
+    //   - check if equal to initial slice
+    //   - encode ptr to the value
+    //   - check if encode bytes are same
+    //   - decode into ptrs to: nil, then 1-elem slice, equal-length, then large len slice
+    //   - decode into non-addressable slice of equal length, then larger len 
+    //   - for each decode, compare elem-by-elem to the original slice
+    //   - 
+    //   - rinse and repeat for a MapBySlice version
+    //   - 
+    */}}
+    var v{{$i}}v1, v{{$i}}v2 []{{ .Elem }}
+	v{{$i}}v1 = v
+	bs{{$i}} := testMarshalErr(v{{$i}}v1, h, t, "enc-slice-v{{$i}}")
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
+	testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}")
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
+	testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-slice-v{{$i}}-noaddr") // non-addressable value
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-noaddr")
+	// ...
+	bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-slice-v{{$i}}-p")
+	v{{$i}}v2 = nil
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p")
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	v{{$i}}v2 = v{{$i}}va[:1:1]
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-1")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-1")
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	v{{$i}}v2 = v{{$i}}va[:len(v{{$i}}v1):len(v{{$i}}v1)]
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-len")
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	v{{$i}}v2 = v{{$i}}va[:]
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-cap")
+	if len(v{{$i}}v1) > 1 {
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	testUnmarshalErr((&v{{$i}}va)[:len(v{{$i}}v1)], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len-noaddr")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-len-noaddr")
+	v{{$i}}va = [8]{{ .Elem }}{} // clear the array
+	testUnmarshalErr((&v{{$i}}va)[:], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap-noaddr")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-cap-noaddr")
+    }
+    // ...
+    var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMbs" false }}
+	v{{$i}}v2 = nil
+    if v != nil { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
+    v{{$i}}v3 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v1)
+    v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2)
+    bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom")
+    testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom")
+    testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom")
+    bs{{$i}} = testMarshalErr(&v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom-p")
+    v{{$i}}v2 = nil
+    v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2)
+    testUnmarshalErr(&v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom-p")
+    testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom-p")
+    }
+{{end}}{{end}}{{end}}
+}
+
+func doTestMammothMaps(t *testing.T, h Handle) {
+{{range $i, $e := .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
+*/}}
+    for _, v := range []map[{{ .MapKey }}]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .MapKey }}:{{ zerocmd .Elem }} {{if ne "bool" .MapKey}}, {{ nonzerocmd .MapKey }}:{{ nonzerocmd .Elem }} {{end}} } } {
+    // fmt.Printf(">>>> running mammoth map v{{$i}}: %v\n", v)
+    var v{{$i}}v1, v{{$i}}v2 map[{{ .MapKey }}]{{ .Elem }}
+	v{{$i}}v1 = v
+	bs{{$i}} := testMarshalErr(v{{$i}}v1, h, t, "enc-map-v{{$i}}")
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
+	testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}")
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
+	testUnmarshalErr(reflect.ValueOf(v{{$i}}v2), bs{{$i}}, h, t, "dec-map-v{{$i}}-noaddr") // decode into non-addressable map value
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-noaddr")
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-len")
+	bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-map-v{{$i}}-p")
+	v{{$i}}v2 = nil
+	testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-nil")
+	testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-nil")
+    // ...
+	if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
+    var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMap" false }}
+	v{{$i}}v3 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v1)
+	v{{$i}}v4 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v2)
+    bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-map-v{{$i}}-custom")
+	testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len")
+	testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-map-v{{$i}}-p-len")
+    }
+{{end}}{{end}}{{end}}
+
+}
+
+func doTestMammothMapsAndSlices(t *testing.T, h Handle) {
+     doTestMammothSlices(t, h)
+     doTestMammothMaps(t, h)
+}
diff --git a/vendor/github.com/ugorji/go/codec/mammoth2-test.go.tmpl b/vendor/github.com/ugorji/go/codec/mammoth2-test.go.tmpl
new file mode 100644
index 000000000..7cdf8f5d7
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/mammoth2-test.go.tmpl
@@ -0,0 +1,94 @@
+// +build !notfastpath
+
+// 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.
+
+// Code generated from mammoth2-test.go.tmpl - DO NOT EDIT.
+
+package codec
+
+// Increase codecoverage by covering all the codecgen paths, in fast-path and gen-helper.go....
+//
+// Add:
+// - test file for creating a mammoth generated file as _mammoth_generated.go
+//   - generate a second mammoth files in a different file: mammoth2_generated_test.go
+//     - mammoth-test.go.tmpl will do this
+//   - run codecgen on it, into mammoth2_codecgen_generated_test.go (no build tags)
+//   - as part of TestMammoth, run it also
+//   - this will cover all the codecgen, gen-helper, etc in one full run
+//   - check in mammoth* files into github also
+// - then
+//
+// Now, add some types:
+//  - some that implement BinaryMarshal, TextMarshal, JSONMarshal, and one that implements none of it
+//  - create a wrapper type that includes TestMammoth2, with it in slices, and maps, and the custom types
+//  - this wrapper object is what we work encode/decode (so that the codecgen methods are called)
+
+
+// import "encoding/binary"
+import "fmt"
+
+type TestMammoth2 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}}
+
+}
+
+// -----------
+
+type testMammoth2Binary uint64
+func (x testMammoth2Binary) MarshalBinary() (data []byte, err error) {
+data = make([]byte, 8)
+bigen.PutUint64(data, uint64(x))
+return
+}
+func (x *testMammoth2Binary) UnmarshalBinary(data []byte) (err error) {
+*x = testMammoth2Binary(bigen.Uint64(data))
+return
+}
+
+type testMammoth2Text uint64
+func (x testMammoth2Text) MarshalText() (data []byte, err error) {
+data = []byte(fmt.Sprintf("%b", uint64(x)))
+return
+}
+func (x *testMammoth2Text) UnmarshalText(data []byte) (err error) {
+_, err = fmt.Sscanf(string(data), "%b", (*uint64)(x))
+return
+}
+
+type testMammoth2Json uint64
+func (x testMammoth2Json) MarshalJSON() (data []byte, err error) {
+data = []byte(fmt.Sprintf("%v", uint64(x)))
+return
+}
+func (x *testMammoth2Json) UnmarshalJSON(data []byte) (err error) {
+_, err = fmt.Sscanf(string(data), "%v", (*uint64)(x))
+return
+}
+
+type testMammoth2Basic [4]uint64
+
+type TestMammoth2Wrapper struct {
+  V TestMammoth2
+  T testMammoth2Text
+  B testMammoth2Binary
+  J testMammoth2Json
+  C testMammoth2Basic
+  M map[testMammoth2Basic]TestMammoth2
+  L []TestMammoth2
+  A [4]int64
+}
diff --git a/vendor/github.com/ugorji/go/codec/msgpack.go b/vendor/github.com/ugorji/go/codec/msgpack.go
index f9f872362..b716d1487 100644
--- a/vendor/github.com/ugorji/go/codec/msgpack.go
+++ b/vendor/github.com/ugorji/go/codec/msgpack.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 /*
@@ -15,8 +15,8 @@ For compatibility with behaviour of msgpack-c reference implementation:
   - Go intX (<0)
        IS ENCODED AS
     msgpack -ve fixnum, signed
-
 */
+
 package codec
 
 import (
@@ -25,6 +25,7 @@ import (
 	"math"
 	"net/rpc"
 	"reflect"
+	"time"
 )
 
 const (
@@ -78,6 +79,89 @@ const (
 	mpNegFixNumMax = 0xff
 )
 
+var mpTimeExtTag int8 = -1
+var mpTimeExtTagU = uint8(mpTimeExtTag)
+
+// var mpdesc = map[byte]string{
+// 	mpPosFixNumMin: "PosFixNumMin",
+// 	mpPosFixNumMax: "PosFixNumMax",
+// 	mpFixMapMin:    "FixMapMin",
+// 	mpFixMapMax:    "FixMapMax",
+// 	mpFixArrayMin:  "FixArrayMin",
+// 	mpFixArrayMax:  "FixArrayMax",
+// 	mpFixStrMin:    "FixStrMin",
+// 	mpFixStrMax:    "FixStrMax",
+// 	mpNil:          "Nil",
+// 	mpFalse:        "False",
+// 	mpTrue:         "True",
+// 	mpFloat:        "Float",
+// 	mpDouble:       "Double",
+// 	mpUint8:        "Uint8",
+// 	mpUint16:       "Uint16",
+// 	mpUint32:       "Uint32",
+// 	mpUint64:       "Uint64",
+// 	mpInt8:         "Int8",
+// 	mpInt16:        "Int16",
+// 	mpInt32:        "Int32",
+// 	mpInt64:        "Int64",
+// 	mpBin8:         "Bin8",
+// 	mpBin16:        "Bin16",
+// 	mpBin32:        "Bin32",
+// 	mpExt8:         "Ext8",
+// 	mpExt16:        "Ext16",
+// 	mpExt32:        "Ext32",
+// 	mpFixExt1:      "FixExt1",
+// 	mpFixExt2:      "FixExt2",
+// 	mpFixExt4:      "FixExt4",
+// 	mpFixExt8:      "FixExt8",
+// 	mpFixExt16:     "FixExt16",
+// 	mpStr8:         "Str8",
+// 	mpStr16:        "Str16",
+// 	mpStr32:        "Str32",
+// 	mpArray16:      "Array16",
+// 	mpArray32:      "Array32",
+// 	mpMap16:        "Map16",
+// 	mpMap32:        "Map32",
+// 	mpNegFixNumMin: "NegFixNumMin",
+// 	mpNegFixNumMax: "NegFixNumMax",
+// }
+
+func mpdesc(bd byte) string {
+	switch bd {
+	case mpNil:
+		return "nil"
+	case mpFalse:
+		return "false"
+	case mpTrue:
+		return "true"
+	case mpFloat, mpDouble:
+		return "float"
+	case mpUint8, mpUint16, mpUint32, mpUint64:
+		return "uint"
+	case mpInt8, mpInt16, mpInt32, mpInt64:
+		return "int"
+	default:
+		switch {
+		case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax:
+			return "int"
+		case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax:
+			return "int"
+		case bd == mpStr8, bd == mpStr16, bd == mpStr32, bd >= mpFixStrMin && bd <= mpFixStrMax:
+			return "string|bytes"
+		case bd == mpBin8, bd == mpBin16, bd == mpBin32:
+			return "bytes"
+		case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax:
+			return "array"
+		case bd == mpMap16, bd == mpMap32, bd >= mpFixMapMin && bd <= mpFixMapMax:
+			return "map"
+		case bd >= mpFixExt1 && bd <= mpFixExt16, bd >= mpExt8 && bd <= mpExt32:
+			return "ext"
+		default:
+			return "unknown"
+		}
+	}
+}
+
 // MsgpackSpecRpcMultiArgs is a special type which signifies to the MsgpackSpecRpcCodec
 // that the backend RPC service takes multiple arguments, which have been arranged
 // in sequence in the slice.
@@ -94,21 +178,31 @@ type msgpackContainerType struct {
 }
 
 var (
-	msgpackContainerStr  = msgpackContainerType{32, mpFixStrMin, mpStr8, mpStr16, mpStr32, true, true, false}
-	msgpackContainerBin  = msgpackContainerType{0, 0, mpBin8, mpBin16, mpBin32, false, true, true}
-	msgpackContainerList = msgpackContainerType{16, mpFixArrayMin, 0, mpArray16, mpArray32, true, false, false}
-	msgpackContainerMap  = msgpackContainerType{16, mpFixMapMin, 0, mpMap16, mpMap32, true, false, false}
+	msgpackContainerStr = msgpackContainerType{
+		32, mpFixStrMin, mpStr8, mpStr16, mpStr32, true, true, false,
+	}
+	msgpackContainerBin = msgpackContainerType{
+		0, 0, mpBin8, mpBin16, mpBin32, false, true, true,
+	}
+	msgpackContainerList = msgpackContainerType{
+		16, mpFixArrayMin, 0, mpArray16, mpArray32, true, false, false,
+	}
+	msgpackContainerMap = msgpackContainerType{
+		16, mpFixMapMin, 0, mpMap16, mpMap32, true, false, false,
+	}
 )
 
 //---------------------------------------------
 
 type msgpackEncDriver struct {
 	noBuiltInTypes
-	encNoSeparator
+	encDriverNoopContainerWriter
+	// encNoSeparator
 	e *Encoder
 	w encWriter
 	h *MsgpackHandle
 	x [8]byte
+	// _ [3]uint64 // padding
 }
 
 func (e *msgpackEncDriver) EncodeNil() {
@@ -116,10 +210,25 @@ func (e *msgpackEncDriver) EncodeNil() {
 }
 
 func (e *msgpackEncDriver) EncodeInt(i int64) {
-	if i >= 0 {
+	if e.h.PositiveIntUnsigned && i >= 0 {
 		e.EncodeUint(uint64(i))
+	} else if i > math.MaxInt8 {
+		if i <= math.MaxInt16 {
+			e.w.writen1(mpInt16)
+			bigenHelper{e.x[:2], e.w}.writeUint16(uint16(i))
+		} else if i <= math.MaxInt32 {
+			e.w.writen1(mpInt32)
+			bigenHelper{e.x[:4], e.w}.writeUint32(uint32(i))
+		} else {
+			e.w.writen1(mpInt64)
+			bigenHelper{e.x[:8], e.w}.writeUint64(uint64(i))
+		}
 	} else if i >= -32 {
-		e.w.writen1(byte(i))
+		if e.h.NoFixedNum {
+			e.w.writen2(mpInt8, byte(i))
+		} else {
+			e.w.writen1(byte(i))
+		}
 	} else if i >= math.MinInt8 {
 		e.w.writen2(mpInt8, byte(i))
 	} else if i >= math.MinInt16 {
@@ -136,7 +245,11 @@ func (e *msgpackEncDriver) EncodeInt(i int64) {
 
 func (e *msgpackEncDriver) EncodeUint(i uint64) {
 	if i <= math.MaxInt8 {
-		e.w.writen1(byte(i))
+		if e.h.NoFixedNum {
+			e.w.writen2(mpUint8, byte(i))
+		} else {
+			e.w.writen1(byte(i))
+		}
 	} else if i <= math.MaxUint8 {
 		e.w.writen2(mpUint8, byte(i))
 	} else if i <= math.MaxUint16 {
@@ -169,6 +282,39 @@ func (e *msgpackEncDriver) EncodeFloat64(f float64) {
 	bigenHelper{e.x[:8], e.w}.writeUint64(math.Float64bits(f))
 }
 
+func (e *msgpackEncDriver) EncodeTime(t time.Time) {
+	if t.IsZero() {
+		e.EncodeNil()
+		return
+	}
+	t = t.UTC()
+	sec, nsec := t.Unix(), uint64(t.Nanosecond())
+	var data64 uint64
+	var l = 4
+	if sec >= 0 && sec>>34 == 0 {
+		data64 = (nsec << 34) | uint64(sec)
+		if data64&0xffffffff00000000 != 0 {
+			l = 8
+		}
+	} else {
+		l = 12
+	}
+	if e.h.WriteExt {
+		e.encodeExtPreamble(mpTimeExtTagU, l)
+	} else {
+		e.writeContainerLen(msgpackContainerStr, l)
+	}
+	switch l {
+	case 4:
+		bigenHelper{e.x[:4], e.w}.writeUint32(uint32(data64))
+	case 8:
+		bigenHelper{e.x[:8], e.w}.writeUint64(data64)
+	case 12:
+		bigenHelper{e.x[:4], e.w}.writeUint32(uint32(nsec))
+		bigenHelper{e.x[:8], e.w}.writeUint64(uint64(sec))
+	}
+}
+
 func (e *msgpackEncDriver) EncodeExt(v interface{}, xtag uint64, ext Ext, _ *Encoder) {
 	bs := ext.WriteExt(v)
 	if bs == nil {
@@ -179,7 +325,7 @@ func (e *msgpackEncDriver) EncodeExt(v interface{}, xtag uint64, ext Ext, _ *Enc
 		e.encodeExtPreamble(uint8(xtag), len(bs))
 		e.w.writeb(bs)
 	} else {
-		e.EncodeStringBytes(c_RAW, bs)
+		e.EncodeStringBytes(cRAW, bs)
 	}
 }
 
@@ -213,36 +359,38 @@ 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) {
-	if c == c_RAW && e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerBin, len(s))
+	slen := len(s)
+	if c == cRAW && e.h.WriteExt {
+		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)
 	}
 }
 
-func (e *msgpackEncDriver) EncodeSymbol(v string) {
-	e.EncodeString(c_UTF8, v)
-}
-
 func (e *msgpackEncDriver) EncodeStringBytes(c charEncoding, bs []byte) {
-	if c == c_RAW && e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerBin, len(bs))
-	} else {
-		e.writeContainerLen(msgpackContainerStr, len(bs))
+	if bs == nil {
+		e.EncodeNil()
+		return
 	}
-	if len(bs) > 0 {
+	slen := len(bs)
+	if c == cRAW && e.h.WriteExt {
+		e.writeContainerLen(msgpackContainerBin, slen)
+	} else {
+		e.writeContainerLen(msgpackContainerStr, slen)
+	}
+	if slen > 0 {
 		e.w.writeb(bs)
 	}
 }
@@ -264,16 +412,18 @@ func (e *msgpackEncDriver) writeContainerLen(ct msgpackContainerType, l int) {
 //---------------------------------------------
 
 type msgpackDecDriver struct {
-	d      *Decoder
-	r      decReader // *Decoder decReader decReaderT
-	h      *MsgpackHandle
-	b      [scratchByteArrayLen]byte
+	d *Decoder
+	r decReader
+	h *MsgpackHandle
+	// b      [scratchByteArrayLen]byte
 	bd     byte
 	bdRead bool
 	br     bool // bytes reader
 	noBuiltInTypes
-	noStreamingCodec
-	decNoSeparator
+	// noStreamingCodec
+	// decNoSeparator
+	decDriverNoopContainerReader
+	// _ [3]uint64 // padding
 }
 
 // Note: This returns either a primitive (int, bool, etc) for non-containers,
@@ -286,7 +436,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 +499,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
@@ -364,9 +514,14 @@ func (d *msgpackDecDriver) DecodeNaked() {
 			n.v = valueTypeExt
 			clen := d.readExtLen()
 			n.u = uint64(d.r.readn1())
-			n.l = d.r.readx(clen)
+			if n.u == uint64(mpTimeExtTagU) {
+				n.v = valueTypeTime
+				n.t = d.decodeTime(clen)
+			} else {
+				n.l = d.r.readx(clen)
+			}
 		default:
-			d.d.errorf("Nil-Deciphered DecodeValue: %s: hex: %x, dec: %d", msgBadDesc, bd, bd)
+			d.d.errorf("cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd))
 		}
 	}
 	if !decodeFurther {
@@ -380,7 +535,7 @@ func (d *msgpackDecDriver) DecodeNaked() {
 }
 
 // int can be decoded from msgpack type: intXXX or uintXXX
-func (d *msgpackDecDriver) DecodeInt(bitsize uint8) (i int64) {
+func (d *msgpackDecDriver) DecodeInt64() (i int64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -408,14 +563,7 @@ func (d *msgpackDecDriver) DecodeInt(bitsize uint8) (i int64) {
 		case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
 			i = int64(int8(d.bd))
 		default:
-			d.d.errorf("Unhandled single-byte unsigned integer value: %s: %x", msgBadDesc, d.bd)
-			return
-		}
-	}
-	// check overflow (logic adapted from std pkg reflect/value.go OverflowUint()
-	if bitsize > 0 {
-		if trunc := (i << (64 - bitsize)) >> (64 - bitsize); i != trunc {
-			d.d.errorf("Overflow int value: %v", i)
+			d.d.errorf("cannot decode signed integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
 			return
 		}
 	}
@@ -424,7 +572,7 @@ func (d *msgpackDecDriver) DecodeInt(bitsize uint8) (i int64) {
 }
 
 // uint can be decoded from msgpack type: intXXX or uintXXX
-func (d *msgpackDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
+func (d *msgpackDecDriver) DecodeUint64() (ui uint64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -441,28 +589,28 @@ func (d *msgpackDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
 		if i := int64(int8(d.r.readn1())); i >= 0 {
 			ui = uint64(i)
 		} else {
-			d.d.errorf("Assigning negative signed value: %v, to unsigned type", i)
+			d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
 			return
 		}
 	case mpInt16:
 		if i := int64(int16(bigen.Uint16(d.r.readx(2)))); i >= 0 {
 			ui = uint64(i)
 		} else {
-			d.d.errorf("Assigning negative signed value: %v, to unsigned type", i)
+			d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
 			return
 		}
 	case mpInt32:
 		if i := int64(int32(bigen.Uint32(d.r.readx(4)))); i >= 0 {
 			ui = uint64(i)
 		} else {
-			d.d.errorf("Assigning negative signed value: %v, to unsigned type", i)
+			d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
 			return
 		}
 	case mpInt64:
 		if i := int64(bigen.Uint64(d.r.readx(8))); i >= 0 {
 			ui = uint64(i)
 		} else {
-			d.d.errorf("Assigning negative signed value: %v, to unsigned type", i)
+			d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
 			return
 		}
 	default:
@@ -470,17 +618,10 @@ func (d *msgpackDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
 		case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax:
 			ui = uint64(d.bd)
 		case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
-			d.d.errorf("Assigning negative signed value: %v, to unsigned type", int(d.bd))
+			d.d.errorf("assigning negative signed value: %v, to unsigned type", int(d.bd))
 			return
 		default:
-			d.d.errorf("Unhandled single-byte unsigned integer value: %s: %x", msgBadDesc, d.bd)
-			return
-		}
-	}
-	// check overflow (logic adapted from std pkg reflect/value.go OverflowUint()
-	if bitsize > 0 {
-		if trunc := (ui << (64 - bitsize)) >> (64 - bitsize); ui != trunc {
-			d.d.errorf("Overflow uint value: %v", ui)
+			d.d.errorf("cannot decode unsigned integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
 			return
 		}
 	}
@@ -489,7 +630,7 @@ func (d *msgpackDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
 }
 
 // float can either be decoded from msgpack type: float, double or intX
-func (d *msgpackDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+func (d *msgpackDecDriver) DecodeFloat64() (f float64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -498,11 +639,7 @@ func (d *msgpackDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
 	} else if d.bd == mpDouble {
 		f = math.Float64frombits(bigen.Uint64(d.r.readx(8)))
 	} else {
-		f = float64(d.DecodeInt(0))
-	}
-	if chkOverflow32 && chkOvf.Float32(f) {
-		d.d.errorf("msgpack: float32 overflow: %v", f)
-		return
+		f = float64(d.DecodeInt64())
 	}
 	d.bdRead = false
 	return
@@ -518,25 +655,45 @@ func (d *msgpackDecDriver) DecodeBool() (b bool) {
 	} else if d.bd == mpTrue || d.bd == 1 {
 		b = true
 	} else {
-		d.d.errorf("Invalid single-byte value for bool: %s: %x", msgBadDesc, d.bd)
+		d.d.errorf("cannot decode bool: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
 		return
 	}
 	d.bdRead = false
 	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()
 	}
+
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	bd := d.bd
+	// 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 == mpBin8 || bd == mpBin16 || bd == mpBin32 {
+			clen = d.readContainerLen(msgpackContainerBin)
+		} else {
+			clen = d.readContainerLen(msgpackContainerStr)
+		}
+	case valueTypeString:
 		clen = d.readContainerLen(msgpackContainerStr)
+	case valueTypeArray:
+		if zerocopy && len(bs) == 0 {
+			bs = d.d.b[:]
+		}
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		return
+	default:
+		d.d.errorf("invalid container type: expecting bin|str|array, got: 0x%x", uint8(vt))
+		return
 	}
-	// println("DecodeBytes: clen: ", clen)
+
+	// these are (bin|str)(8|16|32)
 	d.bdRead = false
 	// bytes may be nil, so handle it. if nil, clen=-1.
 	if clen < 0 {
@@ -546,14 +703,18 @@ func (d *msgpackDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOu
 		if d.br {
 			return d.r.readx(clen)
 		} else if len(bs) == 0 {
-			bs = d.b[:]
+			bs = d.d.b[:]
 		}
 	}
-	return decByteSlice(d.r, clen, bs)
+	return decByteSlice(d.r, clen, d.h.MaxInitLen, bs)
 }
 
 func (d *msgpackDecDriver) DecodeString() (s string) {
-	return string(d.DecodeBytes(d.b[:], true, true))
+	return string(d.DecodeBytes(d.d.b[:], true))
+}
+
+func (d *msgpackDecDriver) DecodeStringAsBytes() (s []byte) {
+	return d.DecodeBytes(d.d.b[:], true)
 }
 
 func (d *msgpackDecDriver) readNextBd() {
@@ -561,7 +722,17 @@ func (d *msgpackDecDriver) readNextBd() {
 	d.bdRead = true
 }
 
+func (d *msgpackDecDriver) uncacheRead() {
+	if d.bdRead {
+		d.r.unreadn1()
+		d.bdRead = false
+	}
+}
+
 func (d *msgpackDecDriver) ContainerType() (vt valueType) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	bd := d.bd
 	if bd == mpNil {
 		return valueTypeNil
@@ -576,9 +747,10 @@ func (d *msgpackDecDriver) ContainerType() (vt valueType) {
 		return valueTypeArray
 	} else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) {
 		return valueTypeMap
-	} else {
-		// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
 	}
+	// else {
+	// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+	// }
 	return valueTypeUnset
 }
 
@@ -588,7 +760,7 @@ func (d *msgpackDecDriver) TryDecodeAsNil() (v bool) {
 	}
 	if d.bd == mpNil {
 		d.bdRead = false
-		v = true
+		return true
 	}
 	return
 }
@@ -606,7 +778,7 @@ func (d *msgpackDecDriver) readContainerLen(ct msgpackContainerType) (clen int)
 	} else if (ct.bFixMin & bd) == ct.bFixMin {
 		clen = int(ct.bFixMin ^ bd)
 	} else {
-		d.d.errorf("readContainerLen: %s: hex: %x, decimal: %d", msgBadDesc, bd, bd)
+		d.d.errorf("cannot read container length: %s: hex: %x, decimal: %d", msgBadDesc, bd, bd)
 		return
 	}
 	d.bdRead = false
@@ -614,10 +786,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)
 }
 
@@ -648,9 +826,60 @@ func (d *msgpackDecDriver) readExtLen() (clen int) {
 	return
 }
 
+func (d *msgpackDecDriver) DecodeTime() (t time.Time) {
+	// decode time from string bytes or ext
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.bd == mpNil {
+		d.bdRead = false
+		return
+	}
+	var clen int
+	switch d.ContainerType() {
+	case valueTypeBytes, valueTypeString:
+		clen = d.readContainerLen(msgpackContainerStr)
+	default:
+		// expect to see mpFixExt4,-1 OR mpFixExt8,-1 OR mpExt8,12,-1
+		d.bdRead = false
+		b2 := d.r.readn1()
+		if d.bd == mpFixExt4 && b2 == mpTimeExtTagU {
+			clen = 4
+		} else if d.bd == mpFixExt8 && b2 == mpTimeExtTagU {
+			clen = 8
+		} else if d.bd == mpExt8 && b2 == 12 && d.r.readn1() == mpTimeExtTagU {
+			clen = 12
+		} else {
+			d.d.errorf("invalid bytes for decoding time as extension: got 0x%x, 0x%x", d.bd, b2)
+			return
+		}
+	}
+	return d.decodeTime(clen)
+}
+
+func (d *msgpackDecDriver) decodeTime(clen int) (t time.Time) {
+	// bs = d.r.readx(clen)
+	d.bdRead = false
+	switch clen {
+	case 4:
+		t = time.Unix(int64(bigen.Uint32(d.r.readx(4))), 0).UTC()
+	case 8:
+		tv := bigen.Uint64(d.r.readx(8))
+		t = time.Unix(int64(tv&0x00000003ffffffff), int64(tv>>34)).UTC()
+	case 12:
+		nsec := bigen.Uint32(d.r.readx(4))
+		sec := bigen.Uint64(d.r.readx(8))
+		t = time.Unix(int64(sec), int64(nsec)).UTC()
+	default:
+		d.d.errorf("invalid length of bytes for decoding time - expecting 4 or 8 or 12, got %d", clen)
+		return
+	}
+	return
+}
+
 func (d *msgpackDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
 	if xtag > 0xff {
-		d.d.errorf("decodeExt: tag must be <= 0xff; got: %v", xtag)
+		d.d.errorf("ext: tag must be <= 0xff; got: %v", xtag)
 		return
 	}
 	realxtag1, xbs := d.decodeExtV(ext != nil, uint8(xtag))
@@ -671,15 +900,15 @@ 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()
 		if verifyTag && xtag != tag {
-			d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", xtag, tag)
+			d.d.errorf("wrong extension tag - got %b, expecting %v", xtag, tag)
 			return
 		}
 		xbs = d.r.readx(clen)
@@ -697,6 +926,9 @@ type MsgpackHandle struct {
 	// RawToString controls how raw bytes are decoded into a nil interface{}.
 	RawToString bool
 
+	// NoFixedNum says to output all signed integers as 2-bytes, never as 1-byte fixednum.
+	NoFixedNum bool
+
 	// WriteExt flag supports encoding configured extensions with extension tags.
 	// It also controls whether other elements of the new spec are encoded (ie Str8).
 	//
@@ -708,11 +940,22 @@ type MsgpackHandle struct {
 	// type is provided (e.g. decoding into a nil interface{}), you get back
 	// a []byte or string based on the setting of RawToString.
 	WriteExt bool
+
+	// PositiveIntUnsigned says to encode positive integers as unsigned.
+	PositiveIntUnsigned bool
+
 	binaryEncodingType
+	noElemSeparators
+
+	// _ [1]uint64 // padding
 }
 
+// Name returns the name of the handle: msgpack
+func (h *MsgpackHandle) Name() string { return "msgpack" }
+
+// SetBytesExt sets an extension
 func (h *MsgpackHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
-	return h.SetExt(rt, tag, &setExtWrapper{b: ext})
+	return h.SetExt(rt, tag, &extWrapper{ext, interfaceExtFailer{}})
 }
 
 func (h *MsgpackHandle) newEncDriver(e *Encoder) encDriver {
@@ -720,7 +963,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() {
@@ -728,7 +971,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
 }
 
@@ -750,7 +993,7 @@ func (c *msgpackSpecRpcCodec) WriteRequest(r *rpc.Request, body interface{}) err
 		bodyArr = []interface{}{body}
 	}
 	r2 := []interface{}{0, uint32(r.Seq), r.ServiceMethod, bodyArr}
-	return c.write(r2, nil, false, true)
+	return c.write(r2, nil, false)
 }
 
 func (c *msgpackSpecRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error {
@@ -762,7 +1005,7 @@ func (c *msgpackSpecRpcCodec) WriteResponse(r *rpc.Response, body interface{}) e
 		body = nil
 	}
 	r2 := []interface{}{1, uint32(r.Seq), moe, body}
-	return c.write(r2, nil, false, true)
+	return c.write(r2, nil, false)
 }
 
 func (c *msgpackSpecRpcCodec) ReadResponseHeader(r *rpc.Response) error {
@@ -782,7 +1025,6 @@ func (c *msgpackSpecRpcCodec) ReadRequestBody(body interface{}) error {
 }
 
 func (c *msgpackSpecRpcCodec) parseCustomHeader(expectTypeByte byte, msgid *uint64, methodOrError *string) (err error) {
-
 	if c.isClosed() {
 		return io.EOF
 	}
@@ -796,28 +1038,34 @@ func (c *msgpackSpecRpcCodec) parseCustomHeader(expectTypeByte byte, msgid *uint
 	// 	err = fmt.Errorf("Unexpected value for array descriptor: Expecting %v. Received %v", fia, bs1)
 	// 	return
 	// }
-	var b byte
-	b, err = c.br.ReadByte()
-	if err != nil {
-		return
-	}
-	if b != fia {
-		err = fmt.Errorf("Unexpected value for array descriptor: Expecting %v. Received %v", fia, b)
-		return
+	var ba [1]byte
+	var n int
+	for {
+		n, err = c.r.Read(ba[:])
+		if err != nil {
+			return
+		}
+		if n == 1 {
+			break
+		}
 	}
 
-	if err = c.read(&b); err != nil {
-		return
-	}
-	if b != expectTypeByte {
-		err = fmt.Errorf("Unexpected byte descriptor in header. Expecting %v. Received %v", expectTypeByte, b)
-		return
-	}
-	if err = c.read(msgid); err != nil {
-		return
-	}
-	if err = c.read(methodOrError); err != nil {
-		return
+	var b = ba[0]
+	if b != fia {
+		err = fmt.Errorf("not array - %s %x/%s", msgBadDesc, b, mpdesc(b))
+	} else {
+		err = c.read(&b)
+		if err == nil {
+			if b != expectTypeByte {
+				err = fmt.Errorf("%s - expecting %v but got %x/%s",
+					msgBadDesc, expectTypeByte, b, mpdesc(b))
+			} else {
+				err = c.read(msgid)
+				if err == nil {
+					err = c.read(methodOrError)
+				}
+			}
+		}
 	}
 	return
 }
@@ -830,7 +1078,8 @@ type msgpackSpecRpc struct{}
 
 // MsgpackSpecRpc implements Rpc using the communication protocol defined in
 // the msgpack spec at https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md .
-// Its methods (ServerCodec and ClientCodec) return values that implement RpcCodecBuffered.
+//
+// See GoRpc documentation, for information on buffering for better performance.
 var MsgpackSpecRpc msgpackSpecRpc
 
 func (x msgpackSpecRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
diff --git a/vendor/github.com/ugorji/go/codec/noop.go b/vendor/github.com/ugorji/go/codec/noop.go
deleted file mode 100644
index cfee3d084..000000000
--- a/vendor/github.com/ugorji/go/codec/noop.go
+++ /dev/null
@@ -1,213 +0,0 @@
-// 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 (
-	"math/rand"
-	"time"
-)
-
-// NoopHandle returns a no-op handle. It basically does nothing.
-// It is only useful for benchmarking, as it gives an idea of the
-// overhead from the codec framework.
-//
-// LIBRARY USERS: *** DO NOT USE ***
-func NoopHandle(slen int) *noopHandle {
-	h := noopHandle{}
-	h.rand = rand.New(rand.NewSource(time.Now().UnixNano()))
-	h.B = make([][]byte, slen)
-	h.S = make([]string, slen)
-	for i := 0; i < len(h.S); i++ {
-		b := make([]byte, i+1)
-		for j := 0; j < len(b); j++ {
-			b[j] = 'a' + byte(i)
-		}
-		h.B[i] = b
-		h.S[i] = string(b)
-	}
-	return &h
-}
-
-// noopHandle does nothing.
-// It is used to simulate the overhead of the codec framework.
-type noopHandle struct {
-	BasicHandle
-	binaryEncodingType
-	noopDrv // noopDrv is unexported here, so we can get a copy of it when needed.
-}
-
-type noopDrv struct {
-	d    *Decoder
-	e    *Encoder
-	i    int
-	S    []string
-	B    [][]byte
-	mks  []bool    // stack. if map (true), else if array (false)
-	mk   bool      // top of stack. what container are we on? map or array?
-	ct   valueType // last response for IsContainerType.
-	cb   int       // counter for ContainerType
-	rand *rand.Rand
-}
-
-func (h *noopDrv) r(v int) int { return h.rand.Intn(v) }
-func (h *noopDrv) m(v int) int { h.i++; return h.i % v }
-
-func (h *noopDrv) newEncDriver(e *Encoder) encDriver { h.e = e; return h }
-func (h *noopDrv) newDecDriver(d *Decoder) decDriver { h.d = d; return h }
-
-func (h *noopDrv) reset()       {}
-func (h *noopDrv) uncacheRead() {}
-
-// --- encDriver
-
-// stack functions (for map and array)
-func (h *noopDrv) start(b bool) {
-	// println("start", len(h.mks)+1)
-	h.mks = append(h.mks, b)
-	h.mk = b
-}
-func (h *noopDrv) end() {
-	// println("end: ", len(h.mks)-1)
-	h.mks = h.mks[:len(h.mks)-1]
-	if len(h.mks) > 0 {
-		h.mk = h.mks[len(h.mks)-1]
-	} else {
-		h.mk = false
-	}
-}
-
-func (h *noopDrv) EncodeBuiltin(rt uintptr, v interface{}) {}
-func (h *noopDrv) EncodeNil()                              {}
-func (h *noopDrv) EncodeInt(i int64)                       {}
-func (h *noopDrv) EncodeUint(i uint64)                     {}
-func (h *noopDrv) EncodeBool(b bool)                       {}
-func (h *noopDrv) EncodeFloat32(f float32)                 {}
-func (h *noopDrv) EncodeFloat64(f float64)                 {}
-func (h *noopDrv) EncodeRawExt(re *RawExt, e *Encoder)     {}
-func (h *noopDrv) EncodeArrayStart(length int)             { h.start(true) }
-func (h *noopDrv) EncodeMapStart(length int)               { h.start(false) }
-func (h *noopDrv) EncodeEnd()                              { h.end() }
-
-func (h *noopDrv) EncodeString(c charEncoding, v string)      {}
-func (h *noopDrv) EncodeSymbol(v string)                      {}
-func (h *noopDrv) EncodeStringBytes(c charEncoding, v []byte) {}
-
-func (h *noopDrv) EncodeExt(rv interface{}, xtag uint64, ext Ext, e *Encoder) {}
-
-// ---- decDriver
-func (h *noopDrv) initReadNext()                              {}
-func (h *noopDrv) CheckBreak() bool                           { return false }
-func (h *noopDrv) IsBuiltinType(rt uintptr) bool              { return false }
-func (h *noopDrv) DecodeBuiltin(rt uintptr, v interface{})    {}
-func (h *noopDrv) DecodeInt(bitsize uint8) (i int64)          { return int64(h.m(15)) }
-func (h *noopDrv) DecodeUint(bitsize uint8) (ui uint64)       { return uint64(h.m(35)) }
-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(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) ReadEnd() { h.end() }
-
-// toggle map/slice
-func (h *noopDrv) ReadMapStart() int   { h.start(true); return h.m(10) }
-func (h *noopDrv) ReadArrayStart() int { h.start(false); return h.m(10) }
-
-func (h *noopDrv) ContainerType() (vt valueType) {
-	// return h.m(2) == 0
-	// handle kStruct, which will bomb is it calls this and doesn't get back a map or array.
-	// consequently, if the return value is not map or array, reset it to one of them based on h.m(7) % 2
-	// for kstruct: at least one out of every 2 times, return one of valueTypeMap or Array (else kstruct bombs)
-	// however, every 10th time it is called, we just return something else.
-	var vals = [...]valueType{valueTypeArray, valueTypeMap}
-	//  ------------ TAKE ------------
-	// if h.cb%2 == 0 {
-	// 	if h.ct == valueTypeMap || h.ct == valueTypeArray {
-	// 	} else {
-	// 		h.ct = vals[h.m(2)]
-	// 	}
-	// } else if h.cb%5 == 0 {
-	// 	h.ct = valueType(h.m(8))
-	// } else {
-	// 	h.ct = vals[h.m(2)]
-	// }
-	//  ------------ TAKE ------------
-	// if h.cb%16 == 0 {
-	// 	h.ct = valueType(h.cb % 8)
-	// } else {
-	// 	h.ct = vals[h.cb%2]
-	// }
-	h.ct = vals[h.cb%2]
-	h.cb++
-	return h.ct
-
-	// if h.ct == valueTypeNil || h.ct == valueTypeString || h.ct == valueTypeBytes {
-	// 	return h.ct
-	// }
-	// return valueTypeUnset
-	// TODO: may need to tweak this so it works.
-	// if h.ct == valueTypeMap && vt == valueTypeArray || h.ct == valueTypeArray && vt == valueTypeMap {
-	// 	h.cb = !h.cb
-	// 	h.ct = vt
-	// 	return h.cb
-	// }
-	// // go in a loop and check it.
-	// h.ct = vt
-	// h.cb = h.m(7) == 0
-	// return h.cb
-}
-func (h *noopDrv) TryDecodeAsNil() bool {
-	if h.mk {
-		return false
-	} else {
-		return h.m(8) == 0
-	}
-}
-func (h *noopDrv) DecodeExt(rv interface{}, xtag uint64, ext Ext) uint64 {
-	return 0
-}
-
-func (h *noopDrv) DecodeNaked() {
-	// use h.r (random) not h.m() because h.m() could cause the same value to be given.
-	var sk int
-	if h.mk {
-		// if mapkey, do not support values of nil OR bytes, array, map or rawext
-		sk = h.r(7) + 1
-	} else {
-		sk = h.r(12)
-	}
-	n := &h.d.n
-	switch sk {
-	case 0:
-		n.v = valueTypeNil
-	case 1:
-		n.v, n.b = valueTypeBool, false
-	case 2:
-		n.v, n.b = valueTypeBool, true
-	case 3:
-		n.v, n.i = valueTypeInt, h.DecodeInt(64)
-	case 4:
-		n.v, n.u = valueTypeUint, h.DecodeUint(64)
-	case 5:
-		n.v, n.f = valueTypeFloat, h.DecodeFloat(true)
-	case 6:
-		n.v, n.f = valueTypeFloat, h.DecodeFloat(false)
-	case 7:
-		n.v, n.s = valueTypeString, h.DecodeString()
-	case 8:
-		n.v, n.l = valueTypeBytes, h.B[h.m(len(h.B))]
-	case 9:
-		n.v = valueTypeArray
-	case 10:
-		n.v = valueTypeMap
-	default:
-		n.v = valueTypeExt
-		n.u = h.DecodeUint(64)
-		n.l = h.B[h.m(len(h.B))]
-	}
-	h.ct = n.v
-	return
-}
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 2353263e8..000000000
--- 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 100644
index 909f4bb0f..000000000
--- 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 dad53d0c6..9fb3c0149 100644
--- a/vendor/github.com/ugorji/go/codec/rpc.go
+++ b/vendor/github.com/ugorji/go/codec/rpc.go
@@ -1,127 +1,152 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 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
-}
-
 // Rpc provides a rpc Server or Client Codec for rpc communication.
 type Rpc interface {
 	ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec
 	ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec
 }
 
-// RpcCodecBuffered allows access to the underlying bufio.Reader/Writer
-// used by the rpc connection. It accomodates use-cases where the connection
-// should be used by rpc and non-rpc functions, e.g. streaming a file after
-// sending an rpc response.
-type RpcCodecBuffered interface {
-	BufferedReader() *bufio.Reader
-	BufferedWriter() *bufio.Writer
+// RPCOptions holds options specific to rpc functionality
+type RPCOptions struct {
+	// RPCNoBuffer configures whether we attempt to buffer reads and writes during RPC calls.
+	//
+	// Set RPCNoBuffer=true to turn buffering off.
+	// Buffering can still be done if buffered connections are passed in, or
+	// buffering is configured on the handle.
+	RPCNoBuffer bool
 }
 
-// -------------------------------------
-
 // rpcCodec defines the struct members and common methods.
 type rpcCodec struct {
-	rwc io.ReadWriteCloser
+	c io.Closer
+	r io.Reader
+	w io.Writer
+	f ioFlusher
+
 	dec *Decoder
 	enc *Encoder
-	bw  *bufio.Writer
-	br  *bufio.Reader
-	mu  sync.Mutex
-	h   Handle
+	// bw  *bufio.Writer
+	// br  *bufio.Reader
+	mu sync.Mutex
+	h  Handle
 
-	cls   bool
-	clsmu sync.RWMutex
+	cls    bool
+	clsmu  sync.RWMutex
+	clsErr error
 }
 
 func newRPCCodec(conn io.ReadWriteCloser, h Handle) rpcCodec {
-	bw := bufio.NewWriter(conn)
-	br := bufio.NewReader(conn)
+	// return newRPCCodec2(bufio.NewReader(conn), bufio.NewWriter(conn), conn, h)
+	return newRPCCodec2(conn, conn, conn, h)
+}
+
+func newRPCCodec2(r io.Reader, w io.Writer, c io.Closer, h Handle) rpcCodec {
+	// 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"))
+	}
+	// always ensure that we use a flusher, and always flush what was written to the connection.
+	// we lose nothing by using a buffered writer internally.
+	f, ok := w.(ioFlusher)
+	bh := h.getBasicHandle()
+	if !bh.RPCNoBuffer {
+		if bh.WriterBufferSize <= 0 {
+			if !ok {
+				bw := bufio.NewWriter(w)
+				f, w = bw, bw
+			}
+		}
+		if bh.ReaderBufferSize <= 0 {
+			if _, ok = w.(ioPeeker); !ok {
+				if _, ok = w.(ioBuffered); !ok {
+					br := bufio.NewReader(r)
+					r = br
+				}
+			}
+		}
+	}
 	return rpcCodec{
-		rwc: conn,
-		bw:  bw,
-		br:  br,
-		enc: NewEncoder(bw, h),
-		dec: NewDecoder(br, h),
+		c:   c,
+		w:   w,
+		r:   r,
+		f:   f,
 		h:   h,
+		enc: NewEncoder(w, h),
+		dec: NewDecoder(r, h),
 	}
 }
 
-func (c *rpcCodec) BufferedReader() *bufio.Reader {
-	return c.br
-}
-
-func (c *rpcCodec) BufferedWriter() *bufio.Writer {
-	return c.bw
-}
-
-func (c *rpcCodec) write(obj1, obj2 interface{}, writeObj2, doFlush bool) (err error) {
+func (c *rpcCodec) write(obj1, obj2 interface{}, writeObj2 bool) (err error) {
 	if c.isClosed() {
-		return io.EOF
+		return c.clsErr
 	}
-	if err = c.enc.Encode(obj1); err != nil {
-		return
-	}
-	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())
+	err = c.enc.Encode(obj1)
+	if err == nil {
+		if writeObj2 {
+			err = c.enc.Encode(obj2)
 		}
+		// if err == nil && c.f != nil {
+		// 	err = c.f.Flush()
+		// }
 	}
-	if doFlush {
-		return c.bw.Flush()
+	if c.f != nil {
+		if err == nil {
+			err = c.f.Flush()
+		} else {
+			_ = c.f.Flush() // swallow flush error, so we maintain prior error on write
+		}
 	}
 	return
 }
 
+func (c *rpcCodec) swallow(err *error) {
+	defer panicToErr(c.dec, err)
+	c.dec.swallow()
+}
+
 func (c *rpcCodec) read(obj interface{}) (err error) {
 	if c.isClosed() {
-		return io.EOF
+		return c.clsErr
 	}
-	//If nil is passed in, we should still attempt to read content to nowhere.
+	//If nil is passed in, we should read and discard
 	if obj == nil {
-		var obj2 interface{}
-		return c.dec.Decode(&obj2)
+		// var obj2 interface{}
+		// return c.dec.Decode(&obj2)
+		c.swallow(&err)
+		return
 	}
 	return c.dec.Decode(obj)
 }
 
-func (c *rpcCodec) isClosed() bool {
-	c.clsmu.RLock()
-	x := c.cls
-	c.clsmu.RUnlock()
-	return x
+func (c *rpcCodec) isClosed() (b bool) {
+	if c.c != nil {
+		c.clsmu.RLock()
+		b = c.cls
+		c.clsmu.RUnlock()
+	}
+	return
 }
 
 func (c *rpcCodec) Close() error {
-	if c.isClosed() {
-		return io.EOF
+	if c.c == nil || c.isClosed() {
+		return c.clsErr
 	}
 	c.clsmu.Lock()
 	c.cls = true
+	c.clsErr = c.c.Close()
 	c.clsmu.Unlock()
-	return c.rwc.Close()
+	return c.clsErr
 }
 
 func (c *rpcCodec) ReadResponseBody(body interface{}) error {
@@ -138,13 +163,13 @@ func (c *goRpcCodec) WriteRequest(r *rpc.Request, body interface{}) error {
 	// Must protect for concurrent access as per API
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	return c.write(r, body, true, true)
+	return c.write(r, body, true)
 }
 
 func (c *goRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error {
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	return c.write(r, body, true, true)
+	return c.write(r, body, true)
 }
 
 func (c *goRpcCodec) ReadResponseHeader(r *rpc.Response) error {
@@ -166,7 +191,36 @@ func (c *goRpcCodec) ReadRequestBody(body interface{}) error {
 type goRpc struct{}
 
 // GoRpc implements Rpc using the communication protocol defined in net/rpc package.
-// Its methods (ServerCodec and ClientCodec) return values that implement RpcCodecBuffered.
+//
+// Note: network connection (from net.Dial, of type io.ReadWriteCloser) is not buffered.
+//
+// For performance, you should configure WriterBufferSize and ReaderBufferSize on the handle.
+// This ensures we use an adequate buffer during reading and writing.
+// If not configured, we will internally initialize and use a buffer during reads and writes.
+// This can be turned off via the RPCNoBuffer option on the Handle.
+//   var handle codec.JsonHandle
+//   handle.RPCNoBuffer = true // turns off attempt by rpc module to initialize a buffer
+//
+// Example 1: one way of configuring buffering explicitly:
+//   var handle codec.JsonHandle // codec handle
+//   handle.ReaderBufferSize = 1024
+//   handle.WriterBufferSize = 1024
+//   var conn io.ReadWriteCloser // connection got from a socket
+//   var serverCodec = GoRpc.ServerCodec(conn, handle)
+//   var clientCodec = GoRpc.ClientCodec(conn, handle)
+//
+// Example 2: you can also explicitly create a buffered connection yourself,
+// and not worry about configuring the buffer sizes in the Handle.
+//   var handle codec.Handle     // codec handle
+//   var conn io.ReadWriteCloser // connection got from a socket
+//   var bufconn = struct {      // bufconn here is a buffered io.ReadWriteCloser
+//       io.Closer
+//       *bufio.Reader
+//       *bufio.Writer
+//   }{conn, bufio.NewReader(conn), bufio.NewWriter(conn)}
+//   var serverCodec = GoRpc.ServerCodec(bufconn, handle)
+//   var clientCodec = GoRpc.ClientCodec(bufconn, handle)
+//
 var GoRpc goRpc
 
 func (x goRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
@@ -176,5 +230,3 @@ func (x goRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
 func (x goRpc) ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec {
 	return &goRpcCodec{newRPCCodec(conn, h)}
 }
-
-var _ RpcCodecBuffered = (*rpcCodec)(nil) // ensure *rpcCodec implements RpcCodecBuffered
diff --git a/vendor/github.com/ugorji/go/codec/simple.go b/vendor/github.com/ugorji/go/codec/simple.go
index 7c0ba7aff..6a81ca416 100644
--- a/vendor/github.com/ugorji/go/codec/simple.go
+++ b/vendor/github.com/ugorji/go/codec/simple.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
+// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
 
 package codec
@@ -6,6 +6,7 @@ package codec
 import (
 	"math"
 	"reflect"
+	"time"
 )
 
 const (
@@ -20,6 +21,8 @@ const (
 	simpleVdPosInt = 8
 	simpleVdNegInt = 12
 
+	simpleVdTime = 24
+
 	// containers: each lasts for 4 (ie n, n+1, n+2, ... n+7)
 	simpleVdString    = 216
 	simpleVdByteArray = 224
@@ -30,11 +33,15 @@ const (
 
 type simpleEncDriver struct {
 	noBuiltInTypes
-	encNoSeparator
+	// encNoSeparator
 	e *Encoder
 	h *SimpleHandle
 	w encWriter
 	b [8]byte
+	// c containerState
+	encDriverTrackContainerWriter
+	// encDriverNoopContainerWriter
+	_ [3]uint64 // padding
 }
 
 func (e *simpleEncDriver) EncodeNil() {
@@ -42,6 +49,10 @@ func (e *simpleEncDriver) EncodeNil() {
 }
 
 func (e *simpleEncDriver) EncodeBool(b bool) {
+	if e.h.EncZeroValuesAsNil && e.c != containerMapKey && !b {
+		e.EncodeNil()
+		return
+	}
 	if b {
 		e.w.writen1(simpleVdTrue)
 	} else {
@@ -50,11 +61,19 @@ func (e *simpleEncDriver) EncodeBool(b bool) {
 }
 
 func (e *simpleEncDriver) EncodeFloat32(f float32) {
+	if e.h.EncZeroValuesAsNil && e.c != containerMapKey && f == 0.0 {
+		e.EncodeNil()
+		return
+	}
 	e.w.writen1(simpleVdFloat32)
 	bigenHelper{e.b[:4], e.w}.writeUint32(math.Float32bits(f))
 }
 
 func (e *simpleEncDriver) EncodeFloat64(f float64) {
+	if e.h.EncZeroValuesAsNil && e.c != containerMapKey && f == 0.0 {
+		e.EncodeNil()
+		return
+	}
 	e.w.writen1(simpleVdFloat64)
 	bigenHelper{e.b[:8], e.w}.writeUint64(math.Float64bits(f))
 }
@@ -72,6 +91,10 @@ func (e *simpleEncDriver) EncodeUint(v uint64) {
 }
 
 func (e *simpleEncDriver) encUint(v uint64, bd uint8) {
+	if e.h.EncZeroValuesAsNil && e.c != containerMapKey && v == 0 {
+		e.EncodeNil()
+		return
+	}
 	if v <= math.MaxUint8 {
 		e.w.writen2(bd, uint8(v))
 	} else if v <= math.MaxUint16 {
@@ -124,28 +147,55 @@ 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.c = containerArrayStart
 	e.encLen(simpleVdArray, length)
 }
 
-func (e *simpleEncDriver) EncodeMapStart(length int) {
+func (e *simpleEncDriver) WriteMapStart(length int) {
+	e.c = containerMapStart
 	e.encLen(simpleVdMap, length)
 }
 
 func (e *simpleEncDriver) EncodeString(c charEncoding, v string) {
+	if false && e.h.EncZeroValuesAsNil && e.c != containerMapKey && v == "" {
+		e.EncodeNil()
+		return
+	}
 	e.encLen(simpleVdString, len(v))
 	e.w.writestr(v)
 }
 
-func (e *simpleEncDriver) EncodeSymbol(v string) {
-	e.EncodeString(c_UTF8, v)
-}
+// func (e *simpleEncDriver) EncodeSymbol(v string) {
+// 	e.EncodeString(cUTF8, v)
+// }
 
 func (e *simpleEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
+	// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && v == nil {
+	if v == nil {
+		e.EncodeNil()
+		return
+	}
 	e.encLen(simpleVdByteArray, len(v))
 	e.w.writeb(v)
 }
 
+func (e *simpleEncDriver) EncodeTime(t time.Time) {
+	// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && t.IsZero() {
+	if t.IsZero() {
+		e.EncodeNil()
+		return
+	}
+	v, err := t.MarshalBinary()
+	if err != nil {
+		e.e.errorv(err)
+		return
+	}
+	// time.Time marshalbinary takes about 14 bytes.
+	e.w.writen2(simpleVdTime, uint8(len(v)))
+	e.w.writeb(v)
+}
+
 //------------------------------------
 
 type simpleDecDriver struct {
@@ -154,11 +204,13 @@ type simpleDecDriver struct {
 	r      decReader
 	bdRead bool
 	bd     byte
-	br     bool // bytes reader
+	br     bool // a bytes reader?
+	c      containerState
+	// b      [scratchByteArrayLen]byte
 	noBuiltInTypes
-	noStreamingCodec
-	decNoSeparator
-	b [scratchByteArrayLen]byte
+	// noStreamingCodec
+	decDriverNoopContainerReader
+	// _ [3]uint64 // padding
 }
 
 func (d *simpleDecDriver) readNextBd() {
@@ -166,24 +218,38 @@ func (d *simpleDecDriver) readNextBd() {
 	d.bdRead = true
 }
 
-func (d *simpleDecDriver) ContainerType() (vt valueType) {
-	if d.bd == simpleVdNil {
-		return valueTypeNil
-	} else if d.bd == simpleVdByteArray || d.bd == simpleVdByteArray+1 ||
-		d.bd == simpleVdByteArray+2 || d.bd == simpleVdByteArray+3 || d.bd == simpleVdByteArray+4 {
-		return valueTypeBytes
-	} else if d.bd == simpleVdString || d.bd == simpleVdString+1 ||
-		d.bd == simpleVdString+2 || d.bd == simpleVdString+3 || d.bd == simpleVdString+4 {
-		return valueTypeString
-	} else if d.bd == simpleVdArray || d.bd == simpleVdArray+1 ||
-		d.bd == simpleVdArray+2 || d.bd == simpleVdArray+3 || d.bd == simpleVdArray+4 {
-		return valueTypeArray
-	} else if d.bd == simpleVdMap || d.bd == simpleVdMap+1 ||
-		d.bd == simpleVdMap+2 || d.bd == simpleVdMap+3 || d.bd == simpleVdMap+4 {
-		return valueTypeMap
-	} else {
-		// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+func (d *simpleDecDriver) uncacheRead() {
+	if d.bdRead {
+		d.r.unreadn1()
+		d.bdRead = false
 	}
+}
+
+func (d *simpleDecDriver) ContainerType() (vt valueType) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	switch d.bd {
+	case simpleVdNil:
+		return valueTypeNil
+	case simpleVdByteArray, simpleVdByteArray + 1,
+		simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
+		return valueTypeBytes
+	case simpleVdString, simpleVdString + 1,
+		simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
+		return valueTypeString
+	case simpleVdArray, simpleVdArray + 1,
+		simpleVdArray + 2, simpleVdArray + 3, simpleVdArray + 4:
+		return valueTypeArray
+	case simpleVdMap, simpleVdMap + 1,
+		simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4:
+		return valueTypeMap
+		// case simpleVdTime:
+		// 	return valueTypeTime
+	}
+	// else {
+	// d.d.errorf("isContainerType: unsupported parameter: %v", vt)
+	// }
 	return valueTypeUnset
 }
 
@@ -224,7 +290,7 @@ func (d *simpleDecDriver) decCheckInteger() (ui uint64, neg bool) {
 		ui = uint64(bigen.Uint64(d.r.readx(8)))
 		neg = true
 	default:
-		d.d.errorf("decIntAny: Integer only valid from pos/neg integer1..8. Invalid descriptor: %v", d.bd)
+		d.d.errorf("integer only valid from pos/neg integer1..8. Invalid descriptor: %v", d.bd)
 		return
 	}
 	// don't do this check, because callers may only want the unsigned value.
@@ -235,39 +301,27 @@ func (d *simpleDecDriver) decCheckInteger() (ui uint64, neg bool) {
 	return
 }
 
-func (d *simpleDecDriver) DecodeInt(bitsize uint8) (i int64) {
+func (d *simpleDecDriver) DecodeInt64() (i int64) {
 	ui, neg := d.decCheckInteger()
-	i, overflow := chkOvf.SignedInt(ui)
-	if overflow {
-		d.d.errorf("simple: overflow converting %v to signed integer", ui)
-		return
-	}
+	i = chkOvf.SignedIntV(ui)
 	if neg {
 		i = -i
 	}
-	if chkOvf.Int(i, bitsize) {
-		d.d.errorf("simple: overflow integer: %v", i)
-		return
-	}
 	d.bdRead = false
 	return
 }
 
-func (d *simpleDecDriver) DecodeUint(bitsize uint8) (ui uint64) {
+func (d *simpleDecDriver) DecodeUint64() (ui uint64) {
 	ui, neg := d.decCheckInteger()
 	if neg {
-		d.d.errorf("Assigning negative signed value to unsigned type")
-		return
-	}
-	if chkOvf.Uint(ui, bitsize) {
-		d.d.errorf("simple: overflow integer: %v", ui)
+		d.d.errorf("assigning negative signed value to unsigned type")
 		return
 	}
 	d.bdRead = false
 	return
 }
 
-func (d *simpleDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
+func (d *simpleDecDriver) DecodeFloat64() (f float64) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -277,16 +331,12 @@ func (d *simpleDecDriver) DecodeFloat(chkOverflow32 bool) (f float64) {
 		f = math.Float64frombits(bigen.Uint64(d.r.readx(8)))
 	} else {
 		if d.bd >= simpleVdPosInt && d.bd <= simpleVdNegInt+3 {
-			f = float64(d.DecodeInt(64))
+			f = float64(d.DecodeInt64())
 		} else {
-			d.d.errorf("Float only valid from float32/64: Invalid descriptor: %v", d.bd)
+			d.d.errorf("float only valid from float32/64: Invalid descriptor: %v", d.bd)
 			return
 		}
 	}
-	if chkOverflow32 && chkOvf.Float32(f) {
-		d.d.errorf("msgpack: float32 overflow: %v", f)
-		return
-	}
 	d.bdRead = false
 	return
 }
@@ -300,7 +350,7 @@ func (d *simpleDecDriver) DecodeBool() (b bool) {
 		b = true
 	} else if d.bd == simpleVdFalse {
 	} else {
-		d.d.errorf("Invalid single-byte value for bool: %s: %x", msgBadDesc, d.bd)
+		d.d.errorf("cannot decode bool - %s: %x", msgBadDesc, d.bd)
 		return
 	}
 	d.bdRead = false
@@ -308,15 +358,43 @@ func (d *simpleDecDriver) DecodeBool() (b bool) {
 }
 
 func (d *simpleDecDriver) ReadMapStart() (length int) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	d.bdRead = false
+	d.c = containerMapStart
 	return d.decLen()
 }
 
 func (d *simpleDecDriver) ReadArrayStart() (length int) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
 	d.bdRead = false
+	d.c = containerArrayStart
 	return d.decLen()
 }
 
+func (d *simpleDecDriver) ReadArrayElem() {
+	d.c = containerArrayElem
+}
+
+func (d *simpleDecDriver) ReadArrayEnd() {
+	d.c = containerArrayEnd
+}
+
+func (d *simpleDecDriver) ReadMapElemKey() {
+	d.c = containerMapKey
+}
+
+func (d *simpleDecDriver) ReadMapElemValue() {
+	d.c = containerMapValue
+}
+
+func (d *simpleDecDriver) ReadMapEnd() {
+	d.c = containerMapEnd
+}
+
 func (d *simpleDecDriver) decLen() int {
 	switch d.bd % 8 {
 	case 0:
@@ -328,27 +406,31 @@ func (d *simpleDecDriver) decLen() int {
 	case 3:
 		ui := uint64(bigen.Uint32(d.r.readx(4)))
 		if chkOvf.Uint(ui, intBitsize) {
-			d.d.errorf("simple: overflow integer: %v", ui)
+			d.d.errorf("overflow integer: %v", ui)
 			return 0
 		}
 		return int(ui)
 	case 4:
 		ui := bigen.Uint64(d.r.readx(8))
 		if chkOvf.Uint(ui, intBitsize) {
-			d.d.errorf("simple: overflow integer: %v", ui)
+			d.d.errorf("overflow integer: %v", ui)
 			return 0
 		}
 		return int(ui)
 	}
-	d.d.errorf("decLen: Cannot read length: bd%8 must be in range 0..4. Got: %d", d.bd%8)
+	d.d.errorf("cannot read length: bd%%8 must be in range 0..4. Got: %d", d.bd%8)
 	return -1
 }
 
 func (d *simpleDecDriver) DecodeString() (s string) {
-	return string(d.DecodeBytes(d.b[:], true, true))
+	return string(d.DecodeBytes(d.d.b[:], true))
 }
 
-func (d *simpleDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte) {
+func (d *simpleDecDriver) DecodeStringAsBytes() (s []byte) {
+	return d.DecodeBytes(d.d.b[:], true)
+}
+
+func (d *simpleDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
 	if !d.bdRead {
 		d.readNextBd()
 	}
@@ -356,21 +438,51 @@ func (d *simpleDecDriver) DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut
 		d.bdRead = false
 		return
 	}
+	// check if an "array" of uint8's (see ContainerType for how to infer if an array)
+	if d.bd >= simpleVdArray && d.bd <= simpleVdMap+4 {
+		if len(bs) == 0 && zerocopy {
+			bs = d.d.b[:]
+		}
+		bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
+		return
+	}
+
 	clen := d.decLen()
 	d.bdRead = false
 	if zerocopy {
 		if d.br {
 			return d.r.readx(clen)
 		} else if len(bs) == 0 {
-			bs = d.b[:]
+			bs = d.d.b[:]
 		}
 	}
-	return decByteSlice(d.r, clen, bs)
+	return decByteSlice(d.r, clen, d.d.h.MaxInitLen, bs)
+}
+
+func (d *simpleDecDriver) DecodeTime() (t time.Time) {
+	if !d.bdRead {
+		d.readNextBd()
+	}
+	if d.bd == simpleVdNil {
+		d.bdRead = false
+		return
+	}
+	if d.bd != simpleVdTime {
+		d.d.errorf("invalid descriptor for time.Time - expect 0x%x, received 0x%x", simpleVdTime, d.bd)
+		return
+	}
+	d.bdRead = false
+	clen := int(d.r.readn1())
+	b := d.r.readx(clen)
+	if err := (&t).UnmarshalBinary(b); err != nil {
+		d.d.errorv(err)
+	}
+	return
 }
 
 func (d *simpleDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
 	if xtag > 0xff {
-		d.d.errorf("decodeExt: tag must be <= 0xff; got: %v", xtag)
+		d.d.errorf("ext: tag must be <= 0xff; got: %v", xtag)
 		return
 	}
 	realxtag1, xbs := d.decodeExtV(ext != nil, uint8(xtag))
@@ -394,14 +506,15 @@ func (d *simpleDecDriver) decodeExtV(verifyTag bool, tag byte) (xtag byte, xbs [
 		l := d.decLen()
 		xtag = d.r.readn1()
 		if verifyTag && xtag != tag {
-			d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", xtag, tag)
+			d.d.errorf("wrong extension tag. Got %b. Expecting: %v", xtag, tag)
 			return
 		}
 		xbs = d.r.readx(l)
-	case simpleVdByteArray, simpleVdByteArray + 1, simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
-		xbs = d.DecodeBytes(nil, false, true)
+	case simpleVdByteArray, simpleVdByteArray + 1,
+		simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
+		xbs = d.DecodeBytes(nil, true)
 	default:
-		d.d.errorf("Invalid d.bd for extensions (Expecting extensions or byte array). Got: 0x%x", d.bd)
+		d.d.errorf("ext - %s - expecting extensions/bytearray, got: 0x%x", msgBadDesc, d.bd)
 		return
 	}
 	d.bdRead = false
@@ -413,7 +526,7 @@ func (d *simpleDecDriver) DecodeNaked() {
 		d.readNextBd()
 	}
 
-	n := &d.d.n
+	n := d.d.n
 	var decodeFurther bool
 
 	switch d.bd {
@@ -428,39 +541,45 @@ func (d *simpleDecDriver) DecodeNaked() {
 	case simpleVdPosInt, simpleVdPosInt + 1, simpleVdPosInt + 2, simpleVdPosInt + 3:
 		if d.h.SignedInteger {
 			n.v = valueTypeInt
-			n.i = d.DecodeInt(64)
+			n.i = d.DecodeInt64()
 		} else {
 			n.v = valueTypeUint
-			n.u = d.DecodeUint(64)
+			n.u = d.DecodeUint64()
 		}
 	case simpleVdNegInt, simpleVdNegInt + 1, simpleVdNegInt + 2, simpleVdNegInt + 3:
 		n.v = valueTypeInt
-		n.i = d.DecodeInt(64)
+		n.i = d.DecodeInt64()
 	case simpleVdFloat32:
 		n.v = valueTypeFloat
-		n.f = d.DecodeFloat(true)
+		n.f = d.DecodeFloat64()
 	case simpleVdFloat64:
 		n.v = valueTypeFloat
-		n.f = d.DecodeFloat(false)
-	case simpleVdString, simpleVdString + 1, simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
+		n.f = d.DecodeFloat64()
+	case simpleVdTime:
+		n.v = valueTypeTime
+		n.t = d.DecodeTime()
+	case simpleVdString, simpleVdString + 1,
+		simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
 		n.v = valueTypeString
 		n.s = d.DecodeString()
-	case simpleVdByteArray, simpleVdByteArray + 1, simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
+	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()
 		n.u = uint64(d.r.readn1())
 		n.l = d.r.readx(l)
-	case simpleVdArray, simpleVdArray + 1, simpleVdArray + 2, simpleVdArray + 3, simpleVdArray + 4:
+	case simpleVdArray, simpleVdArray + 1, simpleVdArray + 2,
+		simpleVdArray + 3, simpleVdArray + 4:
 		n.v = valueTypeArray
 		decodeFurther = true
 	case simpleVdMap, simpleVdMap + 1, simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4:
 		n.v = valueTypeMap
 		decodeFurther = true
 	default:
-		d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
+		d.d.errorf("cannot infer value - %s 0x%x", msgBadDesc, d.bd)
 	}
 
 	if !decodeFurther {
@@ -474,12 +593,12 @@ func (d *simpleDecDriver) DecodeNaked() {
 // SimpleHandle is a Handle for a very simple encoding format.
 //
 // simple is a simplistic codec similar to binc, but not as compact.
-//   - Encoding of a value is always preceeded by the descriptor byte (bd)
+//   - Encoding of a value is always preceded by the descriptor byte (bd)
 //   - True, false, nil are encoded fully in 1 byte (the descriptor)
 //   - Integers (intXXX, uintXXX) are encoded in 1, 2, 4 or 8 bytes (plus a descriptor byte).
 //     There are positive (uintXXX and intXXX >= 0) and negative (intXXX < 0) integers.
 //   - Floats are encoded in 4 or 8 bytes (plus a descriptor byte)
-//   - Lenght of containers (strings, bytes, array, map, extensions)
+//   - Length of containers (strings, bytes, array, map, extensions)
 //     are encoded in 0, 1, 2, 4 or 8 bytes.
 //     Zero-length containers have no length encoded.
 //     For others, the number of bytes is given by pow(2, bd%3)
@@ -487,31 +606,45 @@ func (d *simpleDecDriver) DecodeNaked() {
 //   - arrays are encoded as [bd] [length] [value]...
 //   - extensions are encoded as [bd] [length] [tag] [byte]...
 //   - strings/bytearrays are encoded as [bd] [length] [byte]...
+//   - time.Time are encoded as [bd] [length] [byte]...
 //
 // The full spec will be published soon.
 type SimpleHandle struct {
 	BasicHandle
 	binaryEncodingType
+	noElemSeparators
+	// EncZeroValuesAsNil says to encode zero values for numbers, bool, string, etc as nil
+	EncZeroValuesAsNil bool
+
+	// _ [1]uint64 // padding
 }
 
+// Name returns the name of the handle: simple
+func (h *SimpleHandle) Name() string { return "simple" }
+
+// SetBytesExt sets an extension
 func (h *SimpleHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
-	return h.SetExt(rt, tag, &setExtWrapper{b: ext})
+	return h.SetExt(rt, tag, &extWrapper{ext, interfaceExtFailer{}})
 }
 
+func (h *SimpleHandle) hasElemSeparators() bool { return true } // as it implements Write(Map|Array)XXX
+
 func (h *SimpleHandle) newEncDriver(e *Encoder) encDriver {
 	return &simpleEncDriver{e: e, w: e.w, h: h}
 }
 
 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() {
+	e.c = 0
 	e.w = e.e.w
 }
 
 func (d *simpleDecDriver) reset() {
-	d.r = d.d.r
+	d.c = 0
+	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 c0ad20b34..800376f68 100644
--- 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 100644
index 00857b620..000000000
--- a/vendor/github.com/ugorji/go/codec/tests.sh
+++ /dev/null
@@ -1,80 +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" ]]; 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
-else
-    _run "$@"
-fi
diff --git a/vendor/github.com/ugorji/go/codec/time.go b/vendor/github.com/ugorji/go/codec/time.go
deleted file mode 100644
index 718b731ec..000000000
--- a/vendor/github.com/ugorji/go/codec/time.go
+++ /dev/null
@@ -1,233 +0,0 @@
-// 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 (
-	"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
-	}
-)
-
-type timeExt struct{}
-
-func (x timeExt) WriteExt(v interface{}) (bs []byte) {
-	switch v2 := v.(type) {
-	case time.Time:
-		bs = encodeTime(v2)
-	case *time.Time:
-		bs = encodeTime(*v2)
-	default:
-		panic(fmt.Errorf("unsupported format for time conversion: expecting time.Time; got %T", v2))
-	}
-	return
-}
-func (x timeExt) ReadExt(v interface{}, bs []byte) {
-	tt, err := decodeTime(bs)
-	if err != nil {
-		panic(err)
-	}
-	*(v.(*time.Time)) = tt
-}
-
-func (x timeExt) ConvertExt(v interface{}) interface{} {
-	return x.WriteExt(v)
-}
-func (x timeExt) UpdateExt(v interface{}, src interface{}) {
-	x.ReadExt(v, src.([]byte))
-}
-
-// EncodeTime encodes a time.Time as a []byte, including
-// information on the instant in time and UTC offset.
-//
-// Format Description
-//
-//   A timestamp is composed of 3 components:
-//
-//   - secs: signed integer representing seconds since unix epoch
-//   - nsces: unsigned integer representing fractional seconds as a
-//     nanosecond offset within secs, in the range 0 <= nsecs < 1e9
-//   - tz: signed integer representing timezone offset in minutes east of UTC,
-//     and a dst (daylight savings time) flag
-//
-//   When encoding a timestamp, the first byte is the descriptor, which
-//   defines which components are encoded and how many bytes are used to
-//   encode secs and nsecs components. *If secs/nsecs is 0 or tz is UTC, it
-//   is not encoded in the byte array explicitly*.
-//
-//       Descriptor 8 bits are of the form `A B C DDD EE`:
-//           A:   Is secs component encoded? 1 = true
-//           B:   Is nsecs component encoded? 1 = true
-//           C:   Is tz component encoded? 1 = true
-//           DDD: Number of extra bytes for secs (range 0-7).
-//                If A = 1, secs encoded in DDD+1 bytes.
-//                    If A = 0, secs is not encoded, and is assumed to be 0.
-//                    If A = 1, then we need at least 1 byte to encode secs.
-//                    DDD says the number of extra bytes beyond that 1.
-//                    E.g. if DDD=0, then secs is represented in 1 byte.
-//                         if DDD=2, then secs is represented in 3 bytes.
-//           EE:  Number of extra bytes for nsecs (range 0-3).
-//                If B = 1, nsecs encoded in EE+1 bytes (similar to secs/DDD above)
-//
-//   Following the descriptor bytes, subsequent bytes are:
-//
-//       secs component encoded in `DDD + 1` bytes (if A == 1)
-//       nsecs component encoded in `EE + 1` bytes (if B == 1)
-//       tz component encoded in 2 bytes (if C == 1)
-//
-//   secs and nsecs components are integers encoded in a BigEndian
-//   2-complement encoding format.
-//
-//   tz component is encoded as 2 bytes (16 bits). Most significant bit 15 to
-//   Least significant bit 0 are described below:
-//
-//       Timezone offset has a range of -12:00 to +14:00 (ie -720 to +840 minutes).
-//       Bit 15 = have\_dst: set to 1 if we set the dst flag.
-//       Bit 14 = dst\_on: set to 1 if dst is in effect at the time, or 0 if not.
-//       Bits 13..0 = timezone offset in minutes. It is a signed integer in Big Endian format.
-//
-func encodeTime(t time.Time) []byte {
-	//t := rv.Interface().(time.Time)
-	tsecs, tnsecs := t.Unix(), t.Nanosecond()
-	var (
-		bd   byte
-		btmp [8]byte
-		bs   [16]byte
-		i    int = 1
-	)
-	l := t.Location()
-	if l == time.UTC {
-		l = nil
-	}
-	if tsecs != 0 {
-		bd = bd | 0x80
-		bigen.PutUint64(btmp[:], uint64(tsecs))
-		f := pruneSignExt(btmp[:], tsecs >= 0)
-		bd = bd | (byte(7-f) << 2)
-		copy(bs[i:], btmp[f:])
-		i = i + (8 - f)
-	}
-	if tnsecs != 0 {
-		bd = bd | 0x40
-		bigen.PutUint32(btmp[:4], uint32(tnsecs))
-		f := pruneSignExt(btmp[:4], true)
-		bd = bd | byte(3-f)
-		copy(bs[i:], btmp[f:4])
-		i = i + (4 - f)
-	}
-	if l != nil {
-		bd = bd | 0x20
-		// Note that Go Libs do not give access to dst flag.
-		_, zoneOffset := t.Zone()
-		//zoneName, zoneOffset := t.Zone()
-		zoneOffset /= 60
-		z := uint16(zoneOffset)
-		bigen.PutUint16(btmp[:2], z)
-		// clear dst flags
-		bs[i] = btmp[0] & 0x3f
-		bs[i+1] = btmp[1]
-		i = i + 2
-	}
-	bs[0] = bd
-	return bs[0:i]
-}
-
-// DecodeTime decodes a []byte into a time.Time.
-func decodeTime(bs []byte) (tt time.Time, err error) {
-	bd := bs[0]
-	var (
-		tsec  int64
-		tnsec uint32
-		tz    uint16
-		i     byte = 1
-		i2    byte
-		n     byte
-	)
-	if bd&(1<<7) != 0 {
-		var btmp [8]byte
-		n = ((bd >> 2) & 0x7) + 1
-		i2 = i + n
-		copy(btmp[8-n:], bs[i:i2])
-		//if first bit of bs[i] is set, then fill btmp[0..8-n] with 0xff (ie sign extend it)
-		if bs[i]&(1<<7) != 0 {
-			copy(btmp[0:8-n], bsAll0xff)
-			//for j,k := byte(0), 8-n; j < k; j++ {	btmp[j] = 0xff }
-		}
-		i = i2
-		tsec = int64(bigen.Uint64(btmp[:]))
-	}
-	if bd&(1<<6) != 0 {
-		var btmp [4]byte
-		n = (bd & 0x3) + 1
-		i2 = i + n
-		copy(btmp[4-n:], bs[i:i2])
-		i = i2
-		tnsec = bigen.Uint32(btmp[:])
-	}
-	if bd&(1<<5) == 0 {
-		tt = time.Unix(tsec, int64(tnsec)).UTC()
-		return
-	}
-	// In stdlib time.Parse, when a date is parsed without a zone name, it uses "" as zone name.
-	// However, we need name here, so it can be shown when time is printed.
-	// Zone name is in form: UTC-08:00.
-	// Note that Go Libs do not give access to dst flag, so we ignore dst bits
-
-	i2 = i + 2
-	tz = bigen.Uint16(bs[i:i2])
-	i = i2
-	// sign extend sign bit into top 2 MSB (which were dst bits):
-	if tz&(1<<13) == 0 { // positive
-		tz = tz & 0x3fff //clear 2 MSBs: dst bits
-	} else { // negative
-		tz = tz | 0xc000 //set 2 MSBs: dst bits
-		//tzname[3] = '-' (TODO: verify. this works here)
-	}
-	tzint := int16(tz)
-	if tzint == 0 {
-		tt = time.Unix(tsec, int64(tnsec)).UTC()
-	} else {
-		// For Go Time, do not use a descriptive timezone.
-		// It's unnecessary, and makes it harder to do a reflect.DeepEqual.
-		// The Offset already tells what the offset should be, if not on UTC and unknown zone name.
-		// var zoneName = timeLocUTCName(tzint)
-		tt = time.Unix(tsec, int64(tnsec)).In(time.FixedZone("", int(tzint)*60))
-	}
-	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)
-}
diff --git a/vendor/github.com/zclconf/go-cty/LICENSE b/vendor/github.com/zclconf/go-cty/LICENSE
new file mode 100644
index 000000000..d6503b555
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2018 Martin Atkins
+
+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/github.com/zclconf/go-cty/cty/capsule.go b/vendor/github.com/zclconf/go-cty/cty/capsule.go
new file mode 100644
index 000000000..d273d1483
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/capsule.go
@@ -0,0 +1,89 @@
+package cty
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type capsuleType struct {
+	typeImplSigil
+	Name   string
+	GoType reflect.Type
+}
+
+func (t *capsuleType) Equals(other Type) bool {
+	if otherP, ok := other.typeImpl.(*capsuleType); ok {
+		// capsule types compare by pointer identity
+		return otherP == t
+	}
+	return false
+}
+
+func (t *capsuleType) FriendlyName(mode friendlyTypeNameMode) string {
+	return t.Name
+}
+
+func (t *capsuleType) GoString() string {
+	// To get a useful representation of our native type requires some
+	// shenanigans.
+	victimVal := reflect.Zero(t.GoType)
+	return fmt.Sprintf("cty.Capsule(%q, reflect.TypeOf(%#v))", t.Name, victimVal.Interface())
+}
+
+// Capsule creates a new Capsule type.
+//
+// A Capsule type is a special type that can be used to transport arbitrary
+// Go native values of a given type through the cty type system. A language
+// that uses cty as its type system might, for example, provide functions
+// that return capsule-typed values and then other functions that operate
+// on those values.
+//
+// From cty's perspective, Capsule types have a few interesting characteristics,
+// described in the following paragraphs.
+//
+// Each capsule type has an associated Go native type that it is able to
+// transport. Capsule types compare by identity, so each call to the
+// Capsule function creates an entirely-distinct cty Type, even if two calls
+// use the same native type.
+//
+// Each capsule-typed value contains a pointer to a value of the given native
+// type. A capsule-typed value supports no operations except equality, and
+// equality is implemented by pointer identity of the encapsulated pointer.
+//
+// The given name is used as the new type's "friendly name". This can be any
+// string in principle, but will usually be a short, all-lowercase name aimed
+// at users of the embedding language (i.e. not mention Go-specific details)
+// and will ideally not create ambiguity with any predefined cty type.
+//
+// Capsule types are never introduced by any standard cty operation, so a
+// calling application opts in to including them within its own type system
+// by creating them and introducing them via its own functions. At that point,
+// the application is responsible for dealing with any capsule-typed values
+// that might be returned.
+func Capsule(name string, nativeType reflect.Type) Type {
+	return Type{
+		&capsuleType{
+			Name:   name,
+			GoType: nativeType,
+		},
+	}
+}
+
+// IsCapsuleType returns true if this type is a capsule type, as created
+// by cty.Capsule .
+func (t Type) IsCapsuleType() bool {
+	_, ok := t.typeImpl.(*capsuleType)
+	return ok
+}
+
+// EncapsulatedType returns the encapsulated native type of a capsule type,
+// or panics if the receiver is not a Capsule type.
+//
+// Is IsCapsuleType to determine if this method is safe to call.
+func (t Type) EncapsulatedType() reflect.Type {
+	impl, ok := t.typeImpl.(*capsuleType)
+	if !ok {
+		panic("not a capsule type")
+	}
+	return impl.GoType
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/collection.go b/vendor/github.com/zclconf/go-cty/cty/collection.go
new file mode 100644
index 000000000..ab3919b14
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/collection.go
@@ -0,0 +1,34 @@
+package cty
+
+import (
+	"errors"
+)
+
+type collectionTypeImpl interface {
+	ElementType() Type
+}
+
+// IsCollectionType returns true if the given type supports the operations
+// that are defined for all collection types.
+func (t Type) IsCollectionType() bool {
+	_, ok := t.typeImpl.(collectionTypeImpl)
+	return ok
+}
+
+// ElementType returns the element type of the receiver if it is a collection
+// type, or panics if it is not. Use IsCollectionType first to test whether
+// this method will succeed.
+func (t Type) ElementType() Type {
+	if ct, ok := t.typeImpl.(collectionTypeImpl); ok {
+		return ct.ElementType()
+	}
+	panic(errors.New("not a collection type"))
+}
+
+// ElementCallback is a callback type used for iterating over elements of
+// collections and attributes of objects.
+//
+// The types of key and value depend on what type is being iterated over.
+// Return true to stop iterating after the current element, or false to
+// continue iterating.
+type ElementCallback func(key Value, val Value) (stop bool)
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go b/vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go
new file mode 100644
index 000000000..d84f6ac10
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go
@@ -0,0 +1,165 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// compareTypes implements a preference order for unification.
+//
+// The result of this method is not useful for anything other than unification
+// preferences, since it assumes that the caller will verify that any suggested
+// conversion is actually possible and it is thus able to to make certain
+// optimistic assumptions.
+func compareTypes(a cty.Type, b cty.Type) int {
+
+	// DynamicPseudoType always has lowest preference, because anything can
+	// convert to it (it acts as a placeholder for "any type") and we want
+	// to optimistically assume that any dynamics will converge on matching
+	// their neighbors.
+	if a == cty.DynamicPseudoType || b == cty.DynamicPseudoType {
+		if a != cty.DynamicPseudoType {
+			return -1
+		}
+		if b != cty.DynamicPseudoType {
+			return 1
+		}
+		return 0
+	}
+
+	if a.IsPrimitiveType() && b.IsPrimitiveType() {
+		// String is a supertype of all primitive types, because we can
+		// represent all primitive values as specially-formatted strings.
+		if a == cty.String || b == cty.String {
+			if a != cty.String {
+				return 1
+			}
+			if b != cty.String {
+				return -1
+			}
+			return 0
+		}
+	}
+
+	if a.IsListType() && b.IsListType() {
+		return compareTypes(a.ElementType(), b.ElementType())
+	}
+	if a.IsSetType() && b.IsSetType() {
+		return compareTypes(a.ElementType(), b.ElementType())
+	}
+	if a.IsMapType() && b.IsMapType() {
+		return compareTypes(a.ElementType(), b.ElementType())
+	}
+
+	// From this point on we may have swapped the two items in order to
+	// simplify our cases. Therefore any non-zero return after this point
+	// must be multiplied by "swap" to potentially invert the return value
+	// if needed.
+	swap := 1
+	switch {
+	case a.IsTupleType() && b.IsListType():
+		fallthrough
+	case a.IsObjectType() && b.IsMapType():
+		fallthrough
+	case a.IsSetType() && b.IsTupleType():
+		fallthrough
+	case a.IsSetType() && b.IsListType():
+		a, b = b, a
+		swap = -1
+	}
+
+	if b.IsSetType() && (a.IsTupleType() || a.IsListType()) {
+		// We'll just optimistically assume that the element types are
+		// unifyable/convertible, and let a second recursive pass
+		// figure out how to make that so.
+		return -1 * swap
+	}
+
+	if a.IsListType() && b.IsTupleType() {
+		// We'll just optimistically assume that the tuple's element types
+		// can be unified into something compatible with the list's element
+		// type.
+		return -1 * swap
+	}
+
+	if a.IsMapType() && b.IsObjectType() {
+		// We'll just optimistically assume that the object's attribute types
+		// can be unified into something compatible with the map's element
+		// type.
+		return -1 * swap
+	}
+
+	// For object and tuple types, comparing two types doesn't really tell
+	// the whole story because it may be possible to construct a new type C
+	// that is the supertype of both A and B by unifying each attribute/element
+	// separately. That possibility is handled by Unify as a follow-up if
+	// type sorting is insufficient to produce a valid result.
+	//
+	// Here we will take care of the simple possibilities where no new type
+	// is needed.
+	if a.IsObjectType() && b.IsObjectType() {
+		atysA := a.AttributeTypes()
+		atysB := b.AttributeTypes()
+
+		if len(atysA) != len(atysB) {
+			return 0
+		}
+
+		hasASuper := false
+		hasBSuper := false
+		for k := range atysA {
+			if _, has := atysB[k]; !has {
+				return 0
+			}
+
+			cmp := compareTypes(atysA[k], atysB[k])
+			if cmp < 0 {
+				hasASuper = true
+			} else if cmp > 0 {
+				hasBSuper = true
+			}
+		}
+
+		switch {
+		case hasASuper && hasBSuper:
+			return 0
+		case hasASuper:
+			return -1 * swap
+		case hasBSuper:
+			return 1 * swap
+		default:
+			return 0
+		}
+	}
+	if a.IsTupleType() && b.IsTupleType() {
+		etysA := a.TupleElementTypes()
+		etysB := b.TupleElementTypes()
+
+		if len(etysA) != len(etysB) {
+			return 0
+		}
+
+		hasASuper := false
+		hasBSuper := false
+		for i := range etysA {
+			cmp := compareTypes(etysA[i], etysB[i])
+			if cmp < 0 {
+				hasASuper = true
+			} else if cmp > 0 {
+				hasBSuper = true
+			}
+		}
+
+		switch {
+		case hasASuper && hasBSuper:
+			return 0
+		case hasASuper:
+			return -1 * swap
+		case hasBSuper:
+			return 1 * swap
+		default:
+			return 0
+		}
+	}
+
+	return 0
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
new file mode 100644
index 000000000..f9aacb4ee
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
@@ -0,0 +1,143 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// conversion is an internal variant of Conversion that carries around
+// a cty.Path to be used in error responses.
+type conversion func(cty.Value, cty.Path) (cty.Value, error)
+
+func getConversion(in cty.Type, out cty.Type, unsafe bool) conversion {
+	conv := getConversionKnown(in, out, unsafe)
+	if conv == nil {
+		return nil
+	}
+
+	// Wrap the conversion in some standard checks that we don't want to
+	// have to repeat in every conversion function.
+	return func(in cty.Value, path cty.Path) (cty.Value, error) {
+		if out == cty.DynamicPseudoType {
+			// Conversion to DynamicPseudoType always just passes through verbatim.
+			return in, nil
+		}
+		if !in.IsKnown() {
+			return cty.UnknownVal(out), nil
+		}
+		if in.IsNull() {
+			// We'll pass through nulls, albeit type converted, and let
+			// the caller deal with whatever handling they want to do in
+			// case null values are considered valid in some applications.
+			return cty.NullVal(out), nil
+		}
+
+		return conv(in, path)
+	}
+}
+
+func getConversionKnown(in cty.Type, out cty.Type, unsafe bool) conversion {
+	switch {
+
+	case out == cty.DynamicPseudoType:
+		// Conversion *to* DynamicPseudoType means that the caller wishes
+		// to allow any type in this position, so we'll produce a do-nothing
+		// conversion that just passes through the value as-is.
+		return dynamicPassthrough
+
+	case unsafe && in == cty.DynamicPseudoType:
+		// Conversion *from* DynamicPseudoType means that we have a value
+		// whose type isn't yet known during type checking. For these we will
+		// assume that conversion will succeed and deal with any errors that
+		// result (which is why we can only do this when "unsafe" is set).
+		return dynamicFixup(out)
+
+	case in.IsPrimitiveType() && out.IsPrimitiveType():
+		conv := primitiveConversionsSafe[in][out]
+		if conv != nil {
+			return conv
+		}
+		if unsafe {
+			return primitiveConversionsUnsafe[in][out]
+		}
+		return nil
+
+	case out.IsObjectType() && in.IsObjectType():
+		return conversionObjectToObject(in, out, unsafe)
+
+	case out.IsTupleType() && in.IsTupleType():
+		return conversionTupleToTuple(in, out, unsafe)
+
+	case out.IsListType() && (in.IsListType() || in.IsSetType()):
+		inEty := in.ElementType()
+		outEty := out.ElementType()
+		if inEty.Equals(outEty) {
+			// This indicates that we're converting from list to set with
+			// the same element type, so we don't need an element converter.
+			return conversionCollectionToList(outEty, nil)
+		}
+
+		convEty := getConversion(inEty, outEty, unsafe)
+		if convEty == nil {
+			return nil
+		}
+		return conversionCollectionToList(outEty, convEty)
+
+	case out.IsSetType() && (in.IsListType() || in.IsSetType()):
+		if in.IsListType() && !unsafe {
+			// Conversion from list to map is unsafe because it will lose
+			// information: the ordering will not be preserved, and any
+			// duplicate elements will be conflated.
+			return nil
+		}
+		inEty := in.ElementType()
+		outEty := out.ElementType()
+		convEty := getConversion(inEty, outEty, unsafe)
+		if inEty.Equals(outEty) {
+			// This indicates that we're converting from set to list with
+			// the same element type, so we don't need an element converter.
+			return conversionCollectionToSet(outEty, nil)
+		}
+
+		if convEty == nil {
+			return nil
+		}
+		return conversionCollectionToSet(outEty, convEty)
+
+	case out.IsMapType() && in.IsMapType():
+		inEty := in.ElementType()
+		outEty := out.ElementType()
+		convEty := getConversion(inEty, outEty, unsafe)
+		if convEty == nil {
+			return nil
+		}
+		return conversionCollectionToMap(outEty, convEty)
+
+	case out.IsListType() && in.IsTupleType():
+		outEty := out.ElementType()
+		return conversionTupleToList(in, outEty, unsafe)
+
+	case out.IsSetType() && in.IsTupleType():
+		outEty := out.ElementType()
+		return conversionTupleToSet(in, outEty, unsafe)
+
+	case out.IsMapType() && in.IsObjectType():
+		outEty := out.ElementType()
+		return conversionObjectToMap(in, outEty, unsafe)
+
+	default:
+		return nil
+
+	}
+}
+
+// retConversion wraps a conversion (internal type) so it can be returned
+// as a Conversion (public type).
+func retConversion(conv conversion) Conversion {
+	if conv == nil {
+		return nil
+	}
+
+	return func(in cty.Value) (cty.Value, error) {
+		return conv(in, cty.Path(nil))
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
new file mode 100644
index 000000000..3039ba22e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
@@ -0,0 +1,340 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// conversionCollectionToList returns a conversion that will apply the given
+// conversion to all of the elements of a collection (something that supports
+// ForEachElement and LengthInt) and then returns the result as a list.
+//
+// "conv" can be nil if the elements are expected to already be of the
+// correct type and just need to be re-wrapped into a list. (For example,
+// if we're converting from a set into a list of the same element type.)
+func conversionCollectionToList(ety cty.Type, conv conversion) conversion {
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elems := make([]cty.Value, 0, val.LengthInt())
+		i := int64(0)
+		path = append(path, nil)
+		it := val.ElementIterator()
+		for it.Next() {
+			_, val := it.Element()
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(i),
+			}
+
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+			elems = append(elems, val)
+
+			i++
+		}
+
+		if len(elems) == 0 {
+			return cty.ListValEmpty(ety), nil
+		}
+
+		return cty.ListVal(elems), nil
+	}
+}
+
+// conversionCollectionToSet returns a conversion that will apply the given
+// conversion to all of the elements of a collection (something that supports
+// ForEachElement and LengthInt) and then returns the result as a set.
+//
+// "conv" can be nil if the elements are expected to already be of the
+// correct type and just need to be re-wrapped into a set. (For example,
+// if we're converting from a list into a set of the same element type.)
+func conversionCollectionToSet(ety cty.Type, conv conversion) conversion {
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elems := make([]cty.Value, 0, val.LengthInt())
+		i := int64(0)
+		path = append(path, nil)
+		it := val.ElementIterator()
+		for it.Next() {
+			_, val := it.Element()
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(i),
+			}
+
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+			elems = append(elems, val)
+
+			i++
+		}
+
+		if len(elems) == 0 {
+			return cty.SetValEmpty(ety), nil
+		}
+
+		return cty.SetVal(elems), nil
+	}
+}
+
+// conversionCollectionToMap returns a conversion that will apply the given
+// conversion to all of the elements of a collection (something that supports
+// ForEachElement and LengthInt) and then returns the result as a map.
+//
+// "conv" can be nil if the elements are expected to already be of the
+// correct type and just need to be re-wrapped into a map.
+func conversionCollectionToMap(ety cty.Type, conv conversion) conversion {
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elems := make(map[string]cty.Value, 0)
+		path = append(path, nil)
+		it := val.ElementIterator()
+		for it.Next() {
+			key, val := it.Element()
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: key,
+			}
+
+			keyStr, err := Convert(key, cty.String)
+			if err != nil {
+				// Should never happen, because keys can only be numbers or
+				// strings and both can convert to string.
+				return cty.DynamicVal, path.NewErrorf("cannot convert key type %s to string for map", key.Type().FriendlyName())
+			}
+
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+
+			elems[keyStr.AsString()] = val
+		}
+
+		if len(elems) == 0 {
+			return cty.MapValEmpty(ety), nil
+		}
+
+		return cty.MapVal(elems), nil
+	}
+}
+
+// conversionTupleToSet returns a conversion that will take a value of the
+// given tuple type and return a set of the given element type.
+//
+// Will panic if the given tupleType isn't actually a tuple type.
+func conversionTupleToSet(tupleType cty.Type, listEty cty.Type, unsafe bool) conversion {
+	tupleEtys := tupleType.TupleElementTypes()
+
+	if len(tupleEtys) == 0 {
+		// Empty tuple short-circuit
+		return func(val cty.Value, path cty.Path) (cty.Value, error) {
+			return cty.SetValEmpty(listEty), nil
+		}
+	}
+
+	if listEty == cty.DynamicPseudoType {
+		// This is a special case where the caller wants us to find
+		// a suitable single type that all elements can convert to, if
+		// possible.
+		listEty, _ = unify(tupleEtys, unsafe)
+		if listEty == cty.NilType {
+			return nil
+		}
+	}
+
+	elemConvs := make([]conversion, len(tupleEtys))
+	for i, tupleEty := range tupleEtys {
+		if tupleEty.Equals(listEty) {
+			// no conversion required
+			continue
+		}
+
+		elemConvs[i] = getConversion(tupleEty, listEty, unsafe)
+		if elemConvs[i] == nil {
+			// If any of our element conversions are impossible, then the our
+			// whole conversion is impossible.
+			return nil
+		}
+	}
+
+	// If we fall out here then a conversion is possible, using the
+	// element conversions in elemConvs
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elems := make([]cty.Value, 0, len(elemConvs))
+		path = append(path, nil)
+		i := int64(0)
+		it := val.ElementIterator()
+		for it.Next() {
+			_, val := it.Element()
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(i),
+			}
+
+			conv := elemConvs[i]
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+			elems = append(elems, val)
+
+			i++
+		}
+
+		return cty.SetVal(elems), nil
+	}
+}
+
+// conversionTupleToList returns a conversion that will take a value of the
+// given tuple type and return a list of the given element type.
+//
+// Will panic if the given tupleType isn't actually a tuple type.
+func conversionTupleToList(tupleType cty.Type, listEty cty.Type, unsafe bool) conversion {
+	tupleEtys := tupleType.TupleElementTypes()
+
+	if len(tupleEtys) == 0 {
+		// Empty tuple short-circuit
+		return func(val cty.Value, path cty.Path) (cty.Value, error) {
+			return cty.ListValEmpty(listEty), nil
+		}
+	}
+
+	if listEty == cty.DynamicPseudoType {
+		// This is a special case where the caller wants us to find
+		// a suitable single type that all elements can convert to, if
+		// possible.
+		listEty, _ = unify(tupleEtys, unsafe)
+		if listEty == cty.NilType {
+			return nil
+		}
+	}
+
+	elemConvs := make([]conversion, len(tupleEtys))
+	for i, tupleEty := range tupleEtys {
+		if tupleEty.Equals(listEty) {
+			// no conversion required
+			continue
+		}
+
+		elemConvs[i] = getConversion(tupleEty, listEty, unsafe)
+		if elemConvs[i] == nil {
+			// If any of our element conversions are impossible, then the our
+			// whole conversion is impossible.
+			return nil
+		}
+	}
+
+	// If we fall out here then a conversion is possible, using the
+	// element conversions in elemConvs
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elems := make([]cty.Value, 0, len(elemConvs))
+		path = append(path, nil)
+		i := int64(0)
+		it := val.ElementIterator()
+		for it.Next() {
+			_, val := it.Element()
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(i),
+			}
+
+			conv := elemConvs[i]
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+			elems = append(elems, val)
+
+			i++
+		}
+
+		return cty.ListVal(elems), nil
+	}
+}
+
+// conversionObjectToMap returns a conversion that will take a value of the
+// given object type and return a map of the given element type.
+//
+// Will panic if the given objectType isn't actually an object type.
+func conversionObjectToMap(objectType cty.Type, mapEty cty.Type, unsafe bool) conversion {
+	objectAtys := objectType.AttributeTypes()
+
+	if len(objectAtys) == 0 {
+		// Empty object short-circuit
+		return func(val cty.Value, path cty.Path) (cty.Value, error) {
+			return cty.MapValEmpty(mapEty), nil
+		}
+	}
+
+	if mapEty == cty.DynamicPseudoType {
+		// This is a special case where the caller wants us to find
+		// a suitable single type that all elements can convert to, if
+		// possible.
+		objectAtysList := make([]cty.Type, 0, len(objectAtys))
+		for _, aty := range objectAtys {
+			objectAtysList = append(objectAtysList, aty)
+		}
+		mapEty, _ = unify(objectAtysList, unsafe)
+		if mapEty == cty.NilType {
+			return nil
+		}
+	}
+
+	elemConvs := make(map[string]conversion, len(objectAtys))
+	for name, objectAty := range objectAtys {
+		if objectAty.Equals(mapEty) {
+			// no conversion required
+			continue
+		}
+
+		elemConvs[name] = getConversion(objectAty, mapEty, unsafe)
+		if elemConvs[name] == nil {
+			// If any of our element conversions are impossible, then the our
+			// whole conversion is impossible.
+			return nil
+		}
+	}
+
+	// If we fall out here then a conversion is possible, using the
+	// element conversions in elemConvs
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elems := make(map[string]cty.Value, len(elemConvs))
+		path = append(path, nil)
+		it := val.ElementIterator()
+		for it.Next() {
+			name, val := it.Element()
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: name,
+			}
+
+			conv := elemConvs[name.AsString()]
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+			elems[name.AsString()] = val
+		}
+
+		return cty.MapVal(elems), nil
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go
new file mode 100644
index 000000000..4d19cf6c5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go
@@ -0,0 +1,33 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// dynamicFixup deals with just-in-time conversions of values that were
+// input-typed as cty.DynamicPseudoType during analysis, ensuring that
+// we end up with the desired output type once the value is known, or
+// failing with an error if that is not possible.
+//
+// This is in the spirit of the cty philosophy of optimistically assuming that
+// DynamicPseudoType values will become the intended value eventually, and
+// dealing with any inconsistencies during final evaluation.
+func dynamicFixup(wantType cty.Type) conversion {
+	return func(in cty.Value, path cty.Path) (cty.Value, error) {
+		ret, err := Convert(in, wantType)
+		if err != nil {
+			// Re-wrap this error so that the returned path is relative
+			// to the caller's original value, rather than relative to our
+			// conversion value here.
+			return cty.NilVal, path.NewError(err)
+		}
+		return ret, nil
+	}
+}
+
+// dynamicPassthrough is an identity conversion that is used when the
+// target type is DynamicPseudoType, indicating that the caller doesn't care
+// which type is returned.
+func dynamicPassthrough(in cty.Value, path cty.Path) (cty.Value, error) {
+	return in, nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
new file mode 100644
index 000000000..62dabb8d1
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_object.go
@@ -0,0 +1,76 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// conversionObjectToObject returns a conversion that will make the input
+// object type conform to the output object type, if possible.
+//
+// Conversion is possible only if the output type is a subset of the input
+// type, meaning that each attribute of the output type has a corresponding
+// attribute in the input type where a recursive conversion is available.
+//
+// Shallow object conversions work the same for both safe and unsafe modes,
+// but the safety flag is passed on to recursive conversions and may thus
+// limit the above definition of "subset".
+func conversionObjectToObject(in, out cty.Type, unsafe bool) conversion {
+	inAtys := in.AttributeTypes()
+	outAtys := out.AttributeTypes()
+	attrConvs := make(map[string]conversion)
+
+	for name, outAty := range outAtys {
+		inAty, exists := inAtys[name]
+		if !exists {
+			// No conversion is available, then.
+			return nil
+		}
+
+		if inAty.Equals(outAty) {
+			// No conversion needed, but we'll still record the attribute
+			// in our map for later reference.
+			attrConvs[name] = nil
+			continue
+		}
+
+		attrConvs[name] = getConversion(inAty, outAty, unsafe)
+		if attrConvs[name] == nil {
+			// If a recursive conversion isn't available, then our top-level
+			// configuration is impossible too.
+			return nil
+		}
+	}
+
+	// If we get here then a conversion is possible, using the attribute
+	// conversions given in attrConvs.
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		attrVals := make(map[string]cty.Value, len(attrConvs))
+		path = append(path, nil)
+		pathStep := &path[len(path)-1]
+
+		for it := val.ElementIterator(); it.Next(); {
+			nameVal, val := it.Element()
+			var err error
+
+			name := nameVal.AsString()
+			*pathStep = cty.GetAttrStep{
+				Name: name,
+			}
+
+			conv, exists := attrConvs[name]
+			if !exists {
+				continue
+			}
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+
+			attrVals[name] = val
+		}
+
+		return cty.ObjectVal(attrVals), nil
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
new file mode 100644
index 000000000..e0dbf491e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
@@ -0,0 +1,48 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+var stringTrue = cty.StringVal("true")
+var stringFalse = cty.StringVal("false")
+
+var primitiveConversionsSafe = map[cty.Type]map[cty.Type]conversion{
+	cty.Number: {
+		cty.String: func(val cty.Value, path cty.Path) (cty.Value, error) {
+			f := val.AsBigFloat()
+			return cty.StringVal(f.Text('f', -1)), nil
+		},
+	},
+	cty.Bool: {
+		cty.String: func(val cty.Value, path cty.Path) (cty.Value, error) {
+			if val.True() {
+				return stringTrue, nil
+			} else {
+				return stringFalse, nil
+			}
+		},
+	},
+}
+
+var primitiveConversionsUnsafe = map[cty.Type]map[cty.Type]conversion{
+	cty.String: {
+		cty.Number: func(val cty.Value, path cty.Path) (cty.Value, error) {
+			v, err := cty.ParseNumberVal(val.AsString())
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("a number is required")
+			}
+			return v, nil
+		},
+		cty.Bool: func(val cty.Value, path cty.Path) (cty.Value, error) {
+			switch val.AsString() {
+			case "true", "1":
+				return cty.True, nil
+			case "false", "0":
+				return cty.False, nil
+			default:
+				return cty.NilVal, path.NewErrorf("a bool is required")
+			}
+		},
+	},
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_tuple.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_tuple.go
new file mode 100644
index 000000000..592980a70
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_tuple.go
@@ -0,0 +1,71 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// conversionTupleToTuple returns a conversion that will make the input
+// tuple type conform to the output tuple type, if possible.
+//
+// Conversion is possible only if the two tuple types have the same number
+// of elements and the corresponding elements by index can be converted.
+//
+// Shallow tuple conversions work the same for both safe and unsafe modes,
+// but the safety flag is passed on to recursive conversions and may thus
+// limit which element type conversions are possible.
+func conversionTupleToTuple(in, out cty.Type, unsafe bool) conversion {
+	inEtys := in.TupleElementTypes()
+	outEtys := out.TupleElementTypes()
+
+	if len(inEtys) != len(outEtys) {
+		return nil // no conversion is possible
+	}
+
+	elemConvs := make([]conversion, len(inEtys))
+
+	for i, outEty := range outEtys {
+		inEty := inEtys[i]
+
+		if inEty.Equals(outEty) {
+			// No conversion needed, so we can leave this one nil.
+			continue
+		}
+
+		elemConvs[i] = getConversion(inEty, outEty, unsafe)
+		if elemConvs[i] == nil {
+			// If a recursive conversion isn't available, then our top-level
+			// configuration is impossible too.
+			return nil
+		}
+	}
+
+	// If we get here then a conversion is possible, using the element
+	// conversions given in elemConvs.
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elemVals := make([]cty.Value, len(elemConvs))
+		path = append(path, nil)
+		pathStep := &path[len(path)-1]
+
+		i := 0
+		for it := val.ElementIterator(); it.Next(); i++ {
+			_, val := it.Element()
+			var err error
+
+			*pathStep = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			conv := elemConvs[i]
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+
+			elemVals[i] = val
+		}
+
+		return cty.TupleVal(elemVals), nil
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/doc.go b/vendor/github.com/zclconf/go-cty/cty/convert/doc.go
new file mode 100644
index 000000000..2037299ba
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/doc.go
@@ -0,0 +1,15 @@
+// Package convert contains some routines for converting between cty types.
+// The intent of providing this package is to encourage applications using
+// cty to have consistent type conversion behavior for maximal interoperability
+// when Values pass from one application to another.
+//
+// The conversions are categorized into two categories. "Safe" conversions are
+// ones that are guaranteed to succeed if given a non-null value of the
+// appropriate source type. "Unsafe" conversions, on the other hand, are valid
+// for only a subset of input values, and thus may fail with an error when
+// called for values outside of that valid subset.
+//
+// The functions whose names end in Unsafe support all of the conversions that
+// are supported by the corresponding functions whose names do not have that
+// suffix, and then additional unsafe conversions as well.
+package convert
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/mismatch_msg.go b/vendor/github.com/zclconf/go-cty/cty/convert/mismatch_msg.go
new file mode 100644
index 000000000..581304ecd
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/mismatch_msg.go
@@ -0,0 +1,220 @@
+package convert
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// MismatchMessage is a helper to return an English-language description of
+// the differences between got and want, phrased as a reason why got does
+// not conform to want.
+//
+// This function does not itself attempt conversion, and so it should generally
+// be used only after a conversion has failed, to report the conversion failure
+// to an English-speaking user. The result will be confusing got is actually
+// conforming to or convertable to want.
+//
+// The shorthand helper function Convert uses this function internally to
+// produce its error messages, so callers of that function do not need to
+// also use MismatchMessage.
+//
+// This function is similar to Type.TestConformance, but it is tailored to
+// describing conversion failures and so the messages it generates relate
+// specifically to the conversion rules implemented in this package.
+func MismatchMessage(got, want cty.Type) string {
+	switch {
+
+	case got.IsObjectType() && want.IsObjectType():
+		// If both types are object types then we may be able to say something
+		// about their respective attributes.
+		return mismatchMessageObjects(got, want)
+
+	case got.IsTupleType() && want.IsListType() && want.ElementType() == cty.DynamicPseudoType:
+		// If conversion from tuple to list failed then it's because we couldn't
+		// find a common type to convert all of the tuple elements to.
+		return "all list elements must have the same type"
+
+	case got.IsTupleType() && want.IsSetType() && want.ElementType() == cty.DynamicPseudoType:
+		// If conversion from tuple to set failed then it's because we couldn't
+		// find a common type to convert all of the tuple elements to.
+		return "all set elements must have the same type"
+
+	case got.IsObjectType() && want.IsMapType() && want.ElementType() == cty.DynamicPseudoType:
+		// If conversion from object to map failed then it's because we couldn't
+		// find a common type to convert all of the object attributes to.
+		return "all map elements must have the same type"
+
+	case (got.IsTupleType() || got.IsObjectType()) && want.IsCollectionType():
+		return mismatchMessageCollectionsFromStructural(got, want)
+
+	case got.IsCollectionType() && want.IsCollectionType():
+		return mismatchMessageCollectionsFromCollections(got, want)
+
+	default:
+		// If we have nothing better to say, we'll just state what was required.
+		return want.FriendlyNameForConstraint() + " required"
+	}
+}
+
+func mismatchMessageObjects(got, want cty.Type) string {
+	// Per our conversion rules, "got" is allowed to be a superset of "want",
+	// and so we'll produce error messages here under that assumption.
+	gotAtys := got.AttributeTypes()
+	wantAtys := want.AttributeTypes()
+
+	// If we find missing attributes then we'll report those in preference,
+	// but if not then we will report a maximum of one non-conforming
+	// attribute, just to keep our messages relatively terse.
+	// We'll also prefer to report a recursive type error from an _unsafe_
+	// conversion over a safe one, because these are subjectively more
+	// "serious".
+	var missingAttrs []string
+	var unsafeMismatchAttr string
+	var safeMismatchAttr string
+
+	for name, wantAty := range wantAtys {
+		gotAty, exists := gotAtys[name]
+		if !exists {
+			missingAttrs = append(missingAttrs, name)
+			continue
+		}
+
+		// We'll now try to convert these attributes in isolation and
+		// see if we have a nested conversion error to report.
+		// We'll try an unsafe conversion first, and then fall back on
+		// safe if unsafe is possible.
+
+		// If we already have an unsafe mismatch attr error then we won't bother
+		// hunting for another one.
+		if unsafeMismatchAttr != "" {
+			continue
+		}
+		if conv := GetConversionUnsafe(gotAty, wantAty); conv == nil {
+			unsafeMismatchAttr = fmt.Sprintf("attribute %q: %s", name, MismatchMessage(gotAty, wantAty))
+		}
+
+		// If we already have a safe mismatch attr error then we won't bother
+		// hunting for another one.
+		if safeMismatchAttr != "" {
+			continue
+		}
+		if conv := GetConversion(gotAty, wantAty); conv == nil {
+			safeMismatchAttr = fmt.Sprintf("attribute %q: %s", name, MismatchMessage(gotAty, wantAty))
+		}
+	}
+
+	// We should now have collected at least one problem. If we have more than
+	// one then we'll use our preference order to decide what is most important
+	// to report.
+	switch {
+
+	case len(missingAttrs) != 0:
+		sort.Strings(missingAttrs)
+		switch len(missingAttrs) {
+		case 1:
+			return fmt.Sprintf("attribute %q is required", missingAttrs[0])
+		case 2:
+			return fmt.Sprintf("attributes %q and %q are required", missingAttrs[0], missingAttrs[1])
+		default:
+			sort.Strings(missingAttrs)
+			var buf bytes.Buffer
+			for _, name := range missingAttrs[:len(missingAttrs)-1] {
+				fmt.Fprintf(&buf, "%q, ", name)
+			}
+			fmt.Fprintf(&buf, "and %q", missingAttrs[len(missingAttrs)-1])
+			return fmt.Sprintf("attributes %s are required", buf.Bytes())
+		}
+
+	case unsafeMismatchAttr != "":
+		return unsafeMismatchAttr
+
+	case safeMismatchAttr != "":
+		return safeMismatchAttr
+
+	default:
+		// We should never get here, but if we do then we'll return
+		// just a generic message.
+		return "incorrect object attributes"
+	}
+}
+
+func mismatchMessageCollectionsFromStructural(got, want cty.Type) string {
+	// First some straightforward cases where the kind is just altogether wrong.
+	switch {
+	case want.IsListType() && !got.IsTupleType():
+		return want.FriendlyNameForConstraint() + " required"
+	case want.IsSetType() && !got.IsTupleType():
+		return want.FriendlyNameForConstraint() + " required"
+	case want.IsMapType() && !got.IsObjectType():
+		return want.FriendlyNameForConstraint() + " required"
+	}
+
+	// If the kinds are matched well enough then we'll move on to checking
+	// individual elements.
+	wantEty := want.ElementType()
+	switch {
+	case got.IsTupleType():
+		for i, gotEty := range got.TupleElementTypes() {
+			if gotEty.Equals(wantEty) {
+				continue // exact match, so no problem
+			}
+			if conv := getConversion(gotEty, wantEty, true); conv != nil {
+				continue // conversion is available, so no problem
+			}
+			return fmt.Sprintf("element %d: %s", i, MismatchMessage(gotEty, wantEty))
+		}
+
+		// If we get down here then something weird is going on but we'll
+		// return a reasonable fallback message anyway.
+		return fmt.Sprintf("all elements must be %s", wantEty.FriendlyNameForConstraint())
+
+	case got.IsObjectType():
+		for name, gotAty := range got.AttributeTypes() {
+			if gotAty.Equals(wantEty) {
+				continue // exact match, so no problem
+			}
+			if conv := getConversion(gotAty, wantEty, true); conv != nil {
+				continue // conversion is available, so no problem
+			}
+			return fmt.Sprintf("element %q: %s", name, MismatchMessage(gotAty, wantEty))
+		}
+
+		// If we get down here then something weird is going on but we'll
+		// return a reasonable fallback message anyway.
+		return fmt.Sprintf("all elements must be %s", wantEty.FriendlyNameForConstraint())
+
+	default:
+		// Should not be possible to get here since we only call this function
+		// with got as structural types, but...
+		return want.FriendlyNameForConstraint() + " required"
+	}
+}
+
+func mismatchMessageCollectionsFromCollections(got, want cty.Type) string {
+	// First some straightforward cases where the kind is just altogether wrong.
+	switch {
+	case want.IsListType() && !(got.IsListType() || got.IsSetType()):
+		return want.FriendlyNameForConstraint() + " required"
+	case want.IsSetType() && !(got.IsListType() || got.IsSetType()):
+		return want.FriendlyNameForConstraint() + " required"
+	case want.IsMapType() && !got.IsMapType():
+		return want.FriendlyNameForConstraint() + " required"
+	}
+
+	// If the kinds are matched well enough then we'll check the element types.
+	gotEty := got.ElementType()
+	wantEty := want.ElementType()
+	noun := "element type"
+	switch {
+	case want.IsListType():
+		noun = "list element type"
+	case want.IsSetType():
+		noun = "set element type"
+	case want.IsMapType():
+		noun = "map element type"
+	}
+	return fmt.Sprintf("incorrect %s: %s", noun, MismatchMessage(gotEty, wantEty))
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/public.go b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
new file mode 100644
index 000000000..af19bdc50
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
@@ -0,0 +1,83 @@
+package convert
+
+import (
+	"errors"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// This file contains the public interface of this package, which is intended
+// to be a small, convenient interface designed for easy integration into
+// a hypothetical language type checker and interpreter.
+
+// Conversion is a named function type representing a conversion from a
+// value of one type to a value of another type.
+//
+// The source type for a conversion is always the source type given to
+// the function that returned the Conversion, but there is no way to recover
+// that from a Conversion value itself. If a Conversion is given a value
+// that is not of its expected type (with the exception of DynamicPseudoType,
+// which is always supported) then the function may panic or produce undefined
+// results.
+type Conversion func(in cty.Value) (out cty.Value, err error)
+
+// GetConversion returns a Conversion between the given in and out Types if
+// a safe one is available, or returns nil otherwise.
+func GetConversion(in cty.Type, out cty.Type) Conversion {
+	return retConversion(getConversion(in, out, false))
+}
+
+// GetConversionUnsafe returns a Conversion between the given in and out Types
+// if either a safe or unsafe one is available, or returns nil otherwise.
+func GetConversionUnsafe(in cty.Type, out cty.Type) Conversion {
+	return retConversion(getConversion(in, out, true))
+}
+
+// Convert returns the result of converting the given value to the given type
+// if an safe or unsafe conversion is available, or returns an error if such a
+// conversion is impossible.
+//
+// This is a convenience wrapper around calling GetConversionUnsafe and then
+// immediately passing the given value to the resulting function.
+func Convert(in cty.Value, want cty.Type) (cty.Value, error) {
+	if in.Type().Equals(want) {
+		return in, nil
+	}
+
+	conv := GetConversionUnsafe(in.Type(), want)
+	if conv == nil {
+		return cty.NilVal, errors.New(MismatchMessage(in.Type(), want))
+	}
+	return conv(in)
+}
+
+// Unify attempts to find the most general type that can be converted from
+// all of the given types. If this is possible, that type is returned along
+// with a slice of necessary conversions for some of the given types.
+//
+// If no common supertype can be found, this function returns cty.NilType and
+// a nil slice.
+//
+// If a common supertype *can* be found, the returned slice will always be
+// non-nil and will contain a non-nil conversion for each given type that
+// needs to be converted, with indices corresponding to the input slice.
+// Any given type that does *not* need conversion (because it is already of
+// the appropriate type) will have a nil Conversion.
+//
+// cty.DynamicPseudoType is, as usual, a special case. If the given type list
+// contains a mixture of dynamic and non-dynamic types, the dynamic types are
+// disregarded for type selection and a conversion is returned for them that
+// will attempt a late conversion of the given value to the target type,
+// failing with a conversion error if the eventual concrete type is not
+// compatible. If *all* given types are DynamicPseudoType, or in the
+// degenerate case of an empty slice of types, the returned type is itself
+// cty.DynamicPseudoType and no conversions are attempted.
+func Unify(types []cty.Type) (cty.Type, []Conversion) {
+	return unify(types, false)
+}
+
+// UnifyUnsafe is the same as Unify except that it may return unsafe
+// conversions in situations where a safe conversion isn't also available.
+func UnifyUnsafe(types []cty.Type) (cty.Type, []Conversion) {
+	return unify(types, true)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go b/vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go
new file mode 100644
index 000000000..b7769106d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go
@@ -0,0 +1,69 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// sortTypes produces an ordering of the given types that serves as a
+// preference order for the result of unification of the given types.
+// The return value is a slice of indices into the given slice, and will
+// thus always be the same length as the given slice.
+//
+// The goal is that the most general of the given types will appear first
+// in the ordering. If there are uncomparable pairs of types in the list
+// then they will appear in an undefined order, and the unification pass
+// will presumably then fail.
+func sortTypes(tys []cty.Type) []int {
+	l := len(tys)
+
+	// First we build a graph whose edges represent "more general than",
+	// which we will then do a topological sort of.
+	edges := make([][]int, l)
+	for i := 0; i < (l - 1); i++ {
+		for j := i + 1; j < l; j++ {
+			cmp := compareTypes(tys[i], tys[j])
+			switch {
+			case cmp < 0:
+				edges[i] = append(edges[i], j)
+			case cmp > 0:
+				edges[j] = append(edges[j], i)
+			}
+		}
+	}
+
+	// Compute the in-degree of each node
+	inDegree := make([]int, l)
+	for _, outs := range edges {
+		for _, j := range outs {
+			inDegree[j]++
+		}
+	}
+
+	// The array backing our result will double as our queue for visiting
+	// the nodes, with the queue slice moving along this array until it
+	// is empty and positioned at the end of the array. Thus our visiting
+	// order is also our result order.
+	result := make([]int, l)
+	queue := result[0:0]
+
+	// Initialize the queue with any item of in-degree 0, preserving
+	// their relative order.
+	for i, n := range inDegree {
+		if n == 0 {
+			queue = append(queue, i)
+		}
+	}
+
+	for len(queue) != 0 {
+		i := queue[0]
+		queue = queue[1:]
+		for _, j := range edges[i] {
+			inDegree[j]--
+			if inDegree[j] == 0 {
+				queue = append(queue, j)
+			}
+		}
+	}
+
+	return result
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/unify.go b/vendor/github.com/zclconf/go-cty/cty/convert/unify.go
new file mode 100644
index 000000000..53ebbfe08
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/unify.go
@@ -0,0 +1,314 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// The current unify implementation is somewhat inefficient, but we accept this
+// under the assumption that it will generally be used with small numbers of
+// types and with types of reasonable complexity. However, it does have a
+// "happy path" where all of the given types are equal.
+//
+// This function is likely to have poor performance in cases where any given
+// types are very complex (lots of deeply-nested structures) or if the list
+// of types itself is very large. In particular, it will walk the nested type
+// structure under the given types several times, especially when given a
+// list of types for which unification is not possible, since each permutation
+// will be tried to determine that result.
+func unify(types []cty.Type, unsafe bool) (cty.Type, []Conversion) {
+	if len(types) == 0 {
+		// Degenerate case
+		return cty.NilType, nil
+	}
+
+	// If all of the given types are of the same structural kind, we may be
+	// able to construct a new type that they can all be unified to, even if
+	// that is not one of the given types. We must try this before the general
+	// behavior below because in unsafe mode we can convert an object type to
+	// a subset of that type, which would be a much less useful conversion for
+	// unification purposes.
+	{
+		objectCt := 0
+		tupleCt := 0
+		dynamicCt := 0
+		for _, ty := range types {
+			switch {
+			case ty.IsObjectType():
+				objectCt++
+			case ty.IsTupleType():
+				tupleCt++
+			case ty == cty.DynamicPseudoType:
+				dynamicCt++
+			default:
+				break
+			}
+		}
+		switch {
+		case objectCt > 0 && (objectCt+dynamicCt) == len(types):
+			return unifyObjectTypes(types, unsafe, dynamicCt > 0)
+		case tupleCt > 0 && (tupleCt+dynamicCt) == len(types):
+			return unifyTupleTypes(types, unsafe, dynamicCt > 0)
+		case objectCt > 0 && tupleCt > 0:
+			// Can never unify object and tuple types since they have incompatible kinds
+			return cty.NilType, nil
+		}
+	}
+
+	prefOrder := sortTypes(types)
+
+	// sortTypes gives us an order where earlier items are preferable as
+	// our result type. We'll now walk through these and choose the first
+	// one we encounter for which conversions exist for all source types.
+	conversions := make([]Conversion, len(types))
+Preferences:
+	for _, wantTypeIdx := range prefOrder {
+		wantType := types[wantTypeIdx]
+		for i, tryType := range types {
+			if i == wantTypeIdx {
+				// Don't need to convert our wanted type to itself
+				conversions[i] = nil
+				continue
+			}
+
+			if tryType.Equals(wantType) {
+				conversions[i] = nil
+				continue
+			}
+
+			if unsafe {
+				conversions[i] = GetConversionUnsafe(tryType, wantType)
+			} else {
+				conversions[i] = GetConversion(tryType, wantType)
+			}
+
+			if conversions[i] == nil {
+				// wantType is not a suitable unification type, so we'll
+				// try the next one in our preference order.
+				continue Preferences
+			}
+		}
+
+		return wantType, conversions
+	}
+
+	// If we fall out here, no unification is possible
+	return cty.NilType, nil
+}
+
+func unifyObjectTypes(types []cty.Type, unsafe bool, hasDynamic bool) (cty.Type, []Conversion) {
+	// If we had any dynamic types in the input here then we can't predict
+	// what path we'll take through here once these become known types, so
+	// we'll conservatively produce DynamicVal for these.
+	if hasDynamic {
+		return unifyAllAsDynamic(types)
+	}
+
+	// There are two different ways we can succeed here:
+	// - If all of the given object types have the same set of attribute names
+	//   and the corresponding types are all unifyable, then we construct that
+	//   type.
+	// - If the given object types have different attribute names or their
+	//   corresponding types are not unifyable, we'll instead try to unify
+	//   all of the attribute types together to produce a map type.
+	//
+	// Our unification behavior is intentionally stricter than our conversion
+	// behavior for subset object types because user intent is different with
+	// unification use-cases: it makes sense to allow {"foo":true} to convert
+	// to emptyobjectval, but unifying an object with an attribute with the
+	// empty object type should be an error because unifying to the empty
+	// object type would be suprising and useless.
+
+	firstAttrs := types[0].AttributeTypes()
+	for _, ty := range types[1:] {
+		thisAttrs := ty.AttributeTypes()
+		if len(thisAttrs) != len(firstAttrs) {
+			// If number of attributes is different then there can be no
+			// object type in common.
+			return unifyObjectTypesToMap(types, unsafe)
+		}
+		for name := range thisAttrs {
+			if _, ok := firstAttrs[name]; !ok {
+				// If attribute names don't exactly match then there can be
+				// no object type in common.
+				return unifyObjectTypesToMap(types, unsafe)
+			}
+		}
+	}
+
+	// If we get here then we've proven that all of the given object types
+	// have exactly the same set of attribute names, though the types may
+	// differ.
+	retAtys := make(map[string]cty.Type)
+	atysAcross := make([]cty.Type, len(types))
+	for name := range firstAttrs {
+		for i, ty := range types {
+			atysAcross[i] = ty.AttributeType(name)
+		}
+		retAtys[name], _ = unify(atysAcross, unsafe)
+		if retAtys[name] == cty.NilType {
+			// Cannot unify this attribute alone, which means that unification
+			// of everything down to a map type can't be possible either.
+			return cty.NilType, nil
+		}
+	}
+	retTy := cty.Object(retAtys)
+
+	conversions := make([]Conversion, len(types))
+	for i, ty := range types {
+		if ty.Equals(retTy) {
+			continue
+		}
+		if unsafe {
+			conversions[i] = GetConversionUnsafe(ty, retTy)
+		} else {
+			conversions[i] = GetConversion(ty, retTy)
+		}
+		if conversions[i] == nil {
+			// Shouldn't be reachable, since we were able to unify
+			return unifyObjectTypesToMap(types, unsafe)
+		}
+	}
+
+	return retTy, conversions
+}
+
+func unifyObjectTypesToMap(types []cty.Type, unsafe bool) (cty.Type, []Conversion) {
+	// This is our fallback case for unifyObjectTypes, where we see if we can
+	// construct a map type that can accept all of the attribute types.
+
+	var atys []cty.Type
+	for _, ty := range types {
+		for _, aty := range ty.AttributeTypes() {
+			atys = append(atys, aty)
+		}
+	}
+
+	ety, _ := unify(atys, unsafe)
+	if ety == cty.NilType {
+		return cty.NilType, nil
+	}
+
+	retTy := cty.Map(ety)
+	conversions := make([]Conversion, len(types))
+	for i, ty := range types {
+		if ty.Equals(retTy) {
+			continue
+		}
+		if unsafe {
+			conversions[i] = GetConversionUnsafe(ty, retTy)
+		} else {
+			conversions[i] = GetConversion(ty, retTy)
+		}
+		if conversions[i] == nil {
+			return cty.NilType, nil
+		}
+	}
+	return retTy, conversions
+}
+
+func unifyTupleTypes(types []cty.Type, unsafe bool, hasDynamic bool) (cty.Type, []Conversion) {
+	// If we had any dynamic types in the input here then we can't predict
+	// what path we'll take through here once these become known types, so
+	// we'll conservatively produce DynamicVal for these.
+	if hasDynamic {
+		return unifyAllAsDynamic(types)
+	}
+
+	// There are two different ways we can succeed here:
+	// - If all of the given tuple types have the same sequence of element types
+	//   and the corresponding types are all unifyable, then we construct that
+	//   type.
+	// - If the given tuple types have different element types or their
+	//   corresponding types are not unifyable, we'll instead try to unify
+	//   all of the elements types together to produce a list type.
+
+	firstEtys := types[0].TupleElementTypes()
+	for _, ty := range types[1:] {
+		thisEtys := ty.TupleElementTypes()
+		if len(thisEtys) != len(firstEtys) {
+			// If number of elements is different then there can be no
+			// tuple type in common.
+			return unifyTupleTypesToList(types, unsafe)
+		}
+	}
+
+	// If we get here then we've proven that all of the given tuple types
+	// have the same number of elements, though the types may differ.
+	retEtys := make([]cty.Type, len(firstEtys))
+	atysAcross := make([]cty.Type, len(types))
+	for idx := range firstEtys {
+		for tyI, ty := range types {
+			atysAcross[tyI] = ty.TupleElementTypes()[idx]
+		}
+		retEtys[idx], _ = unify(atysAcross, unsafe)
+		if retEtys[idx] == cty.NilType {
+			// Cannot unify this element alone, which means that unification
+			// of everything down to a map type can't be possible either.
+			return cty.NilType, nil
+		}
+	}
+	retTy := cty.Tuple(retEtys)
+
+	conversions := make([]Conversion, len(types))
+	for i, ty := range types {
+		if ty.Equals(retTy) {
+			continue
+		}
+		if unsafe {
+			conversions[i] = GetConversionUnsafe(ty, retTy)
+		} else {
+			conversions[i] = GetConversion(ty, retTy)
+		}
+		if conversions[i] == nil {
+			// Shouldn't be reachable, since we were able to unify
+			return unifyTupleTypesToList(types, unsafe)
+		}
+	}
+
+	return retTy, conversions
+}
+
+func unifyTupleTypesToList(types []cty.Type, unsafe bool) (cty.Type, []Conversion) {
+	// This is our fallback case for unifyTupleTypes, where we see if we can
+	// construct a list type that can accept all of the element types.
+
+	var etys []cty.Type
+	for _, ty := range types {
+		for _, ety := range ty.TupleElementTypes() {
+			etys = append(etys, ety)
+		}
+	}
+
+	ety, _ := unify(etys, unsafe)
+	if ety == cty.NilType {
+		return cty.NilType, nil
+	}
+
+	retTy := cty.List(ety)
+	conversions := make([]Conversion, len(types))
+	for i, ty := range types {
+		if ty.Equals(retTy) {
+			continue
+		}
+		if unsafe {
+			conversions[i] = GetConversionUnsafe(ty, retTy)
+		} else {
+			conversions[i] = GetConversion(ty, retTy)
+		}
+		if conversions[i] == nil {
+			// Shouldn't be reachable, since we were able to unify
+			return unifyObjectTypesToMap(types, unsafe)
+		}
+	}
+	return retTy, conversions
+}
+
+func unifyAllAsDynamic(types []cty.Type) (cty.Type, []Conversion) {
+	conversions := make([]Conversion, len(types))
+	for i := range conversions {
+		conversions[i] = func(cty.Value) (cty.Value, error) {
+			return cty.DynamicVal, nil
+		}
+	}
+	return cty.DynamicPseudoType, conversions
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/doc.go b/vendor/github.com/zclconf/go-cty/cty/doc.go
new file mode 100644
index 000000000..d31f0547b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/doc.go
@@ -0,0 +1,18 @@
+// Package cty (pronounced see-tie) provides some infrastructure for a type
+// system that might be useful for applications that need to represent
+// configuration values provided by the user whose types are not known
+// at compile time, particularly if the calling application also allows
+// such values to be used in expressions.
+//
+// The type system consists of primitive types Number, String and Bool, as
+// well as List and Map collection types and Object types that can have
+// arbitrarily-typed sets of attributes.
+//
+// A set of operations is defined on these types, which is accessible via
+// the wrapper struct Value, which annotates the raw, internal representation
+// of a value with its corresponding type.
+//
+// This package is oriented towards being a building block for configuration
+// languages used to bootstrap an application. It is not optimized for use
+// in tight loops where CPU time or memory pressure are a concern.
+package cty
diff --git a/vendor/github.com/zclconf/go-cty/cty/element_iterator.go b/vendor/github.com/zclconf/go-cty/cty/element_iterator.go
new file mode 100644
index 000000000..0bf84c774
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/element_iterator.go
@@ -0,0 +1,191 @@
+package cty
+
+import (
+	"sort"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// ElementIterator is the interface type returned by Value.ElementIterator to
+// allow the caller to iterate over elements of a collection-typed value.
+//
+// Its usage pattern is as follows:
+//
+//     it := val.ElementIterator()
+//     for it.Next() {
+//         key, val := it.Element()
+//         // ...
+//     }
+type ElementIterator interface {
+	Next() bool
+	Element() (key Value, value Value)
+}
+
+func canElementIterator(val Value) bool {
+	switch {
+	case val.ty.IsListType():
+		return true
+	case val.ty.IsMapType():
+		return true
+	case val.ty.IsSetType():
+		return true
+	case val.ty.IsTupleType():
+		return true
+	case val.ty.IsObjectType():
+		return true
+	default:
+		return false
+	}
+}
+
+func elementIterator(val Value) ElementIterator {
+	switch {
+	case val.ty.IsListType():
+		return &listElementIterator{
+			ety:  val.ty.ElementType(),
+			vals: val.v.([]interface{}),
+			idx:  -1,
+		}
+	case val.ty.IsMapType():
+		// We iterate the keys in a predictable lexicographical order so
+		// that results will always be stable given the same input map.
+		rawMap := val.v.(map[string]interface{})
+		keys := make([]string, 0, len(rawMap))
+		for key := range rawMap {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+
+		return &mapElementIterator{
+			ety:  val.ty.ElementType(),
+			vals: rawMap,
+			keys: keys,
+			idx:  -1,
+		}
+	case val.ty.IsSetType():
+		rawSet := val.v.(set.Set)
+		return &setElementIterator{
+			ety:   val.ty.ElementType(),
+			setIt: rawSet.Iterator(),
+		}
+	case val.ty.IsTupleType():
+		return &tupleElementIterator{
+			etys: val.ty.TupleElementTypes(),
+			vals: val.v.([]interface{}),
+			idx:  -1,
+		}
+	case val.ty.IsObjectType():
+		// We iterate the keys in a predictable lexicographical order so
+		// that results will always be stable given the same object type.
+		atys := val.ty.AttributeTypes()
+		keys := make([]string, 0, len(atys))
+		for key := range atys {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+
+		return &objectElementIterator{
+			atys:      atys,
+			vals:      val.v.(map[string]interface{}),
+			attrNames: keys,
+			idx:       -1,
+		}
+	default:
+		panic("attempt to iterate on non-collection, non-tuple type")
+	}
+}
+
+type listElementIterator struct {
+	ety  Type
+	vals []interface{}
+	idx  int
+}
+
+func (it *listElementIterator) Element() (Value, Value) {
+	i := it.idx
+	return NumberIntVal(int64(i)), Value{
+		ty: it.ety,
+		v:  it.vals[i],
+	}
+}
+
+func (it *listElementIterator) Next() bool {
+	it.idx++
+	return it.idx < len(it.vals)
+}
+
+type mapElementIterator struct {
+	ety  Type
+	vals map[string]interface{}
+	keys []string
+	idx  int
+}
+
+func (it *mapElementIterator) Element() (Value, Value) {
+	key := it.keys[it.idx]
+	return StringVal(key), Value{
+		ty: it.ety,
+		v:  it.vals[key],
+	}
+}
+
+func (it *mapElementIterator) Next() bool {
+	it.idx++
+	return it.idx < len(it.keys)
+}
+
+type setElementIterator struct {
+	ety   Type
+	setIt *set.Iterator
+}
+
+func (it *setElementIterator) Element() (Value, Value) {
+	val := Value{
+		ty: it.ety,
+		v:  it.setIt.Value(),
+	}
+	return val, val
+}
+
+func (it *setElementIterator) Next() bool {
+	return it.setIt.Next()
+}
+
+type tupleElementIterator struct {
+	etys []Type
+	vals []interface{}
+	idx  int
+}
+
+func (it *tupleElementIterator) Element() (Value, Value) {
+	i := it.idx
+	return NumberIntVal(int64(i)), Value{
+		ty: it.etys[i],
+		v:  it.vals[i],
+	}
+}
+
+func (it *tupleElementIterator) Next() bool {
+	it.idx++
+	return it.idx < len(it.vals)
+}
+
+type objectElementIterator struct {
+	atys      map[string]Type
+	vals      map[string]interface{}
+	attrNames []string
+	idx       int
+}
+
+func (it *objectElementIterator) Element() (Value, Value) {
+	key := it.attrNames[it.idx]
+	return StringVal(key), Value{
+		ty: it.atys[key],
+		v:  it.vals[key],
+	}
+}
+
+func (it *objectElementIterator) Next() bool {
+	it.idx++
+	return it.idx < len(it.attrNames)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/error.go b/vendor/github.com/zclconf/go-cty/cty/error.go
new file mode 100644
index 000000000..dd139f724
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/error.go
@@ -0,0 +1,55 @@
+package cty
+
+import (
+	"fmt"
+)
+
+// PathError is a specialization of error that represents where in a
+// potentially-deep data structure an error occured, using a Path.
+type PathError struct {
+	error
+	Path Path
+}
+
+func errorf(path Path, f string, args ...interface{}) error {
+	// We need to copy the Path because often our caller builds it by
+	// continually mutating the same underlying buffer.
+	sPath := make(Path, len(path))
+	copy(sPath, path)
+	return PathError{
+		error: fmt.Errorf(f, args...),
+		Path:  sPath,
+	}
+}
+
+// NewErrorf creates a new PathError for the current path by passing the
+// given format and arguments to fmt.Errorf and then wrapping the result
+// similarly to NewError.
+func (p Path) NewErrorf(f string, args ...interface{}) error {
+	return errorf(p, f, args...)
+}
+
+// NewError creates a new PathError for the current path, wrapping the given
+// error.
+func (p Path) NewError(err error) error {
+	// if we're being asked to wrap an existing PathError then our new
+	// PathError will be the concatenation of the two paths, ensuring
+	// that we still get a single flat PathError that's thus easier for
+	// callers to deal with.
+	perr, wrappingPath := err.(PathError)
+	pathLen := len(p)
+	if wrappingPath {
+		pathLen = pathLen + len(perr.Path)
+	}
+
+	sPath := make(Path, pathLen)
+	copy(sPath, p)
+	if wrappingPath {
+		copy(sPath[len(p):], perr.Path)
+	}
+
+	return PathError{
+		error: err,
+		Path:  sPath,
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/argument.go b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
new file mode 100644
index 000000000..bfd30157e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
@@ -0,0 +1,50 @@
+package function
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Parameter represents a parameter to a function.
+type Parameter struct {
+	// Name is an optional name for the argument. This package ignores this
+	// value, but callers may use it for documentation, etc.
+	Name string
+
+	// A type that any argument for this parameter must conform to.
+	// cty.DynamicPseudoType can be used, either at top-level or nested
+	// in a parameterized type, to indicate that any type should be
+	// permitted, to allow the definition of type-generic functions.
+	Type cty.Type
+
+	// If AllowNull is set then null values may be passed into this
+	// argument's slot in both the type-check function and the implementation
+	// function. If not set, such values are rejected by the built-in
+	// checking rules.
+	AllowNull bool
+
+	// If AllowUnknown is set then unknown values may be passed into this
+	// argument's slot in the implementation function. If not set, any
+	// unknown values will cause the function to immediately return
+	// an unkonwn value without calling the implementation function, thus
+	// freeing the function implementer from dealing with this case.
+	AllowUnknown bool
+
+	// If AllowDynamicType is set then DynamicVal may be passed into this
+	// argument's slot in the implementation function. If not set, any
+	// dynamic values will cause the function to immediately return
+	// DynamicVal value without calling the implementation function, thus
+	// freeing the function implementer from dealing with this case.
+	//
+	// Note that DynamicVal is also unknown, so in order to receive dynamic
+	// *values* it is also necessary to set AllowUnknown.
+	//
+	// However, it is valid to set AllowDynamicType without AllowUnknown, in
+	// which case a dynamic value may be passed to the type checking function
+	// but will not make it to the *implementation* function. Instead, an
+	// unknown value of the type returned by the type-check function will be
+	// returned. This is suggested for functions that have a static return
+	// type since it allows the return value to be typed even if the input
+	// values are not, thus improving the type-check accuracy of derived
+	// values.
+	AllowDynamicType bool
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/doc.go b/vendor/github.com/zclconf/go-cty/cty/function/doc.go
new file mode 100644
index 000000000..393b3110b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/doc.go
@@ -0,0 +1,6 @@
+// Package function builds on the functionality of cty by modeling functions
+// that operate on cty Values.
+//
+// Functions are, at their core, Go anonymous functions. However, this package
+// wraps around them utility functions for parameter type checking, etc.
+package function
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/error.go b/vendor/github.com/zclconf/go-cty/cty/function/error.go
new file mode 100644
index 000000000..2b5677998
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/error.go
@@ -0,0 +1,50 @@
+package function
+
+import (
+	"fmt"
+	"runtime/debug"
+)
+
+// ArgError represents an error with one of the arguments in a call. The
+// attribute Index represents the zero-based index of the argument in question.
+//
+// Its error *may* be a cty.PathError, in which case the error actually
+// pertains to a nested value within the data structure passed as the argument.
+type ArgError struct {
+	error
+	Index int
+}
+
+func NewArgErrorf(i int, f string, args ...interface{}) error {
+	return ArgError{
+		error: fmt.Errorf(f, args...),
+		Index: i,
+	}
+}
+
+func NewArgError(i int, err error) error {
+	return ArgError{
+		error: err,
+		Index: i,
+	}
+}
+
+// PanicError indicates that a panic occurred while executing either a
+// function's type or implementation function. This is captured and wrapped
+// into a normal error so that callers (expected to be language runtimes)
+// are freed from having to deal with panics in buggy functions.
+type PanicError struct {
+	Value interface{}
+	Stack []byte
+}
+
+func errorForPanic(val interface{}) error {
+	return PanicError{
+		Value: val,
+		Stack: debug.Stack(),
+	}
+}
+
+func (e PanicError) Error() string {
+	return fmt.Sprintf("panic in function implementation: %s\n%s", e.Value, e.Stack)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/function.go b/vendor/github.com/zclconf/go-cty/cty/function/function.go
new file mode 100644
index 000000000..9e8bf3376
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/function.go
@@ -0,0 +1,291 @@
+package function
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Function represents a function. This is the main type in this package.
+type Function struct {
+	spec *Spec
+}
+
+// Spec is the specification of a function, used to instantiate
+// a new Function.
+type Spec struct {
+	// Params is a description of the positional parameters for the function.
+	// The standard checking logic rejects any calls that do not provide
+	// arguments conforming to this definition, freeing the function
+	// implementer from dealing with such inconsistencies.
+	Params []Parameter
+
+	// VarParam is an optional specification of additional "varargs" the
+	// function accepts. If this is non-nil then callers may provide an
+	// arbitrary number of additional arguments (after those matching with
+	// the fixed parameters in Params) that conform to the given specification,
+	// which will appear as additional values in the slices of values
+	// provided to the type and implementation functions.
+	VarParam *Parameter
+
+	// Type is the TypeFunc that decides the return type of the function
+	// given its arguments, which may be Unknown. See the documentation
+	// of TypeFunc for more information.
+	//
+	// Use StaticReturnType if the function's return type does not vary
+	// depending on its arguments.
+	Type TypeFunc
+
+	// Impl is the ImplFunc that implements the function's behavior.
+	//
+	// Functions are expected to behave as pure functions, and not create
+	// any visible side-effects.
+	//
+	// If a TypeFunc is also provided, the value returned from Impl *must*
+	// conform to the type it returns, or a call to the function will panic.
+	Impl ImplFunc
+}
+
+// New creates a new function with the given specification.
+//
+// After passing a Spec to this function, the caller must no longer read from
+// or mutate it.
+func New(spec *Spec) Function {
+	f := Function{
+		spec: spec,
+	}
+	return f
+}
+
+// TypeFunc is a callback type for determining the return type of a function
+// given its arguments.
+//
+// Any of the values passed to this function may be unknown, even if the
+// parameters are not configured to accept unknowns.
+//
+// If any of the given values are *not* unknown, the TypeFunc may use the
+// values for pre-validation and for choosing the return type. For example,
+// a hypothetical JSON-unmarshalling function could return
+// cty.DynamicPseudoType if the given JSON string is unknown, but return
+// a concrete type based on the JSON structure if the JSON string is already
+// known.
+type TypeFunc func(args []cty.Value) (cty.Type, error)
+
+// ImplFunc is a callback type for the main implementation of a function.
+//
+// "args" are the values for the arguments, and this slice will always be at
+// least as long as the argument definition slice for the function.
+//
+// "retType" is the type returned from the Type callback, included as a
+// convenience to avoid the need to re-compute the return type for generic
+// functions whose return type is a function of the arguments.
+type ImplFunc func(args []cty.Value, retType cty.Type) (cty.Value, error)
+
+// StaticReturnType returns a TypeFunc that always returns the given type.
+//
+// This is provided as a convenience for defining a function whose return
+// type does not depend on the argument types.
+func StaticReturnType(ty cty.Type) TypeFunc {
+	return func([]cty.Value) (cty.Type, error) {
+		return ty, nil
+	}
+}
+
+// ReturnType returns the return type of a function given a set of candidate
+// argument types, or returns an error if the given types are unacceptable.
+//
+// If the caller already knows values for at least some of the arguments
+// it can be better to call ReturnTypeForValues, since certain functions may
+// determine their return types from their values and return DynamicVal if
+// the values are unknown.
+func (f Function) ReturnType(argTypes []cty.Type) (cty.Type, error) {
+	vals := make([]cty.Value, len(argTypes))
+	for i, ty := range argTypes {
+		vals[i] = cty.UnknownVal(ty)
+	}
+	return f.ReturnTypeForValues(vals)
+}
+
+// ReturnTypeForValues is similar to ReturnType but can be used if the caller
+// already knows the values of some or all of the arguments, in which case
+// the function may be able to determine a more definite result if its
+// return type depends on the argument *values*.
+//
+// For any arguments whose values are not known, pass an Unknown value of
+// the appropriate type.
+func (f Function) ReturnTypeForValues(args []cty.Value) (ty cty.Type, err error) {
+	var posArgs []cty.Value
+	var varArgs []cty.Value
+
+	if f.spec.VarParam == nil {
+		if len(args) != len(f.spec.Params) {
+			return cty.Type{}, fmt.Errorf(
+				"wrong number of arguments (%d required; %d given)",
+				len(f.spec.Params), len(args),
+			)
+		}
+
+		posArgs = args
+		varArgs = nil
+	} else {
+		if len(args) < len(f.spec.Params) {
+			return cty.Type{}, fmt.Errorf(
+				"wrong number of arguments (at least %d required; %d given)",
+				len(f.spec.Params), len(args),
+			)
+		}
+
+		posArgs = args[0:len(f.spec.Params)]
+		varArgs = args[len(f.spec.Params):]
+	}
+
+	for i, spec := range f.spec.Params {
+		val := posArgs[i]
+
+		if val.IsNull() && !spec.AllowNull {
+			return cty.Type{}, NewArgErrorf(i, "argument must not be null")
+		}
+
+		// AllowUnknown is ignored for type-checking, since we expect to be
+		// able to type check with unknown values. We *do* still need to deal
+		// with DynamicPseudoType here though, since the Type function might
+		// not be ready to deal with that.
+
+		if val.Type() == cty.DynamicPseudoType {
+			if !spec.AllowDynamicType {
+				return cty.DynamicPseudoType, nil
+			}
+		} else if errs := val.Type().TestConformance(spec.Type); errs != nil {
+			// For now we'll just return the first error in the set, since
+			// we don't have a good way to return the whole list here.
+			// Would be good to do something better at some point...
+			return cty.Type{}, NewArgError(i, errs[0])
+		}
+	}
+
+	if varArgs != nil {
+		spec := f.spec.VarParam
+		for i, val := range varArgs {
+			realI := i + len(posArgs)
+
+			if val.IsNull() && !spec.AllowNull {
+				return cty.Type{}, NewArgErrorf(realI, "argument must not be null")
+			}
+
+			if val.Type() == cty.DynamicPseudoType {
+				if !spec.AllowDynamicType {
+					return cty.DynamicPseudoType, nil
+				}
+			} else if errs := val.Type().TestConformance(spec.Type); errs != nil {
+				// For now we'll just return the first error in the set, since
+				// we don't have a good way to return the whole list here.
+				// Would be good to do something better at some point...
+				return cty.Type{}, NewArgError(i, errs[0])
+			}
+		}
+	}
+
+	// Intercept any panics from the function and return them as normal errors,
+	// so a calling language runtime doesn't need to deal with panics.
+	defer func() {
+		if r := recover(); r != nil {
+			ty = cty.NilType
+			err = errorForPanic(r)
+		}
+	}()
+
+	return f.spec.Type(args)
+}
+
+// Call actually calls the function with the given arguments, which must
+// conform to the function's parameter specification or an error will be
+// returned.
+func (f Function) Call(args []cty.Value) (val cty.Value, err error) {
+	expectedType, err := f.ReturnTypeForValues(args)
+	if err != nil {
+		return cty.NilVal, err
+	}
+
+	// Type checking already dealt with most situations relating to our
+	// parameter specification, but we still need to deal with unknown
+	// values.
+	posArgs := args[:len(f.spec.Params)]
+	varArgs := args[len(f.spec.Params):]
+
+	for i, spec := range f.spec.Params {
+		val := posArgs[i]
+
+		if !val.IsKnown() && !spec.AllowUnknown {
+			return cty.UnknownVal(expectedType), nil
+		}
+	}
+
+	if f.spec.VarParam != nil {
+		spec := f.spec.VarParam
+		for _, val := range varArgs {
+			if !val.IsKnown() && !spec.AllowUnknown {
+				return cty.UnknownVal(expectedType), nil
+			}
+		}
+	}
+
+	var retVal cty.Value
+	{
+		// Intercept any panics from the function and return them as normal errors,
+		// so a calling language runtime doesn't need to deal with panics.
+		defer func() {
+			if r := recover(); r != nil {
+				val = cty.NilVal
+				err = errorForPanic(r)
+			}
+		}()
+
+		retVal, err = f.spec.Impl(args, expectedType)
+		if err != nil {
+			return cty.NilVal, err
+		}
+	}
+
+	// Returned value must conform to what the Type function expected, to
+	// protect callers from having to deal with inconsistencies.
+	if errs := retVal.Type().TestConformance(expectedType); errs != nil {
+		panic(fmt.Errorf(
+			"returned value %#v does not conform to expected return type %#v: %s",
+			retVal, expectedType, errs[0],
+		))
+	}
+
+	return retVal, nil
+}
+
+// ProxyFunc the type returned by the method Function.Proxy.
+type ProxyFunc func(args ...cty.Value) (cty.Value, error)
+
+// Proxy returns a function that can be called with cty.Value arguments
+// to run the function. This is provided as a convenience for when using
+// a function directly within Go code.
+func (f Function) Proxy() ProxyFunc {
+	return func(args ...cty.Value) (cty.Value, error) {
+		return f.Call(args)
+	}
+}
+
+// Params returns information about the function's fixed positional parameters.
+// This does not include information about any variadic arguments accepted;
+// for that, call VarParam.
+func (f Function) Params() []Parameter {
+	new := make([]Parameter, len(f.spec.Params))
+	copy(new, f.spec.Params)
+	return new
+}
+
+// VarParam returns information about the variadic arguments the function
+// expects, or nil if the function is not variadic.
+func (f Function) VarParam() *Parameter {
+	if f.spec.VarParam == nil {
+		return nil
+	}
+
+	ret := *f.spec.VarParam
+	return &ret
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
new file mode 100644
index 000000000..a473d0ec3
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
@@ -0,0 +1,73 @@
+package stdlib
+
+import (
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var NotFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "val",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Not(), nil
+	},
+})
+
+var AndFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].And(args[1]), nil
+	},
+})
+
+var OrFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Or(args[1]), nil
+	},
+})
+
+// Not returns the logical complement of the given boolean value.
+func Not(num cty.Value) (cty.Value, error) {
+	return NotFunc.Call([]cty.Value{num})
+}
+
+// And returns true if and only if both of the given boolean values are true.
+func And(a, b cty.Value) (cty.Value, error) {
+	return AndFunc.Call([]cty.Value{a, b})
+}
+
+// Or returns true if either of the given boolean values are true.
+func Or(a, b cty.Value) (cty.Value, error) {
+	return OrFunc.Call([]cty.Value{a, b})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
new file mode 100644
index 000000000..a132e0cde
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
@@ -0,0 +1,112 @@
+package stdlib
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// Bytes is a capsule type that can be used with the binary functions to
+// support applications that need to support raw buffers in addition to
+// UTF-8 strings.
+var Bytes = cty.Capsule("bytes", reflect.TypeOf([]byte(nil)))
+
+// BytesVal creates a new Bytes value from the given buffer, which must be
+// non-nil or this function will panic.
+//
+// Once a byte slice has been wrapped in a Bytes capsule, its underlying array
+// must be considered immutable.
+func BytesVal(buf []byte) cty.Value {
+	if buf == nil {
+		panic("can't make Bytes value from nil slice")
+	}
+
+	return cty.CapsuleVal(Bytes, &buf)
+}
+
+// BytesLen is a Function that returns the length of the buffer encapsulated
+// in a Bytes value.
+var BytesLenFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "buf",
+			Type:             Bytes,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		bufPtr := args[0].EncapsulatedValue().(*[]byte)
+		return cty.NumberIntVal(int64(len(*bufPtr))), nil
+	},
+})
+
+// BytesSlice is a Function that returns a slice of the given Bytes value.
+var BytesSliceFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "buf",
+			Type:             Bytes,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "offset",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "length",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(Bytes),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		bufPtr := args[0].EncapsulatedValue().(*[]byte)
+
+		var offset, length int
+
+		var err error
+		err = gocty.FromCtyValue(args[1], &offset)
+		if err != nil {
+			return cty.NilVal, err
+		}
+		err = gocty.FromCtyValue(args[2], &length)
+		if err != nil {
+			return cty.NilVal, err
+		}
+
+		if offset < 0 || length < 0 {
+			return cty.NilVal, fmt.Errorf("offset and length must be non-negative")
+		}
+
+		if offset > len(*bufPtr) {
+			return cty.NilVal, fmt.Errorf(
+				"offset %d is greater than total buffer length %d",
+				offset, len(*bufPtr),
+			)
+		}
+
+		end := offset + length
+
+		if end > len(*bufPtr) {
+			return cty.NilVal, fmt.Errorf(
+				"offset %d + length %d is greater than total buffer length %d",
+				offset, length, len(*bufPtr),
+			)
+		}
+
+		return BytesVal((*bufPtr)[offset:end]), nil
+	},
+})
+
+func BytesLen(buf cty.Value) (cty.Value, error) {
+	return BytesLenFunc.Call([]cty.Value{buf})
+}
+
+func BytesSlice(buf cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+	return BytesSliceFunc.Call([]cty.Value{buf, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
new file mode 100644
index 000000000..967ba03c8
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
@@ -0,0 +1,140 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+var HasIndexFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "collection",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "key",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		collTy := args[0].Type()
+		if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy == cty.DynamicPseudoType) {
+			return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+		}
+		return cty.Bool, nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].HasIndex(args[1]), nil
+	},
+})
+
+var IndexFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "collection",
+			Type: cty.DynamicPseudoType,
+		},
+		{
+			Name:             "key",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		collTy := args[0].Type()
+		key := args[1]
+		keyTy := key.Type()
+		switch {
+		case collTy.IsTupleType():
+			if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+				return cty.NilType, fmt.Errorf("key for tuple must be number")
+			}
+			if !key.IsKnown() {
+				return cty.DynamicPseudoType, nil
+			}
+			var idx int
+			err := gocty.FromCtyValue(key, &idx)
+			if err != nil {
+				return cty.NilType, fmt.Errorf("invalid key for tuple: %s", err)
+			}
+
+			etys := collTy.TupleElementTypes()
+
+			if idx >= len(etys) || idx < 0 {
+				return cty.NilType, fmt.Errorf("key must be between 0 and %d inclusive", len(etys))
+			}
+
+			return etys[idx], nil
+
+		case collTy.IsListType():
+			if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+				return cty.NilType, fmt.Errorf("key for list must be number")
+			}
+
+			return collTy.ElementType(), nil
+
+		case collTy.IsMapType():
+			if keyTy != cty.String && keyTy != cty.DynamicPseudoType {
+				return cty.NilType, fmt.Errorf("key for map must be string")
+			}
+
+			return collTy.ElementType(), nil
+
+		default:
+			return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+		}
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		has, err := HasIndex(args[0], args[1])
+		if err != nil {
+			return cty.NilVal, err
+		}
+		if has.False() { // safe because collection and key are guaranteed known here
+			return cty.NilVal, fmt.Errorf("invalid index")
+		}
+
+		return args[0].Index(args[1]), nil
+	},
+})
+
+var LengthFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "collection",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		collTy := args[0].Type()
+		if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy.IsSetType() || collTy == cty.DynamicPseudoType) {
+			return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+		}
+		return cty.Number, nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].Length(), nil
+	},
+})
+
+// HasIndex determines whether the given collection can be indexed with the
+// given key.
+func HasIndex(collection cty.Value, key cty.Value) (cty.Value, error) {
+	return HasIndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Index returns an element from the given collection using the given key,
+// or returns an error if there is no element for the given key.
+func Index(collection cty.Value, key cty.Value) (cty.Value, error) {
+	return IndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Length returns the number of elements in the given collection.
+func Length(collection cty.Value) (cty.Value, error) {
+	return LengthFunc.Call([]cty.Value{collection})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
new file mode 100644
index 000000000..5070a5adf
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
@@ -0,0 +1,93 @@
+package stdlib
+
+import (
+	"encoding/csv"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var CSVDecodeFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "str",
+			Type: cty.String,
+		},
+	},
+	Type: func(args []cty.Value) (cty.Type, error) {
+		str := args[0]
+		if !str.IsKnown() {
+			return cty.DynamicPseudoType, nil
+		}
+
+		r := strings.NewReader(str.AsString())
+		cr := csv.NewReader(r)
+		headers, err := cr.Read()
+		if err == io.EOF {
+			return cty.DynamicPseudoType, fmt.Errorf("missing header line")
+		}
+		if err != nil {
+			return cty.DynamicPseudoType, err
+		}
+
+		atys := make(map[string]cty.Type, len(headers))
+		for _, name := range headers {
+			if _, exists := atys[name]; exists {
+				return cty.DynamicPseudoType, fmt.Errorf("duplicate column name %q", name)
+			}
+			atys[name] = cty.String
+		}
+		return cty.List(cty.Object(atys)), nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		ety := retType.ElementType()
+		atys := ety.AttributeTypes()
+		str := args[0]
+		r := strings.NewReader(str.AsString())
+		cr := csv.NewReader(r)
+		cr.FieldsPerRecord = len(atys)
+
+		// Read the header row first, since that'll tell us which indices
+		// map to which attribute names.
+		headers, err := cr.Read()
+		if err != nil {
+			return cty.DynamicVal, err
+		}
+
+		var rows []cty.Value
+		for {
+			cols, err := cr.Read()
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				return cty.DynamicVal, err
+			}
+
+			vals := make(map[string]cty.Value, len(cols))
+			for i, str := range cols {
+				name := headers[i]
+				vals[name] = cty.StringVal(str)
+			}
+			rows = append(rows, cty.ObjectVal(vals))
+		}
+
+		if len(rows) == 0 {
+			return cty.ListValEmpty(ety), nil
+		}
+		return cty.ListVal(rows), nil
+	},
+})
+
+// CSVDecode parses the given CSV (RFC 4180) string and, if it is valid,
+// returns a list of objects representing the rows.
+//
+// The result is always a list of some object type. The first row of the
+// input is used to determine the object attributes, and subsequent rows
+// determine the values of those attributes.
+func CSVDecode(str cty.Value) (cty.Value, error) {
+	return CSVDecodeFunc.Call([]cty.Value{str})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
new file mode 100644
index 000000000..aa15b7bde
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/datetime.go
@@ -0,0 +1,385 @@
+package stdlib
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var FormatDateFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "format",
+			Type: cty.String,
+		},
+		{
+			Name: "time",
+			Type: cty.String,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		formatStr := args[0].AsString()
+		timeStr := args[1].AsString()
+		t, err := parseTimestamp(timeStr)
+		if err != nil {
+			return cty.DynamicVal, function.NewArgError(1, err)
+		}
+
+		var buf bytes.Buffer
+		sc := bufio.NewScanner(strings.NewReader(formatStr))
+		sc.Split(splitDateFormat)
+		const esc = '\''
+		for sc.Scan() {
+			tok := sc.Bytes()
+
+			// The leading byte signals the token type
+			switch {
+			case tok[0] == esc:
+				if tok[len(tok)-1] != esc || len(tok) == 1 {
+					return cty.DynamicVal, function.NewArgErrorf(0, "unterminated literal '")
+				}
+				if len(tok) == 2 {
+					// Must be a single escaped quote, ''
+					buf.WriteByte(esc)
+				} else {
+					// The content (until a closing esc) is printed out verbatim
+					// except that we must un-double any double-esc escapes in
+					// the middle of the string.
+					raw := tok[1 : len(tok)-1]
+					for i := 0; i < len(raw); i++ {
+						buf.WriteByte(raw[i])
+						if raw[i] == esc {
+							i++ // skip the escaped quote
+						}
+					}
+				}
+
+			case startsDateFormatVerb(tok[0]):
+				switch tok[0] {
+				case 'Y':
+					y := t.Year()
+					switch len(tok) {
+					case 2:
+						fmt.Fprintf(&buf, "%02d", y%100)
+					case 4:
+						fmt.Fprintf(&buf, "%04d", y)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: year must either be \"YY\" or \"YYYY\"", tok)
+					}
+				case 'M':
+					m := t.Month()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", m)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", m)
+					case 3:
+						buf.WriteString(m.String()[:3])
+					case 4:
+						buf.WriteString(m.String())
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: month must be \"M\", \"MM\", \"MMM\", or \"MMMM\"", tok)
+					}
+				case 'D':
+					d := t.Day()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", d)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", d)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: day of month must either be \"D\" or \"DD\"", tok)
+					}
+				case 'E':
+					d := t.Weekday()
+					switch len(tok) {
+					case 3:
+						buf.WriteString(d.String()[:3])
+					case 4:
+						buf.WriteString(d.String())
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: day of week must either be \"EEE\" or \"EEEE\"", tok)
+					}
+				case 'h':
+					h := t.Hour()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", h)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", h)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: 24-hour must either be \"h\" or \"hh\"", tok)
+					}
+				case 'H':
+					h := t.Hour() % 12
+					if h == 0 {
+						h = 12
+					}
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", h)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", h)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: 12-hour must either be \"H\" or \"HH\"", tok)
+					}
+				case 'A', 'a':
+					if len(tok) != 2 {
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: must be \"%s%s\"", tok, tok[0:1], tok[0:1])
+					}
+					upper := tok[0] == 'A'
+					switch t.Hour() / 12 {
+					case 0:
+						if upper {
+							buf.WriteString("AM")
+						} else {
+							buf.WriteString("am")
+						}
+					case 1:
+						if upper {
+							buf.WriteString("PM")
+						} else {
+							buf.WriteString("pm")
+						}
+					}
+				case 'm':
+					m := t.Minute()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", m)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", m)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: minute must either be \"m\" or \"mm\"", tok)
+					}
+				case 's':
+					s := t.Second()
+					switch len(tok) {
+					case 1:
+						fmt.Fprintf(&buf, "%d", s)
+					case 2:
+						fmt.Fprintf(&buf, "%02d", s)
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: second must either be \"s\" or \"ss\"", tok)
+					}
+				case 'Z':
+					// We'll just lean on Go's own formatter for this one, since
+					// the necessary information is unexported.
+					switch len(tok) {
+					case 1:
+						buf.WriteString(t.Format("Z07:00"))
+					case 3:
+						str := t.Format("-0700")
+						switch str {
+						case "+0000":
+							buf.WriteString("UTC")
+						default:
+							buf.WriteString(str)
+						}
+					case 4:
+						buf.WriteString(t.Format("-0700"))
+					case 5:
+						buf.WriteString(t.Format("-07:00"))
+					default:
+						return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q: timezone must be Z, ZZZZ, or ZZZZZ", tok)
+					}
+				default:
+					return cty.DynamicVal, function.NewArgErrorf(0, "invalid date format verb %q", tok)
+				}
+
+			default:
+				// Any other starting character indicates a literal sequence
+				buf.Write(tok)
+			}
+		}
+
+		return cty.StringVal(buf.String()), nil
+	},
+})
+
+// FormatDate reformats a timestamp given in RFC3339 syntax into another time
+// syntax defined by a given format string.
+//
+// The format string uses letter mnemonics to represent portions of the
+// timestamp, with repetition signifying length variants of each portion.
+// Single quote characters ' can be used to quote sequences of literal letters
+// that should not be interpreted as formatting mnemonics.
+//
+// The full set of supported mnemonic sequences is listed below:
+//
+//     YY       Year modulo 100 zero-padded to two digits, like "06".
+//     YYYY     Four (or more) digit year, like "2006".
+//     M        Month number, like "1" for January.
+//     MM       Month number zero-padded to two digits, like "01".
+//     MMM      English month name abbreviated to three letters, like "Jan".
+//     MMMM     English month name unabbreviated, like "January".
+//     D        Day of month number, like "2".
+//     DD       Day of month number zero-padded to two digits, like "02".
+//     EEE      English day of week name abbreviated to three letters, like "Mon".
+//     EEEE     English day of week name unabbreviated, like "Monday".
+//     h        24-hour number, like "2".
+//     hh       24-hour number zero-padded to two digits, like "02".
+//     H        12-hour number, like "2".
+//     HH       12-hour number zero-padded to two digits, like "02".
+//     AA       Hour AM/PM marker in uppercase, like "AM".
+//     aa       Hour AM/PM marker in lowercase, like "am".
+//     m        Minute within hour, like "5".
+//     mm       Minute within hour zero-padded to two digits, like "05".
+//     s        Second within minute, like "9".
+//     ss       Second within minute zero-padded to two digits, like "09".
+//     ZZZZ     Timezone offset with just sign and digit, like "-0800".
+//     ZZZZZ    Timezone offset with colon separating hours and minutes, like "-08:00".
+//     Z        Like ZZZZZ but with a special case "Z" for UTC.
+//     ZZZ      Like ZZZZ but with a special case "UTC" for UTC.
+//
+// The format syntax is optimized mainly for generating machine-oriented
+// timestamps rather than human-oriented timestamps; the English language
+// portions of the output reflect the use of English names in a number of
+// machine-readable date formatting standards. For presentation to humans,
+// a locale-aware time formatter (not included in this package) is a better
+// choice.
+//
+// The format syntax is not compatible with that of any other language, but
+// is optimized so that patterns for common standard date formats can be
+// recognized quickly even by a reader unfamiliar with the format syntax.
+func FormatDate(format cty.Value, timestamp cty.Value) (cty.Value, error) {
+	return FormatDateFunc.Call([]cty.Value{format, timestamp})
+}
+
+func parseTimestamp(ts string) (time.Time, error) {
+	t, err := time.Parse(time.RFC3339, ts)
+	if err != nil {
+		switch err := err.(type) {
+		case *time.ParseError:
+			// If err is s time.ParseError then its string representation is not
+			// appropriate since it relies on details of Go's strange date format
+			// representation, which a caller of our functions is not expected
+			// to be familiar with.
+			//
+			// Therefore we do some light transformation to get a more suitable
+			// error that should make more sense to our callers. These are
+			// still not awesome error messages, but at least they refer to
+			// the timestamp portions by name rather than by Go's example
+			// values.
+			if err.LayoutElem == "" && err.ValueElem == "" && err.Message != "" {
+				// For some reason err.Message is populated with a ": " prefix
+				// by the time package.
+				return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp%s", err.Message)
+			}
+			var what string
+			switch err.LayoutElem {
+			case "2006":
+				what = "year"
+			case "01":
+				what = "month"
+			case "02":
+				what = "day of month"
+			case "15":
+				what = "hour"
+			case "04":
+				what = "minute"
+			case "05":
+				what = "second"
+			case "Z07:00":
+				what = "UTC offset"
+			case "T":
+				return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: missing required time introducer 'T'")
+			case ":", "-":
+				if err.ValueElem == "" {
+					return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: end of string where %q is expected", err.LayoutElem)
+				} else {
+					return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: found %q where %q is expected", err.ValueElem, err.LayoutElem)
+				}
+			default:
+				// Should never get here, because time.RFC3339 includes only the
+				// above portions, but since that might change in future we'll
+				// be robust here.
+				what = "timestamp segment"
+			}
+			if err.ValueElem == "" {
+				return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: end of string before %s", what)
+			} else {
+				return time.Time{}, fmt.Errorf("not a valid RFC3339 timestamp: cannot use %q as %s", err.ValueElem, what)
+			}
+		}
+		return time.Time{}, err
+	}
+	return t, nil
+}
+
+// splitDataFormat is a bufio.SplitFunc used to tokenize a date format.
+func splitDateFormat(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	if len(data) == 0 {
+		return 0, nil, nil
+	}
+
+	const esc = '\''
+
+	switch {
+
+	case data[0] == esc:
+		// If we have another quote immediately after then this is a single
+		// escaped escape.
+		if len(data) > 1 && data[1] == esc {
+			return 2, data[:2], nil
+		}
+
+		// Beginning of quoted sequence, so we will seek forward until we find
+		// the closing quote, ignoring escaped quotes along the way.
+		for i := 1; i < len(data); i++ {
+			if data[i] == esc {
+				if (i + 1) == len(data) {
+					// We need at least one more byte to decide if this is an
+					// escape or a terminator.
+					return 0, nil, nil
+				}
+				if data[i+1] == esc {
+					i++ // doubled-up quotes are an escape sequence
+					continue
+				}
+				// We've found the closing quote
+				return i + 1, data[:i+1], nil
+			}
+		}
+		// If we fall out here then we need more bytes to find the end,
+		// unless we're already at the end with an unclosed quote.
+		if atEOF {
+			return len(data), data, nil
+		}
+		return 0, nil, nil
+
+	case startsDateFormatVerb(data[0]):
+		rep := data[0]
+		for i := 1; i < len(data); i++ {
+			if data[i] != rep {
+				return i, data[:i], nil
+			}
+		}
+		if atEOF {
+			return len(data), data, nil
+		}
+		// We need more data to decide if we've found the end
+		return 0, nil, nil
+
+	default:
+		for i := 1; i < len(data); i++ {
+			if data[i] == esc || startsDateFormatVerb(data[i]) {
+				return i, data[:i], nil
+			}
+		}
+		// We might not actually be at the end of a literal sequence,
+		// but that doesn't matter since we'll concat them back together
+		// anyway.
+		return len(data), data, nil
+	}
+}
+
+func startsDateFormatVerb(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
new file mode 100644
index 000000000..cfb613e5a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
@@ -0,0 +1,13 @@
+// Package stdlib is a collection of cty functions that are expected to be
+// generally useful, and are thus factored out into this shared library in
+// the hope that cty-using applications will have consistent behavior when
+// using these functions.
+//
+// See the parent package "function" for more information on the purpose
+// and usage of cty functions.
+//
+// This package contains both Go functions, which provide convenient access
+// to call the functions from Go code, and the Function objects themselves.
+// The latter follow the naming scheme of appending "Func" to the end of
+// the function name.
+package stdlib
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
new file mode 100644
index 000000000..664790b46
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
@@ -0,0 +1,501 @@
+package stdlib
+
+import (
+	"bytes"
+	"fmt"
+	"math/big"
+	"strings"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/json"
+)
+
+//go:generate ragel -Z format_fsm.rl
+//go:generate gofmt -w format_fsm.go
+
+var FormatFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "format",
+			Type: cty.String,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:      "args",
+		Type:      cty.DynamicPseudoType,
+		AllowNull: true,
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		for _, arg := range args[1:] {
+			if !arg.IsWhollyKnown() {
+				// We require all nested values to be known because the only
+				// thing we can do for a collection/structural type is print
+				// it as JSON and that requires it to be wholly known.
+				return cty.UnknownVal(cty.String), nil
+			}
+		}
+		str, err := formatFSM(args[0].AsString(), args[1:])
+		return cty.StringVal(str), err
+	},
+})
+
+var FormatListFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "format",
+			Type: cty.String,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:         "args",
+		Type:         cty.DynamicPseudoType,
+		AllowNull:    true,
+		AllowUnknown: true,
+	},
+	Type: function.StaticReturnType(cty.List(cty.String)),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		fmtVal := args[0]
+		args = args[1:]
+
+		if len(args) == 0 {
+			// With no arguments, this function is equivalent to Format, but
+			// returning a single-element list result.
+			result, err := Format(fmtVal, args...)
+			return cty.ListVal([]cty.Value{result}), err
+		}
+
+		fmtStr := fmtVal.AsString()
+
+		// Each of our arguments will be dealt with either as an iterator
+		// or as a single value. Iterators are used for sequence-type values
+		// (lists, sets, tuples) while everything else is treated as a
+		// single value. The sequences we iterate over are required to be
+		// all the same length.
+		iterLen := -1
+		lenChooser := -1
+		iterators := make([]cty.ElementIterator, len(args))
+		singleVals := make([]cty.Value, len(args))
+		for i, arg := range args {
+			argTy := arg.Type()
+			switch {
+			case (argTy.IsListType() || argTy.IsSetType() || argTy.IsTupleType()) && !arg.IsNull():
+				if !argTy.IsTupleType() && !arg.IsKnown() {
+					// We can't iterate this one at all yet then, so we can't
+					// yet produce a result.
+					return cty.UnknownVal(retType), nil
+				}
+				thisLen := arg.LengthInt()
+				if iterLen == -1 {
+					iterLen = thisLen
+					lenChooser = i
+				} else {
+					if thisLen != iterLen {
+						return cty.NullVal(cty.List(cty.String)), function.NewArgErrorf(
+							i+1,
+							"argument %d has length %d, which is inconsistent with argument %d of length %d",
+							i+1, thisLen,
+							lenChooser+1, iterLen,
+						)
+					}
+				}
+				iterators[i] = arg.ElementIterator()
+			default:
+				singleVals[i] = arg
+			}
+		}
+
+		if iterLen == 0 {
+			// If our sequences are all empty then our result must be empty.
+			return cty.ListValEmpty(cty.String), nil
+		}
+
+		if iterLen == -1 {
+			// If we didn't encounter any iterables at all then we're going
+			// to just do one iteration with items from singleVals.
+			iterLen = 1
+		}
+
+		ret := make([]cty.Value, 0, iterLen)
+		fmtArgs := make([]cty.Value, len(iterators))
+	Results:
+		for iterIdx := 0; iterIdx < iterLen; iterIdx++ {
+
+			// Construct our arguments for a single format call
+			for i := range fmtArgs {
+				switch {
+				case iterators[i] != nil:
+					iterator := iterators[i]
+					iterator.Next()
+					_, val := iterator.Element()
+					fmtArgs[i] = val
+				default:
+					fmtArgs[i] = singleVals[i]
+				}
+
+				// If any of the arguments to this call would be unknown then
+				// this particular result is unknown, but we'll keep going
+				// to see if any other iterations can produce known values.
+				if !fmtArgs[i].IsWhollyKnown() {
+					// We require all nested values to be known because the only
+					// thing we can do for a collection/structural type is print
+					// it as JSON and that requires it to be wholly known.
+					ret = append(ret, cty.UnknownVal(cty.String))
+					continue Results
+				}
+			}
+
+			str, err := formatFSM(fmtStr, fmtArgs)
+			if err != nil {
+				return cty.NullVal(cty.List(cty.String)), fmt.Errorf(
+					"error on format iteration %d: %s", iterIdx, err,
+				)
+			}
+
+			ret = append(ret, cty.StringVal(str))
+		}
+
+		return cty.ListVal(ret), nil
+	},
+})
+
+// Format produces a string representation of zero or more values using a
+// format string similar to the "printf" function in C.
+//
+// It supports the following "verbs":
+//
+//     %%      Literal percent sign, consuming no value
+//     %v      A default formatting of the value based on type, as described below.
+//     %#v     JSON serialization of the value
+//     %t      Converts to boolean and then produces "true" or "false"
+//     %b      Converts to number, requires integer, produces binary representation
+//     %d      Converts to number, requires integer, produces decimal representation
+//     %o      Converts to number, requires integer, produces octal representation
+//     %x      Converts to number, requires integer, produces hexadecimal representation
+//             with lowercase letters
+//     %X      Like %x but with uppercase letters
+//     %e      Converts to number, produces scientific notation like -1.234456e+78
+//     %E      Like %e but with an uppercase "E" representing the exponent
+//     %f      Converts to number, produces decimal representation with fractional
+//             part but no exponent, like 123.456
+//     %g      %e for large exponents or %f otherwise
+//     %G      %E for large exponents or %f otherwise
+//     %s      Converts to string and produces the string's characters
+//     %q      Converts to string and produces JSON-quoted string representation,
+//             like %v.
+//
+// The default format selections made by %v are:
+//
+//     string  %s
+//     number  %g
+//     bool    %t
+//     other   %#v
+//
+// Null values produce the literal keyword "null" for %v and %#v, and produce
+// an error otherwise.
+//
+// Width is specified by an optional decimal number immediately preceding the
+// verb letter. If absent, the width is whatever is necessary to represent the
+// value. Precision is specified after the (optional) width by a period
+// followed by a decimal number. If no period is present, a default precision
+// is used. A period with no following number is invalid.
+// For examples:
+//
+//     %f     default width, default precision
+//     %9f    width 9, default precision
+//     %.2f   default width, precision 2
+//     %9.2f  width 9, precision 2
+//
+// Width and precision are measured in unicode characters (grapheme clusters).
+//
+// For most values, width is the minimum number of characters to output,
+// padding the formatted form with spaces if necessary.
+//
+// For strings, precision limits the length of the input to be formatted (not
+// the size of the output), truncating if necessary.
+//
+// For numbers, width sets the minimum width of the field and precision sets
+// the number of places after the decimal, if appropriate, except that for
+// %g/%G precision sets the total number of significant digits.
+//
+// The following additional symbols can be used immediately after the percent
+// introducer as flags:
+//
+//           (a space) leave a space where the sign would be if number is positive
+//     +     Include a sign for a number even if it is positive (numeric only)
+//     -     Pad with spaces on the left rather than the right
+//     0     Pad with zeros rather than spaces.
+//
+// Flag characters are ignored for verbs that do not support them.
+//
+// By default, % sequences consume successive arguments starting with the first.
+// Introducing a [n] sequence immediately before the verb letter, where n is a
+// decimal integer, explicitly chooses a particular value argument by its
+// one-based index. Subsequent calls without an explicit index will then
+// proceed with n+1, n+2, etc.
+//
+// An error is produced if the format string calls for an impossible conversion
+// or accesses more values than are given. An error is produced also for
+// an unsupported format verb.
+func Format(format cty.Value, vals ...cty.Value) (cty.Value, error) {
+	args := make([]cty.Value, 0, len(vals)+1)
+	args = append(args, format)
+	args = append(args, vals...)
+	return FormatFunc.Call(args)
+}
+
+// FormatList applies the same formatting behavior as Format, but accepts
+// a mixture of list and non-list values as arguments. Any list arguments
+// passed must have the same length, which dictates the length of the
+// resulting list.
+//
+// Any non-list arguments are used repeatedly for each iteration over the
+// list arguments. The list arguments are iterated in order by key, so
+// corresponding items are formatted together.
+func FormatList(format cty.Value, vals ...cty.Value) (cty.Value, error) {
+	args := make([]cty.Value, 0, len(vals)+1)
+	args = append(args, format)
+	args = append(args, vals...)
+	return FormatListFunc.Call(args)
+}
+
+type formatVerb struct {
+	Raw    string
+	Offset int
+
+	ArgNum int
+	Mode   rune
+
+	Zero  bool
+	Sharp bool
+	Plus  bool
+	Minus bool
+	Space bool
+
+	HasPrec bool
+	Prec    int
+
+	HasWidth bool
+	Width    int
+}
+
+// formatAppend is called by formatFSM (generated by format_fsm.rl) for each
+// formatting sequence that is encountered.
+func formatAppend(verb *formatVerb, buf *bytes.Buffer, args []cty.Value) error {
+	argIdx := verb.ArgNum - 1
+	if argIdx >= len(args) {
+		return fmt.Errorf(
+			"not enough arguments for %q at %d: need index %d but have %d total",
+			verb.Raw, verb.Offset,
+			verb.ArgNum, len(args),
+		)
+	}
+	arg := args[argIdx]
+
+	if verb.Mode != 'v' && arg.IsNull() {
+		return fmt.Errorf("unsupported value for %q at %d: null value cannot be formatted", verb.Raw, verb.Offset)
+	}
+
+	// Normalize to make some things easier for downstream formatters
+	if !verb.HasWidth {
+		verb.Width = -1
+	}
+	if !verb.HasPrec {
+		verb.Prec = -1
+	}
+
+	// For our first pass we'll ensure the verb is supported and then fan
+	// out to other functions based on what conversion is needed.
+	switch verb.Mode {
+
+	case 'v':
+		return formatAppendAsIs(verb, buf, arg)
+
+	case 't':
+		return formatAppendBool(verb, buf, arg)
+
+	case 'b', 'd', 'o', 'x', 'X', 'e', 'E', 'f', 'g', 'G':
+		return formatAppendNumber(verb, buf, arg)
+
+	case 's', 'q':
+		return formatAppendString(verb, buf, arg)
+
+	default:
+		return fmt.Errorf("unsupported format verb %q in %q at offset %d", verb.Mode, verb.Raw, verb.Offset)
+	}
+}
+
+func formatAppendAsIs(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+
+	if !verb.Sharp && !arg.IsNull() {
+		// Unless the caller overrode it with the sharp flag, we'll try some
+		// specialized formats before we fall back on JSON.
+		switch arg.Type() {
+		case cty.String:
+			fmted := arg.AsString()
+			fmted = formatPadWidth(verb, fmted)
+			buf.WriteString(fmted)
+			return nil
+		case cty.Number:
+			bf := arg.AsBigFloat()
+			fmted := bf.Text('g', -1)
+			fmted = formatPadWidth(verb, fmted)
+			buf.WriteString(fmted)
+			return nil
+		}
+	}
+
+	jb, err := json.Marshal(arg, arg.Type())
+	if err != nil {
+		return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+	}
+	fmted := formatPadWidth(verb, string(jb))
+	buf.WriteString(fmted)
+
+	return nil
+}
+
+func formatAppendBool(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+	var err error
+	arg, err = convert.Convert(arg, cty.Bool)
+	if err != nil {
+		return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+	}
+
+	if arg.True() {
+		buf.WriteString("true")
+	} else {
+		buf.WriteString("false")
+	}
+	return nil
+}
+
+func formatAppendNumber(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+	var err error
+	arg, err = convert.Convert(arg, cty.Number)
+	if err != nil {
+		return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+	}
+
+	switch verb.Mode {
+	case 'b', 'd', 'o', 'x', 'X':
+		return formatAppendInteger(verb, buf, arg)
+	default:
+		bf := arg.AsBigFloat()
+
+		// For floats our format syntax is a subset of Go's, so it's
+		// safe for us to just lean on the existing Go implementation.
+		fmtstr := formatStripIndexSegment(verb.Raw)
+		fmted := fmt.Sprintf(fmtstr, bf)
+		buf.WriteString(fmted)
+		return nil
+	}
+}
+
+func formatAppendInteger(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+	bf := arg.AsBigFloat()
+	bi, acc := bf.Int(nil)
+	if acc != big.Exact {
+		return fmt.Errorf("unsupported value for %q at %d: an integer is required", verb.Raw, verb.Offset)
+	}
+
+	// For integers our format syntax is a subset of Go's, so it's
+	// safe for us to just lean on the existing Go implementation.
+	fmtstr := formatStripIndexSegment(verb.Raw)
+	fmted := fmt.Sprintf(fmtstr, bi)
+	buf.WriteString(fmted)
+	return nil
+}
+
+func formatAppendString(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+	var err error
+	arg, err = convert.Convert(arg, cty.String)
+	if err != nil {
+		return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+	}
+
+	// We _cannot_ directly use the Go fmt.Sprintf implementation for strings
+	// because it measures widths and precisions in runes rather than grapheme
+	// clusters.
+
+	str := arg.AsString()
+	if verb.Prec > 0 {
+		strB := []byte(str)
+		pos := 0
+		wanted := verb.Prec
+		for i := 0; i < wanted; i++ {
+			next := strB[pos:]
+			if len(next) == 0 {
+				// ran out of characters before we hit our max width
+				break
+			}
+			d, _, _ := textseg.ScanGraphemeClusters(strB[pos:], true)
+			pos += d
+		}
+		str = str[:pos]
+	}
+
+	switch verb.Mode {
+	case 's':
+		fmted := formatPadWidth(verb, str)
+		buf.WriteString(fmted)
+	case 'q':
+		jb, err := json.Marshal(cty.StringVal(str), cty.String)
+		if err != nil {
+			// Should never happen, since we know this is a known, non-null string
+			panic(fmt.Errorf("failed to marshal %#v as JSON: %s", arg, err))
+		}
+		fmted := formatPadWidth(verb, string(jb))
+		buf.WriteString(fmted)
+	default:
+		// Should never happen because formatAppend should've already validated
+		panic(fmt.Errorf("invalid string formatting mode %q", verb.Mode))
+	}
+	return nil
+}
+
+func formatPadWidth(verb *formatVerb, fmted string) string {
+	if verb.Width < 0 {
+		return fmted
+	}
+
+	// Safe to ignore errors because ScanGraphemeClusters cannot produce errors
+	givenLen, _ := textseg.TokenCount([]byte(fmted), textseg.ScanGraphemeClusters)
+	wantLen := verb.Width
+	if givenLen >= wantLen {
+		return fmted
+	}
+
+	padLen := wantLen - givenLen
+	padChar := " "
+	if verb.Zero {
+		padChar = "0"
+	}
+	pads := strings.Repeat(padChar, padLen)
+
+	if verb.Minus {
+		return fmted + pads
+	}
+	return pads + fmted
+}
+
+// formatStripIndexSegment strips out any [nnn] segment present in a verb
+// string so that we can pass it through to Go's fmt.Sprintf with a single
+// argument. This is used in cases where we're just leaning on Go's formatter
+// because it's a superset of ours.
+func formatStripIndexSegment(rawVerb string) string {
+	// We assume the string has already been validated here, since we should
+	// only be using this function with strings that were accepted by our
+	// scanner in formatFSM.
+	start := strings.Index(rawVerb, "[")
+	end := strings.Index(rawVerb, "]")
+	if start == -1 || end == -1 {
+		return rawVerb
+	}
+
+	return rawVerb[:start] + rawVerb[end+1:]
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
new file mode 100644
index 000000000..32b1ac971
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
@@ -0,0 +1,374 @@
+// line 1 "format_fsm.rl"
+// This file is generated from format_fsm.rl. DO NOT EDIT.
+
+// line 5 "format_fsm.rl"
+
+package stdlib
+
+import (
+	"bytes"
+	"fmt"
+	"unicode/utf8"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+// line 21 "format_fsm.go"
+var _formatfsm_actions []byte = []byte{
+	0, 1, 0, 1, 1, 1, 2, 1, 4,
+	1, 5, 1, 6, 1, 7, 1, 8,
+	1, 9, 1, 10, 1, 11, 1, 14,
+	1, 16, 1, 17, 1, 18, 2, 3,
+	4, 2, 12, 10, 2, 12, 16, 2,
+	12, 18, 2, 13, 14, 2, 15, 10,
+	2, 15, 18,
+}
+
+var _formatfsm_key_offsets []byte = []byte{
+	0, 0, 14, 27, 34, 36, 39, 43,
+	51,
+}
+
+var _formatfsm_trans_keys []byte = []byte{
+	32, 35, 37, 43, 45, 46, 48, 91,
+	49, 57, 65, 90, 97, 122, 32, 35,
+	43, 45, 46, 48, 91, 49, 57, 65,
+	90, 97, 122, 91, 48, 57, 65, 90,
+	97, 122, 49, 57, 93, 48, 57, 65,
+	90, 97, 122, 46, 91, 48, 57, 65,
+	90, 97, 122, 37,
+}
+
+var _formatfsm_single_lengths []byte = []byte{
+	0, 8, 7, 1, 0, 1, 0, 2,
+	1,
+}
+
+var _formatfsm_range_lengths []byte = []byte{
+	0, 3, 3, 3, 1, 1, 2, 3,
+	0,
+}
+
+var _formatfsm_index_offsets []byte = []byte{
+	0, 0, 12, 23, 28, 30, 33, 36,
+	42,
+}
+
+var _formatfsm_indicies []byte = []byte{
+	1, 2, 3, 4, 5, 6, 7, 10,
+	8, 9, 9, 0, 1, 2, 4, 5,
+	6, 7, 10, 8, 9, 9, 0, 13,
+	11, 12, 12, 0, 14, 0, 15, 14,
+	0, 9, 9, 0, 16, 19, 17, 18,
+	18, 0, 20, 3,
+}
+
+var _formatfsm_trans_targs []byte = []byte{
+	0, 2, 2, 8, 2, 2, 3, 2,
+	7, 8, 4, 3, 8, 4, 5, 6,
+	3, 7, 8, 4, 1,
+}
+
+var _formatfsm_trans_actions []byte = []byte{
+	7, 17, 9, 3, 15, 13, 25, 11,
+	43, 29, 19, 27, 49, 46, 21, 0,
+	37, 23, 40, 34, 1,
+}
+
+var _formatfsm_eof_actions []byte = []byte{
+	0, 31, 31, 31, 31, 31, 31, 31,
+	5,
+}
+
+const formatfsm_start int = 8
+const formatfsm_first_final int = 8
+const formatfsm_error int = 0
+
+const formatfsm_en_main int = 8
+
+// line 20 "format_fsm.rl"
+
+func formatFSM(format string, a []cty.Value) (string, error) {
+	var buf bytes.Buffer
+	data := format
+	nextArg := 1 // arg numbers are 1-based
+	var verb formatVerb
+	highestArgIdx := 0 // zero means "none", since arg numbers are 1-based
+
+	// line 159 "format_fsm.rl"
+
+	// Ragel state
+	p := 0          // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+	cs := 0         // current state (will be initialized by ragel-generated code)
+	ts := 0
+	te := 0
+	eof := pe
+
+	// Keep Go compiler happy even if generated code doesn't use these
+	_ = ts
+	_ = te
+	_ = eof
+
+	// line 123 "format_fsm.go"
+	{
+		cs = formatfsm_start
+	}
+
+	// line 128 "format_fsm.go"
+	{
+		var _klen int
+		var _trans int
+		var _acts int
+		var _nacts uint
+		var _keys int
+		if p == pe {
+			goto _test_eof
+		}
+		if cs == 0 {
+			goto _out
+		}
+	_resume:
+		_keys = int(_formatfsm_key_offsets[cs])
+		_trans = int(_formatfsm_index_offsets[cs])
+
+		_klen = int(_formatfsm_single_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + _klen - 1)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + ((_upper - _lower) >> 1)
+				switch {
+				case data[p] < _formatfsm_trans_keys[_mid]:
+					_upper = _mid - 1
+				case data[p] > _formatfsm_trans_keys[_mid]:
+					_lower = _mid + 1
+				default:
+					_trans += int(_mid - int(_keys))
+					goto _match
+				}
+			}
+			_keys += _klen
+			_trans += _klen
+		}
+
+		_klen = int(_formatfsm_range_lengths[cs])
+		if _klen > 0 {
+			_lower := int(_keys)
+			var _mid int
+			_upper := int(_keys + (_klen << 1) - 2)
+			for {
+				if _upper < _lower {
+					break
+				}
+
+				_mid = _lower + (((_upper - _lower) >> 1) & ^1)
+				switch {
+				case data[p] < _formatfsm_trans_keys[_mid]:
+					_upper = _mid - 2
+				case data[p] > _formatfsm_trans_keys[_mid+1]:
+					_lower = _mid + 2
+				default:
+					_trans += int((_mid - int(_keys)) >> 1)
+					goto _match
+				}
+			}
+			_trans += _klen
+		}
+
+	_match:
+		_trans = int(_formatfsm_indicies[_trans])
+		cs = int(_formatfsm_trans_targs[_trans])
+
+		if _formatfsm_trans_actions[_trans] == 0 {
+			goto _again
+		}
+
+		_acts = int(_formatfsm_trans_actions[_trans])
+		_nacts = uint(_formatfsm_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _formatfsm_actions[_acts-1] {
+			case 0:
+				// line 31 "format_fsm.rl"
+
+				verb = formatVerb{
+					ArgNum: nextArg,
+					Prec:   -1,
+					Width:  -1,
+				}
+				ts = p
+
+			case 1:
+				// line 40 "format_fsm.rl"
+
+				buf.WriteByte(data[p])
+
+			case 4:
+				// line 51 "format_fsm.rl"
+
+				// We'll try to slurp a whole UTF-8 sequence here, to give the user
+				// better feedback.
+				r, _ := utf8.DecodeRuneInString(data[p:])
+				return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+
+			case 5:
+				// line 58 "format_fsm.rl"
+
+				verb.Sharp = true
+
+			case 6:
+				// line 61 "format_fsm.rl"
+
+				verb.Zero = true
+
+			case 7:
+				// line 64 "format_fsm.rl"
+
+				verb.Minus = true
+
+			case 8:
+				// line 67 "format_fsm.rl"
+
+				verb.Plus = true
+
+			case 9:
+				// line 70 "format_fsm.rl"
+
+				verb.Space = true
+
+			case 10:
+				// line 74 "format_fsm.rl"
+
+				verb.ArgNum = 0
+
+			case 11:
+				// line 77 "format_fsm.rl"
+
+				verb.ArgNum = (10 * verb.ArgNum) + (int(data[p]) - '0')
+
+			case 12:
+				// line 81 "format_fsm.rl"
+
+				verb.HasWidth = true
+
+			case 13:
+				// line 84 "format_fsm.rl"
+
+				verb.Width = 0
+
+			case 14:
+				// line 87 "format_fsm.rl"
+
+				verb.Width = (10 * verb.Width) + (int(data[p]) - '0')
+
+			case 15:
+				// line 91 "format_fsm.rl"
+
+				verb.HasPrec = true
+
+			case 16:
+				// line 94 "format_fsm.rl"
+
+				verb.Prec = 0
+
+			case 17:
+				// line 97 "format_fsm.rl"
+
+				verb.Prec = (10 * verb.Prec) + (int(data[p]) - '0')
+
+			case 18:
+				// line 101 "format_fsm.rl"
+
+				verb.Mode = rune(data[p])
+				te = p + 1
+				verb.Raw = data[ts:te]
+				verb.Offset = ts
+
+				if verb.ArgNum > highestArgIdx {
+					highestArgIdx = verb.ArgNum
+				}
+
+				err := formatAppend(&verb, &buf, a)
+				if err != nil {
+					return buf.String(), err
+				}
+				nextArg = verb.ArgNum + 1
+
+				// line 330 "format_fsm.go"
+			}
+		}
+
+	_again:
+		if cs == 0 {
+			goto _out
+		}
+		p++
+		if p != pe {
+			goto _resume
+		}
+	_test_eof:
+		{
+		}
+		if p == eof {
+			__acts := _formatfsm_eof_actions[cs]
+			__nacts := uint(_formatfsm_actions[__acts])
+			__acts++
+			for ; __nacts > 0; __nacts-- {
+				__acts++
+				switch _formatfsm_actions[__acts-1] {
+				case 2:
+					// line 44 "format_fsm.rl"
+
+				case 3:
+					// line 47 "format_fsm.rl"
+
+					return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
+
+				case 4:
+					// line 51 "format_fsm.rl"
+
+					// We'll try to slurp a whole UTF-8 sequence here, to give the user
+					// better feedback.
+					r, _ := utf8.DecodeRuneInString(data[p:])
+					return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+
+					// line 369 "format_fsm.go"
+				}
+			}
+		}
+
+	_out:
+		{
+		}
+	}
+
+	// line 177 "format_fsm.rl"
+
+	// If we fall out here without being in a final state then we've
+	// encountered something that the scanner can't match, which should
+	// be impossible (the scanner matches all bytes _somehow_) but we'll
+	// flag it anyway rather than just losing data from the end.
+	if cs < formatfsm_first_final {
+		return buf.String(), fmt.Errorf("extraneous characters beginning at offset %d", p)
+	}
+
+	if highestArgIdx < len(a) {
+		// Extraneous args are an error, to more easily detect mistakes
+		firstBad := highestArgIdx + 1
+		if highestArgIdx == 0 {
+			// Custom error message for this case
+			return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; no verbs in format string")
+		}
+		return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; only %d used by format string", highestArgIdx)
+	}
+
+	return buf.String(), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
new file mode 100644
index 000000000..3c642d9e1
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
@@ -0,0 +1,198 @@
+// This file is generated from format_fsm.rl. DO NOT EDIT.
+%%{
+	# (except you are actually in scan_tokens.rl here, so edit away!)
+	machine formatfsm;
+}%%
+
+package stdlib
+
+import (
+	"bytes"
+	"fmt"
+	"unicode/utf8"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+%%{
+	write data;
+}%%
+
+func formatFSM(format string, a []cty.Value) (string, error) {
+	var buf bytes.Buffer
+	data := format
+	nextArg := 1 // arg numbers are 1-based
+	var verb formatVerb
+	highestArgIdx := 0 // zero means "none", since arg numbers are 1-based
+
+	%%{
+
+	action begin {
+		verb = formatVerb{
+			ArgNum: nextArg,
+			Prec:   -1,
+			Width:  -1,
+		}
+		ts = p
+	}
+
+	action emit {
+		buf.WriteByte(fc);
+	}
+
+	action finish_ok {
+	}
+
+	action finish_err {
+		return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
+	}
+
+	action err_char {
+		// We'll try to slurp a whole UTF-8 sequence here, to give the user
+		// better feedback.
+		r, _ := utf8.DecodeRuneInString(data[p:])
+		return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+	}
+
+	action flag_sharp {
+		verb.Sharp = true
+	}
+	action flag_zero {
+		verb.Zero = true
+	}
+	action flag_minus {
+		verb.Minus = true
+	}
+	action flag_plus {
+		verb.Plus = true
+	}
+	action flag_space {
+		verb.Space = true
+	}
+
+	action argidx_reset {
+		verb.ArgNum = 0
+	}
+	action argidx_num {
+		verb.ArgNum = (10 * verb.ArgNum) + (int(fc) - '0')
+	}
+
+	action has_width {
+		verb.HasWidth = true
+	}
+	action width_reset {
+		verb.Width = 0
+	}
+	action width_num {
+		verb.Width = (10 * verb.Width) + (int(fc) - '0')
+	}
+
+	action has_prec {
+		verb.HasPrec = true
+	}
+	action prec_reset {
+		verb.Prec = 0
+	}
+	action prec_num {
+		verb.Prec = (10 * verb.Prec) + (int(fc) - '0')
+	}
+
+	action mode {
+		verb.Mode = rune(fc)
+		te = p+1
+		verb.Raw = data[ts:te]
+		verb.Offset = ts
+
+		if verb.ArgNum > highestArgIdx {
+			highestArgIdx = verb.ArgNum
+		}
+
+		err := formatAppend(&verb, &buf, a)
+		if err != nil {
+			return buf.String(), err
+		}
+		nextArg = verb.ArgNum + 1
+	}
+
+	# a number that isn't zero and doesn't have a leading zero
+	num = [1-9] [0-9]*;
+
+	flags = (
+		'0' @flag_zero |
+		'#' @flag_sharp |
+		'-' @flag_minus |
+		'+' @flag_plus |
+		' ' @flag_space
+	)*;
+
+	argidx = ((
+		'[' (num $argidx_num) ']'
+	) >argidx_reset)?;
+
+	width = (
+		( num $width_num ) >width_reset %has_width
+	)?;
+
+	precision = (
+		('.' ( digit* $prec_num )) >prec_reset %has_prec
+	)?;
+
+	# We accept any letter here, but will be more picky in formatAppend
+	mode = ('a'..'z' | 'A'..'Z') @mode;
+
+	fmt_verb = (
+		'%' @begin
+		flags
+		width
+		precision
+		argidx
+		mode
+	);
+
+	main := (
+		[^%] @emit |
+		'%%' @emit |
+		fmt_verb
+	)* @/finish_err %/finish_ok $!err_char;
+
+	}%%
+
+	// Ragel state
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+	cs := 0 // current state (will be initialized by ragel-generated code)
+	ts := 0
+	te := 0
+	eof := pe
+
+	// Keep Go compiler happy even if generated code doesn't use these
+	_ = ts
+	_ = te
+	_ = eof
+
+	%%{
+		write init;
+		write exec;
+	}%%
+
+	// If we fall out here without being in a final state then we've
+	// encountered something that the scanner can't match, which should
+	// be impossible (the scanner matches all bytes _somehow_) but we'll
+	// flag it anyway rather than just losing data from the end.
+	if cs < formatfsm_first_final {
+		return buf.String(), fmt.Errorf("extraneous characters beginning at offset %d", p)
+	}
+
+	if highestArgIdx < len(a) {
+		// Extraneous args are an error, to more easily detect mistakes
+		firstBad := highestArgIdx+1
+		if highestArgIdx == 0 {
+			// Custom error message for this case
+			return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; no verbs in format string")
+		}
+		return buf.String(), function.NewArgErrorf(firstBad, "too many arguments; only %d used by format string", highestArgIdx)
+	}
+
+	return buf.String(), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
new file mode 100644
index 000000000..6b31f2661
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
@@ -0,0 +1,107 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var EqualFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].Equals(args[1]), nil
+	},
+})
+
+var NotEqualFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].Equals(args[1]).Not(), nil
+	},
+})
+
+var CoalesceFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name:             "vals",
+		Type:             cty.DynamicPseudoType,
+		AllowUnknown:     true,
+		AllowDynamicType: true,
+		AllowNull:        true,
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		argTypes := make([]cty.Type, len(args))
+		for i, val := range args {
+			argTypes[i] = val.Type()
+		}
+		retType, _ := convert.UnifyUnsafe(argTypes)
+		if retType == cty.NilType {
+			return cty.NilType, fmt.Errorf("all arguments must have the same type")
+		}
+		return retType, nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		for _, argVal := range args {
+			if !argVal.IsKnown() {
+				return cty.UnknownVal(retType), nil
+			}
+			if argVal.IsNull() {
+				continue
+			}
+
+			return convert.Convert(argVal, retType)
+		}
+		return cty.NilVal, fmt.Errorf("no non-null arguments")
+	},
+})
+
+// Equal determines whether the two given values are equal, returning a
+// bool value.
+func Equal(a cty.Value, b cty.Value) (cty.Value, error) {
+	return EqualFunc.Call([]cty.Value{a, b})
+}
+
+// NotEqual is the opposite of Equal.
+func NotEqual(a cty.Value, b cty.Value) (cty.Value, error) {
+	return NotEqualFunc.Call([]cty.Value{a, b})
+}
+
+// Coalesce returns the first of the given arguments that is not null. If
+// all arguments are null, an error is produced.
+func Coalesce(vals ...cty.Value) (cty.Value, error) {
+	return CoalesceFunc.Call(vals)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
new file mode 100644
index 000000000..07901c65d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
@@ -0,0 +1,72 @@
+package stdlib
+
+import (
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/json"
+)
+
+var JSONEncodeFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "val",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		val := args[0]
+		if !val.IsWhollyKnown() {
+			// We can't serialize unknowns, so if the value is unknown or
+			// contains any _nested_ unknowns then our result must be
+			// unknown.
+			return cty.UnknownVal(retType), nil
+		}
+
+		buf, err := json.Marshal(val, val.Type())
+		if err != nil {
+			return cty.NilVal, err
+		}
+
+		return cty.StringVal(string(buf)), nil
+	},
+})
+
+var JSONDecodeFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "str",
+			Type: cty.String,
+		},
+	},
+	Type: func(args []cty.Value) (cty.Type, error) {
+		str := args[0]
+		if !str.IsKnown() {
+			return cty.DynamicPseudoType, nil
+		}
+
+		buf := []byte(str.AsString())
+		return json.ImpliedType(buf)
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		buf := []byte(args[0].AsString())
+		return json.Unmarshal(buf, retType)
+	},
+})
+
+// JSONEncode returns a JSON serialization of the given value.
+func JSONEncode(val cty.Value) (cty.Value, error) {
+	return JSONEncodeFunc.Call([]cty.Value{val})
+}
+
+// JSONDecode parses the given JSON string and, if it is valid, returns the
+// value it represents.
+//
+// Note that applying JSONDecode to the result of JSONEncode may not produce
+// an identically-typed result, since JSON encoding is lossy for cty Types.
+// The resulting value will consist only of primitive types, object types, and
+// tuple types.
+func JSONDecode(str cty.Value) (cty.Value, error) {
+	return JSONDecodeFunc.Call([]cty.Value{str})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
new file mode 100644
index 000000000..bd9b2e51b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
@@ -0,0 +1,428 @@
+package stdlib
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var AbsoluteFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "num",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Absolute(), nil
+	},
+})
+
+var AddFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Add can panic if the input values are opposing infinities,
+		// so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't compute sum of opposing infinities")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+		return args[0].Add(args[1]), nil
+	},
+})
+
+var SubtractFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Sub can panic if the input values are infinities,
+		// so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't subtract infinity from itself")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+		return args[0].Subtract(args[1]), nil
+	},
+})
+
+var MultiplyFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Mul can panic if the input values are both zero or both
+		// infinity, so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't multiply zero by infinity")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+
+		return args[0].Multiply(args[1]), nil
+	},
+})
+
+var DivideFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Quo can panic if the input values are both zero or both
+		// infinity, so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't divide zero by zero or infinity by infinity")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+
+		return args[0].Divide(args[1]), nil
+	},
+})
+
+var ModuloFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Mul can panic if the input values are both zero or both
+		// infinity, so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't use modulo with zero and infinity")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+
+		return args[0].Modulo(args[1]), nil
+	},
+})
+
+var GreaterThanFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].GreaterThan(args[1]), nil
+	},
+})
+
+var GreaterThanOrEqualToFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].GreaterThanOrEqualTo(args[1]), nil
+	},
+})
+
+var LessThanFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].LessThan(args[1]), nil
+	},
+})
+
+var LessThanOrEqualToFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].LessThanOrEqualTo(args[1]), nil
+	},
+})
+
+var NegateFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "num",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Negate(), nil
+	},
+})
+
+var MinFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name:             "numbers",
+		Type:             cty.Number,
+		AllowDynamicType: true,
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		if len(args) == 0 {
+			return cty.NilVal, fmt.Errorf("must pass at least one number")
+		}
+
+		min := cty.PositiveInfinity
+		for _, num := range args {
+			if num.LessThan(min).True() {
+				min = num
+			}
+		}
+
+		return min, nil
+	},
+})
+
+var MaxFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name:             "numbers",
+		Type:             cty.Number,
+		AllowDynamicType: true,
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		if len(args) == 0 {
+			return cty.NilVal, fmt.Errorf("must pass at least one number")
+		}
+
+		max := cty.NegativeInfinity
+		for _, num := range args {
+			if num.GreaterThan(max).True() {
+				max = num
+			}
+		}
+
+		return max, nil
+	},
+})
+
+var IntFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "num",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		bf := args[0].AsBigFloat()
+		if bf.IsInt() {
+			return args[0], nil
+		}
+		bi, _ := bf.Int(nil)
+		bf = (&big.Float{}).SetInt(bi)
+		return cty.NumberVal(bf), nil
+	},
+})
+
+// Absolute returns the magnitude of the given number, without its sign.
+// That is, it turns negative values into positive values.
+func Absolute(num cty.Value) (cty.Value, error) {
+	return AbsoluteFunc.Call([]cty.Value{num})
+}
+
+// Add returns the sum of the two given numbers.
+func Add(a cty.Value, b cty.Value) (cty.Value, error) {
+	return AddFunc.Call([]cty.Value{a, b})
+}
+
+// Subtract returns the difference between the two given numbers.
+func Subtract(a cty.Value, b cty.Value) (cty.Value, error) {
+	return SubtractFunc.Call([]cty.Value{a, b})
+}
+
+// Multiply returns the product of the two given numbers.
+func Multiply(a cty.Value, b cty.Value) (cty.Value, error) {
+	return MultiplyFunc.Call([]cty.Value{a, b})
+}
+
+// Divide returns a divided by b, where both a and b are numbers.
+func Divide(a cty.Value, b cty.Value) (cty.Value, error) {
+	return DivideFunc.Call([]cty.Value{a, b})
+}
+
+// Negate returns the given number multipled by -1.
+func Negate(num cty.Value) (cty.Value, error) {
+	return NegateFunc.Call([]cty.Value{num})
+}
+
+// LessThan returns true if a is less than b.
+func LessThan(a cty.Value, b cty.Value) (cty.Value, error) {
+	return LessThanFunc.Call([]cty.Value{a, b})
+}
+
+// LessThanOrEqualTo returns true if a is less than b.
+func LessThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+	return LessThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThan returns true if a is less than b.
+func GreaterThan(a cty.Value, b cty.Value) (cty.Value, error) {
+	return GreaterThanFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThanOrEqualTo returns true if a is less than b.
+func GreaterThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+	return GreaterThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// Modulo returns the remainder of a divided by b under integer division,
+// where both a and b are numbers.
+func Modulo(a cty.Value, b cty.Value) (cty.Value, error) {
+	return ModuloFunc.Call([]cty.Value{a, b})
+}
+
+// Min returns the minimum number from the given numbers.
+func Min(numbers ...cty.Value) (cty.Value, error) {
+	return MinFunc.Call(numbers)
+}
+
+// Max returns the maximum number from the given numbers.
+func Max(numbers ...cty.Value) (cty.Value, error) {
+	return MaxFunc.Call(numbers)
+}
+
+// Int removes the fractional component of the given number returning an
+// integer representing the whole number component, rounding towards zero.
+// For example, -1.5 becomes -1.
+//
+// If an infinity is passed to Int, an error is returned.
+func Int(num cty.Value) (cty.Value, error) {
+	if num == cty.PositiveInfinity || num == cty.NegativeInfinity {
+		return cty.NilVal, fmt.Errorf("can't truncate infinity to an integer")
+	}
+	return IntFunc.Call([]cty.Value{num})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
new file mode 100644
index 000000000..2dd6348a2
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/regexp.go
@@ -0,0 +1,233 @@
+package stdlib
+
+import (
+	"fmt"
+	"regexp"
+	resyntax "regexp/syntax"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var RegexFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "pattern",
+			Type: cty.String,
+		},
+		{
+			Name: "string",
+			Type: cty.String,
+		},
+	},
+	Type: func(args []cty.Value) (cty.Type, error) {
+		if !args[0].IsKnown() {
+			// We can't predict our type without seeing our pattern
+			return cty.DynamicPseudoType, nil
+		}
+
+		retTy, err := regexPatternResultType(args[0].AsString())
+		if err != nil {
+			err = function.NewArgError(0, err)
+		}
+		return retTy, err
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		if retType == cty.DynamicPseudoType {
+			return cty.DynamicVal, nil
+		}
+
+		re, err := regexp.Compile(args[0].AsString())
+		if err != nil {
+			// Should never happen, since we checked this in the Type function above.
+			return cty.NilVal, function.NewArgErrorf(0, "error parsing pattern: %s", err)
+		}
+		str := args[1].AsString()
+
+		captureIdxs := re.FindStringSubmatchIndex(str)
+		if captureIdxs == nil {
+			return cty.NilVal, fmt.Errorf("pattern did not match any part of the given string")
+		}
+
+		return regexPatternResult(re, str, captureIdxs, retType), nil
+	},
+})
+
+var RegexAllFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "pattern",
+			Type: cty.String,
+		},
+		{
+			Name: "string",
+			Type: cty.String,
+		},
+	},
+	Type: func(args []cty.Value) (cty.Type, error) {
+		if !args[0].IsKnown() {
+			// We can't predict our type without seeing our pattern,
+			// but we do know it'll always be a list of something.
+			return cty.List(cty.DynamicPseudoType), nil
+		}
+
+		retTy, err := regexPatternResultType(args[0].AsString())
+		if err != nil {
+			err = function.NewArgError(0, err)
+		}
+		return cty.List(retTy), err
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		ety := retType.ElementType()
+		if ety == cty.DynamicPseudoType {
+			return cty.DynamicVal, nil
+		}
+
+		re, err := regexp.Compile(args[0].AsString())
+		if err != nil {
+			// Should never happen, since we checked this in the Type function above.
+			return cty.NilVal, function.NewArgErrorf(0, "error parsing pattern: %s", err)
+		}
+		str := args[1].AsString()
+
+		captureIdxsEach := re.FindAllStringSubmatchIndex(str, -1)
+		if len(captureIdxsEach) == 0 {
+			return cty.ListValEmpty(ety), nil
+		}
+
+		elems := make([]cty.Value, len(captureIdxsEach))
+		for i, captureIdxs := range captureIdxsEach {
+			elems[i] = regexPatternResult(re, str, captureIdxs, ety)
+		}
+		return cty.ListVal(elems), nil
+	},
+})
+
+// Regex is a function that extracts one or more substrings from a given
+// string by applying a regular expression pattern, describing the first
+// match.
+//
+// The return type depends on the composition of the capture groups (if any)
+// in the pattern:
+//
+//   - If there are no capture groups at all, the result is a single string
+//     representing the entire matched pattern.
+//   - If all of the capture groups are named, the result is an object whose
+//     keys are the named groups and whose values are their sub-matches, or
+//     null if a particular sub-group was inside another group that didn't
+//     match.
+//   - If none of the capture groups are named, the result is a tuple whose
+//     elements are the sub-groups in order and whose values are their
+//     sub-matches, or null if a particular sub-group was inside another group
+//     that didn't match.
+//   - It is invalid to use both named and un-named capture groups together in
+//     the same pattern.
+//
+// If the pattern doesn't match, this function returns an error. To test for
+// a match, call RegexAll and check if the length of the result is greater
+// than zero.
+func Regex(pattern, str cty.Value) (cty.Value, error) {
+	return RegexFunc.Call([]cty.Value{pattern, str})
+}
+
+// RegexAll is similar to Regex but it finds all of the non-overlapping matches
+// in the given string and returns a list of them.
+//
+// The result type is always a list, whose element type is deduced from the
+// pattern in the same way as the return type for Regex is decided.
+//
+// If the pattern doesn't match at all, this function returns an empty list.
+func RegexAll(pattern, str cty.Value) (cty.Value, error) {
+	return RegexAllFunc.Call([]cty.Value{pattern, str})
+}
+
+// regexPatternResultType parses the given regular expression pattern and
+// returns the structural type that would be returned to represent its
+// capture groups.
+//
+// Returns an error if parsing fails or if the pattern uses a mixture of
+// named and unnamed capture groups, which is not permitted.
+func regexPatternResultType(pattern string) (cty.Type, error) {
+	re, rawErr := regexp.Compile(pattern)
+	switch err := rawErr.(type) {
+	case *resyntax.Error:
+		return cty.NilType, fmt.Errorf("invalid regexp pattern: %s in %s", err.Code, err.Expr)
+	case error:
+		// Should never happen, since all regexp compile errors should
+		// be resyntax.Error, but just in case...
+		return cty.NilType, fmt.Errorf("error parsing pattern: %s", err)
+	}
+
+	allNames := re.SubexpNames()[1:]
+	var names []string
+	unnamed := 0
+	for _, name := range allNames {
+		if name == "" {
+			unnamed++
+		} else {
+			if names == nil {
+				names = make([]string, 0, len(allNames))
+			}
+			names = append(names, name)
+		}
+	}
+	switch {
+	case unnamed == 0 && len(names) == 0:
+		// If there are no capture groups at all then we'll return just a
+		// single string for the whole match.
+		return cty.String, nil
+	case unnamed > 0 && len(names) > 0:
+		return cty.NilType, fmt.Errorf("invalid regexp pattern: cannot mix both named and unnamed capture groups")
+	case unnamed > 0:
+		// For unnamed captures, we return a tuple of them all in order.
+		etys := make([]cty.Type, unnamed)
+		for i := range etys {
+			etys[i] = cty.String
+		}
+		return cty.Tuple(etys), nil
+	default:
+		// For named captures, we return an object using the capture names
+		// as keys.
+		atys := make(map[string]cty.Type, len(names))
+		for _, name := range names {
+			atys[name] = cty.String
+		}
+		return cty.Object(atys), nil
+	}
+}
+
+func regexPatternResult(re *regexp.Regexp, str string, captureIdxs []int, retType cty.Type) cty.Value {
+	switch {
+	case retType == cty.String:
+		start, end := captureIdxs[0], captureIdxs[1]
+		return cty.StringVal(str[start:end])
+	case retType.IsTupleType():
+		captureIdxs = captureIdxs[2:] // index 0 is the whole pattern span, which we ignore by skipping one pair
+		vals := make([]cty.Value, len(captureIdxs)/2)
+		for i := range vals {
+			start, end := captureIdxs[i*2], captureIdxs[i*2+1]
+			if start < 0 || end < 0 {
+				vals[i] = cty.NullVal(cty.String) // Did not match anything because containing group didn't match
+				continue
+			}
+			vals[i] = cty.StringVal(str[start:end])
+		}
+		return cty.TupleVal(vals)
+	case retType.IsObjectType():
+		captureIdxs = captureIdxs[2:] // index 0 is the whole pattern span, which we ignore by skipping one pair
+		vals := make(map[string]cty.Value, len(captureIdxs)/2)
+		names := re.SubexpNames()[1:]
+		for i, name := range names {
+			start, end := captureIdxs[i*2], captureIdxs[i*2+1]
+			if start < 0 || end < 0 {
+				vals[name] = cty.NullVal(cty.String) // Did not match anything because containing group didn't match
+				continue
+			}
+			vals[name] = cty.StringVal(str[start:end])
+		}
+		return cty.ObjectVal(vals)
+	default:
+		// Should never happen
+		panic(fmt.Sprintf("invalid return type %#v", retType))
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
new file mode 100644
index 000000000..d3cc341dd
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
@@ -0,0 +1,218 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var ConcatFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name: "seqs",
+		Type: cty.DynamicPseudoType,
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		if len(args) == 0 {
+			return cty.NilType, fmt.Errorf("at least one argument is required")
+		}
+
+		if args[0].Type().IsListType() {
+			// Possibly we're going to return a list, if all of our other
+			// args are also lists and we can find a common element type.
+			tys := make([]cty.Type, len(args))
+			for i, val := range args {
+				ty := val.Type()
+				if !ty.IsListType() {
+					tys = nil
+					break
+				}
+				tys[i] = ty
+			}
+
+			if tys != nil {
+				commonType, _ := convert.UnifyUnsafe(tys)
+				if commonType != cty.NilType {
+					return commonType, nil
+				}
+			}
+		}
+
+		etys := make([]cty.Type, 0, len(args))
+		for i, val := range args {
+			ety := val.Type()
+			switch {
+			case ety.IsTupleType():
+				etys = append(etys, ety.TupleElementTypes()...)
+			case ety.IsListType():
+				if !val.IsKnown() {
+					// We need to know the list to count its elements to
+					// build our tuple type, so any concat of an unknown
+					// list can't be typed yet.
+					return cty.DynamicPseudoType, nil
+				}
+
+				l := val.LengthInt()
+				subEty := ety.ElementType()
+				for j := 0; j < l; j++ {
+					etys = append(etys, subEty)
+				}
+			default:
+				return cty.NilType, function.NewArgErrorf(
+					i, "all arguments must be lists or tuples; got %s",
+					ety.FriendlyName(),
+				)
+			}
+		}
+		return cty.Tuple(etys), nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		switch {
+		case retType.IsListType():
+			// If retType is a list type then we know that all of the
+			// given values will be lists and that they will either be of
+			// retType or of something we can convert to retType.
+			vals := make([]cty.Value, 0, len(args))
+			for i, list := range args {
+				list, err = convert.Convert(list, retType)
+				if err != nil {
+					// Conversion might fail because we used UnifyUnsafe
+					// to choose our return type.
+					return cty.NilVal, function.NewArgError(i, err)
+				}
+
+				it := list.ElementIterator()
+				for it.Next() {
+					_, v := it.Element()
+					vals = append(vals, v)
+				}
+			}
+			if len(vals) == 0 {
+				return cty.ListValEmpty(retType.ElementType()), nil
+			}
+
+			return cty.ListVal(vals), nil
+		case retType.IsTupleType():
+			// If retType is a tuple type then we could have a mixture of
+			// lists and tuples but we know they all have known values
+			// (because our params don't AllowUnknown) and we know that
+			// concatenating them all together will produce a tuple of
+			// retType because of the work we did in the Type function above.
+			vals := make([]cty.Value, 0, len(args))
+
+			for _, seq := range args {
+				// Both lists and tuples support ElementIterator, so this is easy.
+				it := seq.ElementIterator()
+				for it.Next() {
+					_, v := it.Element()
+					vals = append(vals, v)
+				}
+			}
+
+			return cty.TupleVal(vals), nil
+		default:
+			// should never happen if Type is working correctly above
+			panic("unsupported return type")
+		}
+	},
+})
+
+var RangeFunc = function.New(&function.Spec{
+	VarParam: &function.Parameter{
+		Name: "params",
+		Type: cty.Number,
+	},
+	Type: function.StaticReturnType(cty.List(cty.Number)),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		var start, end, step cty.Value
+		switch len(args) {
+		case 1:
+			if args[0].LessThan(cty.Zero).True() {
+				start, end, step = cty.Zero, args[0], cty.NumberIntVal(-1)
+			} else {
+				start, end, step = cty.Zero, args[0], cty.NumberIntVal(1)
+			}
+		case 2:
+			if args[1].LessThan(args[0]).True() {
+				start, end, step = args[0], args[1], cty.NumberIntVal(-1)
+			} else {
+				start, end, step = args[0], args[1], cty.NumberIntVal(1)
+			}
+		case 3:
+			start, end, step = args[0], args[1], args[2]
+		default:
+			return cty.NilVal, fmt.Errorf("must have one, two, or three arguments")
+		}
+
+		var vals []cty.Value
+
+		if step == cty.Zero {
+			return cty.NilVal, function.NewArgErrorf(2, "step must not be zero")
+		}
+		down := step.LessThan(cty.Zero).True()
+
+		if down {
+			if end.GreaterThan(start).True() {
+				return cty.NilVal, function.NewArgErrorf(1, "end must be less than start when step is negative")
+			}
+		} else {
+			if end.LessThan(start).True() {
+				return cty.NilVal, function.NewArgErrorf(1, "end must be greater than start when step is positive")
+			}
+		}
+
+		num := start
+		for {
+			if down {
+				if num.LessThanOrEqualTo(end).True() {
+					break
+				}
+			} else {
+				if num.GreaterThanOrEqualTo(end).True() {
+					break
+				}
+			}
+			if len(vals) >= 1024 {
+				// Artificial limit to prevent bad arguments from consuming huge amounts of memory
+				return cty.NilVal, fmt.Errorf("more than 1024 values were generated; either decrease the difference between start and end or use a smaller step")
+			}
+			vals = append(vals, num)
+			num = num.Add(step)
+		}
+		if len(vals) == 0 {
+			return cty.ListValEmpty(cty.Number), nil
+		}
+		return cty.ListVal(vals), nil
+	},
+})
+
+// Concat takes one or more sequences (lists or tuples) and returns the single
+// sequence that results from concatenating them together in order.
+//
+// If all of the given sequences are lists of the same element type then the
+// result is a list of that type. Otherwise, the result is a of a tuple type
+// constructed from the given sequence types.
+func Concat(seqs ...cty.Value) (cty.Value, error) {
+	return ConcatFunc.Call(seqs)
+}
+
+// Range creates a list of numbers by starting from the given starting value,
+// then adding the given step value until the result is greater than or
+// equal to the given stopping value. Each intermediate result becomes an
+// element in the resulting list.
+//
+// When all three parameters are set, the order is (start, end, step). If
+// only two parameters are set, they are the start and end respectively and
+// step defaults to 1. If only one argument is set, it gives the end value
+// with start defaulting to 0 and step defaulting to 1.
+//
+// Because the resulting list must be fully buffered in memory, there is an
+// artificial cap of 1024 elements, after which this function will return
+// an error to avoid consuming unbounded amounts of memory. The Range function
+// is primarily intended for creating small lists of indices to iterate over,
+// so there should be no reason to generate huge lists with it.
+func Range(params ...cty.Value) (cty.Value, error) {
+	return RangeFunc.Call(params)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
new file mode 100644
index 000000000..100078fdc
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
@@ -0,0 +1,195 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty/convert"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var SetHasElementFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "set",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "elem",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].HasElement(args[1]), nil
+	},
+})
+
+var SetUnionFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "first_set",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:             "other_sets",
+		Type:             cty.Set(cty.DynamicPseudoType),
+		AllowDynamicType: true,
+	},
+	Type: setOperationReturnType,
+	Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+		return s1.Union(s2)
+	}),
+})
+
+var SetIntersectionFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "first_set",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:             "other_sets",
+		Type:             cty.Set(cty.DynamicPseudoType),
+		AllowDynamicType: true,
+	},
+	Type: setOperationReturnType,
+	Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+		return s1.Intersection(s2)
+	}),
+})
+
+var SetSubtractFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+	},
+	Type: setOperationReturnType,
+	Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+		return s1.Subtract(s2)
+	}),
+})
+
+var SetSymmetricDifferenceFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "first_set",
+			Type:             cty.Set(cty.DynamicPseudoType),
+			AllowDynamicType: true,
+		},
+	},
+	VarParam: &function.Parameter{
+		Name:             "other_sets",
+		Type:             cty.Set(cty.DynamicPseudoType),
+		AllowDynamicType: true,
+	},
+	Type: setOperationReturnType,
+	Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+		return s1.Subtract(s2)
+	}),
+})
+
+// SetHasElement determines whether the given set contains the given value as an
+// element.
+func SetHasElement(set cty.Value, elem cty.Value) (cty.Value, error) {
+	return SetHasElementFunc.Call([]cty.Value{set, elem})
+}
+
+// SetUnion returns a new set containing all of the elements from the given
+// sets, which must have element types that can all be converted to some
+// common type using the standard type unification rules. If conversion
+// is not possible, an error is returned.
+//
+// The union operation is performed after type conversion, which may result
+// in some previously-distinct values being conflated.
+//
+// At least one set must be provided.
+func SetUnion(sets ...cty.Value) (cty.Value, error) {
+	return SetUnionFunc.Call(sets)
+}
+
+// Intersection returns a new set containing the elements that exist
+// in all of the given sets, which must have element types that can all be
+// converted to some common type using the standard type unification rules.
+// If conversion is not possible, an error is returned.
+//
+// The intersection operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+//
+// At least one set must be provided.
+func SetIntersection(sets ...cty.Value) (cty.Value, error) {
+	return SetIntersectionFunc.Call(sets)
+}
+
+// SetSubtract returns a new set containing the elements from the
+// first set that are not present in the second set. The sets must have
+// element types that can both be converted to some common type using the
+// standard type unification rules. If conversion is not possible, an error
+// is returned.
+//
+// The subtract operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+func SetSubtract(a, b cty.Value) (cty.Value, error) {
+	return SetSubtractFunc.Call([]cty.Value{a, b})
+}
+
+// SetSymmetricDifference returns a new set containing elements that appear
+// in any of the given sets but not multiple. The sets must have
+// element types that can all be converted to some common type using the
+// standard type unification rules. If conversion is not possible, an error
+// is returned.
+//
+// The difference operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+func SetSymmetricDifference(sets ...cty.Value) (cty.Value, error) {
+	return SetSymmetricDifferenceFunc.Call(sets)
+}
+
+func setOperationReturnType(args []cty.Value) (ret cty.Type, err error) {
+	var etys []cty.Type
+	for _, arg := range args {
+		etys = append(etys, arg.Type().ElementType())
+	}
+	newEty, _ := convert.UnifyUnsafe(etys)
+	if newEty == cty.NilType {
+		return cty.NilType, fmt.Errorf("given sets must all have compatible element types")
+	}
+	return cty.Set(newEty), nil
+}
+
+func setOperationImpl(f func(s1, s2 cty.ValueSet) cty.ValueSet) function.ImplFunc {
+	return func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		first := args[0]
+		first, err = convert.Convert(first, retType)
+		if err != nil {
+			return cty.NilVal, function.NewArgError(0, err)
+		}
+
+		set := first.AsValueSet()
+		for i, arg := range args[1:] {
+			arg, err := convert.Convert(arg, retType)
+			if err != nil {
+				return cty.NilVal, function.NewArgError(i+1, err)
+			}
+
+			argSet := arg.AsValueSet()
+			set = f(set, argSet)
+		}
+		return cty.SetValFromValueSet(set), nil
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
new file mode 100644
index 000000000..d7c89fa82
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
@@ -0,0 +1,234 @@
+package stdlib
+
+import (
+	"strings"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+	"github.com/apparentlymart/go-textseg/textseg"
+)
+
+var UpperFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := args[0].AsString()
+		out := strings.ToUpper(in)
+		return cty.StringVal(out), nil
+	},
+})
+
+var LowerFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := args[0].AsString()
+		out := strings.ToLower(in)
+		return cty.StringVal(out), nil
+	},
+})
+
+var ReverseFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := []byte(args[0].AsString())
+		out := make([]byte, len(in))
+		pos := len(out)
+
+		inB := []byte(in)
+		for i := 0; i < len(in); {
+			d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+			cluster := in[i : i+d]
+			pos -= len(cluster)
+			copy(out[pos:], cluster)
+			i += d
+		}
+
+		return cty.StringVal(string(out)), nil
+	},
+})
+
+var StrlenFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := args[0].AsString()
+		l := 0
+
+		inB := []byte(in)
+		for i := 0; i < len(in); {
+			d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+			l++
+			i += d
+		}
+
+		return cty.NumberIntVal(int64(l)), nil
+	},
+})
+
+var SubstrFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "offset",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "length",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := []byte(args[0].AsString())
+		var offset, length int
+
+		var err error
+		err = gocty.FromCtyValue(args[1], &offset)
+		if err != nil {
+			return cty.NilVal, err
+		}
+		err = gocty.FromCtyValue(args[2], &length)
+		if err != nil {
+			return cty.NilVal, err
+		}
+
+		if offset < 0 {
+			totalLenNum, err := Strlen(args[0])
+			if err != nil {
+				// should never happen
+				panic("Stdlen returned an error")
+			}
+
+			var totalLen int
+			err = gocty.FromCtyValue(totalLenNum, &totalLen)
+			if err != nil {
+				// should never happen
+				panic("Stdlen returned a non-int number")
+			}
+
+			offset += totalLen
+		}
+
+		sub := in
+		pos := 0
+		var i int
+
+		// First we'll seek forward to our offset
+		if offset > 0 {
+			for i = 0; i < len(sub); {
+				d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+				i += d
+				pos++
+				if pos == offset {
+					break
+				}
+				if i >= len(in) {
+					return cty.StringVal(""), nil
+				}
+			}
+
+			sub = sub[i:]
+		}
+
+		if length < 0 {
+			// Taking the remainder of the string is a fast path since
+			// we can just return the rest of the buffer verbatim.
+			return cty.StringVal(string(sub)), nil
+		}
+
+		// Otherwise we need to start seeking forward again until we
+		// reach the length we want.
+		pos = 0
+		for i = 0; i < len(sub); {
+			d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+			i += d
+			pos++
+			if pos == length {
+				break
+			}
+		}
+
+		sub = sub[:i]
+
+		return cty.StringVal(string(sub)), nil
+	},
+})
+
+// Upper is a Function that converts a given string to uppercase.
+func Upper(str cty.Value) (cty.Value, error) {
+	return UpperFunc.Call([]cty.Value{str})
+}
+
+// Lower is a Function that converts a given string to lowercase.
+func Lower(str cty.Value) (cty.Value, error) {
+	return LowerFunc.Call([]cty.Value{str})
+}
+
+// Reverse is a Function that reverses the order of the characters in the
+// given string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Reverse(str cty.Value) (cty.Value, error) {
+	return ReverseFunc.Call([]cty.Value{str})
+}
+
+// Strlen is a Function that returns the length of the given string in
+// characters.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Strlen(str cty.Value) (cty.Value, error) {
+	return StrlenFunc.Call([]cty.Value{str})
+}
+
+// Substr is a Function that extracts a sequence of characters from another
+// string and creates a new string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+//
+// The "offset" index may be negative, in which case it is relative to the
+// end of the given string.
+//
+// The "length" may be -1, in which case the remainder of the string after
+// the given offset will be returned.
+func Substr(str cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+	return SubstrFunc.Call([]cty.Value{str, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go b/vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go
new file mode 100644
index 000000000..3495550af
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go
@@ -0,0 +1,31 @@
+package function
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Unpredictable wraps a given function such that it retains the same arguments
+// and type checking behavior but will return an unknown value when called.
+//
+// It is recommended that most functions be "pure", which is to say that they
+// will always produce the same value given particular input. However,
+// sometimes it is necessary to offer functions whose behavior depends on
+// some external state, such as reading a file or determining the current time.
+// In such cases, an unpredictable wrapper might be used to stand in for
+// the function during some sort of prior "checking" phase in order to delay
+// the actual effect until later.
+//
+// While Unpredictable can support a function that isn't pure in its
+// implementation, it still expects a function to be pure in its type checking
+// behavior, except for the special case of returning cty.DynamicPseudoType
+// if it is not yet able to predict its return value based on current argument
+// information.
+func Unpredictable(f Function) Function {
+	newSpec := *f.spec // shallow copy
+	newSpec.Impl = unpredictableImpl
+	return New(&newSpec)
+}
+
+func unpredictableImpl(args []cty.Value, retType cty.Type) (cty.Value, error) {
+	return cty.UnknownVal(retType), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gob.go b/vendor/github.com/zclconf/go-cty/cty/gob.go
new file mode 100644
index 000000000..a77dace27
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gob.go
@@ -0,0 +1,125 @@
+package cty
+
+import (
+	"bytes"
+	"encoding/gob"
+	"fmt"
+	"math/big"
+)
+
+// GobEncode is an implementation of the gob.GobEncoder interface, which
+// allows Values to be included in structures encoded with encoding/gob.
+//
+// Currently it is not possible to represent values of capsule types in gob,
+// because the types themselves cannot be represented.
+func (val Value) GobEncode() ([]byte, error) {
+	buf := &bytes.Buffer{}
+	enc := gob.NewEncoder(buf)
+
+	gv := gobValue{
+		Version: 0,
+		Ty:      val.ty,
+		V:       val.v,
+	}
+
+	err := enc.Encode(gv)
+	if err != nil {
+		return nil, fmt.Errorf("error encoding cty.Value: %s", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+// GobDecode is an implementation of the gob.GobDecoder interface, which
+// inverts the operation performed by GobEncode. See the documentation of
+// GobEncode for considerations when using cty.Value instances with gob.
+func (val *Value) GobDecode(buf []byte) error {
+	r := bytes.NewReader(buf)
+	dec := gob.NewDecoder(r)
+
+	var gv gobValue
+	err := dec.Decode(&gv)
+	if err != nil {
+		return fmt.Errorf("error decoding cty.Value: %s", err)
+	}
+	if gv.Version != 0 {
+		return fmt.Errorf("unsupported cty.Value encoding version %d; only 0 is supported", gv.Version)
+	}
+
+	// big.Float seems to, for some reason, lose its "pointerness" when we
+	// round-trip it, so we'll fix that here.
+	if bf, ok := gv.V.(big.Float); ok {
+		gv.V = &bf
+	}
+
+	val.ty = gv.Ty
+	val.v = gv.V
+
+	return nil
+}
+
+// GobEncode is an implementation of the gob.GobEncoder interface, which
+// allows Types to be included in structures encoded with encoding/gob.
+//
+// Currently it is not possible to represent capsule types in gob.
+func (t Type) GobEncode() ([]byte, error) {
+	buf := &bytes.Buffer{}
+	enc := gob.NewEncoder(buf)
+
+	gt := gobType{
+		Version: 0,
+		Impl:    t.typeImpl,
+	}
+
+	err := enc.Encode(gt)
+	if err != nil {
+		return nil, fmt.Errorf("error encoding cty.Type: %s", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+// GobDecode is an implementatino of the gob.GobDecoder interface, which
+// reverses the encoding performed by GobEncode to allow types to be recovered
+// from gob buffers.
+func (t *Type) GobDecode(buf []byte) error {
+	r := bytes.NewReader(buf)
+	dec := gob.NewDecoder(r)
+
+	var gt gobType
+	err := dec.Decode(&gt)
+	if err != nil {
+		return fmt.Errorf("error decoding cty.Type: %s", err)
+	}
+	if gt.Version != 0 {
+		return fmt.Errorf("unsupported cty.Type encoding version %d; only 0 is supported", gt.Version)
+	}
+
+	t.typeImpl = gt.Impl
+
+	return nil
+}
+
+// Capsule types cannot currently be gob-encoded, because they rely on pointer
+// equality and we have no way to recover the original pointer on decode.
+func (t *capsuleType) GobEncode() ([]byte, error) {
+	return nil, fmt.Errorf("cannot gob-encode capsule type %q", t.FriendlyName(friendlyTypeName))
+}
+
+func (t *capsuleType) GobDecode() ([]byte, error) {
+	return nil, fmt.Errorf("cannot gob-decode capsule type %q", t.FriendlyName(friendlyTypeName))
+}
+
+type gobValue struct {
+	Version int
+	Ty      Type
+	V       interface{}
+}
+
+type gobType struct {
+	Version int
+	Impl    typeImpl
+}
+
+type gobCapsuleTypeImpl struct {
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go b/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
new file mode 100644
index 000000000..a5177d22b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
@@ -0,0 +1,7 @@
+// Package gocty deals with converting between cty Values and native go
+// values.
+//
+// It operates under a similar principle to the encoding/json and
+// encoding/xml packages in the standard library, using reflection to
+// populate native Go data structures from cty values and vice-versa.
+package gocty
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go b/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
new file mode 100644
index 000000000..94ffd2fb7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
@@ -0,0 +1,43 @@
+package gocty
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+var valueType = reflect.TypeOf(cty.Value{})
+var typeType = reflect.TypeOf(cty.Type{})
+
+var setType = reflect.TypeOf(set.Set{})
+
+var bigFloatType = reflect.TypeOf(big.Float{})
+var bigIntType = reflect.TypeOf(big.Int{})
+
+var emptyInterfaceType = reflect.TypeOf(interface{}(nil))
+
+var stringType = reflect.TypeOf("")
+
+// structTagIndices interrogates the fields of the given type (which must
+// be a struct type, or we'll panic) and returns a map from the cty
+// attribute names declared via struct tags to the indices of the
+// fields holding those tags.
+//
+// This function will panic if two fields within the struct are tagged with
+// the same cty attribute name.
+func structTagIndices(st reflect.Type) map[string]int {
+	ct := st.NumField()
+	ret := make(map[string]int, ct)
+
+	for i := 0; i < ct; i++ {
+		field := st.Field(i)
+		attrName := field.Tag.Get("cty")
+		if attrName != "" {
+			ret[attrName] = i
+		}
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/in.go b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
new file mode 100644
index 000000000..ca9de21d2
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
@@ -0,0 +1,548 @@
+package gocty
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// ToCtyValue produces a cty.Value from a Go value. The result will conform
+// to the given type, or an error will be returned if this is not possible.
+//
+// The target type serves as a hint to resolve ambiguities in the mapping.
+// For example, the Go type set.Set tells us that the value is a set but
+// does not describe the set's element type. This also allows for convenient
+// conversions, such as populating a set from a slice rather than having to
+// first explicitly instantiate a set.Set.
+//
+// The audience of this function is assumed to be the developers of Go code
+// that is integrating with cty, and thus the error messages it returns are
+// presented from Go's perspective. These messages are thus not appropriate
+// for display to end-users. An error returned from ToCtyValue represents a
+// bug in the calling program, not user error.
+func ToCtyValue(val interface{}, ty cty.Type) (cty.Value, error) {
+	// 'path' starts off as empty but will grow for each level of recursive
+	// call we make, so by the time toCtyValue returns it is likely to have
+	// unused capacity on the end of it, depending on how deeply-recursive
+	// the given Type is.
+	path := make(cty.Path, 0)
+	return toCtyValue(reflect.ValueOf(val), ty, path)
+}
+
+func toCtyValue(val reflect.Value, ty cty.Type, path cty.Path) (cty.Value, error) {
+	if val != (reflect.Value{}) && val.Type().AssignableTo(valueType) {
+		// If the source value is a cty.Value then we'll try to just pass
+		// through to the target type directly.
+		return toCtyPassthrough(val, ty, path)
+	}
+
+	switch ty {
+	case cty.Bool:
+		return toCtyBool(val, path)
+	case cty.Number:
+		return toCtyNumber(val, path)
+	case cty.String:
+		return toCtyString(val, path)
+	case cty.DynamicPseudoType:
+		return toCtyDynamic(val, path)
+	}
+
+	switch {
+	case ty.IsListType():
+		return toCtyList(val, ty.ElementType(), path)
+	case ty.IsMapType():
+		return toCtyMap(val, ty.ElementType(), path)
+	case ty.IsSetType():
+		return toCtySet(val, ty.ElementType(), path)
+	case ty.IsObjectType():
+		return toCtyObject(val, ty.AttributeTypes(), path)
+	case ty.IsTupleType():
+		return toCtyTuple(val, ty.TupleElementTypes(), path)
+	case ty.IsCapsuleType():
+		return toCtyCapsule(val, ty, path)
+	}
+
+	// We should never fall out here
+	return cty.NilVal, path.NewErrorf("unsupported target type %#v", ty)
+}
+
+func toCtyBool(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Bool), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Bool:
+		return cty.BoolVal(val.Bool()), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to bool", val.Kind())
+
+	}
+
+}
+
+func toCtyNumber(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Number), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return cty.NumberIntVal(val.Int()), nil
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return cty.NumberUIntVal(val.Uint()), nil
+
+	case reflect.Float32, reflect.Float64:
+		return cty.NumberFloatVal(val.Float()), nil
+
+	case reflect.Struct:
+		if val.Type().AssignableTo(bigIntType) {
+			bigInt := val.Interface().(big.Int)
+			bigFloat := (&big.Float{}).SetInt(&bigInt)
+			val = reflect.ValueOf(*bigFloat)
+		}
+
+		if val.Type().AssignableTo(bigFloatType) {
+			bigFloat := val.Interface().(big.Float)
+			return cty.NumberVal(&bigFloat), nil
+		}
+
+		fallthrough
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to number", val.Kind())
+
+	}
+
+}
+
+func toCtyString(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.String), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.String:
+		return cty.StringVal(val.String()), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to string", val.Kind())
+
+	}
+
+}
+
+func toCtyList(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.List(ety)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Slice:
+		if val.IsNil() {
+			return cty.NullVal(cty.List(ety)), nil
+		}
+		fallthrough
+	case reflect.Array:
+		if val.Len() == 0 {
+			return cty.ListValEmpty(ety), nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make([]cty.Value, val.Len())
+		for i := range vals {
+			var err error
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+			vals[i], err = toCtyValue(val.Index(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.ListVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.List(ety))
+
+	}
+}
+
+func toCtyMap(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Map(ety)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Map:
+		if val.IsNil() {
+			return cty.NullVal(cty.Map(ety)), nil
+		}
+
+		if val.Len() == 0 {
+			return cty.MapValEmpty(ety), nil
+		}
+
+		keyType := val.Type().Key()
+		if keyType.Kind() != reflect.String {
+			return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType)
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make(map[string]cty.Value, val.Len())
+		for _, kv := range val.MapKeys() {
+			k := kv.String()
+			var err error
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.StringVal(k),
+			}
+			vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.MapVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Map(ety))
+
+	}
+}
+
+func toCtySet(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Set(ety)), nil
+	}
+
+	var vals []cty.Value
+
+	switch val.Kind() {
+
+	case reflect.Slice:
+		if val.IsNil() {
+			return cty.NullVal(cty.Set(ety)), nil
+		}
+		fallthrough
+	case reflect.Array:
+		if val.Len() == 0 {
+			return cty.SetValEmpty(ety), nil
+		}
+
+		vals = make([]cty.Value, val.Len())
+		for i := range vals {
+			var err error
+			vals[i], err = toCtyValue(val.Index(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+	case reflect.Struct:
+
+		if !val.Type().AssignableTo(setType) {
+			return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Type(), cty.Set(ety))
+		}
+
+		rawSet := val.Interface().(set.Set)
+		inVals := rawSet.Values()
+
+		if len(inVals) == 0 {
+			return cty.SetValEmpty(ety), nil
+		}
+
+		vals = make([]cty.Value, len(inVals))
+		for i := range inVals {
+			var err error
+			vals[i], err = toCtyValue(reflect.ValueOf(inVals[i]), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Set(ety))
+
+	}
+
+	return cty.SetVal(vals), nil
+}
+
+func toCtyObject(val reflect.Value, attrTypes map[string]cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Object(attrTypes)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Map:
+		if val.IsNil() {
+			return cty.NullVal(cty.Object(attrTypes)), nil
+		}
+
+		keyType := val.Type().Key()
+		if keyType.Kind() != reflect.String {
+			return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType)
+		}
+
+		if len(attrTypes) == 0 {
+			return cty.EmptyObjectVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our GetAttr step.
+		path = append(path, cty.PathStep(nil))
+
+		haveKeys := make(map[string]struct{}, val.Len())
+		for _, kv := range val.MapKeys() {
+			haveKeys[kv.String()] = struct{}{}
+		}
+
+		vals := make(map[string]cty.Value, len(attrTypes))
+		for k, at := range attrTypes {
+			var err error
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			if _, have := haveKeys[k]; !have {
+				vals[k] = cty.NullVal(at)
+				continue
+			}
+
+			vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), at, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.ObjectVal(vals), nil
+
+	case reflect.Struct:
+		if len(attrTypes) == 0 {
+			return cty.EmptyObjectVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our GetAttr step.
+		path = append(path, cty.PathStep(nil))
+
+		attrFields := structTagIndices(val.Type())
+
+		vals := make(map[string]cty.Value, len(attrTypes))
+		for k, at := range attrTypes {
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			if fieldIdx, have := attrFields[k]; have {
+				var err error
+				vals[k], err = toCtyValue(val.Field(fieldIdx), at, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			} else {
+				vals[k] = cty.NullVal(at)
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.ObjectVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Object(attrTypes))
+
+	}
+}
+
+func toCtyTuple(val reflect.Value, elemTypes []cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Tuple(elemTypes)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Slice:
+		if val.IsNil() {
+			return cty.NullVal(cty.Tuple(elemTypes)), nil
+		}
+
+		if val.Len() != len(elemTypes) {
+			return cty.NilVal, path.NewErrorf("wrong number of elements %d; need %d", val.Len(), len(elemTypes))
+		}
+
+		if len(elemTypes) == 0 {
+			return cty.EmptyTupleVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our Index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make([]cty.Value, len(elemTypes))
+		for i, ety := range elemTypes {
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			vals[i], err = toCtyValue(val.Index(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.TupleVal(vals), nil
+
+	case reflect.Struct:
+		fieldCount := val.Type().NumField()
+		if fieldCount != len(elemTypes) {
+			return cty.NilVal, path.NewErrorf("wrong number of struct fields %d; need %d", fieldCount, len(elemTypes))
+		}
+
+		if len(elemTypes) == 0 {
+			return cty.EmptyTupleVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our Index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make([]cty.Value, len(elemTypes))
+		for i, ety := range elemTypes {
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			vals[i], err = toCtyValue(val.Field(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.TupleVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Tuple(elemTypes))
+
+	}
+}
+
+func toCtyCapsule(val reflect.Value, capsuleType cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(capsuleType), nil
+	}
+
+	if val.Kind() != reflect.Ptr {
+		if !val.CanAddr() {
+			return cty.NilVal, path.NewErrorf("source value for capsule %#v must be addressable", capsuleType)
+		}
+
+		val = val.Addr()
+	}
+
+	if !val.Type().Elem().AssignableTo(capsuleType.EncapsulatedType()) {
+		return cty.NilVal, path.NewErrorf("value of type %T not compatible with capsule %#v", val.Interface(), capsuleType)
+	}
+
+	return cty.CapsuleVal(capsuleType, val.Interface()), nil
+}
+
+func toCtyDynamic(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.DynamicPseudoType), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Struct:
+		if !val.Type().AssignableTo(valueType) {
+			return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Type())
+		}
+
+		return val.Interface().(cty.Value), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Kind())
+
+	}
+
+}
+
+func toCtyPassthrough(wrappedVal reflect.Value, wantTy cty.Type, path cty.Path) (cty.Value, error) {
+	if wrappedVal = toCtyUnwrapPointer(wrappedVal); !wrappedVal.IsValid() {
+		return cty.NullVal(wantTy), nil
+	}
+
+	givenVal := wrappedVal.Interface().(cty.Value)
+
+	val, err := convert.Convert(givenVal, wantTy)
+	if err != nil {
+		return cty.NilVal, path.NewErrorf("unsuitable value: %s", err)
+	}
+	return val, nil
+}
+
+// toCtyUnwrapPointer is a helper for dealing with Go pointers. It has three
+// possible outcomes:
+//
+// - Given value isn't a pointer, so it's just returned as-is.
+// - Given value is a non-nil pointer, in which case it is dereferenced
+//   and the result returned.
+// - Given value is a nil pointer, in which case an invalid value is returned.
+//
+// For nested pointer types, like **int, they are all dereferenced in turn
+// until a non-pointer value is found, or until a nil pointer is encountered.
+func toCtyUnwrapPointer(val reflect.Value) reflect.Value {
+	for val.Kind() == reflect.Ptr || val.Kind() == reflect.Interface {
+		if val.IsNil() {
+			return reflect.Value{}
+		}
+
+		val = val.Elem()
+	}
+
+	return val
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/out.go b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
new file mode 100644
index 000000000..e9c2599e6
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
@@ -0,0 +1,686 @@
+package gocty
+
+import (
+	"math"
+	"math/big"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FromCtyValue assigns a cty.Value to a reflect.Value, which must be a pointer,
+// using a fixed set of conversion rules.
+//
+// This function considers its audience to be the creator of the cty Value
+// given, and thus the error messages it generates are (unlike with ToCtyValue)
+// presented in cty terminology that is generally appropriate to return to
+// end-users in applications where cty data structures are built from
+// user-provided configuration. In particular this means that if incorrect
+// target types are provided by the calling application the resulting error
+// messages are likely to be confusing, since we assume that the given target
+// type is correct and the cty.Value is where the error lies.
+//
+// If an error is returned, the target data structure may have been partially
+// populated, but the degree to which this is true is an implementation
+// detail that the calling application should not rely on.
+//
+// The function will panic if given a non-pointer as the Go value target,
+// since that is considered to be a bug in the calling program.
+func FromCtyValue(val cty.Value, target interface{}) error {
+	tVal := reflect.ValueOf(target)
+	if tVal.Kind() != reflect.Ptr {
+		panic("target value is not a pointer")
+	}
+	if tVal.IsNil() {
+		panic("target value is nil pointer")
+	}
+
+	// 'path' starts off as empty but will grow for each level of recursive
+	// call we make, so by the time fromCtyValue returns it is likely to have
+	// unused capacity on the end of it, depending on how deeply-recursive
+	// the given cty.Value is.
+	path := make(cty.Path, 0)
+	return fromCtyValue(val, tVal, path)
+}
+
+func fromCtyValue(val cty.Value, target reflect.Value, path cty.Path) error {
+	ty := val.Type()
+
+	deepTarget := fromCtyPopulatePtr(target, false)
+
+	// If we're decoding into a cty.Value then we just pass through the
+	// value as-is, to enable partial decoding. This is the only situation
+	// where unknown values are permitted.
+	if deepTarget.Kind() == reflect.Struct && deepTarget.Type().AssignableTo(valueType) {
+		deepTarget.Set(reflect.ValueOf(val))
+		return nil
+	}
+
+	// Lists and maps can be nil without indirection, but everything else
+	// requires a pointer and we set it immediately to nil.
+	// We also make an exception for capsule types because we want to handle
+	// pointers specially for these.
+	// (fromCtyList and fromCtyMap must therefore deal with val.IsNull, while
+	// other types can assume no nulls after this point.)
+	if val.IsNull() && !val.Type().IsListType() && !val.Type().IsMapType() && !val.Type().IsCapsuleType() {
+		target = fromCtyPopulatePtr(target, true)
+		if target.Kind() != reflect.Ptr {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		target.Set(reflect.Zero(target.Type()))
+		return nil
+	}
+
+	target = deepTarget
+
+	if !val.IsKnown() {
+		return path.NewErrorf("value must be known")
+	}
+
+	switch ty {
+	case cty.Bool:
+		return fromCtyBool(val, target, path)
+	case cty.Number:
+		return fromCtyNumber(val, target, path)
+	case cty.String:
+		return fromCtyString(val, target, path)
+	}
+
+	switch {
+	case ty.IsListType():
+		return fromCtyList(val, target, path)
+	case ty.IsMapType():
+		return fromCtyMap(val, target, path)
+	case ty.IsSetType():
+		return fromCtySet(val, target, path)
+	case ty.IsObjectType():
+		return fromCtyObject(val, target, path)
+	case ty.IsTupleType():
+		return fromCtyTuple(val, target, path)
+	case ty.IsCapsuleType():
+		return fromCtyCapsule(val, target, path)
+	}
+
+	// We should never fall out here; reaching here indicates a bug in this
+	// function.
+	return path.NewErrorf("unsupported source type %#v", ty)
+}
+
+func fromCtyBool(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.Bool:
+		target.SetBool(val.True())
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyNumber(val cty.Value, target reflect.Value, path cty.Path) error {
+	bf := val.AsBigFloat()
+
+	switch target.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return fromCtyNumberInt(bf, target, path)
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return fromCtyNumberUInt(bf, target, path)
+
+	case reflect.Float32, reflect.Float64:
+		return fromCtyNumberFloat(bf, target, path)
+
+	case reflect.Struct:
+		return fromCtyNumberBig(bf, target, path)
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyNumberInt(bf *big.Float, target reflect.Value, path cty.Path) error {
+	// Doing this with switch rather than << arithmetic because << with
+	// result >32-bits is not portable to 32-bit systems.
+	var min int64
+	var max int64
+	switch target.Type().Bits() {
+	case 8:
+		min = math.MinInt8
+		max = math.MaxInt8
+	case 16:
+		min = math.MinInt16
+		max = math.MaxInt16
+	case 32:
+		min = math.MinInt32
+		max = math.MaxInt32
+	case 64:
+		min = math.MinInt64
+		max = math.MaxInt64
+	default:
+		panic("weird number of bits in target int")
+	}
+
+	iv, accuracy := bf.Int64()
+	if accuracy != big.Exact || iv < min || iv > max {
+		return path.NewErrorf("value must be a whole number, between %d and %d", min, max)
+	}
+
+	target.SetInt(iv)
+	return nil
+}
+
+func fromCtyNumberUInt(bf *big.Float, target reflect.Value, path cty.Path) error {
+	// Doing this with switch rather than << arithmetic because << with
+	// result >32-bits is not portable to 32-bit systems.
+	var max uint64
+	switch target.Type().Bits() {
+	case 8:
+		max = math.MaxUint8
+	case 16:
+		max = math.MaxUint16
+	case 32:
+		max = math.MaxUint32
+	case 64:
+		max = math.MaxUint64
+	default:
+		panic("weird number of bits in target uint")
+	}
+
+	iv, accuracy := bf.Uint64()
+	if accuracy != big.Exact || iv > max {
+		return path.NewErrorf("value must be a whole number, between 0 and %d inclusive", max)
+	}
+
+	target.SetUint(iv)
+	return nil
+}
+
+func fromCtyNumberFloat(bf *big.Float, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+	case reflect.Float32, reflect.Float64:
+		fv, accuracy := bf.Float64()
+		if accuracy != big.Exact {
+			// We allow the precision to be truncated as part of our conversion,
+			// but we don't want to silently introduce infinities.
+			if math.IsInf(fv, 0) {
+				return path.NewErrorf("value must be between %f and %f inclusive", -math.MaxFloat64, math.MaxFloat64)
+			}
+		}
+		target.SetFloat(fv)
+		return nil
+	default:
+		panic("unsupported kind of float")
+	}
+}
+
+func fromCtyNumberBig(bf *big.Float, target reflect.Value, path cty.Path) error {
+	switch {
+
+	case bigFloatType.ConvertibleTo(target.Type()):
+		// Easy!
+		target.Set(reflect.ValueOf(bf).Elem().Convert(target.Type()))
+		return nil
+
+	case bigIntType.ConvertibleTo(target.Type()):
+		bi, accuracy := bf.Int(nil)
+		if accuracy != big.Exact {
+			return path.NewErrorf("value must be a whole number")
+		}
+		target.Set(reflect.ValueOf(bi).Elem().Convert(target.Type()))
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+	}
+}
+
+func fromCtyString(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+	case reflect.String:
+		target.SetString(val.AsString())
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyList(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.Slice:
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		length := val.LengthInt()
+		tv := reflect.MakeSlice(target.Type(), length, length)
+
+		path = append(path, nil)
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			targetElem := tv.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		path = path[:len(path)-1]
+
+		target.Set(tv)
+		return nil
+
+	case reflect.Array:
+		if val.IsNull() {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		length := val.LengthInt()
+		if length != target.Len() {
+			return path.NewErrorf("must be a list of length %d", target.Len())
+		}
+
+		path = append(path, nil)
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			targetElem := target.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		path = path[:len(path)-1]
+
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyMap(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	switch target.Kind() {
+
+	case reflect.Map:
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		tv := reflect.MakeMap(target.Type())
+		et := target.Type().Elem()
+
+		path = append(path, nil)
+
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			path[len(path)-1] = cty.IndexStep{
+				Key: key,
+			}
+
+			ks := key.AsString()
+
+			targetElem := reflect.New(et)
+			err = fromCtyValue(val, targetElem, path)
+
+			tv.SetMapIndex(reflect.ValueOf(ks), targetElem.Elem())
+
+			return err != nil
+		})
+		if err != nil {
+			return err
+		}
+
+		path = path[:len(path)-1]
+
+		target.Set(tv)
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtySet(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.Slice:
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		length := val.LengthInt()
+		tv := reflect.MakeSlice(target.Type(), length, length)
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			targetElem := tv.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		target.Set(tv)
+		return nil
+
+	case reflect.Array:
+		if val.IsNull() {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		length := val.LengthInt()
+		if length != target.Len() {
+			return path.NewErrorf("must be a set of length %d", target.Len())
+		}
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			targetElem := target.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		return nil
+
+	// TODO: decode into set.Set instance
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyObject(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	switch target.Kind() {
+
+	case reflect.Struct:
+
+		attrTypes := val.Type().AttributeTypes()
+		targetFields := structTagIndices(target.Type())
+
+		path = append(path, nil)
+
+		for k, i := range targetFields {
+			if _, exists := attrTypes[k]; !exists {
+				// If the field in question isn't able to represent nil,
+				// that's an error.
+				fk := target.Field(i).Kind()
+				switch fk {
+				case reflect.Ptr, reflect.Slice, reflect.Map, reflect.Interface:
+					// okay
+				default:
+					return path.NewErrorf("missing required attribute %q", k)
+				}
+			}
+		}
+
+		for k := range attrTypes {
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			fieldIdx, exists := targetFields[k]
+			if !exists {
+				return path.NewErrorf("unsupported attribute %q", k)
+			}
+
+			ev := val.GetAttr(k)
+
+			targetField := target.Field(fieldIdx)
+			err := fromCtyValue(ev, targetField, path)
+			if err != nil {
+				return err
+			}
+		}
+
+		path = path[:len(path)-1]
+
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyTuple(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	switch target.Kind() {
+
+	case reflect.Struct:
+
+		elemTypes := val.Type().TupleElementTypes()
+		fieldCount := target.Type().NumField()
+
+		if fieldCount != len(elemTypes) {
+			return path.NewErrorf("a tuple of %d elements is required", fieldCount)
+		}
+
+		path = append(path, nil)
+
+		for i := range elemTypes {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			ev := val.Index(cty.NumberIntVal(int64(i)))
+
+			targetField := target.Field(i)
+			err := fromCtyValue(ev, targetField, path)
+			if err != nil {
+				return err
+			}
+		}
+
+		path = path[:len(path)-1]
+
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyCapsule(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	if target.Kind() == reflect.Ptr {
+		// Walk through indirection until we get to the last pointer,
+		// which we might set to null below.
+		target = fromCtyPopulatePtr(target, true)
+
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		// Since a capsule contains a pointer to an object, we'll preserve
+		// that pointer on the way out and thus allow the caller to recover
+		// the original object, rather than a copy of it.
+
+		eType := val.Type().EncapsulatedType()
+
+		if !eType.AssignableTo(target.Elem().Type()) {
+			// Our interface contract promises that we won't expose Go
+			// implementation details in error messages, so we need to keep
+			// this vague. This can only arise if a calling application has
+			// more than one capsule type in play and a user mixes them up.
+			return path.NewErrorf("incorrect type %s", val.Type().FriendlyName())
+		}
+
+		target.Set(reflect.ValueOf(val.EncapsulatedValue()))
+
+		return nil
+	} else {
+		if val.IsNull() {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		// If our target isn't a pointer then we will attempt to copy
+		// the encapsulated value into it.
+
+		eType := val.Type().EncapsulatedType()
+
+		if !eType.AssignableTo(target.Type()) {
+			// Our interface contract promises that we won't expose Go
+			// implementation details in error messages, so we need to keep
+			// this vague. This can only arise if a calling application has
+			// more than one capsule type in play and a user mixes them up.
+			return path.NewErrorf("incorrect type %s", val.Type().FriendlyName())
+		}
+
+		// We know that EncapsulatedValue is always a pointer, so we
+		// can safely call .Elem on its reflect.Value.
+		target.Set(reflect.ValueOf(val.EncapsulatedValue()).Elem())
+
+		return nil
+	}
+
+}
+
+// fromCtyPopulatePtr recognizes when target is a pointer type and allocates
+// a value to assign to that pointer, which it returns.
+//
+// If the given value has multiple levels of indirection, like **int, these
+// will be processed in turn so that the return value is guaranteed to be
+// a non-pointer.
+//
+// As an exception, if decodingNull is true then the returned value will be
+// the final level of pointer, if any, so that the caller can assign it
+// as nil to represent a null value. If the given target value is not a pointer
+// at all then the returned value will be just the given target, so the caller
+// must test if the returned value is a pointer before trying to assign nil
+// to it.
+func fromCtyPopulatePtr(target reflect.Value, decodingNull bool) reflect.Value {
+	for {
+		if target.Kind() == reflect.Interface && !target.IsNil() {
+			e := target.Elem()
+			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
+				target = e
+			}
+		}
+
+		if target.Kind() != reflect.Ptr {
+			break
+		}
+
+		// Stop early if we're decodingNull and we've found our last indirection
+		if target.Elem().Kind() != reflect.Ptr && decodingNull && target.CanSet() {
+			break
+		}
+
+		if target.IsNil() {
+			target.Set(reflect.New(target.Type().Elem()))
+		}
+
+		target = target.Elem()
+	}
+	return target
+}
+
+// likelyRequiredTypesError returns an error that states which types are
+// acceptable by making some assumptions about what types we support for
+// each target Go kind. It's not a precise science but it allows us to return
+// an error message that is cty-user-oriented rather than Go-oriented.
+//
+// Generally these error messages should be a matter of last resort, since
+// the calling application should be validating user-provided value types
+// before decoding anyway.
+func likelyRequiredTypesError(path cty.Path, target reflect.Value) error {
+	switch target.Kind() {
+
+	case reflect.Bool:
+		return path.NewErrorf("bool value is required")
+
+	case reflect.String:
+		return path.NewErrorf("string value is required")
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		fallthrough
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		fallthrough
+	case reflect.Float32, reflect.Float64:
+		return path.NewErrorf("number value is required")
+
+	case reflect.Slice, reflect.Array:
+		return path.NewErrorf("list or set value is required")
+
+	case reflect.Map:
+		return path.NewErrorf("map or object value is required")
+
+	case reflect.Struct:
+		switch {
+
+		case target.Type().AssignableTo(bigFloatType) || target.Type().AssignableTo(bigIntType):
+			return path.NewErrorf("number value is required")
+
+		case target.Type().AssignableTo(setType):
+			return path.NewErrorf("set or list value is required")
+
+		default:
+			return path.NewErrorf("object or tuple value is required")
+
+		}
+
+	default:
+		// We should avoid getting into this path, since this error
+		// message is rather useless.
+		return path.NewErrorf("incorrect type")
+
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
new file mode 100644
index 000000000..ce4c8f1e9
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
@@ -0,0 +1,108 @@
+package gocty
+
+import (
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType takes an arbitrary Go value (as an interface{}) and attempts
+// to find a suitable cty.Type instance that could be used for a conversion
+// with ToCtyValue.
+//
+// This allows -- for simple situations at least -- types to be defined just
+// once in Go and the cty types derived from the Go types, but in the process
+// it makes some assumptions that may be undesirable so applications are
+// encouraged to build their cty types directly if exacting control is
+// required.
+//
+// Not all Go types can be represented as cty types, so an error may be
+// returned which is usually considered to be a bug in the calling program.
+// In particular, ImpliedType will never use capsule types in its returned
+// type, because it cannot know the capsule types supported by the calling
+// program.
+func ImpliedType(gv interface{}) (cty.Type, error) {
+	rt := reflect.TypeOf(gv)
+	var path cty.Path
+	return impliedType(rt, path)
+}
+
+func impliedType(rt reflect.Type, path cty.Path) (cty.Type, error) {
+	switch rt.Kind() {
+
+	case reflect.Ptr:
+		return impliedType(rt.Elem(), path)
+
+	// Primitive types
+	case reflect.Bool:
+		return cty.Bool, nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return cty.Number, nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return cty.Number, nil
+	case reflect.Float32, reflect.Float64:
+		return cty.Number, nil
+	case reflect.String:
+		return cty.String, nil
+
+	// Collection types
+	case reflect.Slice:
+		path := append(path, cty.IndexStep{Key: cty.UnknownVal(cty.Number)})
+		ety, err := impliedType(rt.Elem(), path)
+		if err != nil {
+			return cty.NilType, err
+		}
+		return cty.List(ety), nil
+	case reflect.Map:
+		if !stringType.AssignableTo(rt.Key()) {
+			return cty.NilType, path.NewErrorf("no cty.Type for %s (must have string keys)", rt)
+		}
+		path := append(path, cty.IndexStep{Key: cty.UnknownVal(cty.String)})
+		ety, err := impliedType(rt.Elem(), path)
+		if err != nil {
+			return cty.NilType, err
+		}
+		return cty.Map(ety), nil
+
+	// Structural types
+	case reflect.Struct:
+		return impliedStructType(rt, path)
+
+	default:
+		return cty.NilType, path.NewErrorf("no cty.Type for %s", rt)
+	}
+}
+
+func impliedStructType(rt reflect.Type, path cty.Path) (cty.Type, error) {
+	if valueType.AssignableTo(rt) {
+		// Special case: cty.Value represents cty.DynamicPseudoType, for
+		// type conformance checking.
+		return cty.DynamicPseudoType, nil
+	}
+
+	fieldIdxs := structTagIndices(rt)
+	if len(fieldIdxs) == 0 {
+		return cty.NilType, path.NewErrorf("no cty.Type for %s (no cty field tags)", rt)
+	}
+
+	atys := make(map[string]cty.Type, len(fieldIdxs))
+
+	{
+		// Temporary extension of path for attributes
+		path := append(path, nil)
+
+		for k, fi := range fieldIdxs {
+			path[len(path)-1] = cty.GetAttrStep{Name: k}
+
+			ft := rt.Field(fi).Type
+			aty, err := impliedType(ft, path)
+			if err != nil {
+				return cty.NilType, err
+			}
+
+			atys[k] = aty
+		}
+	}
+
+	return cty.Object(atys), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/helper.go b/vendor/github.com/zclconf/go-cty/cty/helper.go
new file mode 100644
index 000000000..1b88e9fa0
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/helper.go
@@ -0,0 +1,99 @@
+package cty
+
+import (
+	"fmt"
+)
+
+// anyUnknown is a helper to easily check if a set of values contains any
+// unknowns, for operations that short-circuit to return unknown in that case.
+func anyUnknown(values ...Value) bool {
+	for _, val := range values {
+		if val.v == unknown {
+			return true
+		}
+	}
+	return false
+}
+
+// typeCheck tests whether all of the given values belong to the given type.
+// If the given types are a mixture of the given type and the dynamic
+// pseudo-type then a short-circuit dynamic value is returned. If the given
+// values are all of the correct type but at least one is unknown then
+// a short-circuit unknown value is returned. If any other types appear then
+// an error is returned. Otherwise (finally!) the result is nil, nil.
+func typeCheck(required Type, ret Type, values ...Value) (shortCircuit *Value, err error) {
+	hasDynamic := false
+	hasUnknown := false
+
+	for i, val := range values {
+		if val.ty == DynamicPseudoType {
+			hasDynamic = true
+			continue
+		}
+
+		if !val.Type().Equals(required) {
+			return nil, fmt.Errorf(
+				"type mismatch: want %s but value %d is %s",
+				required.FriendlyName(),
+				i, val.ty.FriendlyName(),
+			)
+		}
+
+		if val.v == unknown {
+			hasUnknown = true
+		}
+	}
+
+	if hasDynamic {
+		return &DynamicVal, nil
+	}
+
+	if hasUnknown {
+		ret := UnknownVal(ret)
+		return &ret, nil
+	}
+
+	return nil, nil
+}
+
+// mustTypeCheck is a wrapper around typeCheck that immediately panics if
+// any error is returned.
+func mustTypeCheck(required Type, ret Type, values ...Value) *Value {
+	shortCircuit, err := typeCheck(required, ret, values...)
+	if err != nil {
+		panic(err)
+	}
+	return shortCircuit
+}
+
+// shortCircuitForceType takes the return value from mustTypeCheck and
+// replaces it with an unknown of the given type if the original value was
+// DynamicVal.
+//
+// This is useful for operations that are specified to always return a
+// particular type, since then a dynamic result can safely be "upgrade" to
+// a strongly-typed unknown, which then allows subsequent operations to
+// be actually type-checked.
+//
+// It is safe to use this only if the operation in question is defined as
+// returning either a value of the given type or panicking, since we know
+// then that subsequent operations won't run if the operation panics.
+//
+// If the given short-circuit value is *not* DynamicVal then it must be
+// of the given type, or this function will panic.
+func forceShortCircuitType(shortCircuit *Value, ty Type) *Value {
+	if shortCircuit == nil {
+		return nil
+	}
+
+	if shortCircuit.ty == DynamicPseudoType {
+		ret := UnknownVal(ty)
+		return &ret
+	}
+
+	if !shortCircuit.ty.Equals(ty) {
+		panic("forceShortCircuitType got value of wrong type")
+	}
+
+	return shortCircuit
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json.go b/vendor/github.com/zclconf/go-cty/cty/json.go
new file mode 100644
index 000000000..c421a62ed
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json.go
@@ -0,0 +1,176 @@
+package cty
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// MarshalJSON is an implementation of json.Marshaler that allows Type
+// instances to be serialized as JSON.
+//
+// All standard types can be serialized, but capsule types cannot since there
+// is no way to automatically recover the original pointer and capsule types
+// compare by equality.
+func (t Type) MarshalJSON() ([]byte, error) {
+	switch impl := t.typeImpl.(type) {
+	case primitiveType:
+		switch impl.Kind {
+		case primitiveTypeBool:
+			return []byte{'"', 'b', 'o', 'o', 'l', '"'}, nil
+		case primitiveTypeNumber:
+			return []byte{'"', 'n', 'u', 'm', 'b', 'e', 'r', '"'}, nil
+		case primitiveTypeString:
+			return []byte{'"', 's', 't', 'r', 'i', 'n', 'g', '"'}, nil
+		default:
+			panic("unknown primitive type kind")
+		}
+	case typeList, typeMap, typeSet:
+		buf := &bytes.Buffer{}
+		etyJSON, err := t.ElementType().MarshalJSON()
+		if err != nil {
+			return nil, err
+		}
+		buf.WriteRune('[')
+		switch impl.(type) {
+		case typeList:
+			buf.WriteString(`"list"`)
+		case typeMap:
+			buf.WriteString(`"map"`)
+		case typeSet:
+			buf.WriteString(`"set"`)
+		}
+		buf.WriteRune(',')
+		buf.Write(etyJSON)
+		buf.WriteRune(']')
+		return buf.Bytes(), nil
+	case typeObject:
+		buf := &bytes.Buffer{}
+		atysJSON, err := json.Marshal(t.AttributeTypes())
+		if err != nil {
+			return nil, err
+		}
+		buf.WriteString(`["object",`)
+		buf.Write(atysJSON)
+		buf.WriteRune(']')
+		return buf.Bytes(), nil
+	case typeTuple:
+		buf := &bytes.Buffer{}
+		etysJSON, err := json.Marshal(t.TupleElementTypes())
+		if err != nil {
+			return nil, err
+		}
+		buf.WriteString(`["tuple",`)
+		buf.Write(etysJSON)
+		buf.WriteRune(']')
+		return buf.Bytes(), nil
+	case pseudoTypeDynamic:
+		return []byte{'"', 'd', 'y', 'n', 'a', 'm', 'i', 'c', '"'}, nil
+	case *capsuleType:
+		return nil, fmt.Errorf("type not allowed: %s", t.FriendlyName())
+	default:
+		// should never happen
+		panic("unknown type implementation")
+	}
+}
+
+// UnmarshalJSON is the opposite of MarshalJSON. See the documentation of
+// MarshalJSON for information on the limitations of JSON serialization of
+// types.
+func (t *Type) UnmarshalJSON(buf []byte) error {
+	r := bytes.NewReader(buf)
+	dec := json.NewDecoder(r)
+
+	tok, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	switch v := tok.(type) {
+	case string:
+		switch v {
+		case "bool":
+			*t = Bool
+		case "number":
+			*t = Number
+		case "string":
+			*t = String
+		case "dynamic":
+			*t = DynamicPseudoType
+		default:
+			return fmt.Errorf("invalid primitive type name %q", v)
+		}
+
+		if dec.More() {
+			return fmt.Errorf("extraneous data after type description")
+		}
+		return nil
+	case json.Delim:
+		if rune(v) != '[' {
+			return fmt.Errorf("invalid complex type description")
+		}
+
+		tok, err = dec.Token()
+		if err != nil {
+			return err
+		}
+
+		kind, ok := tok.(string)
+		if !ok {
+			return fmt.Errorf("invalid complex type kind name")
+		}
+
+		switch kind {
+		case "list":
+			var ety Type
+			err = dec.Decode(&ety)
+			if err != nil {
+				return err
+			}
+			*t = List(ety)
+		case "map":
+			var ety Type
+			err = dec.Decode(&ety)
+			if err != nil {
+				return err
+			}
+			*t = Map(ety)
+		case "set":
+			var ety Type
+			err = dec.Decode(&ety)
+			if err != nil {
+				return err
+			}
+			*t = Set(ety)
+		case "object":
+			var atys map[string]Type
+			err = dec.Decode(&atys)
+			if err != nil {
+				return err
+			}
+			*t = Object(atys)
+		case "tuple":
+			var etys []Type
+			err = dec.Decode(&etys)
+			if err != nil {
+				return err
+			}
+			*t = Tuple(etys)
+		default:
+			return fmt.Errorf("invalid complex type kind name")
+		}
+
+		tok, err = dec.Token()
+		if err != nil {
+			return err
+		}
+		if delim, ok := tok.(json.Delim); !ok || rune(delim) != ']' || dec.More() {
+			return fmt.Errorf("unexpected extra data in type description")
+		}
+
+		return nil
+
+	default:
+		return fmt.Errorf("invalid type description")
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/doc.go b/vendor/github.com/zclconf/go-cty/cty/json/doc.go
new file mode 100644
index 000000000..8916513d6
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/doc.go
@@ -0,0 +1,11 @@
+// Package json provides functions for serializing cty types and values in
+// JSON format, and for decoding them again.
+//
+// Since the cty type system is a superset of the JSON type system,
+// round-tripping through JSON is lossy unless type information is provided
+// both at encoding time and decoding time. Callers of this package are
+// therefore suggested to define their expected structure as a cty.Type
+// and pass it in consistently both when encoding and when decoding, though
+// default (type-lossy) behavior is provided for situations where the precise
+// representation of the data is not significant.
+package json
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/marshal.go b/vendor/github.com/zclconf/go-cty/cty/json/marshal.go
new file mode 100644
index 000000000..f7bea1a2f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/marshal.go
@@ -0,0 +1,189 @@
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"sort"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+func marshal(val cty.Value, t cty.Type, path cty.Path, b *bytes.Buffer) error {
+	// If we're going to decode as DynamicPseudoType then we need to save
+	// dynamic type information to recover the real type.
+	if t == cty.DynamicPseudoType && val.Type() != cty.DynamicPseudoType {
+		return marshalDynamic(val, path, b)
+	}
+
+	if val.IsNull() {
+		b.WriteString("null")
+		return nil
+	}
+
+	if !val.IsKnown() {
+		return path.NewErrorf("value is not known")
+	}
+
+	// The caller should've guaranteed that the given val is conformant with
+	// the given type t, so we'll proceed under that assumption here.
+
+	switch {
+	case t.IsPrimitiveType():
+		switch t {
+		case cty.String:
+			json, err := json.Marshal(val.AsString())
+			if err != nil {
+				return path.NewErrorf("failed to serialize value: %s", err)
+			}
+			b.Write(json)
+			return nil
+		case cty.Number:
+			if val.RawEquals(cty.PositiveInfinity) || val.RawEquals(cty.NegativeInfinity) {
+				return path.NewErrorf("cannot serialize infinity as JSON")
+			}
+			b.WriteString(val.AsBigFloat().Text('f', -1))
+			return nil
+		case cty.Bool:
+			if val.True() {
+				b.WriteString("true")
+			} else {
+				b.WriteString("false")
+			}
+			return nil
+		default:
+			panic("unsupported primitive type")
+		}
+	case t.IsListType(), t.IsSetType():
+		b.WriteRune('[')
+		first := true
+		ety := t.ElementType()
+		it := val.ElementIterator()
+		path := append(path, nil) // local override of 'path' with extra element
+		for it.Next() {
+			if !first {
+				b.WriteRune(',')
+			}
+			ek, ev := it.Element()
+			path[len(path)-1] = cty.IndexStep{
+				Key: ek,
+			}
+			err := marshal(ev, ety, path, b)
+			if err != nil {
+				return err
+			}
+			first = false
+		}
+		b.WriteRune(']')
+		return nil
+	case t.IsMapType():
+		b.WriteRune('{')
+		first := true
+		ety := t.ElementType()
+		it := val.ElementIterator()
+		path := append(path, nil) // local override of 'path' with extra element
+		for it.Next() {
+			if !first {
+				b.WriteRune(',')
+			}
+			ek, ev := it.Element()
+			path[len(path)-1] = cty.IndexStep{
+				Key: ek,
+			}
+			var err error
+			err = marshal(ek, ek.Type(), path, b)
+			if err != nil {
+				return err
+			}
+			b.WriteRune(':')
+			err = marshal(ev, ety, path, b)
+			if err != nil {
+				return err
+			}
+			first = false
+		}
+		b.WriteRune('}')
+		return nil
+	case t.IsTupleType():
+		b.WriteRune('[')
+		etys := t.TupleElementTypes()
+		it := val.ElementIterator()
+		path := append(path, nil) // local override of 'path' with extra element
+		i := 0
+		for it.Next() {
+			if i > 0 {
+				b.WriteRune(',')
+			}
+			ety := etys[i]
+			ek, ev := it.Element()
+			path[len(path)-1] = cty.IndexStep{
+				Key: ek,
+			}
+			err := marshal(ev, ety, path, b)
+			if err != nil {
+				return err
+			}
+			i++
+		}
+		b.WriteRune(']')
+		return nil
+	case t.IsObjectType():
+		b.WriteRune('{')
+		atys := t.AttributeTypes()
+		path := append(path, nil) // local override of 'path' with extra element
+
+		names := make([]string, 0, len(atys))
+		for k := range atys {
+			names = append(names, k)
+		}
+		sort.Strings(names)
+
+		for i, k := range names {
+			aty := atys[k]
+			if i > 0 {
+				b.WriteRune(',')
+			}
+			av := val.GetAttr(k)
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+			var err error
+			err = marshal(cty.StringVal(k), cty.String, path, b)
+			if err != nil {
+				return err
+			}
+			b.WriteRune(':')
+			err = marshal(av, aty, path, b)
+			if err != nil {
+				return err
+			}
+		}
+		b.WriteRune('}')
+		return nil
+	case t.IsCapsuleType():
+		rawVal := val.EncapsulatedValue()
+		jsonVal, err := json.Marshal(rawVal)
+		if err != nil {
+			return path.NewError(err)
+		}
+		b.Write(jsonVal)
+		return nil
+	default:
+		// should never happen
+		return path.NewErrorf("cannot JSON-serialize %s", t.FriendlyName())
+	}
+}
+
+// marshalDynamic adds an extra wrapping object containing dynamic type
+// information for the given value.
+func marshalDynamic(val cty.Value, path cty.Path, b *bytes.Buffer) error {
+	typeJSON, err := MarshalType(val.Type())
+	if err != nil {
+		return path.NewErrorf("failed to serialize type: %s", err)
+	}
+	b.WriteString(`{"value":`)
+	marshal(val, val.Type(), path, b)
+	b.WriteString(`,"type":`)
+	b.Write(typeJSON)
+	b.WriteRune('}')
+	return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/simple.go b/vendor/github.com/zclconf/go-cty/cty/json/simple.go
new file mode 100644
index 000000000..507c9cc2c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/simple.go
@@ -0,0 +1,41 @@
+package json
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// SimpleJSONValue is a wrapper around cty.Value that adds implementations of
+// json.Marshaler and json.Unmarshaler for simple-but-type-lossy automatic
+// encoding and decoding of values.
+//
+// The couplet Marshal and Unmarshal both take extra type information to
+// inform the encoding and decoding process so that all of the cty types
+// can be represented even though JSON's type system is a subset.
+//
+// SimpleJSONValue instead takes the approach of discarding the value's type
+// information and then deriving a new type from the stored structure when
+// decoding. This results in the same data being returned but not necessarily
+// with exactly the same type.
+//
+// For information on how types are inferred when decoding, see the
+// documentation of the function ImpliedType.
+type SimpleJSONValue struct {
+	cty.Value
+}
+
+// MarshalJSON is an implementation of json.Marshaler. See the documentation
+// of SimpleJSONValue for more information.
+func (v SimpleJSONValue) MarshalJSON() ([]byte, error) {
+	return Marshal(v.Value, v.Type())
+}
+
+// UnmarshalJSON is an implementation of json.Unmarshaler. See the
+// documentation of SimpleJSONValue for more information.
+func (v *SimpleJSONValue) UnmarshalJSON(buf []byte) error {
+	t, err := ImpliedType(buf)
+	if err != nil {
+		return err
+	}
+	v.Value, err = Unmarshal(buf, t)
+	return err
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/type.go b/vendor/github.com/zclconf/go-cty/cty/json/type.go
new file mode 100644
index 000000000..9131c6c77
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/type.go
@@ -0,0 +1,23 @@
+package json
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// MarshalType returns a JSON serialization of the given type.
+//
+// This is just a thin wrapper around t.MarshalJSON, for symmetry with
+// UnmarshalType.
+func MarshalType(t cty.Type) ([]byte, error) {
+	return t.MarshalJSON()
+}
+
+// UnmarshalType decodes a JSON serialization of the given type as produced
+// by either Type.MarshalJSON or MarshalType.
+//
+// This is a convenience wrapper around Type.UnmarshalJSON.
+func UnmarshalType(buf []byte) (cty.Type, error) {
+	var t cty.Type
+	err := t.UnmarshalJSON(buf)
+	return t, err
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
new file mode 100644
index 000000000..0fa13f6c5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
@@ -0,0 +1,170 @@
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType returns the cty Type implied by the structure of the given
+// JSON-compliant buffer. This function implements the default type mapping
+// behavior used when decoding arbitrary JSON without explicit cty Type
+// information.
+//
+// The rules are as follows:
+//
+// JSON strings, numbers and bools map to their equivalent primitive type in
+// cty.
+//
+// JSON objects map to cty object types, with the attributes defined by the
+// object keys and the types of their values.
+//
+// JSON arrays map to cty tuple types, with the elements defined by the
+// types of the array members.
+//
+// Any nulls are typed as DynamicPseudoType, so callers of this function
+// must be prepared to deal with this. Callers that do not wish to deal with
+// dynamic typing should not use this function and should instead describe
+// their required types explicitly with a cty.Type instance when decoding.
+//
+// Any JSON syntax errors will be returned as an error, and the type will
+// be the invalid value cty.NilType.
+func ImpliedType(buf []byte) (cty.Type, error) {
+	r := bytes.NewReader(buf)
+	dec := json.NewDecoder(r)
+	dec.UseNumber()
+
+	ty, err := impliedType(dec)
+	if err != nil {
+		return cty.NilType, err
+	}
+
+	if dec.More() {
+		return cty.NilType, fmt.Errorf("extraneous data after JSON object")
+	}
+
+	return ty, nil
+}
+
+func impliedType(dec *json.Decoder) (cty.Type, error) {
+	tok, err := dec.Token()
+	if err != nil {
+		return cty.NilType, err
+	}
+
+	return impliedTypeForTok(tok, dec)
+}
+
+func impliedTypeForTok(tok json.Token, dec *json.Decoder) (cty.Type, error) {
+	if tok == nil {
+		return cty.DynamicPseudoType, nil
+	}
+
+	switch ttok := tok.(type) {
+	case bool:
+		return cty.Bool, nil
+
+	case json.Number:
+		return cty.Number, nil
+
+	case string:
+		return cty.String, nil
+
+	case json.Delim:
+
+		switch rune(ttok) {
+		case '{':
+			return impliedObjectType(dec)
+		case '[':
+			return impliedTupleType(dec)
+		default:
+			return cty.NilType, fmt.Errorf("unexpected token %q", ttok)
+		}
+
+	default:
+		return cty.NilType, fmt.Errorf("unsupported JSON token %#v", tok)
+	}
+}
+
+func impliedObjectType(dec *json.Decoder) (cty.Type, error) {
+	// By the time we get in here, we've already consumed the { delimiter
+	// and so our next token should be the first object key.
+
+	var atys map[string]cty.Type
+
+	for {
+		// Read the object key first
+		tok, err := dec.Token()
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		if ttok, ok := tok.(json.Delim); ok {
+			if rune(ttok) != '}' {
+				return cty.NilType, fmt.Errorf("unexpected delimiter %q", ttok)
+			}
+			break
+		}
+
+		key, ok := tok.(string)
+		if !ok {
+			return cty.NilType, fmt.Errorf("expected string but found %T", tok)
+		}
+
+		// Now read the value
+		tok, err = dec.Token()
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		aty, err := impliedTypeForTok(tok, dec)
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		if atys == nil {
+			atys = make(map[string]cty.Type)
+		}
+		atys[key] = aty
+	}
+
+	if len(atys) == 0 {
+		return cty.EmptyObject, nil
+	}
+
+	return cty.Object(atys), nil
+}
+
+func impliedTupleType(dec *json.Decoder) (cty.Type, error) {
+	// By the time we get in here, we've already consumed the [ delimiter
+	// and so our next token should be the first value.
+
+	var etys []cty.Type
+
+	for {
+		tok, err := dec.Token()
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		if ttok, ok := tok.(json.Delim); ok {
+			if rune(ttok) == ']' {
+				break
+			}
+		}
+
+		ety, err := impliedTypeForTok(tok, dec)
+		if err != nil {
+			return cty.NilType, err
+		}
+		etys = append(etys, ety)
+	}
+
+	if len(etys) == 0 {
+		return cty.EmptyTuple, nil
+	}
+
+	return cty.Tuple(etys), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
new file mode 100644
index 000000000..38106455f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
@@ -0,0 +1,459 @@
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+func unmarshal(buf []byte, t cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+
+	tok, err := dec.Token()
+	if err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if tok == nil {
+		return cty.NullVal(t), nil
+	}
+
+	if t == cty.DynamicPseudoType {
+		return unmarshalDynamic(buf, path)
+	}
+
+	switch {
+	case t.IsPrimitiveType():
+		val, err := unmarshalPrimitive(tok, t, path)
+		if err != nil {
+			return cty.NilVal, err
+		}
+		return val, nil
+	case t.IsListType():
+		return unmarshalList(buf, t.ElementType(), path)
+	case t.IsSetType():
+		return unmarshalSet(buf, t.ElementType(), path)
+	case t.IsMapType():
+		return unmarshalMap(buf, t.ElementType(), path)
+	case t.IsTupleType():
+		return unmarshalTuple(buf, t.TupleElementTypes(), path)
+	case t.IsObjectType():
+		return unmarshalObject(buf, t.AttributeTypes(), path)
+	case t.IsCapsuleType():
+		return unmarshalCapsule(buf, t, path)
+	default:
+		return cty.NilVal, path.NewErrorf("unsupported type %s", t.FriendlyName())
+	}
+}
+
+func unmarshalPrimitive(tok json.Token, t cty.Type, path cty.Path) (cty.Value, error) {
+
+	switch t {
+	case cty.Bool:
+		switch v := tok.(type) {
+		case bool:
+			return cty.BoolVal(v), nil
+		case string:
+			val, err := convert.Convert(cty.StringVal(v), t)
+			if err != nil {
+				return cty.NilVal, path.NewError(err)
+			}
+			return val, nil
+		default:
+			return cty.NilVal, path.NewErrorf("bool is required")
+		}
+	case cty.Number:
+		if v, ok := tok.(json.Number); ok {
+			tok = string(v)
+		}
+		switch v := tok.(type) {
+		case string:
+			val, err := cty.ParseNumberVal(v)
+			if err != nil {
+				return cty.NilVal, path.NewError(err)
+			}
+			return val, nil
+		default:
+			return cty.NilVal, path.NewErrorf("number is required")
+		}
+	case cty.String:
+		switch v := tok.(type) {
+		case string:
+			return cty.StringVal(v), nil
+		case json.Number:
+			return cty.StringVal(string(v)), nil
+		case bool:
+			val, err := convert.Convert(cty.BoolVal(v), t)
+			if err != nil {
+				return cty.NilVal, path.NewError(err)
+			}
+			return val, nil
+		default:
+			return cty.NilVal, path.NewErrorf("string is required")
+		}
+	default:
+		// should never happen
+		panic("unsupported primitive type")
+	}
+}
+
+func unmarshalList(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '['); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var vals []cty.Value
+
+	{
+		path := append(path, nil)
+		var idx int64
+
+		for dec.More() {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(idx),
+			}
+			idx++
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read list value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals = append(vals, el)
+		}
+	}
+
+	if err := requireDelim(dec, ']'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) == 0 {
+		return cty.ListValEmpty(ety), nil
+	}
+
+	return cty.ListVal(vals), nil
+}
+
+func unmarshalSet(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '['); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var vals []cty.Value
+
+	{
+		path := append(path, nil)
+
+		for dec.More() {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.UnknownVal(ety),
+			}
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read set value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals = append(vals, el)
+		}
+	}
+
+	if err := requireDelim(dec, ']'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) == 0 {
+		return cty.SetValEmpty(ety), nil
+	}
+
+	return cty.SetVal(vals), nil
+}
+
+func unmarshalMap(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '{'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	vals := make(map[string]cty.Value)
+
+	{
+		path := append(path, nil)
+
+		for dec.More() {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.UnknownVal(cty.String),
+			}
+
+			var err error
+
+			k, err := requireObjectKey(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read map key: %s", err)
+			}
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.StringVal(k),
+			}
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read map value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals[k] = el
+		}
+	}
+
+	if err := requireDelim(dec, '}'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) == 0 {
+		return cty.MapValEmpty(ety), nil
+	}
+
+	return cty.MapVal(vals), nil
+}
+
+func unmarshalTuple(buf []byte, etys []cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '['); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var vals []cty.Value
+
+	{
+		path := append(path, nil)
+		var idx int
+
+		for dec.More() {
+			if idx >= len(etys) {
+				return cty.NilVal, path[:len(path)-1].NewErrorf("too many tuple elements (need %d)", len(etys))
+			}
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(idx)),
+			}
+			ety := etys[idx]
+			idx++
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read tuple value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals = append(vals, el)
+		}
+	}
+
+	if err := requireDelim(dec, ']'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) != len(etys) {
+		return cty.NilVal, path[:len(path)-1].NewErrorf("not enough tuple elements (need %d)", len(etys))
+	}
+
+	if len(vals) == 0 {
+		return cty.EmptyTupleVal, nil
+	}
+
+	return cty.TupleVal(vals), nil
+}
+
+func unmarshalObject(buf []byte, atys map[string]cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '{'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	vals := make(map[string]cty.Value)
+
+	{
+		objPath := path           // some errors report from the object's perspective
+		path := append(path, nil) // path to a specific attribute
+
+		for dec.More() {
+
+			var err error
+
+			k, err := requireObjectKey(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read object key: %s", err)
+			}
+
+			aty, ok := atys[k]
+			if !ok {
+				return cty.NilVal, objPath.NewErrorf("unsupported attribute %q", k)
+			}
+
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read object value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, aty, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals[k] = el
+		}
+	}
+
+	if err := requireDelim(dec, '}'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	// Make sure we have a value for every attribute
+	for k, aty := range atys {
+		if _, exists := vals[k]; !exists {
+			vals[k] = cty.NullVal(aty)
+		}
+	}
+
+	if len(vals) == 0 {
+		return cty.EmptyObjectVal, nil
+	}
+
+	return cty.ObjectVal(vals), nil
+}
+
+func unmarshalCapsule(buf []byte, t cty.Type, path cty.Path) (cty.Value, error) {
+	rawType := t.EncapsulatedType()
+	ptrPtr := reflect.New(reflect.PtrTo(rawType))
+	ptrPtr.Elem().Set(reflect.New(rawType))
+	ptr := ptrPtr.Elem().Interface()
+	err := json.Unmarshal(buf, ptr)
+	if err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	return cty.CapsuleVal(t, ptr), nil
+}
+
+func unmarshalDynamic(buf []byte, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '{'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var t cty.Type
+	var valBody []byte // defer actual decoding until we know the type
+
+	for dec.More() {
+		var err error
+
+		key, err := requireObjectKey(dec)
+		if err != nil {
+			return cty.NilVal, path.NewErrorf("failed to read dynamic type descriptor key: %s", err)
+		}
+
+		rawVal, err := readRawValue(dec)
+		if err != nil {
+			return cty.NilVal, path.NewErrorf("failed to read dynamic type descriptor value: %s", err)
+		}
+
+		switch key {
+		case "type":
+			err := json.Unmarshal(rawVal, &t)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to decode type for dynamic value: %s", err)
+			}
+		case "value":
+			valBody = rawVal
+		default:
+			return cty.NilVal, path.NewErrorf("invalid key %q in dynamically-typed value", key)
+		}
+
+	}
+
+	if err := requireDelim(dec, '}'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if t == cty.NilType {
+		return cty.NilVal, path.NewErrorf("missing type in dynamically-typed value")
+	}
+	if valBody == nil {
+		return cty.NilVal, path.NewErrorf("missing value in dynamically-typed value")
+	}
+
+	val, err := Unmarshal([]byte(valBody), t)
+	if err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+	return val, nil
+}
+
+func requireDelim(dec *json.Decoder, d rune) error {
+	tok, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	if tok != json.Delim(d) {
+		return fmt.Errorf("missing expected %c", d)
+	}
+
+	return nil
+}
+
+func requireObjectKey(dec *json.Decoder) (string, error) {
+	tok, err := dec.Token()
+	if err != nil {
+		return "", err
+	}
+	if s, ok := tok.(string); ok {
+		return s, nil
+	}
+	return "", fmt.Errorf("missing expected object key")
+}
+
+func readRawValue(dec *json.Decoder) ([]byte, error) {
+	var rawVal json.RawMessage
+	err := dec.Decode(&rawVal)
+	if err != nil {
+		return nil, err
+	}
+	return []byte(rawVal), nil
+}
+
+func bufDecoder(buf []byte) *json.Decoder {
+	r := bytes.NewReader(buf)
+	dec := json.NewDecoder(r)
+	dec.UseNumber()
+	return dec
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/value.go b/vendor/github.com/zclconf/go-cty/cty/json/value.go
new file mode 100644
index 000000000..f2f7dd56c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/value.go
@@ -0,0 +1,65 @@
+package json
+
+import (
+	"bytes"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+// Marshal produces a JSON representation of the given value that can later
+// be decoded into a value of the given type.
+//
+// A type is specified separately to allow for the given type to include
+// cty.DynamicPseudoType to represent situations where any type is permitted
+// and so type information must be included to allow recovery of the stored
+// structure when decoding.
+//
+// The given type will also be used to attempt automatic conversions of any
+// non-conformant types in the given value, although this will not always
+// be possible. If the value cannot be made to be conformant then an error is
+// returned, which may be a cty.PathError.
+//
+// Capsule-typed values can be marshalled, but with some caveats. Since
+// capsule values are compared by pointer equality, it is impossible to recover
+// a value that will compare equal to the original value. Additionally,
+// it's not possible to JSON-serialize the capsule type itself, so it's not
+// valid to use capsule types within parts of the value that are conformed to
+// cty.DynamicPseudoType. Otherwise, a capsule value can be used as long as
+// the encapsulated type itself is serializable with the Marshal function
+// in encoding/json.
+func Marshal(val cty.Value, t cty.Type) ([]byte, error) {
+	errs := val.Type().TestConformance(t)
+	if errs != nil {
+		// Attempt a conversion
+		var err error
+		val, err = convert.Convert(val, t)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// From this point onward, val can be assumed to be conforming to t.
+
+	buf := &bytes.Buffer{}
+	var path cty.Path
+	err := marshal(val, t, path, buf)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+// Unmarshal decodes a JSON representation of the given value into a cty Value
+// conforming to the given type.
+//
+// While decoding, type conversions will be done where possible to make
+// the result conformant even if the types given in JSON are not exactly
+// correct. If conversion isn't possible then an error is returned, which
+// may be a cty.PathError.
+func Unmarshal(buf []byte, t cty.Type) (cty.Value, error) {
+	var path cty.Path
+	return unmarshal(buf, t, path)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/list_type.go b/vendor/github.com/zclconf/go-cty/cty/list_type.go
new file mode 100644
index 000000000..2ef02a12f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/list_type.go
@@ -0,0 +1,74 @@
+package cty
+
+import (
+	"fmt"
+)
+
+// TypeList instances represent specific list types. Each distinct ElementType
+// creates a distinct, non-equal list type.
+type typeList struct {
+	typeImplSigil
+	ElementTypeT Type
+}
+
+// List creates a map type with the given element Type.
+//
+// List types are CollectionType implementations.
+func List(elem Type) Type {
+	return Type{
+		typeList{
+			ElementTypeT: elem,
+		},
+	}
+}
+
+// Equals returns true if the other Type is a list whose element type is
+// equal to that of the receiver.
+func (t typeList) Equals(other Type) bool {
+	ot, isList := other.typeImpl.(typeList)
+	if !isList {
+		return false
+	}
+
+	return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeList) FriendlyName(mode friendlyTypeNameMode) string {
+	elemName := t.ElementTypeT.friendlyNameMode(mode)
+	if mode == friendlyTypeConstraintName {
+		if t.ElementTypeT == DynamicPseudoType {
+			elemName = "any single type"
+		}
+	}
+	return "list of " + elemName
+}
+
+func (t typeList) ElementType() Type {
+	return t.ElementTypeT
+}
+
+func (t typeList) GoString() string {
+	return fmt.Sprintf("cty.List(%#v)", t.ElementTypeT)
+}
+
+// IsListType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsListType() bool {
+	_, ok := t.typeImpl.(typeList)
+	return ok
+}
+
+// ListElementType is a convenience method that checks if the given type is
+// a list type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.ListElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) ListElementType() *Type {
+	if lt, ok := t.typeImpl.(typeList); ok {
+		return &lt.ElementTypeT
+	}
+	return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/map_type.go b/vendor/github.com/zclconf/go-cty/cty/map_type.go
new file mode 100644
index 000000000..82d36c628
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/map_type.go
@@ -0,0 +1,74 @@
+package cty
+
+import (
+	"fmt"
+)
+
+// TypeList instances represent specific list types. Each distinct ElementType
+// creates a distinct, non-equal list type.
+type typeMap struct {
+	typeImplSigil
+	ElementTypeT Type
+}
+
+// Map creates a map type with the given element Type.
+//
+// Map types are CollectionType implementations.
+func Map(elem Type) Type {
+	return Type{
+		typeMap{
+			ElementTypeT: elem,
+		},
+	}
+}
+
+// Equals returns true if the other Type is a map whose element type is
+// equal to that of the receiver.
+func (t typeMap) Equals(other Type) bool {
+	ot, isMap := other.typeImpl.(typeMap)
+	if !isMap {
+		return false
+	}
+
+	return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeMap) FriendlyName(mode friendlyTypeNameMode) string {
+	elemName := t.ElementTypeT.friendlyNameMode(mode)
+	if mode == friendlyTypeConstraintName {
+		if t.ElementTypeT == DynamicPseudoType {
+			elemName = "any single type"
+		}
+	}
+	return "map of " + elemName
+}
+
+func (t typeMap) ElementType() Type {
+	return t.ElementTypeT
+}
+
+func (t typeMap) GoString() string {
+	return fmt.Sprintf("cty.Map(%#v)", t.ElementTypeT)
+}
+
+// IsMapType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsMapType() bool {
+	_, ok := t.typeImpl.(typeMap)
+	return ok
+}
+
+// MapElementType is a convenience method that checks if the given type is
+// a map type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.MapElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) MapElementType() *Type {
+	if lt, ok := t.typeImpl.(typeMap); ok {
+		return &lt.ElementTypeT
+	}
+	return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/null.go b/vendor/github.com/zclconf/go-cty/cty/null.go
new file mode 100644
index 000000000..d58d0287b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/null.go
@@ -0,0 +1,14 @@
+package cty
+
+// NullVal returns a null value of the given type. A null can be created of any
+// type, but operations on such values will always panic. Calling applications
+// are encouraged to use nulls only sparingly, particularly when user-provided
+// expressions are to be evaluated, since the precence of nulls creates a
+// much higher chance of evaluation errors that can't be caught by a type
+// checker.
+func NullVal(t Type) Value {
+	return Value{
+		ty: t,
+		v:  nil,
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/object_type.go b/vendor/github.com/zclconf/go-cty/cty/object_type.go
new file mode 100644
index 000000000..187d38751
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/object_type.go
@@ -0,0 +1,135 @@
+package cty
+
+import (
+	"fmt"
+)
+
+type typeObject struct {
+	typeImplSigil
+	AttrTypes map[string]Type
+}
+
+// Object creates an object type with the given attribute types.
+//
+// After a map is passed to this function the caller must no longer access it,
+// since ownership is transferred to this library.
+func Object(attrTypes map[string]Type) Type {
+	attrTypesNorm := make(map[string]Type, len(attrTypes))
+	for k, v := range attrTypes {
+		attrTypesNorm[NormalizeString(k)] = v
+	}
+
+	return Type{
+		typeObject{
+			AttrTypes: attrTypesNorm,
+		},
+	}
+}
+
+func (t typeObject) Equals(other Type) bool {
+	if ot, ok := other.typeImpl.(typeObject); ok {
+		if len(t.AttrTypes) != len(ot.AttrTypes) {
+			// Fast path: if we don't have the same number of attributes
+			// then we can't possibly be equal. This also avoids the need
+			// to test attributes in both directions below, since we know
+			// there can't be extras in "other".
+			return false
+		}
+
+		for attr, ty := range t.AttrTypes {
+			oty, ok := ot.AttrTypes[attr]
+			if !ok {
+				return false
+			}
+			if !oty.Equals(ty) {
+				return false
+			}
+		}
+
+		return true
+	}
+	return false
+}
+
+func (t typeObject) FriendlyName(mode friendlyTypeNameMode) string {
+	// There isn't really a friendly way to write an object type due to its
+	// complexity, so we'll just do something English-ish. Callers will
+	// probably want to make some extra effort to avoid ever printing out
+	// an object type FriendlyName in its entirety. For example, could
+	// produce an error message by diffing two object types and saying
+	// something like "Expected attribute foo to be string, but got number".
+	// TODO: Finish this
+	return "object"
+}
+
+func (t typeObject) GoString() string {
+	if len(t.AttrTypes) == 0 {
+		return "cty.EmptyObject"
+	}
+	return fmt.Sprintf("cty.Object(%#v)", t.AttrTypes)
+}
+
+// EmptyObject is a shorthand for Object(map[string]Type{}), to more
+// easily talk about the empty object type.
+var EmptyObject Type
+
+// EmptyObjectVal is the only possible non-null, non-unknown value of type
+// EmptyObject.
+var EmptyObjectVal Value
+
+func init() {
+	EmptyObject = Object(map[string]Type{})
+	EmptyObjectVal = Value{
+		ty: EmptyObject,
+		v:  map[string]interface{}{},
+	}
+}
+
+// IsObjectType returns true if the given type is an object type, regardless
+// of its element type.
+func (t Type) IsObjectType() bool {
+	_, ok := t.typeImpl.(typeObject)
+	return ok
+}
+
+// HasAttribute returns true if the receiver has an attribute with the given
+// name, regardless of its type. Will panic if the reciever isn't an object
+// type; use IsObjectType to determine whether this operation will succeed.
+func (t Type) HasAttribute(name string) bool {
+	name = NormalizeString(name)
+	if ot, ok := t.typeImpl.(typeObject); ok {
+		_, hasAttr := ot.AttrTypes[name]
+		return hasAttr
+	}
+	panic("HasAttribute on non-object Type")
+}
+
+// AttributeType returns the type of the attribute with the given name. Will
+// panic if the receiver is not an object type (use IsObjectType to confirm)
+// or if the object type has no such attribute (use HasAttribute to confirm).
+func (t Type) AttributeType(name string) Type {
+	name = NormalizeString(name)
+	if ot, ok := t.typeImpl.(typeObject); ok {
+		aty, hasAttr := ot.AttrTypes[name]
+		if !hasAttr {
+			panic("no such attribute")
+		}
+		return aty
+	}
+	panic("AttributeType on non-object Type")
+}
+
+// AttributeTypes returns a map from attribute names to their associated
+// types. Will panic if the receiver is not an object type (use IsObjectType
+// to confirm).
+//
+// The returned map is part of the internal state of the type, and is provided
+// for read access only. It is forbidden for any caller to modify the returned
+// map. For many purposes the attribute-related methods of Value are more
+// appropriate and more convenient to use.
+func (t Type) AttributeTypes() map[string]Type {
+	if ot, ok := t.typeImpl.(typeObject); ok {
+		return ot.AttrTypes
+	}
+	panic("AttributeTypes on non-object Type")
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/path.go b/vendor/github.com/zclconf/go-cty/cty/path.go
new file mode 100644
index 000000000..b31444954
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/path.go
@@ -0,0 +1,250 @@
+package cty
+
+import (
+	"errors"
+	"fmt"
+)
+
+// A Path is a sequence of operations to locate a nested value within a
+// data structure.
+//
+// The empty Path represents the given item. Any PathSteps within represent
+// taking a single step down into a data structure.
+//
+// Path has some convenience methods for gradually constructing a path,
+// but callers can also feel free to just produce a slice of PathStep manually
+// and convert to this type, which may be more appropriate in environments
+// where memory pressure is a concern.
+//
+// Although a Path is technically mutable, by convention callers should not
+// mutate a path once it has been built and passed to some other subsystem.
+// Instead, use Copy and then mutate the copy before using it.
+type Path []PathStep
+
+// PathStep represents a single step down into a data structure, as part
+// of a Path. PathStep is a closed interface, meaning that the only
+// permitted implementations are those within this package.
+type PathStep interface {
+	pathStepSigil() pathStepImpl
+	Apply(Value) (Value, error)
+}
+
+// embed pathImpl into a struct to declare it a PathStep implementation
+type pathStepImpl struct{}
+
+func (p pathStepImpl) pathStepSigil() pathStepImpl {
+	return p
+}
+
+// Index returns a new Path that is the reciever with an IndexStep appended
+// to the end.
+//
+// This is provided as a convenient way to construct paths, but each call
+// will create garbage so it should not be used where memory pressure is a
+// concern.
+func (p Path) Index(v Value) Path {
+	ret := make(Path, len(p)+1)
+	copy(ret, p)
+	ret[len(p)] = IndexStep{
+		Key: v,
+	}
+	return ret
+}
+
+// IndexPath is a convenience method to start a new Path with an IndexStep.
+func IndexPath(v Value) Path {
+	return Path{}.Index(v)
+}
+
+// GetAttr returns a new Path that is the reciever with a GetAttrStep appended
+// to the end.
+//
+// This is provided as a convenient way to construct paths, but each call
+// will create garbage so it should not be used where memory pressure is a
+// concern.
+func (p Path) GetAttr(name string) Path {
+	ret := make(Path, len(p)+1)
+	copy(ret, p)
+	ret[len(p)] = GetAttrStep{
+		Name: name,
+	}
+	return ret
+}
+
+// Equals compares 2 Paths for exact equality.
+func (p Path) Equals(other Path) bool {
+	if len(p) != len(other) {
+		return false
+	}
+
+	for i := range p {
+		pv := p[i]
+		switch pv := pv.(type) {
+		case GetAttrStep:
+			ov, ok := other[i].(GetAttrStep)
+			if !ok || pv != ov {
+				return false
+			}
+		case IndexStep:
+			ov, ok := other[i].(IndexStep)
+			if !ok {
+				return false
+			}
+
+			if !pv.Key.RawEquals(ov.Key) {
+				return false
+			}
+		default:
+			// Any invalid steps default to evaluating false.
+			return false
+		}
+	}
+
+	return true
+
+}
+
+// HasPrefix determines if the path p contains the provided prefix.
+func (p Path) HasPrefix(prefix Path) bool {
+	if len(prefix) > len(p) {
+		return false
+	}
+
+	return p[:len(prefix)].Equals(prefix)
+}
+
+// GetAttrPath is a convenience method to start a new Path with a GetAttrStep.
+func GetAttrPath(name string) Path {
+	return Path{}.GetAttr(name)
+}
+
+// Apply applies each of the steps in turn to successive values starting with
+// the given value, and returns the result. If any step returns an error,
+// the whole operation returns an error.
+func (p Path) Apply(val Value) (Value, error) {
+	var err error
+	for i, step := range p {
+		val, err = step.Apply(val)
+		if err != nil {
+			return NilVal, fmt.Errorf("at step %d: %s", i, err)
+		}
+	}
+	return val, nil
+}
+
+// LastStep applies the given path up to the last step and then returns
+// the resulting value and the final step.
+//
+// This is useful when dealing with assignment operations, since in that
+// case the *value* of the last step is not important (and may not, in fact,
+// present at all) and we care only about its location.
+//
+// Since LastStep applies all steps except the last, it will return errors
+// for those steps in the same way as Apply does.
+//
+// If the path has *no* steps then the returned PathStep will be nil,
+// representing that any operation should be applied directly to the
+// given value.
+func (p Path) LastStep(val Value) (Value, PathStep, error) {
+	var err error
+
+	if len(p) == 0 {
+		return val, nil, nil
+	}
+
+	journey := p[:len(p)-1]
+	val, err = journey.Apply(val)
+	if err != nil {
+		return NilVal, nil, err
+	}
+	return val, p[len(p)-1], nil
+}
+
+// Copy makes a shallow copy of the receiver. Often when paths are passed to
+// caller code they come with the constraint that they are valid only until
+// the caller returns, due to how they are constructed internally. Callers
+// can use Copy to conveniently produce a copy of the value that _they_ control
+// the validity of.
+func (p Path) Copy() Path {
+	ret := make(Path, len(p))
+	copy(ret, p)
+	return ret
+}
+
+// IndexStep is a Step implementation representing applying the index operation
+// to a value, which must be of either a list, map, or set type.
+//
+// When describing a path through a *type* rather than a concrete value,
+// the Key may be an unknown value, indicating that the step applies to
+// *any* key of the given type.
+//
+// When indexing into a set, the Key is actually the element being accessed
+// itself, since in sets elements are their own identity.
+type IndexStep struct {
+	pathStepImpl
+	Key Value
+}
+
+// Apply returns the value resulting from indexing the given value with
+// our key value.
+func (s IndexStep) Apply(val Value) (Value, error) {
+	if val == NilVal || val.IsNull() {
+		return NilVal, errors.New("cannot index a null value")
+	}
+
+	switch s.Key.Type() {
+	case Number:
+		if !(val.Type().IsListType() || val.Type().IsTupleType()) {
+			return NilVal, errors.New("not a list type")
+		}
+	case String:
+		if !val.Type().IsMapType() {
+			return NilVal, errors.New("not a map type")
+		}
+	default:
+		return NilVal, errors.New("key value not number or string")
+	}
+
+	has := val.HasIndex(s.Key)
+	if !has.IsKnown() {
+		return UnknownVal(val.Type().ElementType()), nil
+	}
+	if !has.True() {
+		return NilVal, errors.New("value does not have given index key")
+	}
+
+	return val.Index(s.Key), nil
+}
+
+func (s IndexStep) GoString() string {
+	return fmt.Sprintf("cty.IndexStep{Key:%#v}", s.Key)
+}
+
+// GetAttrStep is a Step implementation representing retrieving an attribute
+// from a value, which must be of an object type.
+type GetAttrStep struct {
+	pathStepImpl
+	Name string
+}
+
+// Apply returns the value of our named attribute from the given value, which
+// must be of an object type that has a value of that name.
+func (s GetAttrStep) Apply(val Value) (Value, error) {
+	if val == NilVal || val.IsNull() {
+		return NilVal, errors.New("cannot access attributes on a null value")
+	}
+
+	if !val.Type().IsObjectType() {
+		return NilVal, errors.New("not an object type")
+	}
+
+	if !val.Type().HasAttribute(s.Name) {
+		return NilVal, fmt.Errorf("object has no attribute %q", s.Name)
+	}
+
+	return val.GetAttr(s.Name), nil
+}
+
+func (s GetAttrStep) GoString() string {
+	return fmt.Sprintf("cty.GetAttrStep{Name:%q}", s.Name)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/path_set.go b/vendor/github.com/zclconf/go-cty/cty/path_set.go
new file mode 100644
index 000000000..f1c892b9d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/path_set.go
@@ -0,0 +1,198 @@
+package cty
+
+import (
+	"fmt"
+	"hash/crc64"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// PathSet represents a set of Path objects. This can be used, for example,
+// to talk about a subset of paths within a value that meet some criteria,
+// without directly modifying the values at those paths.
+type PathSet struct {
+	set set.Set
+}
+
+// NewPathSet creates and returns a PathSet, with initial contents optionally
+// set by the given arguments.
+func NewPathSet(paths ...Path) PathSet {
+	ret := PathSet{
+		set: set.NewSet(pathSetRules{}),
+	}
+
+	for _, path := range paths {
+		ret.Add(path)
+	}
+
+	return ret
+}
+
+// Add inserts a single given path into the set.
+//
+// Paths are immutable after construction by convention. It is particularly
+// important not to mutate a path after it has been placed into a PathSet.
+// If a Path is mutated while in a set, behavior is undefined.
+func (s PathSet) Add(path Path) {
+	s.set.Add(path)
+}
+
+// AddAllSteps is like Add but it also adds all of the steps leading to
+// the given path.
+//
+// For example, if given a path representing "foo.bar", it will add both
+// "foo" and "bar".
+func (s PathSet) AddAllSteps(path Path) {
+	for i := 1; i <= len(path); i++ {
+		s.Add(path[:i])
+	}
+}
+
+// Has returns true if the given path is in the receiving set.
+func (s PathSet) Has(path Path) bool {
+	return s.set.Has(path)
+}
+
+// List makes and returns a slice of all of the paths in the receiving set,
+// in an undefined but consistent order.
+func (s PathSet) List() []Path {
+	if s.Empty() {
+		return nil
+	}
+	ret := make([]Path, 0, s.set.Length())
+	for it := s.set.Iterator(); it.Next(); {
+		ret = append(ret, it.Value().(Path))
+	}
+	return ret
+}
+
+// Remove modifies the receving set to no longer include the given path.
+// If the given path was already absent, this is a no-op.
+func (s PathSet) Remove(path Path) {
+	s.set.Remove(path)
+}
+
+// Empty returns true if the length of the receiving set is zero.
+func (s PathSet) Empty() bool {
+	return s.set.Length() == 0
+}
+
+// Union returns a new set whose contents are the union of the receiver and
+// the given other set.
+func (s PathSet) Union(other PathSet) PathSet {
+	return PathSet{
+		set: s.set.Union(other.set),
+	}
+}
+
+// Intersection returns a new set whose contents are the intersection of the
+// receiver and the given other set.
+func (s PathSet) Intersection(other PathSet) PathSet {
+	return PathSet{
+		set: s.set.Intersection(other.set),
+	}
+}
+
+// Subtract returns a new set whose contents are those from the receiver with
+// any elements of the other given set subtracted.
+func (s PathSet) Subtract(other PathSet) PathSet {
+	return PathSet{
+		set: s.set.Subtract(other.set),
+	}
+}
+
+// SymmetricDifference returns a new set whose contents are the symmetric
+// difference of the receiver and the given other set.
+func (s PathSet) SymmetricDifference(other PathSet) PathSet {
+	return PathSet{
+		set: s.set.SymmetricDifference(other.set),
+	}
+}
+
+// Equal returns true if and only if both the receiver and the given other
+// set contain exactly the same paths.
+func (s PathSet) Equal(other PathSet) bool {
+	if s.set.Length() != other.set.Length() {
+		return false
+	}
+	// Now we know the lengths are the same we only need to test in one
+	// direction whether everything in one is in the other.
+	for it := s.set.Iterator(); it.Next(); {
+		if !other.set.Has(it.Value()) {
+			return false
+		}
+	}
+	return true
+}
+
+var crc64Table = crc64.MakeTable(crc64.ISO)
+
+var indexStepPlaceholder = []byte("#")
+
+// pathSetRules is an implementation of set.Rules from the set package,
+// used internally within PathSet.
+type pathSetRules struct {
+}
+
+func (r pathSetRules) Hash(v interface{}) int {
+	path := v.(Path)
+	hash := crc64.New(crc64Table)
+
+	for _, rawStep := range path {
+		switch step := rawStep.(type) {
+		case GetAttrStep:
+			// (this creates some garbage converting the string name to a
+			// []byte, but that's okay since cty is not designed to be
+			// used in tight loops under memory pressure.)
+			hash.Write([]byte(step.Name))
+		default:
+			// For any other step type we just append a predefined value,
+			// which means that e.g. all indexes into a given collection will
+			// hash to the same value but we assume that collections are
+			// small and thus this won't hurt too much.
+			hash.Write(indexStepPlaceholder)
+		}
+	}
+
+	// We discard half of the hash on 32-bit platforms; collisions just make
+	// our lookups take marginally longer, so not a big deal.
+	return int(hash.Sum64())
+}
+
+func (r pathSetRules) Equivalent(a, b interface{}) bool {
+	aPath := a.(Path)
+	bPath := b.(Path)
+
+	if len(aPath) != len(bPath) {
+		return false
+	}
+
+	for i := range aPath {
+		switch aStep := aPath[i].(type) {
+		case GetAttrStep:
+			bStep, ok := bPath[i].(GetAttrStep)
+			if !ok {
+				return false
+			}
+
+			if aStep.Name != bStep.Name {
+				return false
+			}
+		case IndexStep:
+			bStep, ok := bPath[i].(IndexStep)
+			if !ok {
+				return false
+			}
+
+			eq := aStep.Key.Equals(bStep.Key)
+			if !eq.IsKnown() || eq.False() {
+				return false
+			}
+		default:
+			// Should never happen, since we document PathStep as a closed type.
+			panic(fmt.Errorf("unsupported step type %T", aStep))
+		}
+	}
+
+	return true
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/primitive_type.go b/vendor/github.com/zclconf/go-cty/cty/primitive_type.go
new file mode 100644
index 000000000..7b3d1196c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/primitive_type.go
@@ -0,0 +1,122 @@
+package cty
+
+import "math/big"
+
+// primitiveType is the hidden implementation of the various primitive types
+// that are exposed as variables in this package.
+type primitiveType struct {
+	typeImplSigil
+	Kind primitiveTypeKind
+}
+
+type primitiveTypeKind byte
+
+const (
+	primitiveTypeBool   primitiveTypeKind = 'B'
+	primitiveTypeNumber primitiveTypeKind = 'N'
+	primitiveTypeString primitiveTypeKind = 'S'
+)
+
+func (t primitiveType) Equals(other Type) bool {
+	if otherP, ok := other.typeImpl.(primitiveType); ok {
+		return otherP.Kind == t.Kind
+	}
+	return false
+}
+
+func (t primitiveType) FriendlyName(mode friendlyTypeNameMode) string {
+	switch t.Kind {
+	case primitiveTypeBool:
+		return "bool"
+	case primitiveTypeNumber:
+		return "number"
+	case primitiveTypeString:
+		return "string"
+	default:
+		// should never happen
+		panic("invalid primitive type")
+	}
+}
+
+func (t primitiveType) GoString() string {
+	switch t.Kind {
+	case primitiveTypeBool:
+		return "cty.Bool"
+	case primitiveTypeNumber:
+		return "cty.Number"
+	case primitiveTypeString:
+		return "cty.String"
+	default:
+		// should never happen
+		panic("invalid primitive type")
+	}
+}
+
+// Number is the numeric type. Number values are arbitrary-precision
+// decimal numbers, which can then be converted into Go's various numeric
+// types only if they are in the appropriate range.
+var Number Type
+
+// String is the string type. String values are sequences of unicode codepoints
+// encoded internally as UTF-8.
+var String Type
+
+// Bool is the boolean type. The two values of this type are True and False.
+var Bool Type
+
+// True is the truthy value of type Bool
+var True Value
+
+// False is the falsey value of type Bool
+var False Value
+
+// Zero is a number value representing exactly zero.
+var Zero Value
+
+// PositiveInfinity is a Number value representing positive infinity
+var PositiveInfinity Value
+
+// NegativeInfinity is a Number value representing negative infinity
+var NegativeInfinity Value
+
+func init() {
+	Number = Type{
+		primitiveType{Kind: primitiveTypeNumber},
+	}
+	String = Type{
+		primitiveType{Kind: primitiveTypeString},
+	}
+	Bool = Type{
+		primitiveType{Kind: primitiveTypeBool},
+	}
+	True = Value{
+		ty: Bool,
+		v:  true,
+	}
+	False = Value{
+		ty: Bool,
+		v:  false,
+	}
+	Zero = Value{
+		ty: Number,
+		v:  big.NewFloat(0),
+	}
+	PositiveInfinity = Value{
+		ty: Number,
+		v:  (&big.Float{}).SetInf(false),
+	}
+	NegativeInfinity = Value{
+		ty: Number,
+		v:  (&big.Float{}).SetInf(true),
+	}
+}
+
+// IsPrimitiveType returns true if and only if the reciever is a primitive
+// type, which means it's either number, string, or bool. Any two primitive
+// types can be safely compared for equality using the standard == operator
+// without panic, which is not a guarantee that holds for all types. Primitive
+// types can therefore also be used in switch statements.
+func (t Type) IsPrimitiveType() bool {
+	_, ok := t.typeImpl.(primitiveType)
+	return ok
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/gob.go b/vendor/github.com/zclconf/go-cty/cty/set/gob.go
new file mode 100644
index 000000000..da2978f65
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/gob.go
@@ -0,0 +1,76 @@
+package set
+
+import (
+	"bytes"
+	"encoding/gob"
+	"fmt"
+)
+
+// GobEncode is an implementation of the interface gob.GobEncoder, allowing
+// sets to be included in structures encoded via gob.
+//
+// The set rules are included in the serialized value, so the caller must
+// register its concrete rules type with gob.Register before using a
+// set in a gob, and possibly also implement GobEncode/GobDecode to customize
+// how any parameters are persisted.
+//
+// The set elements are also included, so if they are of non-primitive types
+// they too must be registered with gob.
+//
+// If the produced gob values will persist for a long time, the caller must
+// ensure compatibility of the rules implementation. In particular, if the
+// definition of element equivalence changes between encoding and decoding
+// then two distinct stored elements may be considered equivalent on decoding,
+// causing the recovered set to have fewer elements than when it was stored.
+func (s Set) GobEncode() ([]byte, error) {
+	gs := gobSet{
+		Version: 0,
+		Rules:   s.rules,
+		Values:  s.Values(),
+	}
+
+	buf := &bytes.Buffer{}
+	enc := gob.NewEncoder(buf)
+	err := enc.Encode(gs)
+	if err != nil {
+		return nil, fmt.Errorf("error encoding set.Set: %s", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+// GobDecode is the opposite of GobEncode. See GobEncode for information
+// on the requirements for and caveats of including set values in gobs.
+func (s *Set) GobDecode(buf []byte) error {
+	r := bytes.NewReader(buf)
+	dec := gob.NewDecoder(r)
+
+	var gs gobSet
+	err := dec.Decode(&gs)
+	if err != nil {
+		return fmt.Errorf("error decoding set.Set: %s", err)
+	}
+	if gs.Version != 0 {
+		return fmt.Errorf("unsupported set.Set encoding version %d; need 0", gs.Version)
+	}
+
+	victim := NewSetFromSlice(gs.Rules, gs.Values)
+	s.vals = victim.vals
+	s.rules = victim.rules
+	return nil
+}
+
+type gobSet struct {
+	Version int
+	Rules   Rules
+
+	// The bucket-based representation is for efficient in-memory access, but
+	// for serialization it's enough to just retain the values themselves,
+	// which we can re-bucket using the rules (which may have changed!) when
+	// we re-inflate.
+	Values []interface{}
+}
+
+func init() {
+	gob.Register([]interface{}(nil))
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/iterator.go b/vendor/github.com/zclconf/go-cty/cty/set/iterator.go
new file mode 100644
index 000000000..4a60494f9
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/iterator.go
@@ -0,0 +1,15 @@
+package set
+
+type Iterator struct {
+	vals []interface{}
+	idx  int
+}
+
+func (it *Iterator) Value() interface{} {
+	return it.vals[it.idx]
+}
+
+func (it *Iterator) Next() bool {
+	it.idx++
+	return it.idx < len(it.vals)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/ops.go b/vendor/github.com/zclconf/go-cty/cty/set/ops.go
new file mode 100644
index 000000000..fd1555f21
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/ops.go
@@ -0,0 +1,210 @@
+package set
+
+import (
+	"sort"
+)
+
+// Add inserts the given value into the receiving Set.
+//
+// This mutates the set in-place. This operation is not thread-safe.
+func (s Set) Add(val interface{}) {
+	hv := s.rules.Hash(val)
+	if _, ok := s.vals[hv]; !ok {
+		s.vals[hv] = make([]interface{}, 0, 1)
+	}
+	bucket := s.vals[hv]
+
+	// See if an equivalent value is already present
+	for _, ev := range bucket {
+		if s.rules.Equivalent(val, ev) {
+			return
+		}
+	}
+
+	s.vals[hv] = append(bucket, val)
+}
+
+// Remove deletes the given value from the receiving set, if indeed it was
+// there in the first place. If the value is not present, this is a no-op.
+func (s Set) Remove(val interface{}) {
+	hv := s.rules.Hash(val)
+	bucket, ok := s.vals[hv]
+	if !ok {
+		return
+	}
+
+	for i, ev := range bucket {
+		if s.rules.Equivalent(val, ev) {
+			newBucket := make([]interface{}, 0, len(bucket)-1)
+			newBucket = append(newBucket, bucket[:i]...)
+			newBucket = append(newBucket, bucket[i+1:]...)
+			if len(newBucket) > 0 {
+				s.vals[hv] = newBucket
+			} else {
+				delete(s.vals, hv)
+			}
+			return
+		}
+	}
+}
+
+// Has returns true if the given value is in the receiving set, or false if
+// it is not.
+func (s Set) Has(val interface{}) bool {
+	hv := s.rules.Hash(val)
+	bucket, ok := s.vals[hv]
+	if !ok {
+		return false
+	}
+
+	for _, ev := range bucket {
+		if s.rules.Equivalent(val, ev) {
+			return true
+		}
+	}
+	return false
+}
+
+// Copy performs a shallow copy of the receiving set, returning a new set
+// with the same rules and elements.
+func (s Set) Copy() Set {
+	ret := NewSet(s.rules)
+	for k, v := range s.vals {
+		ret.vals[k] = v
+	}
+	return ret
+}
+
+// Iterator returns an iterator over values in the set. If the set's rules
+// implement OrderedRules then the result is ordered per those rules. If
+// no order is provided, or if it is not a total order, then the iteration
+// order is undefined but consistent for a particular version of cty. Do not
+// rely on specific ordering between cty releases unless the rules order is a
+// total order.
+//
+// The pattern for using the returned iterator is:
+//
+//     it := set.Iterator()
+//     for it.Next() {
+//         val := it.Value()
+//         // ...
+//     }
+//
+// Once an iterator has been created for a set, the set *must not* be mutated
+// until the iterator is no longer in use.
+func (s Set) Iterator() *Iterator {
+	vals := s.Values()
+
+	return &Iterator{
+		vals: vals,
+		idx:  -1,
+	}
+}
+
+// EachValue calls the given callback once for each value in the set, in an
+// undefined order that callers should not depend on.
+func (s Set) EachValue(cb func(interface{})) {
+	it := s.Iterator()
+	for it.Next() {
+		cb(it.Value())
+	}
+}
+
+// Values returns a slice of all the values in the set. If the set rules have
+// an order then the result is in that order. If no order is provided or if
+// it is not a total order then the result order is undefined, but consistent
+// for a particular set value within a specific release of cty.
+func (s Set) Values() []interface{} {
+	var ret []interface{}
+	// Sort the bucketIds to ensure that we always traverse in a
+	// consistent order.
+	bucketIDs := make([]int, 0, len(s.vals))
+	for id := range s.vals {
+		bucketIDs = append(bucketIDs, id)
+	}
+	sort.Ints(bucketIDs)
+
+	for _, bucketID := range bucketIDs {
+		ret = append(ret, s.vals[bucketID]...)
+	}
+
+	if orderRules, ok := s.rules.(OrderedRules); ok {
+		sort.SliceStable(ret, func(i, j int) bool {
+			return orderRules.Less(ret[i], ret[j])
+		})
+	}
+
+	return ret
+}
+
+// Length returns the number of values in the set.
+func (s Set) Length() int {
+	var count int
+	for _, bucket := range s.vals {
+		count = count + len(bucket)
+	}
+	return count
+}
+
+// Union returns a new set that contains all of the members of both the
+// receiving set and the given set. Both sets must have the same rules, or
+// else this function will panic.
+func (s1 Set) Union(s2 Set) Set {
+	mustHaveSameRules(s1, s2)
+	rs := NewSet(s1.rules)
+	s1.EachValue(func(v interface{}) {
+		rs.Add(v)
+	})
+	s2.EachValue(func(v interface{}) {
+		rs.Add(v)
+	})
+	return rs
+}
+
+// Intersection returns a new set that contains the values that both the
+// receiver and given sets have in common. Both sets must have the same rules,
+// or else this function will panic.
+func (s1 Set) Intersection(s2 Set) Set {
+	mustHaveSameRules(s1, s2)
+	rs := NewSet(s1.rules)
+	s1.EachValue(func(v interface{}) {
+		if s2.Has(v) {
+			rs.Add(v)
+		}
+	})
+	return rs
+}
+
+// Subtract returns a new set that contains all of the values from the receiver
+// that are not also in the given set. Both sets must have the same rules,
+// or else this function will panic.
+func (s1 Set) Subtract(s2 Set) Set {
+	mustHaveSameRules(s1, s2)
+	rs := NewSet(s1.rules)
+	s1.EachValue(func(v interface{}) {
+		if !s2.Has(v) {
+			rs.Add(v)
+		}
+	})
+	return rs
+}
+
+// SymmetricDifference returns a new set that contains all of the values from
+// both the receiver and given sets, except those that both sets have in
+// common. Both sets must have the same rules, or else this function will
+// panic.
+func (s1 Set) SymmetricDifference(s2 Set) Set {
+	mustHaveSameRules(s1, s2)
+	rs := NewSet(s1.rules)
+	s1.EachValue(func(v interface{}) {
+		if !s2.Has(v) {
+			rs.Add(v)
+		}
+	})
+	s2.EachValue(func(v interface{}) {
+		if !s1.Has(v) {
+			rs.Add(v)
+		}
+	})
+	return rs
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/rules.go b/vendor/github.com/zclconf/go-cty/cty/set/rules.go
new file mode 100644
index 000000000..51f744b5e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/rules.go
@@ -0,0 +1,43 @@
+package set
+
+// Rules represents the operations that define membership for a Set.
+//
+// Each Set has a Rules instance, whose methods must satisfy the interface
+// contracts given below for any value that will be added to the set.
+type Rules interface {
+	// Hash returns an int that somewhat-uniquely identifies the given value.
+	//
+	// A good hash function will minimize collisions for values that will be
+	// added to the set, though collisions *are* permitted. Collisions will
+	// simply reduce the efficiency of operations on the set.
+	Hash(interface{}) int
+
+	// Equivalent returns true if and only if the two values are considered
+	// equivalent for the sake of set membership. Two values that are
+	// equivalent cannot exist in the set at the same time, and if two
+	// equivalent values are added it is undefined which one will be
+	// returned when enumerating all of the set members.
+	//
+	// Two values that are equivalent *must* result in the same hash value,
+	// though it is *not* required that two values with the same hash value
+	// be equivalent.
+	Equivalent(interface{}, interface{}) bool
+}
+
+// OrderedRules is an extension of Rules that can apply a partial order to
+// element values. When a set's Rules implements OrderedRules an iterator
+// over the set will return items in the order described by the rules.
+//
+// If the given order is not a total order (that is, some pairs of non-equivalent
+// elements do not have a defined order) then the resulting iteration order
+// is undefined but consistent for a particular version of cty. The exact
+// order in that case is not part of the contract and is subject to change
+// between versions.
+type OrderedRules interface {
+	Rules
+
+	// Less returns true if and only if the first argument should sort before
+	// the second argument. If the second argument should sort before the first
+	// or if there is no defined order for the values, return false.
+	Less(interface{}, interface{}) bool
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/set.go b/vendor/github.com/zclconf/go-cty/cty/set/set.go
new file mode 100644
index 000000000..b4fb316f1
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/set.go
@@ -0,0 +1,62 @@
+package set
+
+import (
+	"fmt"
+)
+
+// Set is an implementation of the concept of a set: a collection where all
+// values are conceptually either in or out of the set, but the members are
+// not ordered.
+//
+// This type primarily exists to be the internal type of sets in cty, but
+// it is considered to be at the same level of abstraction as Go's built in
+// slice and map collection types, and so should make no cty-specific
+// assumptions.
+//
+// Set operations are not thread safe. It is the caller's responsibility to
+// provide mutex guarantees where necessary.
+//
+// Set operations are not optimized to minimize memory pressure. Mutating
+// a set will generally create garbage and so should perhaps be avoided in
+// tight loops where memory pressure is a concern.
+type Set struct {
+	vals  map[int][]interface{}
+	rules Rules
+}
+
+// NewSet returns an empty set with the membership rules given.
+func NewSet(rules Rules) Set {
+	return Set{
+		vals:  map[int][]interface{}{},
+		rules: rules,
+	}
+}
+
+func NewSetFromSlice(rules Rules, vals []interface{}) Set {
+	s := NewSet(rules)
+	for _, v := range vals {
+		s.Add(v)
+	}
+	return s
+}
+
+func sameRules(s1 Set, s2 Set) bool {
+	return s1.rules == s2.rules
+}
+
+func mustHaveSameRules(s1 Set, s2 Set) {
+	if !sameRules(s1, s2) {
+		panic(fmt.Errorf("incompatible set rules: %#v, %#v", s1.rules, s2.rules))
+	}
+}
+
+// HasRules returns true if and only if the receiving set has the given rules
+// instance as its rules.
+func (s Set) HasRules(rules Rules) bool {
+	return s.rules == rules
+}
+
+// Rules returns the receiving set's rules instance.
+func (s Set) Rules() Rules {
+	return s.rules
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_helper.go b/vendor/github.com/zclconf/go-cty/cty/set_helper.go
new file mode 100644
index 000000000..a88ddaffb
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set_helper.go
@@ -0,0 +1,126 @@
+package cty
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// ValueSet is to cty.Set what []cty.Value is to cty.List and
+// map[string]cty.Value is to cty.Map. It's provided to allow callers a
+// convenient interface for manipulating sets before wrapping them in cty.Set
+// values using cty.SetValFromValueSet.
+//
+// Unlike value slices and value maps, ValueSet instances have a single
+// homogenous element type because that is a requirement of the underlying
+// set implementation, which uses the element type to select a suitable
+// hashing function.
+//
+// Set mutations are not concurrency-safe.
+type ValueSet struct {
+	// ValueSet is just a thin wrapper around a set.Set with our value-oriented
+	// "rules" applied. We do this so that the caller can work in terms of
+	// cty.Value objects even though the set internals use the raw values.
+	s set.Set
+}
+
+// NewValueSet creates and returns a new ValueSet with the given element type.
+func NewValueSet(ety Type) ValueSet {
+	return newValueSet(set.NewSet(setRules{Type: ety}))
+}
+
+func newValueSet(s set.Set) ValueSet {
+	return ValueSet{
+		s: s,
+	}
+}
+
+// ElementType returns the element type for the receiving ValueSet.
+func (s ValueSet) ElementType() Type {
+	return s.s.Rules().(setRules).Type
+}
+
+// Add inserts the given value into the receiving set.
+func (s ValueSet) Add(v Value) {
+	s.requireElementType(v)
+	s.s.Add(v.v)
+}
+
+// Remove deletes the given value from the receiving set, if indeed it was
+// there in the first place. If the value is not present, this is a no-op.
+func (s ValueSet) Remove(v Value) {
+	s.requireElementType(v)
+	s.s.Remove(v.v)
+}
+
+// Has returns true if the given value is in the receiving set, or false if
+// it is not.
+func (s ValueSet) Has(v Value) bool {
+	s.requireElementType(v)
+	return s.s.Has(v.v)
+}
+
+// Copy performs a shallow copy of the receiving set, returning a new set
+// with the same rules and elements.
+func (s ValueSet) Copy() ValueSet {
+	return newValueSet(s.s.Copy())
+}
+
+// Length returns the number of values in the set.
+func (s ValueSet) Length() int {
+	return s.s.Length()
+}
+
+// Values returns a slice of all of the values in the set in no particular
+// order.
+func (s ValueSet) Values() []Value {
+	l := s.s.Length()
+	if l == 0 {
+		return nil
+	}
+	ret := make([]Value, 0, l)
+	ety := s.ElementType()
+	for it := s.s.Iterator(); it.Next(); {
+		ret = append(ret, Value{
+			ty: ety,
+			v:  it.Value(),
+		})
+	}
+	return ret
+}
+
+// Union returns a new set that contains all of the members of both the
+// receiving set and the given set. Both sets must have the same element type,
+// or else this function will panic.
+func (s ValueSet) Union(other ValueSet) ValueSet {
+	return newValueSet(s.s.Union(other.s))
+}
+
+// Intersection returns a new set that contains the values that both the
+// receiver and given sets have in common. Both sets must have the same element
+// type, or else this function will panic.
+func (s ValueSet) Intersection(other ValueSet) ValueSet {
+	return newValueSet(s.s.Intersection(other.s))
+}
+
+// Subtract returns a new set that contains all of the values from the receiver
+// that are not also in the given set. Both sets must have the same element
+// type, or else this function will panic.
+func (s ValueSet) Subtract(other ValueSet) ValueSet {
+	return newValueSet(s.s.Subtract(other.s))
+}
+
+// SymmetricDifference returns a new set that contains all of the values from
+// both the receiver and given sets, except those that both sets have in
+// common. Both sets must have the same element type, or else this function
+// will panic.
+func (s ValueSet) SymmetricDifference(other ValueSet) ValueSet {
+	return newValueSet(s.s.SymmetricDifference(other.s))
+}
+
+// requireElementType panics if the given value is not of the set's element type.
+func (s ValueSet) requireElementType(v Value) {
+	if !v.Type().Equals(s.ElementType()) {
+		panic(fmt.Errorf("attempt to use %#v value with set of %#v", v.Type(), s.ElementType()))
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_internals.go b/vendor/github.com/zclconf/go-cty/cty/set_internals.go
new file mode 100644
index 000000000..3fd4fb2df
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set_internals.go
@@ -0,0 +1,216 @@
+package cty
+
+import (
+	"bytes"
+	"fmt"
+	"hash/crc32"
+	"math/big"
+	"sort"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// setRules provides a Rules implementation for the ./set package that
+// respects the equality rules for cty values of the given type.
+//
+// This implementation expects that values added to the set will be
+// valid internal values for the given Type, which is to say that wrapping
+// the given value in a Value struct along with the ruleset's type should
+// produce a valid, working Value.
+type setRules struct {
+	Type Type
+}
+
+var _ set.OrderedRules = setRules{}
+
+// Hash returns a hash value for the receiver that can be used for equality
+// checks where some inaccuracy is tolerable.
+//
+// The hash function is value-type-specific, so it is not meaningful to compare
+// hash results for values of different types.
+//
+// This function is not safe to use for security-related applications, since
+// the hash used is not strong enough.
+func (val Value) Hash() int {
+	hashBytes := makeSetHashBytes(val)
+	return int(crc32.ChecksumIEEE(hashBytes))
+}
+
+func (r setRules) Hash(v interface{}) int {
+	return Value{
+		ty: r.Type,
+		v:  v,
+	}.Hash()
+}
+
+func (r setRules) Equivalent(v1 interface{}, v2 interface{}) bool {
+	v1v := Value{
+		ty: r.Type,
+		v:  v1,
+	}
+	v2v := Value{
+		ty: r.Type,
+		v:  v2,
+	}
+
+	eqv := v1v.Equals(v2v)
+
+	// By comparing the result to true we ensure that an Unknown result,
+	// which will result if either value is unknown, will be considered
+	// as non-equivalent. Two unknown values are not equivalent for the
+	// sake of set membership.
+	return eqv.v == true
+}
+
+// Less is an implementation of set.OrderedRules so that we can iterate over
+// set elements in a consistent order, where such an order is possible.
+func (r setRules) Less(v1, v2 interface{}) bool {
+	v1v := Value{
+		ty: r.Type,
+		v:  v1,
+	}
+	v2v := Value{
+		ty: r.Type,
+		v:  v2,
+	}
+
+	if v1v.RawEquals(v2v) { // Easy case: if they are equal then v1 can't be less
+		return false
+	}
+
+	// Null values always sort after non-null values
+	if v2v.IsNull() && !v1v.IsNull() {
+		return true
+	} else if v1v.IsNull() {
+		return false
+	}
+	// Unknown values always sort after known values
+	if v1v.IsKnown() && !v2v.IsKnown() {
+		return true
+	} else if !v1v.IsKnown() {
+		return false
+	}
+
+	switch r.Type {
+	case String:
+		// String values sort lexicographically
+		return v1v.AsString() < v2v.AsString()
+	case Bool:
+		// Weird to have a set of bools, but if we do then false sorts before true.
+		if v2v.True() || !v1v.True() {
+			return true
+		}
+		return false
+	case Number:
+		v1f := v1v.AsBigFloat()
+		v2f := v2v.AsBigFloat()
+		return v1f.Cmp(v2f) < 0
+	default:
+		// No other types have a well-defined ordering, so we just produce a
+		// default consistent-but-undefined ordering then. This situation is
+		// not considered a compatibility constraint; callers should rely only
+		// on the ordering rules for primitive values.
+		v1h := makeSetHashBytes(v1v)
+		v2h := makeSetHashBytes(v2v)
+		return bytes.Compare(v1h, v2h) < 0
+	}
+}
+
+func makeSetHashBytes(val Value) []byte {
+	var buf bytes.Buffer
+	appendSetHashBytes(val, &buf)
+	return buf.Bytes()
+}
+
+func appendSetHashBytes(val Value, buf *bytes.Buffer) {
+	// Exactly what bytes we generate here don't matter as long as the following
+	// constraints hold:
+	// - Unknown and null values all generate distinct strings from
+	//   each other and from any normal value of the given type.
+	// - The delimiter used to separate items in a compound structure can
+	//   never appear literally in any of its elements.
+	// Since we don't support hetrogenous lists we don't need to worry about
+	// collisions between values of different types, apart from
+	// PseudoTypeDynamic.
+	// If in practice we *do* get a collision then it's not a big deal because
+	// the Equivalent function will still distinguish values, but set
+	// performance will be best if we are able to produce a distinct string
+	// for each distinct value, unknown values notwithstanding.
+	if !val.IsKnown() {
+		buf.WriteRune('?')
+		return
+	}
+	if val.IsNull() {
+		buf.WriteRune('~')
+		return
+	}
+
+	switch val.ty {
+	case Number:
+		buf.WriteString(val.v.(*big.Float).String())
+		return
+	case Bool:
+		if val.v.(bool) {
+			buf.WriteRune('T')
+		} else {
+			buf.WriteRune('F')
+		}
+		return
+	case String:
+		buf.WriteString(fmt.Sprintf("%q", val.v.(string)))
+		return
+	}
+
+	if val.ty.IsMapType() {
+		buf.WriteRune('{')
+		val.ForEachElement(func(keyVal, elementVal Value) bool {
+			appendSetHashBytes(keyVal, buf)
+			buf.WriteRune(':')
+			appendSetHashBytes(elementVal, buf)
+			buf.WriteRune(';')
+			return false
+		})
+		buf.WriteRune('}')
+		return
+	}
+
+	if val.ty.IsListType() || val.ty.IsSetType() {
+		buf.WriteRune('[')
+		val.ForEachElement(func(keyVal, elementVal Value) bool {
+			appendSetHashBytes(elementVal, buf)
+			buf.WriteRune(';')
+			return false
+		})
+		buf.WriteRune(']')
+		return
+	}
+
+	if val.ty.IsObjectType() {
+		buf.WriteRune('<')
+		attrNames := make([]string, 0, len(val.ty.AttributeTypes()))
+		for attrName := range val.ty.AttributeTypes() {
+			attrNames = append(attrNames, attrName)
+		}
+		sort.Strings(attrNames)
+		for _, attrName := range attrNames {
+			appendSetHashBytes(val.GetAttr(attrName), buf)
+			buf.WriteRune(';')
+		}
+		buf.WriteRune('>')
+		return
+	}
+
+	if val.ty.IsTupleType() {
+		buf.WriteRune('<')
+		val.ForEachElement(func(keyVal, elementVal Value) bool {
+			appendSetHashBytes(elementVal, buf)
+			buf.WriteRune(';')
+			return false
+		})
+		buf.WriteRune('>')
+		return
+	}
+
+	// should never get down here
+	panic("unsupported type in set hash")
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_type.go b/vendor/github.com/zclconf/go-cty/cty/set_type.go
new file mode 100644
index 000000000..cbc3706f2
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set_type.go
@@ -0,0 +1,72 @@
+package cty
+
+import (
+	"fmt"
+)
+
+type typeSet struct {
+	typeImplSigil
+	ElementTypeT Type
+}
+
+// Set creates a set type with the given element Type.
+//
+// Set types are CollectionType implementations.
+func Set(elem Type) Type {
+	return Type{
+		typeSet{
+			ElementTypeT: elem,
+		},
+	}
+}
+
+// Equals returns true if the other Type is a set whose element type is
+// equal to that of the receiver.
+func (t typeSet) Equals(other Type) bool {
+	ot, isSet := other.typeImpl.(typeSet)
+	if !isSet {
+		return false
+	}
+
+	return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeSet) FriendlyName(mode friendlyTypeNameMode) string {
+	elemName := t.ElementTypeT.friendlyNameMode(mode)
+	if mode == friendlyTypeConstraintName {
+		if t.ElementTypeT == DynamicPseudoType {
+			elemName = "any single type"
+		}
+	}
+	return "set of " + elemName
+}
+
+func (t typeSet) ElementType() Type {
+	return t.ElementTypeT
+}
+
+func (t typeSet) GoString() string {
+	return fmt.Sprintf("cty.Set(%#v)", t.ElementTypeT)
+}
+
+// IsSetType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsSetType() bool {
+	_, ok := t.typeImpl.(typeSet)
+	return ok
+}
+
+// SetElementType is a convenience method that checks if the given type is
+// a set type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.SetElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) SetElementType() *Type {
+	if lt, ok := t.typeImpl.(typeSet); ok {
+		return &lt.ElementTypeT
+	}
+	return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/tuple_type.go b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go
new file mode 100644
index 000000000..798cacd63
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go
@@ -0,0 +1,121 @@
+package cty
+
+import (
+	"fmt"
+)
+
+type typeTuple struct {
+	typeImplSigil
+	ElemTypes []Type
+}
+
+// Tuple creates a tuple type with the given element types.
+//
+// After a slice is passed to this function the caller must no longer access
+// the underlying array, since ownership is transferred to this library.
+func Tuple(elemTypes []Type) Type {
+	return Type{
+		typeTuple{
+			ElemTypes: elemTypes,
+		},
+	}
+}
+
+func (t typeTuple) Equals(other Type) bool {
+	if ot, ok := other.typeImpl.(typeTuple); ok {
+		if len(t.ElemTypes) != len(ot.ElemTypes) {
+			// Fast path: if we don't have the same number of elements
+			// then we can't possibly be equal.
+			return false
+		}
+
+		for i, ty := range t.ElemTypes {
+			oty := ot.ElemTypes[i]
+			if !ok {
+				return false
+			}
+			if !oty.Equals(ty) {
+				return false
+			}
+		}
+
+		return true
+	}
+	return false
+}
+
+func (t typeTuple) FriendlyName(mode friendlyTypeNameMode) string {
+	// There isn't really a friendly way to write a tuple type due to its
+	// complexity, so we'll just do something English-ish. Callers will
+	// probably want to make some extra effort to avoid ever printing out
+	// a tuple type FriendlyName in its entirety. For example, could
+	// produce an error message by diffing two object types and saying
+	// something like "Expected attribute foo to be string, but got number".
+	// TODO: Finish this
+	return "tuple"
+}
+
+func (t typeTuple) GoString() string {
+	if len(t.ElemTypes) == 0 {
+		return "cty.EmptyTuple"
+	}
+	return fmt.Sprintf("cty.Tuple(%#v)", t.ElemTypes)
+}
+
+// EmptyTuple is a shorthand for Tuple([]Type{}), to more easily talk about
+// the empty tuple type.
+var EmptyTuple Type
+
+// EmptyTupleVal is the only possible non-null, non-unknown value of type
+// EmptyTuple.
+var EmptyTupleVal Value
+
+func init() {
+	EmptyTuple = Tuple([]Type{})
+	EmptyTupleVal = Value{
+		ty: EmptyTuple,
+		v:  []interface{}{},
+	}
+}
+
+// IsTupleType returns true if the given type is an object type, regardless
+// of its element type.
+func (t Type) IsTupleType() bool {
+	_, ok := t.typeImpl.(typeTuple)
+	return ok
+}
+
+// Length returns the number of elements of the receiving tuple type.
+// Will panic if the reciever isn't a tuple type; use IsTupleType to determine
+// whether this operation will succeed.
+func (t Type) Length() int {
+	if ot, ok := t.typeImpl.(typeTuple); ok {
+		return len(ot.ElemTypes)
+	}
+	panic("Length on non-tuple Type")
+}
+
+// TupleElementType returns the type of the element with the given index. Will
+// panic if the receiver is not a tuple type (use IsTupleType to confirm)
+// or if the index is out of range (use Length to confirm).
+func (t Type) TupleElementType(idx int) Type {
+	if ot, ok := t.typeImpl.(typeTuple); ok {
+		return ot.ElemTypes[idx]
+	}
+	panic("TupleElementType on non-tuple Type")
+}
+
+// TupleElementTypes returns a slice of the recieving tuple type's element
+// types. Will panic if the receiver is not a tuple type (use IsTupleType
+// to confirm).
+//
+// The returned slice is part of the internal state of the type, and is provided
+// for read access only. It is forbidden for any caller to modify the
+// underlying array. For many purposes the element-related methods of Value
+// are more appropriate and more convenient to use.
+func (t Type) TupleElementTypes() []Type {
+	if ot, ok := t.typeImpl.(typeTuple); ok {
+		return ot.ElemTypes
+	}
+	panic("TupleElementTypes on non-tuple Type")
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/type.go b/vendor/github.com/zclconf/go-cty/cty/type.go
new file mode 100644
index 000000000..730cb9862
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/type.go
@@ -0,0 +1,120 @@
+package cty
+
+// Type represents value types within the type system.
+//
+// This is a closed interface type, meaning that only the concrete
+// implementations provided within this package are considered valid.
+type Type struct {
+	typeImpl
+}
+
+type typeImpl interface {
+	// isTypeImpl is a do-nothing method that exists only to express
+	// that a type is an implementation of typeImpl.
+	isTypeImpl() typeImplSigil
+
+	// Equals returns true if the other given Type exactly equals the
+	// receiver Type.
+	Equals(other Type) bool
+
+	// FriendlyName returns a human-friendly *English* name for the given
+	// type.
+	FriendlyName(mode friendlyTypeNameMode) string
+
+	// GoString implements the GoStringer interface from package fmt.
+	GoString() string
+}
+
+// Base implementation of Type to embed into concrete implementations
+// to signal that they are implementations of Type.
+type typeImplSigil struct{}
+
+func (t typeImplSigil) isTypeImpl() typeImplSigil {
+	return typeImplSigil{}
+}
+
+// Equals returns true if the other given Type exactly equals the receiver
+// type.
+func (t Type) Equals(other Type) bool {
+	return t.typeImpl.Equals(other)
+}
+
+// FriendlyName returns a human-friendly *English* name for the given type.
+func (t Type) FriendlyName() string {
+	return t.typeImpl.FriendlyName(friendlyTypeName)
+}
+
+// FriendlyNameForConstraint is similar to FriendlyName except that the
+// result is specialized for describing type _constraints_ rather than types
+// themselves. This is more appropriate when reporting that a particular value
+// does not conform to an expected type constraint.
+//
+// In particular, this function uses the term "any type" to refer to
+// cty.DynamicPseudoType, rather than "dynamic" as returned by FriendlyName.
+func (t Type) FriendlyNameForConstraint() string {
+	return t.typeImpl.FriendlyName(friendlyTypeConstraintName)
+}
+
+// friendlyNameMode is an internal combination of the various FriendlyName*
+// variants that just directly takes a mode, for easy passthrough for
+// recursive name construction.
+func (t Type) friendlyNameMode(mode friendlyTypeNameMode) string {
+	return t.typeImpl.FriendlyName(mode)
+}
+
+// GoString returns a string approximating how the receiver type would be
+// expressed in Go source code.
+func (t Type) GoString() string {
+	if t.typeImpl == nil {
+		return "cty.NilType"
+	}
+
+	return t.typeImpl.GoString()
+}
+
+// NilType is an invalid type used when a function is returning an error
+// and has no useful type to return. It should not be used and any methods
+// called on it will panic.
+var NilType = Type{}
+
+// HasDynamicTypes returns true either if the receiver is itself
+// DynamicPseudoType or if it is a compound type whose descendent elements
+// are DynamicPseudoType.
+func (t Type) HasDynamicTypes() bool {
+	switch {
+	case t == DynamicPseudoType:
+		return true
+	case t.IsPrimitiveType():
+		return false
+	case t.IsCollectionType():
+		return false
+	case t.IsObjectType():
+		attrTypes := t.AttributeTypes()
+		for _, at := range attrTypes {
+			if at.HasDynamicTypes() {
+				return true
+			}
+		}
+		return false
+	case t.IsTupleType():
+		elemTypes := t.TupleElementTypes()
+		for _, et := range elemTypes {
+			if et.HasDynamicTypes() {
+				return true
+			}
+		}
+		return false
+	case t.IsCapsuleType():
+		return false
+	default:
+		// Should never happen, since above should be exhaustive
+		panic("HasDynamicTypes does not support the given type")
+	}
+}
+
+type friendlyTypeNameMode rune
+
+const (
+	friendlyTypeName           friendlyTypeNameMode = 'N'
+	friendlyTypeConstraintName friendlyTypeNameMode = 'C'
+)
diff --git a/vendor/github.com/zclconf/go-cty/cty/type_conform.go b/vendor/github.com/zclconf/go-cty/cty/type_conform.go
new file mode 100644
index 000000000..476eeea87
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/type_conform.go
@@ -0,0 +1,139 @@
+package cty
+
+// TestConformance recursively walks the receiver and the given other type and
+// returns nil if the receiver *conforms* to the given type.
+//
+// Type conformance is similar to type equality but has one crucial difference:
+// PseudoTypeDynamic can be used within the given type to represent that
+// *any* type is allowed.
+//
+// If any non-conformities are found, the returned slice will be non-nil and
+// contain at least one error value. It will be nil if the type is entirely
+// conformant.
+//
+// Note that the special behavior of PseudoTypeDynamic is the *only* exception
+// to normal type equality. Calling applications may wish to apply their own
+// automatic conversion logic to the given data structure to create a more
+// liberal notion of conformance to a type.
+//
+// Returned errors are usually (but not always) PathError instances that
+// indicate where in the structure the error was found. If a returned error
+// is of that type then the error message is written for (English-speaking)
+// end-users working within the cty type system, not mentioning any Go-oriented
+// implementation details.
+func (t Type) TestConformance(other Type) []error {
+	path := make(Path, 0)
+	var errs []error
+	testConformance(t, other, path, &errs)
+	return errs
+}
+
+func testConformance(given Type, want Type, path Path, errs *[]error) {
+	if want.Equals(DynamicPseudoType) {
+		// anything goes!
+		return
+	}
+
+	if given.Equals(want) {
+		// Any equal types are always conformant
+		return
+	}
+
+	// The remainder of this function is concerned with detecting
+	// and reporting the specific non-conformance, since we wouldn't
+	// have got here if the types were not divergent.
+	// We treat compound structures as special so that we can report
+	// specifically what is non-conforming, rather than simply returning
+	// the entire type names and letting the user puzzle it out.
+
+	if given.IsObjectType() && want.IsObjectType() {
+		givenAttrs := given.AttributeTypes()
+		wantAttrs := want.AttributeTypes()
+
+		for k := range givenAttrs {
+			if _, exists := wantAttrs[k]; !exists {
+				*errs = append(
+					*errs,
+					errorf(path, "unsupported attribute %q", k),
+				)
+			}
+		}
+		for k := range wantAttrs {
+			if _, exists := givenAttrs[k]; !exists {
+				*errs = append(
+					*errs,
+					errorf(path, "missing required attribute %q", k),
+				)
+			}
+		}
+
+		path = append(path, nil)
+		pathIdx := len(path) - 1
+
+		for k, wantAttrType := range wantAttrs {
+			if givenAttrType, exists := givenAttrs[k]; exists {
+				path[pathIdx] = GetAttrStep{Name: k}
+				testConformance(givenAttrType, wantAttrType, path, errs)
+			}
+		}
+
+		path = path[0:pathIdx]
+
+		return
+	}
+
+	if given.IsTupleType() && want.IsTupleType() {
+		givenElems := given.TupleElementTypes()
+		wantElems := want.TupleElementTypes()
+
+		if len(givenElems) != len(wantElems) {
+			*errs = append(
+				*errs,
+				errorf(path, "%d elements are required, but got %d", len(wantElems), len(givenElems)),
+			)
+			return
+		}
+
+		path = append(path, nil)
+		pathIdx := len(path) - 1
+
+		for i, wantElemType := range wantElems {
+			givenElemType := givenElems[i]
+			path[pathIdx] = IndexStep{Key: NumberIntVal(int64(i))}
+			testConformance(givenElemType, wantElemType, path, errs)
+		}
+
+		path = path[0:pathIdx]
+
+		return
+	}
+
+	if given.IsListType() && want.IsListType() {
+		path = append(path, IndexStep{Key: UnknownVal(Number)})
+		pathIdx := len(path) - 1
+		testConformance(given.ElementType(), want.ElementType(), path, errs)
+		path = path[0:pathIdx]
+		return
+	}
+
+	if given.IsMapType() && want.IsMapType() {
+		path = append(path, IndexStep{Key: UnknownVal(String)})
+		pathIdx := len(path) - 1
+		testConformance(given.ElementType(), want.ElementType(), path, errs)
+		path = path[0:pathIdx]
+		return
+	}
+
+	if given.IsSetType() && want.IsSetType() {
+		path = append(path, IndexStep{Key: UnknownVal(given.ElementType())})
+		pathIdx := len(path) - 1
+		testConformance(given.ElementType(), want.ElementType(), path, errs)
+		path = path[0:pathIdx]
+		return
+	}
+
+	*errs = append(
+		*errs,
+		errorf(path, "%s required, but received %s", want.FriendlyName(), given.FriendlyName()),
+	)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/types_to_register.go b/vendor/github.com/zclconf/go-cty/cty/types_to_register.go
new file mode 100644
index 000000000..e1e220aab
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/types_to_register.go
@@ -0,0 +1,57 @@
+package cty
+
+import (
+	"encoding/gob"
+	"fmt"
+	"math/big"
+	"strings"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// InternalTypesToRegister is a slice of values that covers all of the
+// internal types used in the representation of cty.Type and cty.Value
+// across all cty Types.
+//
+// This is intended to be used to register these types with encoding
+// packages that require registration of types used in interfaces, such as
+// encoding/gob, thus allowing cty types and values to be included in streams
+// created from those packages. However, registering with gob is not necessary
+// since that is done automatically as a side-effect of importing this package.
+//
+// Callers should not do anything with the values here except pass them on
+// verbatim to a registration function.
+//
+// If the calling application uses Capsule types that wrap local structs either
+// directly or indirectly, these structs may also need to be registered in
+// order to support encoding and decoding of values of these types. That is the
+// responsibility of the calling application.
+var InternalTypesToRegister []interface{}
+
+func init() {
+	InternalTypesToRegister = []interface{}{
+		primitiveType{},
+		typeList{},
+		typeMap{},
+		typeObject{},
+		typeSet{},
+		setRules{},
+		set.Set{},
+		typeTuple{},
+		big.Float{},
+		capsuleType{},
+		[]interface{}(nil),
+		map[string]interface{}(nil),
+	}
+
+	// Register these with gob here, rather than in gob.go, to ensure
+	// that this will always happen after we build the above.
+	for _, tv := range InternalTypesToRegister {
+		typeName := fmt.Sprintf("%T", tv)
+		if strings.HasPrefix(typeName, "cty.") {
+			gob.RegisterName(fmt.Sprintf("github.com/zclconf/go-cty/%s", typeName), tv)
+		} else {
+			gob.Register(tv)
+		}
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/unknown.go b/vendor/github.com/zclconf/go-cty/cty/unknown.go
new file mode 100644
index 000000000..e54179eb1
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/unknown.go
@@ -0,0 +1,84 @@
+package cty
+
+// unknownType is the placeholder type used for the sigil value representing
+// "Unknown", to make it unambigiously distinct from any other possible value.
+type unknownType struct {
+}
+
+// Unknown is a special value that can be
+var unknown interface{} = &unknownType{}
+
+// UnknownVal returns an Value that represents an unknown value of the given
+// type. Unknown values can be used to represent a value that is
+// not yet known. Its meaning is undefined in cty, but it could be used by
+// an calling application to allow partial evaluation.
+//
+// Unknown values of any type can be created of any type. All operations on
+// Unknown values themselves return Unknown.
+func UnknownVal(t Type) Value {
+	return Value{
+		ty: t,
+		v:  unknown,
+	}
+}
+
+func (t unknownType) GoString() string {
+	// This is the stringification of our internal unknown marker. The
+	// stringification of the public representation of unknowns is in
+	// Value.GoString.
+	return "cty.unknown"
+}
+
+type pseudoTypeDynamic struct {
+	typeImplSigil
+}
+
+// DynamicPseudoType represents the dynamic pseudo-type.
+//
+// This type can represent situations where a type is not yet known. Its
+// meaning is undefined in cty, but it could be used by a calling
+// application to allow expression type checking with some types not yet known.
+// For example, the application might optimistically permit any operation on
+// values of this type in type checking, allowing a partial type-check result,
+// and then repeat the check when more information is known to get the
+// final, concrete type.
+//
+// It is a pseudo-type because it is used only as a sigil to the calling
+// application. "Unknown" is the only valid value of this pseudo-type, so
+// operations on values of this type will always short-circuit as per
+// the rules for that special value.
+var DynamicPseudoType Type
+
+func (t pseudoTypeDynamic) Equals(other Type) bool {
+	_, ok := other.typeImpl.(pseudoTypeDynamic)
+	return ok
+}
+
+func (t pseudoTypeDynamic) FriendlyName(mode friendlyTypeNameMode) string {
+	switch mode {
+	case friendlyTypeConstraintName:
+		return "any type"
+	default:
+		return "dynamic"
+	}
+}
+
+func (t pseudoTypeDynamic) GoString() string {
+	return "cty.DynamicPseudoType"
+}
+
+// DynamicVal is the only valid value of the pseudo-type dynamic.
+// This value can be used as a placeholder where a value or expression's
+// type and value are both unknown, thus allowing partial evaluation. See
+// the docs for DynamicPseudoType for more information.
+var DynamicVal Value
+
+func init() {
+	DynamicPseudoType = Type{
+		pseudoTypeDynamic{},
+	}
+	DynamicVal = Value{
+		ty: DynamicPseudoType,
+		v:  unknown,
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/unknown_as_null.go b/vendor/github.com/zclconf/go-cty/cty/unknown_as_null.go
new file mode 100644
index 000000000..ba926475c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/unknown_as_null.go
@@ -0,0 +1,64 @@
+package cty
+
+// UnknownAsNull returns a value of the same type as the given value but
+// with any unknown values (including nested values) replaced with null
+// values of the same type.
+//
+// This can be useful if a result is to be serialized in a format that can't
+// represent unknowns, such as JSON, as long as the caller does not need to
+// retain the unknown value information.
+func UnknownAsNull(val Value) Value {
+	ty := val.Type()
+	switch {
+	case val.IsNull():
+		return val
+	case !val.IsKnown():
+		return NullVal(ty)
+	case ty.IsListType() || ty.IsTupleType() || ty.IsSetType():
+		length := val.LengthInt()
+		if length == 0 {
+			// If there are no elements then we can't have unknowns
+			return val
+		}
+		vals := make([]Value, 0, length)
+		it := val.ElementIterator()
+		for it.Next() {
+			_, v := it.Element()
+			vals = append(vals, UnknownAsNull(v))
+		}
+		switch {
+		case ty.IsListType():
+			return ListVal(vals)
+		case ty.IsTupleType():
+			return TupleVal(vals)
+		default:
+			return SetVal(vals)
+		}
+	case ty.IsMapType() || ty.IsObjectType():
+		var length int
+		switch {
+		case ty.IsMapType():
+			length = val.LengthInt()
+		default:
+			length = len(val.Type().AttributeTypes())
+		}
+		if length == 0 {
+			// If there are no elements then we can't have unknowns
+			return val
+		}
+		vals := make(map[string]Value, length)
+		it := val.ElementIterator()
+		for it.Next() {
+			k, v := it.Element()
+			vals[k.AsString()] = UnknownAsNull(v)
+		}
+		switch {
+		case ty.IsMapType():
+			return MapVal(vals)
+		default:
+			return ObjectVal(vals)
+		}
+	}
+
+	return val
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value.go b/vendor/github.com/zclconf/go-cty/cty/value.go
new file mode 100644
index 000000000..80cb8f76f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/value.go
@@ -0,0 +1,98 @@
+package cty
+
+// Value represents a value of a particular type, and is the interface by
+// which operations are executed on typed values.
+//
+// Value has two different classes of method. Operation methods stay entirely
+// within the type system (methods accept and return Value instances) and
+// are intended for use in implementing a language in terms of cty, while
+// integration methods either enter or leave the type system, working with
+// native Go values. Operation methods are guaranteed to support all of the
+// expected short-circuit behavior for unknown and dynamic values, while
+// integration methods may not.
+//
+// The philosophy for the operations API is that it's the caller's
+// responsibility to ensure that the given types and values satisfy the
+// specified invariants during a separate type check, so that the caller is
+// able to return errors to its user from the application's own perspective.
+//
+// Consequently the design of these methods assumes such checks have already
+// been done and panics if any invariants turn out not to be satisfied. These
+// panic errors are not intended to be handled, but rather indicate a bug in
+// the calling application that should be fixed with more checks prior to
+// executing operations.
+//
+// A related consequence of this philosophy is that no automatic type
+// conversions are done. If a method specifies that its argument must be
+// number then it's the caller's responsibility to do that conversion before
+// the call, thus allowing the application to have more constrained conversion
+// rules than are offered by the built-in converter where necessary.
+type Value struct {
+	ty Type
+	v  interface{}
+}
+
+// Type returns the type of the value.
+func (val Value) Type() Type {
+	return val.ty
+}
+
+// IsKnown returns true if the value is known. That is, if it is not
+// the result of the unknown value constructor Unknown(...), and is not
+// the result of an operation on another unknown value.
+//
+// Unknown values are only produced either directly or as a result of
+// operating on other unknown values, and so an application that never
+// introduces Unknown values can be guaranteed to never receive any either.
+func (val Value) IsKnown() bool {
+	return val.v != unknown
+}
+
+// IsNull returns true if the value is null. Values of any type can be
+// null, but any operations on a null value will panic. No operation ever
+// produces null, so an application that never introduces Null values can
+// be guaranteed to never receive any either.
+func (val Value) IsNull() bool {
+	return val.v == nil
+}
+
+// NilVal is an invalid Value that can be used as a placeholder when returning
+// with an error from a function that returns (Value, error).
+//
+// NilVal is *not* a valid error and so no operations may be performed on it.
+// Any attempt to use it will result in a panic.
+//
+// This should not be confused with the idea of a Null value, as returned by
+// NullVal. NilVal is a nil within the *Go* type system, and is invalid in
+// the cty type system. Null values *do* exist in the cty type system.
+var NilVal = Value{
+	ty: Type{typeImpl: nil},
+	v:  nil,
+}
+
+// IsWhollyKnown is an extension of IsKnown that also recursively checks
+// inside collections and structures to see if there are any nested unknown
+// values.
+func (val Value) IsWhollyKnown() bool {
+	if !val.IsKnown() {
+		return false
+	}
+
+	if val.IsNull() {
+		// Can't recurse into a null, so we're done
+		return true
+	}
+
+	switch {
+	case val.CanIterateElements():
+		for it := val.ElementIterator(); it.Next(); {
+			_, ev := it.Element()
+			if !ev.IsWhollyKnown() {
+				return false
+			}
+		}
+		return true
+	default:
+		return true
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value_init.go b/vendor/github.com/zclconf/go-cty/cty/value_init.go
new file mode 100644
index 000000000..3deeba3bd
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/value_init.go
@@ -0,0 +1,314 @@
+package cty
+
+import (
+	"fmt"
+	"math/big"
+	"reflect"
+
+	"golang.org/x/text/unicode/norm"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// BoolVal returns a Value of type Number whose internal value is the given
+// bool.
+func BoolVal(v bool) Value {
+	return Value{
+		ty: Bool,
+		v:  v,
+	}
+}
+
+// NumberVal returns a Value of type Number whose internal value is the given
+// big.Float. The returned value becomes the owner of the big.Float object,
+// and so it's forbidden for the caller to mutate the object after it's
+// wrapped in this way.
+func NumberVal(v *big.Float) Value {
+	return Value{
+		ty: Number,
+		v:  v,
+	}
+}
+
+// ParseNumberVal returns a Value of type number produced by parsing the given
+// string as a decimal real number. To ensure that two identical strings will
+// always produce an equal number, always use this function to derive a number
+// from a string; it will ensure that the precision and rounding mode for the
+// internal big decimal is configured in a consistent way.
+//
+// If the given string cannot be parsed as a number, the returned error has
+// the message "a number is required", making it suitable to return to an
+// end-user to signal a type conversion error.
+//
+// If the given string contains a number that becomes a recurring fraction
+// when expressed in binary then it will be truncated to have a 512-bit
+// mantissa. Note that this is a higher precision than that of a float64,
+// so coverting the same decimal number first to float64 and then calling
+// NumberFloatVal will not produce an equal result; the conversion first
+// to float64 will round the mantissa to fewer than 512 bits.
+func ParseNumberVal(s string) (Value, error) {
+	// Base 10, precision 512, and rounding to nearest even is the standard
+	// way to handle numbers arriving as strings.
+	f, _, err := big.ParseFloat(s, 10, 512, big.ToNearestEven)
+	if err != nil {
+		return NilVal, fmt.Errorf("a number is required")
+	}
+	return NumberVal(f), nil
+}
+
+// MustParseNumberVal is like ParseNumberVal but it will panic in case of any
+// error. It can be used during initialization or any other situation where
+// the given string is a constant or otherwise known to be correct by the
+// caller.
+func MustParseNumberVal(s string) Value {
+	ret, err := ParseNumberVal(s)
+	if err != nil {
+		panic(err)
+	}
+	return ret
+}
+
+// NumberIntVal returns a Value of type Number whose internal value is equal
+// to the given integer.
+func NumberIntVal(v int64) Value {
+	return NumberVal(new(big.Float).SetInt64(v))
+}
+
+// NumberUIntVal returns a Value of type Number whose internal value is equal
+// to the given unsigned integer.
+func NumberUIntVal(v uint64) Value {
+	return NumberVal(new(big.Float).SetUint64(v))
+}
+
+// NumberFloatVal returns a Value of type Number whose internal value is
+// equal to the given float.
+func NumberFloatVal(v float64) Value {
+	return NumberVal(new(big.Float).SetFloat64(v))
+}
+
+// StringVal returns a Value of type String whose internal value is the
+// given string.
+//
+// Strings must be UTF-8 encoded sequences of valid unicode codepoints, and
+// they are NFC-normalized on entry into the world of cty values.
+//
+// If the given string is not valid UTF-8 then behavior of string operations
+// is undefined.
+func StringVal(v string) Value {
+	return Value{
+		ty: String,
+		v:  NormalizeString(v),
+	}
+}
+
+// NormalizeString applies the same normalization that cty applies when
+// constructing string values.
+//
+// A return value from this function can be meaningfully compared byte-for-byte
+// with a Value.AsString result.
+func NormalizeString(s string) string {
+	return norm.NFC.String(s)
+}
+
+// ObjectVal returns a Value of an object type whose structure is defined
+// by the key names and value types in the given map.
+func ObjectVal(attrs map[string]Value) Value {
+	attrTypes := make(map[string]Type, len(attrs))
+	attrVals := make(map[string]interface{}, len(attrs))
+
+	for attr, val := range attrs {
+		attr = NormalizeString(attr)
+		attrTypes[attr] = val.ty
+		attrVals[attr] = val.v
+	}
+
+	return Value{
+		ty: Object(attrTypes),
+		v:  attrVals,
+	}
+}
+
+// TupleVal returns a Value of a tuple type whose element types are
+// defined by the value types in the given slice.
+func TupleVal(elems []Value) Value {
+	elemTypes := make([]Type, len(elems))
+	elemVals := make([]interface{}, len(elems))
+
+	for i, val := range elems {
+		elemTypes[i] = val.ty
+		elemVals[i] = val.v
+	}
+
+	return Value{
+		ty: Tuple(elemTypes),
+		v:  elemVals,
+	}
+}
+
+// ListVal returns a Value of list type whose element type is defined by
+// the types of the given values, which must be homogenous.
+//
+// If the types are not all consistent (aside from elements that are of the
+// dynamic pseudo-type) then this function will panic. It will panic also
+// if the given list is empty, since then the element type cannot be inferred.
+// (See also ListValEmpty.)
+func ListVal(vals []Value) Value {
+	if len(vals) == 0 {
+		panic("must not call ListVal with empty slice")
+	}
+	elementType := DynamicPseudoType
+	rawList := make([]interface{}, len(vals))
+
+	for i, val := range vals {
+		if elementType == DynamicPseudoType {
+			elementType = val.ty
+		} else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
+			panic(fmt.Errorf(
+				"inconsistent list element types (%#v then %#v)",
+				elementType, val.ty,
+			))
+		}
+
+		rawList[i] = val.v
+	}
+
+	return Value{
+		ty: List(elementType),
+		v:  rawList,
+	}
+}
+
+// ListValEmpty returns an empty list of the given element type.
+func ListValEmpty(element Type) Value {
+	return Value{
+		ty: List(element),
+		v:  []interface{}{},
+	}
+}
+
+// MapVal returns a Value of a map type whose element type is defined by
+// the types of the given values, which must be homogenous.
+//
+// If the types are not all consistent (aside from elements that are of the
+// dynamic pseudo-type) then this function will panic. It will panic also
+// if the given map is empty, since then the element type cannot be inferred.
+// (See also MapValEmpty.)
+func MapVal(vals map[string]Value) Value {
+	if len(vals) == 0 {
+		panic("must not call MapVal with empty map")
+	}
+	elementType := DynamicPseudoType
+	rawMap := make(map[string]interface{}, len(vals))
+
+	for key, val := range vals {
+		if elementType == DynamicPseudoType {
+			elementType = val.ty
+		} else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
+			panic(fmt.Errorf(
+				"inconsistent map element types (%#v then %#v)",
+				elementType, val.ty,
+			))
+		}
+
+		rawMap[NormalizeString(key)] = val.v
+	}
+
+	return Value{
+		ty: Map(elementType),
+		v:  rawMap,
+	}
+}
+
+// MapValEmpty returns an empty map of the given element type.
+func MapValEmpty(element Type) Value {
+	return Value{
+		ty: Map(element),
+		v:  map[string]interface{}{},
+	}
+}
+
+// SetVal returns a Value of set type whose element type is defined by
+// the types of the given values, which must be homogenous.
+//
+// If the types are not all consistent (aside from elements that are of the
+// dynamic pseudo-type) then this function will panic. It will panic also
+// if the given list is empty, since then the element type cannot be inferred.
+// (See also SetValEmpty.)
+func SetVal(vals []Value) Value {
+	if len(vals) == 0 {
+		panic("must not call SetVal with empty slice")
+	}
+	elementType := DynamicPseudoType
+	rawList := make([]interface{}, len(vals))
+
+	for i, val := range vals {
+		if elementType == DynamicPseudoType {
+			elementType = val.ty
+		} else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
+			panic(fmt.Errorf(
+				"inconsistent set element types (%#v then %#v)",
+				elementType, val.ty,
+			))
+		}
+
+		rawList[i] = val.v
+	}
+
+	rawVal := set.NewSetFromSlice(setRules{elementType}, rawList)
+
+	return Value{
+		ty: Set(elementType),
+		v:  rawVal,
+	}
+}
+
+// SetValFromValueSet returns a Value of set type based on an already-constructed
+// ValueSet.
+//
+// The element type of the returned value is the element type of the given
+// set.
+func SetValFromValueSet(s ValueSet) Value {
+	ety := s.ElementType()
+	rawVal := s.s.Copy() // copy so caller can't mutate what we wrap
+
+	return Value{
+		ty: Set(ety),
+		v:  rawVal,
+	}
+}
+
+// SetValEmpty returns an empty set of the given element type.
+func SetValEmpty(element Type) Value {
+	return Value{
+		ty: Set(element),
+		v:  set.NewSet(setRules{element}),
+	}
+}
+
+// CapsuleVal creates a value of the given capsule type using the given
+// wrapVal, which must be a pointer to a value of the capsule type's native
+// type.
+//
+// This function will panic if the given type is not a capsule type, if
+// the given wrapVal is not compatible with the given capsule type, or if
+// wrapVal is not a pointer.
+func CapsuleVal(ty Type, wrapVal interface{}) Value {
+	if !ty.IsCapsuleType() {
+		panic("not a capsule type")
+	}
+
+	wv := reflect.ValueOf(wrapVal)
+	if wv.Kind() != reflect.Ptr {
+		panic("wrapVal is not a pointer")
+	}
+
+	it := ty.typeImpl.(*capsuleType).GoType
+	if !wv.Type().Elem().AssignableTo(it) {
+		panic("wrapVal target is not compatible with the given capsule type")
+	}
+
+	return Value{
+		ty: ty,
+		v:  wrapVal,
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value_ops.go b/vendor/github.com/zclconf/go-cty/cty/value_ops.go
new file mode 100644
index 000000000..afd621cf4
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/value_ops.go
@@ -0,0 +1,1138 @@
+package cty
+
+import (
+	"fmt"
+	"math/big"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// GoString is an implementation of fmt.GoStringer that produces concise
+// source-like representations of values suitable for use in debug messages.
+func (val Value) GoString() string {
+	if val == NilVal {
+		return "cty.NilVal"
+	}
+
+	if val.IsNull() {
+		return fmt.Sprintf("cty.NullVal(%#v)", val.ty)
+	}
+	if val == DynamicVal { // is unknown, so must be before the IsKnown check below
+		return "cty.DynamicVal"
+	}
+	if !val.IsKnown() {
+		return fmt.Sprintf("cty.UnknownVal(%#v)", val.ty)
+	}
+
+	// By the time we reach here we've dealt with all of the exceptions around
+	// unknowns and nulls, so we're guaranteed that the values are the
+	// canonical internal representation of the given type.
+
+	switch val.ty {
+	case Bool:
+		if val.v.(bool) {
+			return "cty.True"
+		}
+		return "cty.False"
+	case Number:
+		fv := val.v.(*big.Float)
+		// We'll try to use NumberIntVal or NumberFloatVal if we can, since
+		// the fully-general initializer call is pretty ugly-looking.
+		if fv.IsInt() {
+			return fmt.Sprintf("cty.NumberIntVal(%#v)", fv)
+		}
+		if rfv, accuracy := fv.Float64(); accuracy == big.Exact {
+			return fmt.Sprintf("cty.NumberFloatVal(%#v)", rfv)
+		}
+		return fmt.Sprintf("cty.MustParseNumberVal(%q)", fv.Text('f', -1))
+	case String:
+		return fmt.Sprintf("cty.StringVal(%#v)", val.v)
+	}
+
+	switch {
+	case val.ty.IsSetType():
+		vals := val.AsValueSlice()
+		if len(vals) == 0 {
+			return fmt.Sprintf("cty.SetValEmpty(%#v)", val.ty.ElementType())
+		}
+		return fmt.Sprintf("cty.SetVal(%#v)", vals)
+	case val.ty.IsListType():
+		vals := val.AsValueSlice()
+		if len(vals) == 0 {
+			return fmt.Sprintf("cty.ListValEmpty(%#v)", val.ty.ElementType())
+		}
+		return fmt.Sprintf("cty.ListVal(%#v)", vals)
+	case val.ty.IsMapType():
+		vals := val.AsValueMap()
+		if len(vals) == 0 {
+			return fmt.Sprintf("cty.MapValEmpty(%#v)", val.ty.ElementType())
+		}
+		return fmt.Sprintf("cty.MapVal(%#v)", vals)
+	case val.ty.IsTupleType():
+		if val.ty.Equals(EmptyTuple) {
+			return "cty.EmptyTupleVal"
+		}
+		vals := val.AsValueSlice()
+		return fmt.Sprintf("cty.TupleVal(%#v)", vals)
+	case val.ty.IsObjectType():
+		if val.ty.Equals(EmptyObject) {
+			return "cty.EmptyObjectVal"
+		}
+		vals := val.AsValueMap()
+		return fmt.Sprintf("cty.ObjectVal(%#v)", vals)
+	case val.ty.IsCapsuleType():
+		return fmt.Sprintf("cty.CapsuleVal(%#v, %#v)", val.ty, val.v)
+	}
+
+	// Default exposes implementation details, so should actually cover
+	// all of the cases above for good caller UX.
+	return fmt.Sprintf("cty.Value{ty: %#v, v: %#v}", val.ty, val.v)
+}
+
+// Equals returns True if the receiver and the given other value have the
+// same type and are exactly equal in value.
+//
+// As a special case, two null values are always equal regardless of type.
+//
+// The usual short-circuit rules apply, so the result will be unknown if
+// either of the given values are.
+//
+// Use RawEquals to compare if two values are equal *ignoring* the
+// short-circuit rules and the exception for null values.
+func (val Value) Equals(other Value) Value {
+	// Start by handling Unknown values before considering types.
+	// This needs to be done since Null values are always equal regardless of
+	// type.
+	switch {
+	case !val.IsKnown() && !other.IsKnown():
+		// both unknown
+		return UnknownVal(Bool)
+	case val.IsKnown() && !other.IsKnown():
+		switch {
+		case val.IsNull(), other.ty.HasDynamicTypes():
+			// If known is Null, we need to wait for the unkown value since
+			// nulls of any type are equal.
+			// An unkown with a dynamic type compares as unknown, which we need
+			// to check before the type comparison below.
+			return UnknownVal(Bool)
+		case !val.ty.Equals(other.ty):
+			// There is no null comparison or dynamic types, so unequal types
+			// will never be equal.
+			return False
+		default:
+			return UnknownVal(Bool)
+		}
+	case other.IsKnown() && !val.IsKnown():
+		switch {
+		case other.IsNull(), val.ty.HasDynamicTypes():
+			// If known is Null, we need to wait for the unkown value since
+			// nulls of any type are equal.
+			// An unkown with a dynamic type compares as unknown, which we need
+			// to check before the type comparison below.
+			return UnknownVal(Bool)
+		case !other.ty.Equals(val.ty):
+			// There's no null comparison or dynamic types, so unequal types
+			// will never be equal.
+			return False
+		default:
+			return UnknownVal(Bool)
+		}
+	}
+
+	switch {
+	case val.IsNull() && other.IsNull():
+		// Nulls are always equal, regardless of type
+		return BoolVal(true)
+	case val.IsNull() || other.IsNull():
+		// If only one is null then the result must be false
+		return BoolVal(false)
+	}
+
+	if val.ty.HasDynamicTypes() || other.ty.HasDynamicTypes() {
+		return UnknownVal(Bool)
+	}
+
+	if !val.ty.Equals(other.ty) {
+		return BoolVal(false)
+	}
+
+	ty := val.ty
+	result := false
+
+	switch {
+	case ty == Number:
+		result = val.v.(*big.Float).Cmp(other.v.(*big.Float)) == 0
+	case ty == Bool:
+		result = val.v.(bool) == other.v.(bool)
+	case ty == String:
+		// Simple equality is safe because we NFC-normalize strings as they
+		// enter our world from StringVal, and so we can assume strings are
+		// always in normal form.
+		result = val.v.(string) == other.v.(string)
+	case ty.IsObjectType():
+		oty := ty.typeImpl.(typeObject)
+		result = true
+		for attr, aty := range oty.AttrTypes {
+			lhs := Value{
+				ty: aty,
+				v:  val.v.(map[string]interface{})[attr],
+			}
+			rhs := Value{
+				ty: aty,
+				v:  other.v.(map[string]interface{})[attr],
+			}
+			eq := lhs.Equals(rhs)
+			if !eq.IsKnown() {
+				return UnknownVal(Bool)
+			}
+			if eq.False() {
+				result = false
+				break
+			}
+		}
+	case ty.IsTupleType():
+		tty := ty.typeImpl.(typeTuple)
+		result = true
+		for i, ety := range tty.ElemTypes {
+			lhs := Value{
+				ty: ety,
+				v:  val.v.([]interface{})[i],
+			}
+			rhs := Value{
+				ty: ety,
+				v:  other.v.([]interface{})[i],
+			}
+			eq := lhs.Equals(rhs)
+			if !eq.IsKnown() {
+				return UnknownVal(Bool)
+			}
+			if eq.False() {
+				result = false
+				break
+			}
+		}
+	case ty.IsListType():
+		ety := ty.typeImpl.(typeList).ElementTypeT
+		if len(val.v.([]interface{})) == len(other.v.([]interface{})) {
+			result = true
+			for i := range val.v.([]interface{}) {
+				lhs := Value{
+					ty: ety,
+					v:  val.v.([]interface{})[i],
+				}
+				rhs := Value{
+					ty: ety,
+					v:  other.v.([]interface{})[i],
+				}
+				eq := lhs.Equals(rhs)
+				if !eq.IsKnown() {
+					return UnknownVal(Bool)
+				}
+				if eq.False() {
+					result = false
+					break
+				}
+			}
+		}
+	case ty.IsSetType():
+		s1 := val.v.(set.Set)
+		s2 := other.v.(set.Set)
+		equal := true
+
+		// Note that by our definition of sets it's never possible for two
+		// sets that contain unknown values (directly or indicrectly) to
+		// ever be equal, even if they are otherwise identical.
+
+		// FIXME: iterating both lists and checking each item is not the
+		// ideal implementation here, but it works with the primitives we
+		// have in the set implementation. Perhaps the set implementation
+		// can provide its own equality test later.
+		s1.EachValue(func(v interface{}) {
+			if !s2.Has(v) {
+				equal = false
+			}
+		})
+		s2.EachValue(func(v interface{}) {
+			if !s1.Has(v) {
+				equal = false
+			}
+		})
+
+		result = equal
+	case ty.IsMapType():
+		ety := ty.typeImpl.(typeMap).ElementTypeT
+		if len(val.v.(map[string]interface{})) == len(other.v.(map[string]interface{})) {
+			result = true
+			for k := range val.v.(map[string]interface{}) {
+				if _, ok := other.v.(map[string]interface{})[k]; !ok {
+					result = false
+					break
+				}
+				lhs := Value{
+					ty: ety,
+					v:  val.v.(map[string]interface{})[k],
+				}
+				rhs := Value{
+					ty: ety,
+					v:  other.v.(map[string]interface{})[k],
+				}
+				eq := lhs.Equals(rhs)
+				if !eq.IsKnown() {
+					return UnknownVal(Bool)
+				}
+				if eq.False() {
+					result = false
+					break
+				}
+			}
+		}
+	case ty.IsCapsuleType():
+		// A capsule type's encapsulated value is a pointer to a value of its
+		// native type, so we can just compare these to get the identity test
+		// we need.
+		return BoolVal(val.v == other.v)
+
+	default:
+		// should never happen
+		panic(fmt.Errorf("unsupported value type %#v in Equals", ty))
+	}
+
+	return BoolVal(result)
+}
+
+// NotEqual is a shorthand for Equals followed by Not.
+func (val Value) NotEqual(other Value) Value {
+	return val.Equals(other).Not()
+}
+
+// True returns true if the receiver is True, false if False, and panics if
+// the receiver is not of type Bool.
+//
+// This is a helper function to help write application logic that works with
+// values, rather than a first-class operation. It does not work with unknown
+// or null values. For more robust handling with unknown value
+// short-circuiting, use val.Equals(cty.True).
+func (val Value) True() bool {
+	if val.ty != Bool {
+		panic("not bool")
+	}
+	return val.Equals(True).v.(bool)
+}
+
+// False is the opposite of True.
+func (val Value) False() bool {
+	return !val.True()
+}
+
+// RawEquals returns true if and only if the two given values have the same
+// type and equal value, ignoring the usual short-circuit rules about
+// unknowns and dynamic types.
+//
+// This method is more appropriate for testing than for real use, since it
+// skips over usual semantics around unknowns but as a consequence allows
+// testing the result of another operation that is expected to return unknown.
+// It returns a primitive Go bool rather than a Value to remind us that it
+// is not a first-class value operation.
+func (val Value) RawEquals(other Value) bool {
+	if !val.ty.Equals(other.ty) {
+		return false
+	}
+	if (!val.IsKnown()) && (!other.IsKnown()) {
+		return true
+	}
+	if (val.IsKnown() && !other.IsKnown()) || (other.IsKnown() && !val.IsKnown()) {
+		return false
+	}
+	if val.IsNull() && other.IsNull() {
+		return true
+	}
+	if (val.IsNull() && !other.IsNull()) || (other.IsNull() && !val.IsNull()) {
+		return false
+	}
+	if val.ty == DynamicPseudoType && other.ty == DynamicPseudoType {
+		return true
+	}
+
+	ty := val.ty
+	switch {
+	case ty == Number || ty == Bool || ty == String || ty == DynamicPseudoType:
+		return val.Equals(other).True()
+	case ty.IsObjectType():
+		oty := ty.typeImpl.(typeObject)
+		for attr, aty := range oty.AttrTypes {
+			lhs := Value{
+				ty: aty,
+				v:  val.v.(map[string]interface{})[attr],
+			}
+			rhs := Value{
+				ty: aty,
+				v:  other.v.(map[string]interface{})[attr],
+			}
+			eq := lhs.RawEquals(rhs)
+			if !eq {
+				return false
+			}
+		}
+		return true
+	case ty.IsTupleType():
+		tty := ty.typeImpl.(typeTuple)
+		for i, ety := range tty.ElemTypes {
+			lhs := Value{
+				ty: ety,
+				v:  val.v.([]interface{})[i],
+			}
+			rhs := Value{
+				ty: ety,
+				v:  other.v.([]interface{})[i],
+			}
+			eq := lhs.RawEquals(rhs)
+			if !eq {
+				return false
+			}
+		}
+		return true
+	case ty.IsListType():
+		ety := ty.typeImpl.(typeList).ElementTypeT
+		if len(val.v.([]interface{})) == len(other.v.([]interface{})) {
+			for i := range val.v.([]interface{}) {
+				lhs := Value{
+					ty: ety,
+					v:  val.v.([]interface{})[i],
+				}
+				rhs := Value{
+					ty: ety,
+					v:  other.v.([]interface{})[i],
+				}
+				eq := lhs.RawEquals(rhs)
+				if !eq {
+					return false
+				}
+			}
+			return true
+		}
+		return false
+	case ty.IsSetType():
+		s1 := val.v.(set.Set)
+		s2 := other.v.(set.Set)
+
+		// Since we're intentionally ignoring our rule that two unknowns
+		// are never equal, we can cheat here.
+		// (This isn't 100% right since e.g. it will fail if the set contains
+		// numbers that are infinite, which DeepEqual can't compare properly.
+		// We're accepting that limitation for simplicity here, since this
+		// function is here primarily for testing.)
+		return reflect.DeepEqual(s1, s2)
+
+	case ty.IsMapType():
+		ety := ty.typeImpl.(typeMap).ElementTypeT
+		if len(val.v.(map[string]interface{})) == len(other.v.(map[string]interface{})) {
+			for k := range val.v.(map[string]interface{}) {
+				if _, ok := other.v.(map[string]interface{})[k]; !ok {
+					return false
+				}
+				lhs := Value{
+					ty: ety,
+					v:  val.v.(map[string]interface{})[k],
+				}
+				rhs := Value{
+					ty: ety,
+					v:  other.v.(map[string]interface{})[k],
+				}
+				eq := lhs.RawEquals(rhs)
+				if !eq {
+					return false
+				}
+			}
+			return true
+		}
+		return false
+	case ty.IsCapsuleType():
+		// A capsule type's encapsulated value is a pointer to a value of its
+		// native type, so we can just compare these to get the identity test
+		// we need.
+		return val.v == other.v
+
+	default:
+		// should never happen
+		panic(fmt.Errorf("unsupported value type %#v in RawEquals", ty))
+	}
+}
+
+// Add returns the sum of the receiver and the given other value. Both values
+// must be numbers; this method will panic if not.
+func (val Value) Add(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := new(big.Float)
+	ret.Add(val.v.(*big.Float), other.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// Subtract returns receiver minus the given other value. Both values must be
+// numbers; this method will panic if not.
+func (val Value) Subtract(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	return val.Add(other.Negate())
+}
+
+// Negate returns the numeric negative of the receiver, which must be a number.
+// This method will panic when given a value of any other type.
+func (val Value) Negate() Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := new(big.Float).Neg(val.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// Multiply returns the product of the receiver and the given other value.
+// Both values must be numbers; this method will panic if not.
+func (val Value) Multiply(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := new(big.Float)
+	ret.Mul(val.v.(*big.Float), other.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// Divide returns the quotient of the receiver and the given other value.
+// Both values must be numbers; this method will panic if not.
+//
+// If the "other" value is exactly zero, this operation will return either
+// PositiveInfinity or NegativeInfinity, depending on the sign of the
+// receiver value. For some use-cases the presence of infinities may be
+// undesirable, in which case the caller should check whether the
+// other value equals zero before calling and raise an error instead.
+//
+// If both values are zero or infinity, this function will panic with
+// an instance of big.ErrNaN.
+func (val Value) Divide(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := new(big.Float)
+	ret.Quo(val.v.(*big.Float), other.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// Modulo returns the remainder of an integer division of the receiver and
+// the given other value. Both values must be numbers; this method will panic
+// if not.
+//
+// If the "other" value is exactly zero, this operation will return either
+// PositiveInfinity or NegativeInfinity, depending on the sign of the
+// receiver value. For some use-cases the presence of infinities may be
+// undesirable, in which case the caller should check whether the
+// other value equals zero before calling and raise an error instead.
+//
+// This operation is primarily here for use with nonzero natural numbers.
+// Modulo with "other" as a non-natural number gets somewhat philosophical,
+// and this function takes a position on what that should mean, but callers
+// may wish to disallow such things outright or implement their own modulo
+// if they disagree with the interpretation used here.
+func (val Value) Modulo(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	// We cheat a bit here with infinities, just abusing the Multiply operation
+	// to get an infinite result of the correct sign.
+	if val == PositiveInfinity || val == NegativeInfinity || other == PositiveInfinity || other == NegativeInfinity {
+		return val.Multiply(other)
+	}
+
+	if other.RawEquals(Zero) {
+		return val
+	}
+
+	// FIXME: This is a bit clumsy. Should come back later and see if there's a
+	// more straightforward way to do this.
+	rat := val.Divide(other)
+	ratFloorInt := &big.Int{}
+	rat.v.(*big.Float).Int(ratFloorInt)
+	work := (&big.Float{}).SetInt(ratFloorInt)
+	work.Mul(other.v.(*big.Float), work)
+	work.Sub(val.v.(*big.Float), work)
+
+	return NumberVal(work)
+}
+
+// Absolute returns the absolute (signless) value of the receiver, which must
+// be a number or this method will panic.
+func (val Value) Absolute() Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := (&big.Float{}).Abs(val.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// GetAttr returns the value of the given attribute of the receiver, which
+// must be of an object type that has an attribute of the given name.
+// This method will panic if the receiver type is not compatible.
+//
+// The method will also panic if the given attribute name is not defined
+// for the value's type. Use the attribute-related methods on Type to
+// check for the validity of an attribute before trying to use it.
+//
+// This method may be called on a value whose type is DynamicPseudoType,
+// in which case the result will also be DynamicVal.
+func (val Value) GetAttr(name string) Value {
+	if val.ty == DynamicPseudoType {
+		return DynamicVal
+	}
+
+	if !val.ty.IsObjectType() {
+		panic("value is not an object")
+	}
+
+	name = NormalizeString(name)
+	if !val.ty.HasAttribute(name) {
+		panic("value has no attribute of that name")
+	}
+
+	attrType := val.ty.AttributeType(name)
+
+	if !val.IsKnown() {
+		return UnknownVal(attrType)
+	}
+
+	return Value{
+		ty: attrType,
+		v:  val.v.(map[string]interface{})[name],
+	}
+}
+
+// Index returns the value of an element of the receiver, which must have
+// either a list, map or tuple type. This method will panic if the receiver
+// type is not compatible.
+//
+// The key value must be the correct type for the receving collection: a
+// number if the collection is a list or tuple, or a string if it is a map.
+// In the case of a list or tuple, the given number must be convertable to int
+// or this method will panic. The key may alternatively be of
+// DynamicPseudoType, in which case the result itself is an unknown of the
+// collection's element type.
+//
+// The result is of the receiver collection's element type, or in the case
+// of a tuple the type of the specific element index requested.
+//
+// This method may be called on a value whose type is DynamicPseudoType,
+// in which case the result will also be the DynamicValue.
+func (val Value) Index(key Value) Value {
+	if val.ty == DynamicPseudoType {
+		return DynamicVal
+	}
+
+	switch {
+	case val.Type().IsListType():
+		elty := val.Type().ElementType()
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(elty)
+		}
+
+		if key.Type() != Number {
+			panic("element key for list must be number")
+		}
+		if !key.IsKnown() {
+			return UnknownVal(elty)
+		}
+
+		if !val.IsKnown() {
+			return UnknownVal(elty)
+		}
+
+		index, accuracy := key.v.(*big.Float).Int64()
+		if accuracy != big.Exact || index < 0 {
+			panic("element key for list must be non-negative integer")
+		}
+
+		return Value{
+			ty: elty,
+			v:  val.v.([]interface{})[index],
+		}
+	case val.Type().IsMapType():
+		elty := val.Type().ElementType()
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(elty)
+		}
+
+		if key.Type() != String {
+			panic("element key for map must be string")
+		}
+		if !key.IsKnown() {
+			return UnknownVal(elty)
+		}
+
+		if !val.IsKnown() {
+			return UnknownVal(elty)
+		}
+
+		keyStr := key.v.(string)
+
+		return Value{
+			ty: elty,
+			v:  val.v.(map[string]interface{})[keyStr],
+		}
+	case val.Type().IsTupleType():
+		if key.Type() == DynamicPseudoType {
+			return DynamicVal
+		}
+
+		if key.Type() != Number {
+			panic("element key for tuple must be number")
+		}
+		if !key.IsKnown() {
+			return DynamicVal
+		}
+
+		index, accuracy := key.v.(*big.Float).Int64()
+		if accuracy != big.Exact || index < 0 {
+			panic("element key for list must be non-negative integer")
+		}
+
+		eltys := val.Type().TupleElementTypes()
+
+		if !val.IsKnown() {
+			return UnknownVal(eltys[index])
+		}
+
+		return Value{
+			ty: eltys[index],
+			v:  val.v.([]interface{})[index],
+		}
+	default:
+		panic("not a list, map, or tuple type")
+	}
+}
+
+// HasIndex returns True if the receiver (which must be supported for Index)
+// has an element with the given index key, or False if it does not.
+//
+// The result will be UnknownVal(Bool) if either the collection or the
+// key value are unknown.
+//
+// This method will panic if the receiver is not indexable, but does not
+// impose any panic-causing type constraints on the key.
+func (val Value) HasIndex(key Value) Value {
+	if val.ty == DynamicPseudoType {
+		return UnknownVal(Bool)
+	}
+
+	switch {
+	case val.Type().IsListType():
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(Bool)
+		}
+
+		if key.Type() != Number {
+			return False
+		}
+		if !key.IsKnown() {
+			return UnknownVal(Bool)
+		}
+		if !val.IsKnown() {
+			return UnknownVal(Bool)
+		}
+
+		index, accuracy := key.v.(*big.Float).Int64()
+		if accuracy != big.Exact || index < 0 {
+			return False
+		}
+
+		return BoolVal(int(index) < len(val.v.([]interface{})) && index >= 0)
+	case val.Type().IsMapType():
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(Bool)
+		}
+
+		if key.Type() != String {
+			return False
+		}
+		if !key.IsKnown() {
+			return UnknownVal(Bool)
+		}
+		if !val.IsKnown() {
+			return UnknownVal(Bool)
+		}
+
+		keyStr := key.v.(string)
+		_, exists := val.v.(map[string]interface{})[keyStr]
+
+		return BoolVal(exists)
+	case val.Type().IsTupleType():
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(Bool)
+		}
+
+		if key.Type() != Number {
+			return False
+		}
+		if !key.IsKnown() {
+			return UnknownVal(Bool)
+		}
+
+		index, accuracy := key.v.(*big.Float).Int64()
+		if accuracy != big.Exact || index < 0 {
+			return False
+		}
+
+		length := val.Type().Length()
+		return BoolVal(int(index) < length && index >= 0)
+	default:
+		panic("not a list, map, or tuple type")
+	}
+}
+
+// HasElement returns True if the receiver (which must be of a set type)
+// has the given value as an element, or False if it does not.
+//
+// The result will be UnknownVal(Bool) if either the set or the
+// given value are unknown.
+//
+// This method will panic if the receiver is not a set, or if it is a null set.
+func (val Value) HasElement(elem Value) Value {
+	ty := val.Type()
+
+	if !ty.IsSetType() {
+		panic("not a set type")
+	}
+	if !val.IsKnown() || !elem.IsKnown() {
+		return UnknownVal(Bool)
+	}
+	if val.IsNull() {
+		panic("can't call HasElement on a nil value")
+	}
+	if !ty.ElementType().Equals(elem.Type()) {
+		return False
+	}
+
+	s := val.v.(set.Set)
+	return BoolVal(s.Has(elem.v))
+}
+
+// Length returns the length of the receiver, which must be a collection type
+// or tuple type, as a number value. If the receiver is not a compatible type
+// then this method will panic.
+//
+// If the receiver is unknown then the result is also unknown.
+//
+// If the receiver is null then this function will panic.
+//
+// Note that Length is not supported for strings. To determine the length
+// of a string, call AsString and take the length of the native Go string
+// that is returned.
+func (val Value) Length() Value {
+	if val.Type().IsTupleType() {
+		// For tuples, we can return the length even if the value is not known.
+		return NumberIntVal(int64(val.Type().Length()))
+	}
+
+	if !val.IsKnown() {
+		return UnknownVal(Number)
+	}
+
+	return NumberIntVal(int64(val.LengthInt()))
+}
+
+// LengthInt is like Length except it returns an int. It has the same behavior
+// as Length except that it will panic if the receiver is unknown.
+//
+// This is an integration method provided for the convenience of code bridging
+// into Go's type system.
+func (val Value) LengthInt() int {
+	if val.Type().IsTupleType() {
+		// For tuples, we can return the length even if the value is not known.
+		return val.Type().Length()
+	}
+	if val.Type().IsObjectType() {
+		// For objects, the length is the number of attributes associated with the type.
+		return len(val.Type().AttributeTypes())
+	}
+	if !val.IsKnown() {
+		panic("value is not known")
+	}
+	if val.IsNull() {
+		panic("value is null")
+	}
+
+	switch {
+
+	case val.ty.IsListType():
+		return len(val.v.([]interface{}))
+
+	case val.ty.IsSetType():
+		return val.v.(set.Set).Length()
+
+	case val.ty.IsMapType():
+		return len(val.v.(map[string]interface{}))
+
+	default:
+		panic("value is not a collection")
+	}
+}
+
+// ElementIterator returns an ElementIterator for iterating the elements
+// of the receiver, which must be a collection type, a tuple type, or an object
+// type. If called on a method of any other type, this method will panic.
+//
+// The value must be Known and non-Null, or this method will panic.
+//
+// If the receiver is of a list type, the returned keys will be of type Number
+// and the values will be of the list's element type.
+//
+// If the receiver is of a map type, the returned keys will be of type String
+// and the value will be of the map's element type. Elements are passed in
+// ascending lexicographical order by key.
+//
+// If the receiver is of a set type, each element is returned as both the
+// key and the value, since set members are their own identity.
+//
+// If the receiver is of a tuple type, the returned keys will be of type Number
+// and the value will be of the corresponding element's type.
+//
+// If the receiver is of an object type, the returned keys will be of type
+// String and the value will be of the corresponding attributes's type.
+//
+// ElementIterator is an integration method, so it cannot handle Unknown
+// values. This method will panic if the receiver is Unknown.
+func (val Value) ElementIterator() ElementIterator {
+	if !val.IsKnown() {
+		panic("can't use ElementIterator on unknown value")
+	}
+	if val.IsNull() {
+		panic("can't use ElementIterator on null value")
+	}
+	return elementIterator(val)
+}
+
+// CanIterateElements returns true if the receiver can support the
+// ElementIterator method (and by extension, ForEachElement) without panic.
+func (val Value) CanIterateElements() bool {
+	return canElementIterator(val)
+}
+
+// ForEachElement executes a given callback function for each element of
+// the receiver, which must be a collection type or tuple type, or this method
+// will panic.
+//
+// ForEachElement uses ElementIterator internally, and so the values passed
+// to the callback are as described for ElementIterator.
+//
+// Returns true if the iteration exited early due to the callback function
+// returning true, or false if the loop ran to completion.
+//
+// ForEachElement is an integration method, so it cannot handle Unknown
+// values. This method will panic if the receiver is Unknown.
+func (val Value) ForEachElement(cb ElementCallback) bool {
+	it := val.ElementIterator()
+	for it.Next() {
+		key, val := it.Element()
+		stop := cb(key, val)
+		if stop {
+			return true
+		}
+	}
+	return false
+}
+
+// Not returns the logical inverse of the receiver, which must be of type
+// Bool or this method will panic.
+func (val Value) Not() Value {
+	if shortCircuit := mustTypeCheck(Bool, Bool, val); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(!val.v.(bool))
+}
+
+// And returns the result of logical AND with the receiver and the other given
+// value, which must both be of type Bool or this method will panic.
+func (val Value) And(other Value) Value {
+	if shortCircuit := mustTypeCheck(Bool, Bool, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(val.v.(bool) && other.v.(bool))
+}
+
+// Or returns the result of logical OR with the receiver and the other given
+// value, which must both be of type Bool or this method will panic.
+func (val Value) Or(other Value) Value {
+	if shortCircuit := mustTypeCheck(Bool, Bool, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(val.v.(bool) || other.v.(bool))
+}
+
+// LessThan returns True if the receiver is less than the other given value,
+// which must both be numbers or this method will panic.
+func (val Value) LessThan(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Bool, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(val.v.(*big.Float).Cmp(other.v.(*big.Float)) < 0)
+}
+
+// GreaterThan returns True if the receiver is greater than the other given
+// value, which must both be numbers or this method will panic.
+func (val Value) GreaterThan(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Bool, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(val.v.(*big.Float).Cmp(other.v.(*big.Float)) > 0)
+}
+
+// LessThanOrEqualTo is equivalent to LessThan and Equal combined with Or.
+func (val Value) LessThanOrEqualTo(other Value) Value {
+	return val.LessThan(other).Or(val.Equals(other))
+}
+
+// GreaterThanOrEqualTo is equivalent to GreaterThan and Equal combined with Or.
+func (val Value) GreaterThanOrEqualTo(other Value) Value {
+	return val.GreaterThan(other).Or(val.Equals(other))
+}
+
+// AsString returns the native string from a non-null, non-unknown cty.String
+// value, or panics if called on any other value.
+func (val Value) AsString() string {
+	if val.ty != String {
+		panic("not a string")
+	}
+	if val.IsNull() {
+		panic("value is null")
+	}
+	if !val.IsKnown() {
+		panic("value is unknown")
+	}
+
+	return val.v.(string)
+}
+
+// AsBigFloat returns a big.Float representation of a non-null, non-unknown
+// cty.Number value, or panics if called on any other value.
+//
+// For more convenient conversions to other native numeric types, use the
+// "gocty" package.
+func (val Value) AsBigFloat() *big.Float {
+	if val.ty != Number {
+		panic("not a number")
+	}
+	if val.IsNull() {
+		panic("value is null")
+	}
+	if !val.IsKnown() {
+		panic("value is unknown")
+	}
+
+	// Copy the float so that callers can't mutate our internal state
+	ret := *(val.v.(*big.Float))
+
+	return &ret
+}
+
+// AsValueSlice returns a []cty.Value representation of a non-null, non-unknown
+// value of any type that CanIterateElements, or panics if called on
+// any other value.
+//
+// For more convenient conversions to slices of more specific types, use
+// the "gocty" package.
+func (val Value) AsValueSlice() []Value {
+	l := val.LengthInt()
+	if l == 0 {
+		return nil
+	}
+
+	ret := make([]Value, 0, l)
+	for it := val.ElementIterator(); it.Next(); {
+		_, v := it.Element()
+		ret = append(ret, v)
+	}
+	return ret
+}
+
+// AsValueMap returns a map[string]cty.Value representation of a non-null,
+// non-unknown value of any type that CanIterateElements, or panics if called
+// on any other value.
+//
+// For more convenient conversions to maps of more specific types, use
+// the "gocty" package.
+func (val Value) AsValueMap() map[string]Value {
+	l := val.LengthInt()
+	if l == 0 {
+		return nil
+	}
+
+	ret := make(map[string]Value, l)
+	for it := val.ElementIterator(); it.Next(); {
+		k, v := it.Element()
+		ret[k.AsString()] = v
+	}
+	return ret
+}
+
+// AsValueSet returns a ValueSet representation of a non-null,
+// non-unknown value of any collection type, or panics if called
+// on any other value.
+//
+// Unlike AsValueSlice and AsValueMap, this method requires specifically a
+// collection type (list, set or map) and does not allow structural types
+// (tuple or object), because the ValueSet type requires homogenous
+// element types.
+//
+// The returned ValueSet can store only values of the receiver's element type.
+func (val Value) AsValueSet() ValueSet {
+	if !val.Type().IsCollectionType() {
+		panic("not a collection type")
+	}
+
+	// We don't give the caller our own set.Set (assuming we're a cty.Set value)
+	// because then the caller could mutate our internals, which is forbidden.
+	// Instead, we will construct a new set and append our elements into it.
+	ret := NewValueSet(val.Type().ElementType())
+	for it := val.ElementIterator(); it.Next(); {
+		_, v := it.Element()
+		ret.Add(v)
+	}
+	return ret
+}
+
+// EncapsulatedValue returns the native value encapsulated in a non-null,
+// non-unknown capsule-typed value, or panics if called on any other value.
+//
+// The result is the same pointer that was passed to CapsuleVal to create
+// the value. Since cty considers values to be immutable, it is strongly
+// recommended to treat the encapsulated value itself as immutable too.
+func (val Value) EncapsulatedValue() interface{} {
+	if !val.Type().IsCapsuleType() {
+		panic("not a capsule-typed value")
+	}
+
+	return val.v
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/walk.go b/vendor/github.com/zclconf/go-cty/cty/walk.go
new file mode 100644
index 000000000..a6943babe
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/walk.go
@@ -0,0 +1,182 @@
+package cty
+
+// Walk visits all of the values in a possibly-complex structure, calling
+// a given function for each value.
+//
+// For example, given a list of strings the callback would first be called
+// with the whole list and then called once for each element of the list.
+//
+// The callback function may prevent recursive visits to child values by
+// returning false. The callback function my halt the walk altogether by
+// returning a non-nil error. If the returned error is about the element
+// currently being visited, it is recommended to use the provided path
+// value to produce a PathError describing that context.
+//
+// The path passed to the given function may not be used after that function
+// returns, since its backing array is re-used for other calls.
+func Walk(val Value, cb func(Path, Value) (bool, error)) error {
+	var path Path
+	return walk(path, val, cb)
+}
+
+func walk(path Path, val Value, cb func(Path, Value) (bool, error)) error {
+	deeper, err := cb(path, val)
+	if err != nil {
+		return err
+	}
+	if !deeper {
+		return nil
+	}
+
+	if val.IsNull() || !val.IsKnown() {
+		// Can't recurse into null or unknown values, regardless of type
+		return nil
+	}
+
+	ty := val.Type()
+	switch {
+	case ty.IsObjectType():
+		for it := val.ElementIterator(); it.Next(); {
+			nameVal, av := it.Element()
+			path := append(path, GetAttrStep{
+				Name: nameVal.AsString(),
+			})
+			err := walk(path, av, cb)
+			if err != nil {
+				return err
+			}
+		}
+	case val.CanIterateElements():
+		for it := val.ElementIterator(); it.Next(); {
+			kv, ev := it.Element()
+			path := append(path, IndexStep{
+				Key: kv,
+			})
+			err := walk(path, ev, cb)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// Transform visits all of the values in a possibly-complex structure,
+// calling a given function for each value which has an opportunity to
+// replace that value.
+//
+// Unlike Walk, Transform visits child nodes first, so for a list of strings
+// it would first visit the strings and then the _new_ list constructed
+// from the transformed values of the list items.
+//
+// This is useful for creating the effect of being able to make deep mutations
+// to a value even though values are immutable. However, it's the responsibility
+// of the given function to preserve expected invariants, such as homogenity of
+// element types in collections; this function can panic if such invariants
+// are violated, just as if new values were constructed directly using the
+// value constructor functions. An easy way to preserve invariants is to
+// ensure that the transform function never changes the value type.
+//
+// The callback function my halt the walk altogether by
+// returning a non-nil error. If the returned error is about the element
+// currently being visited, it is recommended to use the provided path
+// value to produce a PathError describing that context.
+//
+// The path passed to the given function may not be used after that function
+// returns, since its backing array is re-used for other calls.
+func Transform(val Value, cb func(Path, Value) (Value, error)) (Value, error) {
+	var path Path
+	return transform(path, val, cb)
+}
+
+func transform(path Path, val Value, cb func(Path, Value) (Value, error)) (Value, error) {
+	ty := val.Type()
+	var newVal Value
+
+	switch {
+
+	case val.IsNull() || !val.IsKnown():
+		// Can't recurse into null or unknown values, regardless of type
+		newVal = val
+
+	case ty.IsListType() || ty.IsSetType() || ty.IsTupleType():
+		l := val.LengthInt()
+		switch l {
+		case 0:
+			// No deep transform for an empty sequence
+			newVal = val
+		default:
+			elems := make([]Value, 0, l)
+			for it := val.ElementIterator(); it.Next(); {
+				kv, ev := it.Element()
+				path := append(path, IndexStep{
+					Key: kv,
+				})
+				newEv, err := transform(path, ev, cb)
+				if err != nil {
+					return DynamicVal, err
+				}
+				elems = append(elems, newEv)
+			}
+			switch {
+			case ty.IsListType():
+				newVal = ListVal(elems)
+			case ty.IsSetType():
+				newVal = SetVal(elems)
+			case ty.IsTupleType():
+				newVal = TupleVal(elems)
+			default:
+				panic("unknown sequence type") // should never happen because of the case we are in
+			}
+		}
+
+	case ty.IsMapType():
+		l := val.LengthInt()
+		switch l {
+		case 0:
+			// No deep transform for an empty map
+			newVal = val
+		default:
+			elems := make(map[string]Value)
+			for it := val.ElementIterator(); it.Next(); {
+				kv, ev := it.Element()
+				path := append(path, IndexStep{
+					Key: kv,
+				})
+				newEv, err := transform(path, ev, cb)
+				if err != nil {
+					return DynamicVal, err
+				}
+				elems[kv.AsString()] = newEv
+			}
+			newVal = MapVal(elems)
+		}
+
+	case ty.IsObjectType():
+		switch {
+		case ty.Equals(EmptyObject):
+			// No deep transform for an empty object
+			newVal = val
+		default:
+			atys := ty.AttributeTypes()
+			newAVs := make(map[string]Value)
+			for name := range atys {
+				av := val.GetAttr(name)
+				path := append(path, GetAttrStep{
+					Name: name,
+				})
+				newAV, err := transform(path, av, cb)
+				if err != nil {
+					return DynamicVal, err
+				}
+				newAVs[name] = newAV
+			}
+			newVal = ObjectVal(newAVs)
+		}
+
+	default:
+		newVal = val
+	}
+
+	return cb(path, newVal)
+}
diff --git a/vendor/golang.org/x/crypto/ed25519/ed25519.go b/vendor/golang.org/x/crypto/ed25519/ed25519.go
index d6f683ba3..c7f8c7e64 100644
--- a/vendor/golang.org/x/crypto/ed25519/ed25519.go
+++ b/vendor/golang.org/x/crypto/ed25519/ed25519.go
@@ -2,6 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// In Go 1.13, the ed25519 package was promoted to the standard library as
+// crypto/ed25519, and this package became a wrapper for the standard library one.
+//
+// +build !go1.13
+
 // Package ed25519 implements the Ed25519 signature algorithm. See
 // https://ed25519.cr.yp.to/.
 //
diff --git a/vendor/golang.org/x/crypto/ed25519/ed25519_go113.go b/vendor/golang.org/x/crypto/ed25519/ed25519_go113.go
new file mode 100644
index 000000000..d1448d8d2
--- /dev/null
+++ b/vendor/golang.org/x/crypto/ed25519/ed25519_go113.go
@@ -0,0 +1,73 @@
+// Copyright 2019 The Go 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.13
+
+// Package ed25519 implements the Ed25519 signature algorithm. See
+// https://ed25519.cr.yp.to/.
+//
+// These functions are also compatible with the “Ed25519” function defined in
+// RFC 8032. However, unlike RFC 8032's formulation, this package's private key
+// representation includes a public key suffix to make multiple signing
+// operations with the same key more efficient. This package refers to the RFC
+// 8032 private key as the “seed”.
+//
+// Beginning with Go 1.13, the functionality of this package was moved to the
+// standard library as crypto/ed25519. This package only acts as a compatibility
+// wrapper.
+package ed25519
+
+import (
+	"crypto/ed25519"
+	"io"
+)
+
+const (
+	// PublicKeySize is the size, in bytes, of public keys as used in this package.
+	PublicKeySize = 32
+	// PrivateKeySize is the size, in bytes, of private keys as used in this package.
+	PrivateKeySize = 64
+	// SignatureSize is the size, in bytes, of signatures generated and verified by this package.
+	SignatureSize = 64
+	// SeedSize is the size, in bytes, of private key seeds. These are the private key representations used by RFC 8032.
+	SeedSize = 32
+)
+
+// PublicKey is the type of Ed25519 public keys.
+//
+// This type is an alias for crypto/ed25519's PublicKey type.
+// See the crypto/ed25519 package for the methods on this type.
+type PublicKey = ed25519.PublicKey
+
+// PrivateKey is the type of Ed25519 private keys. It implements crypto.Signer.
+//
+// This type is an alias for crypto/ed25519's PrivateKey type.
+// See the crypto/ed25519 package for the methods on this type.
+type PrivateKey = ed25519.PrivateKey
+
+// GenerateKey generates a public/private key pair using entropy from rand.
+// If rand is nil, crypto/rand.Reader will be used.
+func GenerateKey(rand io.Reader) (PublicKey, PrivateKey, error) {
+	return ed25519.GenerateKey(rand)
+}
+
+// NewKeyFromSeed calculates a private key from a seed. It will panic if
+// len(seed) is not SeedSize. This function is provided for interoperability
+// with RFC 8032. RFC 8032's private keys correspond to seeds in this
+// package.
+func NewKeyFromSeed(seed []byte) PrivateKey {
+	return ed25519.NewKeyFromSeed(seed)
+}
+
+// Sign signs the message with privateKey and returns a signature. It will
+// panic if len(privateKey) is not PrivateKeySize.
+func Sign(privateKey PrivateKey, message []byte) []byte {
+	return ed25519.Sign(privateKey, message)
+}
+
+// Verify reports whether sig is a valid signature of message by publicKey. It
+// will panic if len(publicKey) is not PublicKeySize.
+func Verify(publicKey PublicKey, message, sig []byte) bool {
+	return ed25519.Verify(publicKey, message, sig)
+}
diff --git a/vendor/golang.org/x/crypto/internal/chacha20/asm_ppc64le.s b/vendor/golang.org/x/crypto/internal/chacha20/asm_ppc64le.s
index 8815cb00d..cde3fc989 100644
--- a/vendor/golang.org/x/crypto/internal/chacha20/asm_ppc64le.s
+++ b/vendor/golang.org/x/crypto/internal/chacha20/asm_ppc64le.s
@@ -135,7 +135,7 @@ TEXT ·chaCha20_ctr32_vmx(SB),NOSPLIT|NOFRAME,$0
 	MOVD inp+8(FP), INP
 	MOVD len+16(FP), LEN
 	MOVD key+24(FP), KEY
-	MOVD cnt+32(FP), CNT
+	MOVD counter+32(FP), CNT
 
 	MOVD $·consts(SB), CONSTS // point to consts addr
 
diff --git a/vendor/golang.org/x/crypto/internal/chacha20/chacha_ppc64le.go b/vendor/golang.org/x/crypto/internal/chacha20/chacha_ppc64le.go
index 9bd6df646..638cb5e5d 100644
--- a/vendor/golang.org/x/crypto/internal/chacha20/chacha_ppc64le.go
+++ b/vendor/golang.org/x/crypto/internal/chacha20/chacha_ppc64le.go
@@ -8,9 +8,10 @@ package chacha20
 
 import "encoding/binary"
 
-var haveAsm = true
-
-const bufSize = 256
+const (
+	bufSize = 256
+	haveAsm = true
+)
 
 //go:noescape
 func chaCha20_ctr32_vmx(out, inp *byte, len int, key *[8]uint32, counter *uint32)
diff --git a/vendor/golang.org/x/crypto/ssh/common.go b/vendor/golang.org/x/crypto/ssh/common.go
index d97415d2d..e55fe0ad6 100644
--- a/vendor/golang.org/x/crypto/ssh/common.go
+++ b/vendor/golang.org/x/crypto/ssh/common.go
@@ -51,6 +51,13 @@ var supportedKexAlgos = []string{
 	kexAlgoDH14SHA1, kexAlgoDH1SHA1,
 }
 
+// serverForbiddenKexAlgos contains key exchange algorithms, that are forbidden
+// for the server half.
+var serverForbiddenKexAlgos = map[string]struct{}{
+	kexAlgoDHGEXSHA1:   {}, // server half implementation is only minimal to satisfy the automated tests
+	kexAlgoDHGEXSHA256: {}, // server half implementation is only minimal to satisfy the automated tests
+}
+
 // supportedHostKeyAlgos specifies the supported host-key algorithms (i.e. methods
 // of authenticating servers) in preference order.
 var supportedHostKeyAlgos = []string{
diff --git a/vendor/golang.org/x/crypto/ssh/kex.go b/vendor/golang.org/x/crypto/ssh/kex.go
index f34bcc013..16072004b 100644
--- a/vendor/golang.org/x/crypto/ssh/kex.go
+++ b/vendor/golang.org/x/crypto/ssh/kex.go
@@ -10,7 +10,9 @@ import (
 	"crypto/elliptic"
 	"crypto/rand"
 	"crypto/subtle"
+	"encoding/binary"
 	"errors"
+	"fmt"
 	"io"
 	"math/big"
 
@@ -24,6 +26,12 @@ const (
 	kexAlgoECDH384          = "ecdh-sha2-nistp384"
 	kexAlgoECDH521          = "ecdh-sha2-nistp521"
 	kexAlgoCurve25519SHA256 = "curve25519-sha256@libssh.org"
+
+	// For the following kex only the client half contains a production
+	// ready implementation. The server half only consists of a minimal
+	// implementation to satisfy the automated tests.
+	kexAlgoDHGEXSHA1   = "diffie-hellman-group-exchange-sha1"
+	kexAlgoDHGEXSHA256 = "diffie-hellman-group-exchange-sha256"
 )
 
 // kexResult captures the outcome of a key exchange.
@@ -402,6 +410,8 @@ func init() {
 	kexAlgoMap[kexAlgoECDH384] = &ecdh{elliptic.P384()}
 	kexAlgoMap[kexAlgoECDH256] = &ecdh{elliptic.P256()}
 	kexAlgoMap[kexAlgoCurve25519SHA256] = &curve25519sha256{}
+	kexAlgoMap[kexAlgoDHGEXSHA1] = &dhGEXSHA{hashFunc: crypto.SHA1}
+	kexAlgoMap[kexAlgoDHGEXSHA256] = &dhGEXSHA{hashFunc: crypto.SHA256}
 }
 
 // curve25519sha256 implements the curve25519-sha256@libssh.org key
@@ -538,3 +548,242 @@ func (kex *curve25519sha256) Server(c packetConn, rand io.Reader, magics *handsh
 		Hash:      crypto.SHA256,
 	}, nil
 }
+
+// dhGEXSHA implements the diffie-hellman-group-exchange-sha1 and
+// diffie-hellman-group-exchange-sha256 key agreement protocols,
+// as described in RFC 4419
+type dhGEXSHA struct {
+	g, p     *big.Int
+	hashFunc crypto.Hash
+}
+
+const numMRTests = 64
+
+const (
+	dhGroupExchangeMinimumBits   = 2048
+	dhGroupExchangePreferredBits = 2048
+	dhGroupExchangeMaximumBits   = 8192
+)
+
+func (gex *dhGEXSHA) diffieHellman(theirPublic, myPrivate *big.Int) (*big.Int, error) {
+	if theirPublic.Sign() <= 0 || theirPublic.Cmp(gex.p) >= 0 {
+		return nil, fmt.Errorf("ssh: DH parameter out of bounds")
+	}
+	return new(big.Int).Exp(theirPublic, myPrivate, gex.p), nil
+}
+
+func (gex *dhGEXSHA) Client(c packetConn, randSource io.Reader, magics *handshakeMagics) (*kexResult, error) {
+	// Send GexRequest
+	kexDHGexRequest := kexDHGexRequestMsg{
+		MinBits:      dhGroupExchangeMinimumBits,
+		PreferedBits: dhGroupExchangePreferredBits,
+		MaxBits:      dhGroupExchangeMaximumBits,
+	}
+	if err := c.writePacket(Marshal(&kexDHGexRequest)); err != nil {
+		return nil, err
+	}
+
+	// Receive GexGroup
+	packet, err := c.readPacket()
+	if err != nil {
+		return nil, err
+	}
+
+	var kexDHGexGroup kexDHGexGroupMsg
+	if err = Unmarshal(packet, &kexDHGexGroup); err != nil {
+		return nil, err
+	}
+
+	// reject if p's bit length < dhGroupExchangeMinimumBits or > dhGroupExchangeMaximumBits
+	if kexDHGexGroup.P.BitLen() < dhGroupExchangeMinimumBits || kexDHGexGroup.P.BitLen() > dhGroupExchangeMaximumBits {
+		return nil, fmt.Errorf("ssh: server-generated gex p is out of range (%d bits)", kexDHGexGroup.P.BitLen())
+	}
+
+	gex.p = kexDHGexGroup.P
+	gex.g = kexDHGexGroup.G
+
+	// Check if p is safe by verifing that p and (p-1)/2 are primes
+	one := big.NewInt(1)
+	var pHalf = &big.Int{}
+	pHalf.Rsh(gex.p, 1)
+	if !gex.p.ProbablyPrime(numMRTests) || !pHalf.ProbablyPrime(numMRTests) {
+		return nil, fmt.Errorf("ssh: server provided gex p is not safe")
+	}
+
+	// Check if g is safe by verifing that g > 1 and g < p - 1
+	var pMinusOne = &big.Int{}
+	pMinusOne.Sub(gex.p, one)
+	if gex.g.Cmp(one) != 1 && gex.g.Cmp(pMinusOne) != -1 {
+		return nil, fmt.Errorf("ssh: server provided gex g is not safe")
+	}
+
+	// Send GexInit
+	x, err := rand.Int(randSource, pHalf)
+	if err != nil {
+		return nil, err
+	}
+	X := new(big.Int).Exp(gex.g, x, gex.p)
+	kexDHGexInit := kexDHGexInitMsg{
+		X: X,
+	}
+	if err := c.writePacket(Marshal(&kexDHGexInit)); err != nil {
+		return nil, err
+	}
+
+	// Receive GexReply
+	packet, err = c.readPacket()
+	if err != nil {
+		return nil, err
+	}
+
+	var kexDHGexReply kexDHGexReplyMsg
+	if err = Unmarshal(packet, &kexDHGexReply); err != nil {
+		return nil, err
+	}
+
+	kInt, err := gex.diffieHellman(kexDHGexReply.Y, x)
+	if err != nil {
+		return nil, err
+	}
+
+	// Check if k is safe by verifing that k > 1 and k < p - 1
+	if kInt.Cmp(one) != 1 && kInt.Cmp(pMinusOne) != -1 {
+		return nil, fmt.Errorf("ssh: derived k is not safe")
+	}
+
+	h := gex.hashFunc.New()
+	magics.write(h)
+	writeString(h, kexDHGexReply.HostKey)
+	binary.Write(h, binary.BigEndian, uint32(dhGroupExchangeMinimumBits))
+	binary.Write(h, binary.BigEndian, uint32(dhGroupExchangePreferredBits))
+	binary.Write(h, binary.BigEndian, uint32(dhGroupExchangeMaximumBits))
+	writeInt(h, gex.p)
+	writeInt(h, gex.g)
+	writeInt(h, X)
+	writeInt(h, kexDHGexReply.Y)
+	K := make([]byte, intLength(kInt))
+	marshalInt(K, kInt)
+	h.Write(K)
+
+	return &kexResult{
+		H:         h.Sum(nil),
+		K:         K,
+		HostKey:   kexDHGexReply.HostKey,
+		Signature: kexDHGexReply.Signature,
+		Hash:      gex.hashFunc,
+	}, nil
+}
+
+// Server half implementation of the Diffie Hellman Key Exchange with SHA1 and SHA256.
+//
+// This is a minimal implementation to satisfy the automated tests.
+func (gex *dhGEXSHA) Server(c packetConn, randSource io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) {
+	// Receive GexRequest
+	packet, err := c.readPacket()
+	if err != nil {
+		return
+	}
+	var kexDHGexRequest kexDHGexRequestMsg
+	if err = Unmarshal(packet, &kexDHGexRequest); err != nil {
+		return
+	}
+
+	// smoosh the user's preferred size into our own limits
+	if kexDHGexRequest.PreferedBits > dhGroupExchangeMaximumBits {
+		kexDHGexRequest.PreferedBits = dhGroupExchangeMaximumBits
+	}
+	if kexDHGexRequest.PreferedBits < dhGroupExchangeMinimumBits {
+		kexDHGexRequest.PreferedBits = dhGroupExchangeMinimumBits
+	}
+	// fix min/max if they're inconsistent.  technically, we could just pout
+	// and hang up, but there's no harm in giving them the benefit of the
+	// doubt and just picking a bitsize for them.
+	if kexDHGexRequest.MinBits > kexDHGexRequest.PreferedBits {
+		kexDHGexRequest.MinBits = kexDHGexRequest.PreferedBits
+	}
+	if kexDHGexRequest.MaxBits < kexDHGexRequest.PreferedBits {
+		kexDHGexRequest.MaxBits = kexDHGexRequest.PreferedBits
+	}
+
+	// Send GexGroup
+	// This is the group called diffie-hellman-group14-sha1 in RFC
+	// 4253 and Oakley Group 14 in RFC 3526.
+	p, _ := new(big.Int).SetString("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF", 16)
+	gex.p = p
+	gex.g = big.NewInt(2)
+
+	kexDHGexGroup := kexDHGexGroupMsg{
+		P: gex.p,
+		G: gex.g,
+	}
+	if err := c.writePacket(Marshal(&kexDHGexGroup)); err != nil {
+		return nil, err
+	}
+
+	// Receive GexInit
+	packet, err = c.readPacket()
+	if err != nil {
+		return
+	}
+	var kexDHGexInit kexDHGexInitMsg
+	if err = Unmarshal(packet, &kexDHGexInit); err != nil {
+		return
+	}
+
+	var pHalf = &big.Int{}
+	pHalf.Rsh(gex.p, 1)
+
+	y, err := rand.Int(randSource, pHalf)
+	if err != nil {
+		return
+	}
+
+	Y := new(big.Int).Exp(gex.g, y, gex.p)
+	kInt, err := gex.diffieHellman(kexDHGexInit.X, y)
+	if err != nil {
+		return nil, err
+	}
+
+	hostKeyBytes := priv.PublicKey().Marshal()
+
+	h := gex.hashFunc.New()
+	magics.write(h)
+	writeString(h, hostKeyBytes)
+	binary.Write(h, binary.BigEndian, uint32(dhGroupExchangeMinimumBits))
+	binary.Write(h, binary.BigEndian, uint32(dhGroupExchangePreferredBits))
+	binary.Write(h, binary.BigEndian, uint32(dhGroupExchangeMaximumBits))
+	writeInt(h, gex.p)
+	writeInt(h, gex.g)
+	writeInt(h, kexDHGexInit.X)
+	writeInt(h, Y)
+
+	K := make([]byte, intLength(kInt))
+	marshalInt(K, kInt)
+	h.Write(K)
+
+	H := h.Sum(nil)
+
+	// H is already a hash, but the hostkey signing will apply its
+	// own key-specific hash algorithm.
+	sig, err := signAndMarshal(priv, randSource, H)
+	if err != nil {
+		return nil, err
+	}
+
+	kexDHGexReply := kexDHGexReplyMsg{
+		HostKey:   hostKeyBytes,
+		Y:         Y,
+		Signature: sig,
+	}
+	packet = Marshal(&kexDHGexReply)
+
+	err = c.writePacket(packet)
+
+	return &kexResult{
+		H:         H,
+		K:         K,
+		HostKey:   hostKeyBytes,
+		Signature: sig,
+		Hash:      gex.hashFunc,
+	}, err
+}
diff --git a/vendor/golang.org/x/crypto/ssh/messages.go b/vendor/golang.org/x/crypto/ssh/messages.go
index db914d803..ac41a4168 100644
--- a/vendor/golang.org/x/crypto/ssh/messages.go
+++ b/vendor/golang.org/x/crypto/ssh/messages.go
@@ -97,6 +97,36 @@ type kexDHReplyMsg struct {
 	Signature []byte
 }
 
+// See RFC 4419, section 5.
+const msgKexDHGexGroup = 31
+
+type kexDHGexGroupMsg struct {
+	P *big.Int `sshtype:"31"`
+	G *big.Int
+}
+
+const msgKexDHGexInit = 32
+
+type kexDHGexInitMsg struct {
+	X *big.Int `sshtype:"32"`
+}
+
+const msgKexDHGexReply = 33
+
+type kexDHGexReplyMsg struct {
+	HostKey   []byte `sshtype:"33"`
+	Y         *big.Int
+	Signature []byte
+}
+
+const msgKexDHGexRequest = 34
+
+type kexDHGexRequestMsg struct {
+	MinBits      uint32 `sshtype:"34"`
+	PreferedBits uint32
+	MaxBits      uint32
+}
+
 // See RFC 4253, section 10.
 const msgServiceRequest = 5
 
diff --git a/vendor/golang.org/x/crypto/ssh/server.go b/vendor/golang.org/x/crypto/ssh/server.go
index ac7f8073c..7a5a1d7ad 100644
--- a/vendor/golang.org/x/crypto/ssh/server.go
+++ b/vendor/golang.org/x/crypto/ssh/server.go
@@ -193,6 +193,12 @@ func NewServerConn(c net.Conn, config *ServerConfig) (*ServerConn, <-chan NewCha
 	if fullConf.MaxAuthTries == 0 {
 		fullConf.MaxAuthTries = 6
 	}
+	// Check if the config contains any unsupported key exchanges
+	for _, kex := range fullConf.KeyExchanges {
+		if _, ok := serverForbiddenKexAlgos[kex]; ok {
+			return nil, nil, nil, fmt.Errorf("ssh: unsupported key exchange %s for server", kex)
+		}
+	}
 
 	s := &connection{
 		sshConn: sshConn{conn: c},
diff --git a/vendor/golang.org/x/sys/unix/affinity_linux.go b/vendor/golang.org/x/sys/unix/affinity_linux.go
index 72afe3338..14e4d5caa 100644
--- a/vendor/golang.org/x/sys/unix/affinity_linux.go
+++ b/vendor/golang.org/x/sys/unix/affinity_linux.go
@@ -91,9 +91,13 @@ func onesCount64(x uint64) int {
 	const m0 = 0x5555555555555555 // 01010101 ...
 	const m1 = 0x3333333333333333 // 00110011 ...
 	const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ...
-	const m3 = 0x00ff00ff00ff00ff // etc.
-	const m4 = 0x0000ffff0000ffff
 
+	// Unused in this function, but definitions preserved for
+	// documentation purposes:
+	//
+	//   const m3 = 0x00ff00ff00ff00ff // etc.
+	//   const m4 = 0x0000ffff0000ffff
+	//
 	// Implementation: Parallel summing of adjacent bits.
 	// See "Hacker's Delight", Chap. 5: Counting Bits.
 	// The following pattern shows the general approach:
diff --git a/vendor/golang.org/x/sys/unix/dirent.go b/vendor/golang.org/x/sys/unix/dirent.go
index 4407c505a..304016b68 100644
--- a/vendor/golang.org/x/sys/unix/dirent.go
+++ b/vendor/golang.org/x/sys/unix/dirent.go
@@ -2,16 +2,101 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build aix darwin dragonfly freebsd linux nacl netbsd openbsd solaris
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package unix
 
-import "syscall"
+import "unsafe"
+
+// readInt returns the size-bytes unsigned integer in native byte order at offset off.
+func readInt(b []byte, off, size uintptr) (u uint64, ok bool) {
+	if len(b) < int(off+size) {
+		return 0, false
+	}
+	if isBigEndian {
+		return readIntBE(b[off:], size), true
+	}
+	return readIntLE(b[off:], size), true
+}
+
+func readIntBE(b []byte, size uintptr) uint64 {
+	switch size {
+	case 1:
+		return uint64(b[0])
+	case 2:
+		_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
+		return uint64(b[1]) | uint64(b[0])<<8
+	case 4:
+		_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
+		return uint64(b[3]) | uint64(b[2])<<8 | uint64(b[1])<<16 | uint64(b[0])<<24
+	case 8:
+		_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
+		return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
+			uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
+	default:
+		panic("syscall: readInt with unsupported size")
+	}
+}
+
+func readIntLE(b []byte, size uintptr) uint64 {
+	switch size {
+	case 1:
+		return uint64(b[0])
+	case 2:
+		_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
+		return uint64(b[0]) | uint64(b[1])<<8
+	case 4:
+		_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808
+		return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24
+	case 8:
+		_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
+		return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
+			uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
+	default:
+		panic("syscall: readInt with unsupported size")
+	}
+}
 
 // ParseDirent parses up to max directory entries in buf,
 // appending the names to names. It returns the number of
 // bytes consumed from buf, the number of entries added
 // to names, and the new names slice.
 func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {
-	return syscall.ParseDirent(buf, max, names)
+	origlen := len(buf)
+	count = 0
+	for max != 0 && len(buf) > 0 {
+		reclen, ok := direntReclen(buf)
+		if !ok || reclen > uint64(len(buf)) {
+			return origlen, count, names
+		}
+		rec := buf[:reclen]
+		buf = buf[reclen:]
+		ino, ok := direntIno(rec)
+		if !ok {
+			break
+		}
+		if ino == 0 { // File absent in directory.
+			continue
+		}
+		const namoff = uint64(unsafe.Offsetof(Dirent{}.Name))
+		namlen, ok := direntNamlen(rec)
+		if !ok || namoff+namlen > uint64(len(rec)) {
+			break
+		}
+		name := rec[namoff : namoff+namlen]
+		for i, c := range name {
+			if c == 0 {
+				name = name[:i]
+				break
+			}
+		}
+		// Check for useless names before allocating a string.
+		if string(name) == "." || string(name) == ".." {
+			continue
+		}
+		max--
+		count++
+		names = append(names, string(name))
+	}
+	return origlen - len(buf), count, names
 }
diff --git a/vendor/golang.org/x/sys/unix/endian_little.go b/vendor/golang.org/x/sys/unix/endian_little.go
index 085df2d8d..bcdb5d30e 100644
--- a/vendor/golang.org/x/sys/unix/endian_little.go
+++ b/vendor/golang.org/x/sys/unix/endian_little.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 //
-// +build 386 amd64 amd64p32 arm arm64 ppc64le mipsle mips64le
+// +build 386 amd64 amd64p32 arm arm64 ppc64le mipsle mips64le riscv64
 
 package unix
 
diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh
index 3d85f2795..14624b953 100644
--- a/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -199,6 +199,7 @@ struct ltchars {
 #include <linux/fs.h>
 #include <linux/kexec.h>
 #include <linux/keyctl.h>
+#include <linux/loop.h>
 #include <linux/magic.h>
 #include <linux/memfd.h>
 #include <linux/module.h>
@@ -435,6 +436,8 @@ ccflags="$@"
 		$2 ~ /^TC[IO](ON|OFF)$/ ||
 		$2 ~ /^IN_/ ||
 		$2 ~ /^LOCK_(SH|EX|NB|UN)$/ ||
+		$2 ~ /^LO_(KEY|NAME)_SIZE$/ ||
+		$2 ~ /^LOOP_(CLR|CTL|GET|SET)_/ ||
 		$2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|MCAST|EVFILT|NOTE|EV|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ ||
 		$2 ~ /^TP_STATUS_/ ||
 		$2 ~ /^FALLOC_/ ||
diff --git a/vendor/golang.org/x/sys/unix/syscall_aix.go b/vendor/golang.org/x/sys/unix/syscall_aix.go
index a079243dc..1aa065f9c 100644
--- a/vendor/golang.org/x/sys/unix/syscall_aix.go
+++ b/vendor/golang.org/x/sys/unix/syscall_aix.go
@@ -280,6 +280,22 @@ func sendfile(outfd int, infd int, offset *int64, count int) (written int, err e
 	return -1, ENOSYS
 }
 
+func direntIno(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
+}
+
+func direntReclen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
+}
+
+func direntNamlen(buf []byte) (uint64, bool) {
+	reclen, ok := direntReclen(buf)
+	if !ok {
+		return 0, false
+	}
+	return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
+}
+
 //sys	getdirent(fd int, buf []byte) (n int, err error)
 func Getdents(fd int, buf []byte) (n int, err error) {
 	return getdirent(fd, buf)
diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go
index 212009189..216b4ac9e 100644
--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -77,6 +77,18 @@ func nametomib(name string) (mib []_C_int, err error) {
 	return buf[0 : n/siz], nil
 }
 
+func direntIno(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
+}
+
+func direntReclen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
+}
+
+func direntNamlen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
+}
+
 //sys   ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
 func PtraceAttach(pid int) (err error) { return ptrace(PT_ATTACH, pid, 0, 0) }
 func PtraceDetach(pid int) (err error) { return ptrace(PT_DETACH, pid, 0, 0) }
diff --git a/vendor/golang.org/x/sys/unix/syscall_dragonfly.go b/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
index bf537011f..260a400f9 100644
--- a/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
+++ b/vendor/golang.org/x/sys/unix/syscall_dragonfly.go
@@ -57,6 +57,22 @@ func nametomib(name string) (mib []_C_int, err error) {
 	return buf[0 : n/siz], nil
 }
 
+func direntIno(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Fileno), unsafe.Sizeof(Dirent{}.Fileno))
+}
+
+func direntReclen(buf []byte) (uint64, bool) {
+	namlen, ok := direntNamlen(buf)
+	if !ok {
+		return 0, false
+	}
+	return (16 + namlen + 1 + 7) &^ 7, true
+}
+
+func direntNamlen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
+}
+
 //sysnb pipe() (r int, w int, err error)
 
 func Pipe(p []int) (err error) {
diff --git a/vendor/golang.org/x/sys/unix/syscall_freebsd.go b/vendor/golang.org/x/sys/unix/syscall_freebsd.go
index c9c802df0..329d240b9 100644
--- a/vendor/golang.org/x/sys/unix/syscall_freebsd.go
+++ b/vendor/golang.org/x/sys/unix/syscall_freebsd.go
@@ -82,6 +82,18 @@ func nametomib(name string) (mib []_C_int, err error) {
 	return buf[0 : n/siz], nil
 }
 
+func direntIno(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Fileno), unsafe.Sizeof(Dirent{}.Fileno))
+}
+
+func direntReclen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
+}
+
+func direntNamlen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
+}
+
 func Pipe(p []int) (err error) {
 	return Pipe2(p, 0)
 }
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go
index 11d07ace2..637b5017b 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -1413,6 +1413,22 @@ func Reboot(cmd int) (err error) {
 	return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "")
 }
 
+func direntIno(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
+}
+
+func direntReclen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
+}
+
+func direntNamlen(buf []byte) (uint64, bool) {
+	reclen, ok := direntReclen(buf)
+	if !ok {
+		return 0, false
+	}
+	return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
+}
+
 //sys	mount(source string, target string, fstype string, flags uintptr, data *byte) (err error)
 
 func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) {
diff --git a/vendor/golang.org/x/sys/unix/syscall_netbsd.go b/vendor/golang.org/x/sys/unix/syscall_netbsd.go
index 45377107a..5ef309040 100644
--- a/vendor/golang.org/x/sys/unix/syscall_netbsd.go
+++ b/vendor/golang.org/x/sys/unix/syscall_netbsd.go
@@ -94,6 +94,18 @@ func nametomib(name string) (mib []_C_int, err error) {
 	return mib, nil
 }
 
+func direntIno(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Fileno), unsafe.Sizeof(Dirent{}.Fileno))
+}
+
+func direntReclen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
+}
+
+func direntNamlen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
+}
+
 func SysctlClockinfo(name string) (*Clockinfo, error) {
 	mib, err := sysctlmib(name)
 	if err != nil {
diff --git a/vendor/golang.org/x/sys/unix/syscall_openbsd.go b/vendor/golang.org/x/sys/unix/syscall_openbsd.go
index 4f34d6d03..1a074b2fe 100644
--- a/vendor/golang.org/x/sys/unix/syscall_openbsd.go
+++ b/vendor/golang.org/x/sys/unix/syscall_openbsd.go
@@ -43,6 +43,18 @@ func nametomib(name string) (mib []_C_int, err error) {
 	return nil, EINVAL
 }
 
+func direntIno(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Fileno), unsafe.Sizeof(Dirent{}.Fileno))
+}
+
+func direntReclen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
+}
+
+func direntNamlen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Namlen), unsafe.Sizeof(Dirent{}.Namlen))
+}
+
 func SysctlClockinfo(name string) (*Clockinfo, error) {
 	mib, err := sysctlmib(name)
 	if err != nil {
diff --git a/vendor/golang.org/x/sys/unix/syscall_solaris.go b/vendor/golang.org/x/sys/unix/syscall_solaris.go
index 9147ba152..0153a316d 100644
--- a/vendor/golang.org/x/sys/unix/syscall_solaris.go
+++ b/vendor/golang.org/x/sys/unix/syscall_solaris.go
@@ -35,6 +35,22 @@ type SockaddrDatalink struct {
 	raw    RawSockaddrDatalink
 }
 
+func direntIno(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
+}
+
+func direntReclen(buf []byte) (uint64, bool) {
+	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
+}
+
+func direntNamlen(buf []byte) (uint64, bool) {
+	reclen, ok := direntReclen(buf)
+	if !ok {
+		return 0, false
+	}
+	return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
+}
+
 //sysnb	pipe(p *[2]_C_int) (n int, err error)
 
 func Pipe(p []int) (err error) {
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
index 1db2f00de..5213d820a 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1135,6 +1149,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -1997,6 +2025,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x80108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x80108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x541b
 	SIOCOUTQ                             = 0x5411
 	SIOCOUTQNSD                          = 0x894b
@@ -2204,6 +2236,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2423,6 +2456,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x400854d5
 	TUNDETACHFILTER                      = 0x400854d6
+	TUNGETDEVNETNS                       = 0x54e3
 	TUNGETFEATURES                       = 0x800454cf
 	TUNGETFILTER                         = 0x800854db
 	TUNGETIFF                            = 0x800454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
index 8a9d2eadf..39b630cc5 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1135,6 +1149,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -1998,6 +2026,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x80108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x80108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x541b
 	SIOCOUTQ                             = 0x5411
 	SIOCOUTQNSD                          = 0x894b
@@ -2205,6 +2237,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2424,6 +2457,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x401054d5
 	TUNDETACHFILTER                      = 0x401054d6
+	TUNGETDEVNETNS                       = 0x54e3
 	TUNGETFEATURES                       = 0x800454cf
 	TUNGETFILTER                         = 0x801054db
 	TUNGETIFF                            = 0x800454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
index 2e7455814..c59a1beb3 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1134,6 +1148,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -2004,6 +2032,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x80108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x80108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x541b
 	SIOCOUTQ                             = 0x5411
 	SIOCOUTQNSD                          = 0x894b
@@ -2211,6 +2243,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2430,6 +2463,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x400854d5
 	TUNDETACHFILTER                      = 0x400854d6
+	TUNGETDEVNETNS                       = 0x54e3
 	TUNGETFEATURES                       = 0x800454cf
 	TUNGETFILTER                         = 0x800854db
 	TUNGETIFF                            = 0x800454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
index b1dc633a2..5f35c19d1 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -528,6 +541,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1137,6 +1151,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -1988,6 +2016,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x80108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x80108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x541b
 	SIOCOUTQ                             = 0x5411
 	SIOCOUTQNSD                          = 0x894b
@@ -2196,6 +2228,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2415,6 +2448,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x401054d5
 	TUNDETACHFILTER                      = 0x401054d6
+	TUNGETDEVNETNS                       = 0x54e3
 	TUNGETFEATURES                       = 0x800454cf
 	TUNGETFILTER                         = 0x801054db
 	TUNGETIFF                            = 0x800454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
index ad4d9afb6..7f1b7bef2 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1134,6 +1148,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -1997,6 +2025,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x40108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x40108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x467f
 	SIOCOUTQ                             = 0x7472
 	SIOCOUTQNSD                          = 0x894b
@@ -2205,6 +2237,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2425,6 +2458,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x800854d5
 	TUNDETACHFILTER                      = 0x800854d6
+	TUNGETDEVNETNS                       = 0x200054e3
 	TUNGETFEATURES                       = 0x400454cf
 	TUNGETFILTER                         = 0x400854db
 	TUNGETIFF                            = 0x400454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
index fe2965028..603d88b8b 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1134,6 +1148,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -1997,6 +2025,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x40108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x40108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x467f
 	SIOCOUTQ                             = 0x7472
 	SIOCOUTQNSD                          = 0x894b
@@ -2205,6 +2237,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2425,6 +2458,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x801054d5
 	TUNDETACHFILTER                      = 0x801054d6
+	TUNGETDEVNETNS                       = 0x200054e3
 	TUNGETFEATURES                       = 0x400454cf
 	TUNGETFILTER                         = 0x401054db
 	TUNGETIFF                            = 0x400454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
index 608878303..ed178f8a7 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1134,6 +1148,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -1997,6 +2025,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x40108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x40108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x467f
 	SIOCOUTQ                             = 0x7472
 	SIOCOUTQNSD                          = 0x894b
@@ -2205,6 +2237,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2425,6 +2458,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x801054d5
 	TUNDETACHFILTER                      = 0x801054d6
+	TUNGETDEVNETNS                       = 0x200054e3
 	TUNGETFEATURES                       = 0x400454cf
 	TUNGETFILTER                         = 0x401054db
 	TUNGETIFF                            = 0x400454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
index 4cf9ddfad..080b78933 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1134,6 +1148,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -1997,6 +2025,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x40108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x40108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x467f
 	SIOCOUTQ                             = 0x7472
 	SIOCOUTQNSD                          = 0x894b
@@ -2205,6 +2237,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2425,6 +2458,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x800854d5
 	TUNDETACHFILTER                      = 0x800854d6
+	TUNGETDEVNETNS                       = 0x200054e3
 	TUNGETFEATURES                       = 0x400454cf
 	TUNGETFILTER                         = 0x400854db
 	TUNGETIFF                            = 0x400454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
index 374e3007f..961e8eabe 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1134,6 +1148,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -2055,6 +2083,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x40108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x40108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x4004667f
 	SIOCOUTQ                             = 0x40047473
 	SIOCOUTQNSD                          = 0x894b
@@ -2262,6 +2294,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2485,6 +2518,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x801054d5
 	TUNDETACHFILTER                      = 0x801054d6
+	TUNGETDEVNETNS                       = 0x200054e3
 	TUNGETFEATURES                       = 0x400454cf
 	TUNGETFILTER                         = 0x401054db
 	TUNGETIFF                            = 0x400454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
index badf14102..6e0538f22 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1134,6 +1148,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -2055,6 +2083,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x40108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x40108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x4004667f
 	SIOCOUTQ                             = 0x40047473
 	SIOCOUTQNSD                          = 0x894b
@@ -2262,6 +2294,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2485,6 +2518,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x801054d5
 	TUNDETACHFILTER                      = 0x801054d6
+	TUNGETDEVNETNS                       = 0x200054e3
 	TUNGETFEATURES                       = 0x400454cf
 	TUNGETFILTER                         = 0x401054db
 	TUNGETIFF                            = 0x400454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
index 0ce8c7eff..06c0148c1 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1134,6 +1148,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -1985,6 +2013,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x80108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x80108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x541b
 	SIOCOUTQ                             = 0x5411
 	SIOCOUTQNSD                          = 0x894b
@@ -2192,6 +2224,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2411,6 +2444,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x401054d5
 	TUNDETACHFILTER                      = 0x401054d6
+	TUNGETDEVNETNS                       = 0x54e3
 	TUNGETFEATURES                       = 0x800454cf
 	TUNGETFILTER                         = 0x801054db
 	TUNGETIFF                            = 0x800454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index 47675125a..39875095c 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -196,6 +196,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -217,6 +219,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -238,16 +245,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -290,8 +300,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -411,6 +423,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -527,6 +540,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1134,6 +1148,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -2058,6 +2086,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x80108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x80108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x541b
 	SIOCOUTQ                             = 0x5411
 	SIOCOUTQNSD                          = 0x894b
@@ -2265,6 +2297,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2484,6 +2517,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x401054d5
 	TUNDETACHFILTER                      = 0x401054d6
+	TUNGETDEVNETNS                       = 0x54e3
 	TUNGETFEATURES                       = 0x800454cf
 	TUNGETFILTER                         = 0x801054db
 	TUNGETIFF                            = 0x800454d2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
index a46fc9b43..8d80f99bc 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -199,6 +199,8 @@ const (
 	BPF_A                                = 0x10
 	BPF_ABS                              = 0x20
 	BPF_ADD                              = 0x0
+	BPF_ADJ_ROOM_ENCAP_L2_MASK           = 0xff
+	BPF_ADJ_ROOM_ENCAP_L2_SHIFT          = 0x38
 	BPF_ALU                              = 0x4
 	BPF_ALU64                            = 0x7
 	BPF_AND                              = 0x50
@@ -220,6 +222,11 @@ const (
 	BPF_FROM_BE                          = 0x8
 	BPF_FROM_LE                          = 0x0
 	BPF_FS_MAGIC                         = 0xcafe4a11
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV4         = 0x2
+	BPF_F_ADJ_ROOM_ENCAP_L3_IPV6         = 0x4
+	BPF_F_ADJ_ROOM_ENCAP_L4_GRE          = 0x8
+	BPF_F_ADJ_ROOM_ENCAP_L4_UDP          = 0x10
+	BPF_F_ADJ_ROOM_FIXED_GSO             = 0x1
 	BPF_F_ALLOW_MULTI                    = 0x2
 	BPF_F_ALLOW_OVERRIDE                 = 0x1
 	BPF_F_ANY_ALIGNMENT                  = 0x2
@@ -241,16 +248,19 @@ const (
 	BPF_F_PSEUDO_HDR                     = 0x10
 	BPF_F_QUERY_EFFECTIVE                = 0x1
 	BPF_F_RDONLY                         = 0x8
+	BPF_F_RDONLY_PROG                    = 0x80
 	BPF_F_RECOMPUTE_CSUM                 = 0x1
 	BPF_F_REUSE_STACKID                  = 0x400
 	BPF_F_SEQ_NUMBER                     = 0x8
 	BPF_F_SKIP_FIELD_MASK                = 0xff
 	BPF_F_STACK_BUILD_ID                 = 0x20
 	BPF_F_STRICT_ALIGNMENT               = 0x1
+	BPF_F_SYSCTL_BASE_NAME               = 0x1
 	BPF_F_TUNINFO_IPV6                   = 0x1
 	BPF_F_USER_BUILD_ID                  = 0x800
 	BPF_F_USER_STACK                     = 0x100
 	BPF_F_WRONLY                         = 0x10
+	BPF_F_WRONLY_PROG                    = 0x100
 	BPF_F_ZERO_CSUM_TX                   = 0x2
 	BPF_F_ZERO_SEED                      = 0x40
 	BPF_H                                = 0x8
@@ -293,8 +303,10 @@ const (
 	BPF_OR                               = 0x40
 	BPF_PSEUDO_CALL                      = 0x1
 	BPF_PSEUDO_MAP_FD                    = 0x1
+	BPF_PSEUDO_MAP_VALUE                 = 0x2
 	BPF_RET                              = 0x6
 	BPF_RSH                              = 0x70
+	BPF_SK_STORAGE_GET_F_CREATE          = 0x1
 	BPF_SOCK_OPS_ALL_CB_FLAGS            = 0x7
 	BPF_SOCK_OPS_RETRANS_CB_FLAG         = 0x2
 	BPF_SOCK_OPS_RTO_CB_FLAG             = 0x1
@@ -414,6 +426,7 @@ const (
 	CLONE_NEWUTS                         = 0x4000000
 	CLONE_PARENT                         = 0x8000
 	CLONE_PARENT_SETTID                  = 0x100000
+	CLONE_PIDFD                          = 0x1000
 	CLONE_PTRACE                         = 0x2000
 	CLONE_SETTLS                         = 0x80000
 	CLONE_SIGHAND                        = 0x800
@@ -531,6 +544,7 @@ const (
 	ETH_P_DNA_RC                         = 0x6002
 	ETH_P_DNA_RT                         = 0x6003
 	ETH_P_DSA                            = 0x1b
+	ETH_P_DSA_8021Q                      = 0xdadb
 	ETH_P_ECONET                         = 0x18
 	ETH_P_EDSA                           = 0xdada
 	ETH_P_ERSPAN                         = 0x88be
@@ -1138,6 +1152,20 @@ const (
 	LOCK_NB                              = 0x4
 	LOCK_SH                              = 0x1
 	LOCK_UN                              = 0x8
+	LOOP_CLR_FD                          = 0x4c01
+	LOOP_CTL_ADD                         = 0x4c80
+	LOOP_CTL_GET_FREE                    = 0x4c82
+	LOOP_CTL_REMOVE                      = 0x4c81
+	LOOP_GET_STATUS                      = 0x4c03
+	LOOP_GET_STATUS64                    = 0x4c05
+	LOOP_SET_BLOCK_SIZE                  = 0x4c09
+	LOOP_SET_CAPACITY                    = 0x4c07
+	LOOP_SET_DIRECT_IO                   = 0x4c08
+	LOOP_SET_FD                          = 0x4c00
+	LOOP_SET_STATUS                      = 0x4c02
+	LOOP_SET_STATUS64                    = 0x4c04
+	LO_KEY_SIZE                          = 0x20
+	LO_NAME_SIZE                         = 0x40
 	MADV_DODUMP                          = 0x11
 	MADV_DOFORK                          = 0xb
 	MADV_DONTDUMP                        = 0x10
@@ -2050,6 +2078,10 @@ const (
 	SIOCGSKNS                            = 0x894c
 	SIOCGSTAMP                           = 0x8906
 	SIOCGSTAMPNS                         = 0x8907
+	SIOCGSTAMPNS_NEW                     = 0x40108907
+	SIOCGSTAMPNS_OLD                     = 0x8907
+	SIOCGSTAMP_NEW                       = 0x40108906
+	SIOCGSTAMP_OLD                       = 0x8906
 	SIOCINQ                              = 0x4004667f
 	SIOCOUTQ                             = 0x40047473
 	SIOCOUTQNSD                          = 0x894b
@@ -2257,6 +2289,7 @@ const (
 	SYNC_FILE_RANGE_WAIT_AFTER           = 0x4
 	SYNC_FILE_RANGE_WAIT_BEFORE          = 0x1
 	SYNC_FILE_RANGE_WRITE                = 0x2
+	SYNC_FILE_RANGE_WRITE_AND_WAIT       = 0x7
 	SYSFS_MAGIC                          = 0x62656572
 	S_BLKSIZE                            = 0x200
 	S_IEXEC                              = 0x40
@@ -2473,6 +2506,7 @@ const (
 	TS_COMM_LEN                          = 0x20
 	TUNATTACHFILTER                      = 0x801054d5
 	TUNDETACHFILTER                      = 0x801054d6
+	TUNGETDEVNETNS                       = 0x200054e3
 	TUNGETFEATURES                       = 0x400454cf
 	TUNGETFILTER                         = 0x401054db
 	TUNGETIFF                            = 0x400454d2
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index 33b6e4d1a..e869c0603 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -423,4 +423,10 @@ const (
 	SYS_IO_URING_SETUP               = 425
 	SYS_IO_URING_ENTER               = 426
 	SYS_IO_URING_REGISTER            = 427
+	SYS_OPEN_TREE                    = 428
+	SYS_MOVE_MOUNT                   = 429
+	SYS_FSOPEN                       = 430
+	SYS_FSCONFIG                     = 431
+	SYS_FSMOUNT                      = 432
+	SYS_FSPICK                       = 433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index 9ba207847..4917b8ab6 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -345,4 +345,10 @@ const (
 	SYS_IO_URING_SETUP         = 425
 	SYS_IO_URING_ENTER         = 426
 	SYS_IO_URING_REGISTER      = 427
+	SYS_OPEN_TREE              = 428
+	SYS_MOVE_MOUNT             = 429
+	SYS_FSOPEN                 = 430
+	SYS_FSCONFIG               = 431
+	SYS_FSMOUNT                = 432
+	SYS_FSPICK                 = 433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index 94f68f101..f85fcb4f8 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -387,4 +387,10 @@ const (
 	SYS_IO_URING_SETUP               = 425
 	SYS_IO_URING_ENTER               = 426
 	SYS_IO_URING_REGISTER            = 427
+	SYS_OPEN_TREE                    = 428
+	SYS_MOVE_MOUNT                   = 429
+	SYS_FSOPEN                       = 430
+	SYS_FSCONFIG                     = 431
+	SYS_FSMOUNT                      = 432
+	SYS_FSPICK                       = 433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index 15c413516..678a119bc 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -290,4 +290,10 @@ const (
 	SYS_IO_URING_SETUP         = 425
 	SYS_IO_URING_ENTER         = 426
 	SYS_IO_URING_REGISTER      = 427
+	SYS_OPEN_TREE              = 428
+	SYS_MOVE_MOUNT             = 429
+	SYS_FSOPEN                 = 430
+	SYS_FSCONFIG               = 431
+	SYS_FSMOUNT                = 432
+	SYS_FSPICK                 = 433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index 638465b14..222c9f9a2 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -408,4 +408,10 @@ const (
 	SYS_IO_URING_SETUP               = 4425
 	SYS_IO_URING_ENTER               = 4426
 	SYS_IO_URING_REGISTER            = 4427
+	SYS_OPEN_TREE                    = 4428
+	SYS_MOVE_MOUNT                   = 4429
+	SYS_FSOPEN                       = 4430
+	SYS_FSCONFIG                     = 4431
+	SYS_FSMOUNT                      = 4432
+	SYS_FSPICK                       = 4433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 57ec82aac..28e6d0e9d 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -338,4 +338,10 @@ const (
 	SYS_IO_URING_SETUP         = 5425
 	SYS_IO_URING_ENTER         = 5426
 	SYS_IO_URING_REGISTER      = 5427
+	SYS_OPEN_TREE              = 5428
+	SYS_MOVE_MOUNT             = 5429
+	SYS_FSOPEN                 = 5430
+	SYS_FSCONFIG               = 5431
+	SYS_FSMOUNT                = 5432
+	SYS_FSPICK                 = 5433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index 825a3e3b0..e643c6f63 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -338,4 +338,10 @@ const (
 	SYS_IO_URING_SETUP         = 5425
 	SYS_IO_URING_ENTER         = 5426
 	SYS_IO_URING_REGISTER      = 5427
+	SYS_OPEN_TREE              = 5428
+	SYS_MOVE_MOUNT             = 5429
+	SYS_FSOPEN                 = 5430
+	SYS_FSCONFIG               = 5431
+	SYS_FSMOUNT                = 5432
+	SYS_FSPICK                 = 5433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index f152dfdd0..01d93c420 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -408,4 +408,10 @@ const (
 	SYS_IO_URING_SETUP               = 4425
 	SYS_IO_URING_ENTER               = 4426
 	SYS_IO_URING_REGISTER            = 4427
+	SYS_OPEN_TREE                    = 4428
+	SYS_MOVE_MOUNT                   = 4429
+	SYS_FSOPEN                       = 4430
+	SYS_FSCONFIG                     = 4431
+	SYS_FSMOUNT                      = 4432
+	SYS_FSPICK                       = 4433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index 7cbe78b19..5744149eb 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -387,4 +387,10 @@ const (
 	SYS_IO_URING_SETUP         = 425
 	SYS_IO_URING_ENTER         = 426
 	SYS_IO_URING_REGISTER      = 427
+	SYS_OPEN_TREE              = 428
+	SYS_MOVE_MOUNT             = 429
+	SYS_FSOPEN                 = 430
+	SYS_FSCONFIG               = 431
+	SYS_FSMOUNT                = 432
+	SYS_FSPICK                 = 433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index 51a2f1236..21c832042 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -387,4 +387,10 @@ const (
 	SYS_IO_URING_SETUP         = 425
 	SYS_IO_URING_ENTER         = 426
 	SYS_IO_URING_REGISTER      = 427
+	SYS_OPEN_TREE              = 428
+	SYS_MOVE_MOUNT             = 429
+	SYS_FSOPEN                 = 430
+	SYS_FSCONFIG               = 431
+	SYS_FSMOUNT                = 432
+	SYS_FSPICK                 = 433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index 323432ae3..c1bb6d8f2 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -289,4 +289,10 @@ const (
 	SYS_IO_URING_SETUP         = 425
 	SYS_IO_URING_ENTER         = 426
 	SYS_IO_URING_REGISTER      = 427
+	SYS_OPEN_TREE              = 428
+	SYS_MOVE_MOUNT             = 429
+	SYS_FSOPEN                 = 430
+	SYS_FSCONFIG               = 431
+	SYS_FSMOUNT                = 432
+	SYS_FSPICK                 = 433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index 9dca97484..bc3cc6b5b 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -352,4 +352,10 @@ const (
 	SYS_IO_URING_SETUP         = 425
 	SYS_IO_URING_ENTER         = 426
 	SYS_IO_URING_REGISTER      = 427
+	SYS_OPEN_TREE              = 428
+	SYS_MOVE_MOUNT             = 429
+	SYS_FSOPEN                 = 430
+	SYS_FSCONFIG               = 431
+	SYS_FSMOUNT                = 432
+	SYS_FSPICK                 = 433
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index d3da46f0d..0a2841ba8 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -367,4 +367,10 @@ const (
 	SYS_IO_URING_SETUP         = 425
 	SYS_IO_URING_ENTER         = 426
 	SYS_IO_URING_REGISTER      = 427
+	SYS_OPEN_TREE              = 428
+	SYS_MOVE_MOUNT             = 429
+	SYS_FSOPEN                 = 430
+	SYS_FSCONFIG               = 431
+	SYS_FSMOUNT                = 432
+	SYS_FSPICK                 = 433
 )
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
index 5492b9666..50bc4128f 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
@@ -2484,3 +2484,40 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint16
+	Inode            uint32
+	Rdevice          uint16
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]int8
+	Encrypt_key      [32]uint8
+	Init             [2]uint32
+	Reserved         [4]int8
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
index caf33b2c5..055eaa76a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
@@ -2497,3 +2497,41 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]int8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+	Reserved         [4]int8
+	_                [4]byte
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
index 93aec7e22..66019c9cf 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
@@ -2475,3 +2475,40 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint16
+	Inode            uint32
+	Rdevice          uint16
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint32
+	Reserved         [4]uint8
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
index 0a038436d..3104798c4 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
@@ -2476,3 +2476,41 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint32
+	Inode            uint64
+	Rdevice          uint32
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]int8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+	Reserved         [4]int8
+	_                [4]byte
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
index 2de0e5800..46c86021b 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
@@ -2481,3 +2481,40 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint32
+	Inode            uint32
+	Rdevice          uint32
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]int8
+	Encrypt_key      [32]uint8
+	Init             [2]uint32
+	Reserved         [4]int8
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
index 3735eb42e..c2fe1a62a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
@@ -2478,3 +2478,41 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint32
+	Inode            uint64
+	Rdevice          uint32
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]int8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+	Reserved         [4]int8
+	_                [4]byte
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
index 073c29939..f1eb0d397 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
@@ -2478,3 +2478,41 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint32
+	Inode            uint64
+	Rdevice          uint32
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]int8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+	Reserved         [4]int8
+	_                [4]byte
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
index 58d09f75e..8759bc36b 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
@@ -2481,3 +2481,40 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint32
+	Inode            uint32
+	Rdevice          uint32
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]int8
+	Encrypt_key      [32]uint8
+	Init             [2]uint32
+	Reserved         [4]int8
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
index 3f1e62e03..a81200541 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
@@ -2486,3 +2486,41 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+	Reserved         [4]uint8
+	_                [4]byte
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
index e67be11eb..74b7a9199 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
@@ -2486,3 +2486,41 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+	Reserved         [4]uint8
+	_                [4]byte
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
index f44f29403..8344583e7 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
@@ -2503,3 +2503,41 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint32
+	Inode            uint64
+	Rdevice          uint32
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+	Reserved         [4]uint8
+	_                [4]byte
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
index 90bf5dcc7..d8fc0bc1c 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
@@ -2500,3 +2500,41 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint16
+	Inode            uint64
+	Rdevice          uint16
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]int8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+	Reserved         [4]int8
+	_                [4]byte
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
index 4f054dcbb..5e0ab9329 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
@@ -2481,3 +2481,41 @@ const (
 	LINUX_CAPABILITY_VERSION_2 = 0x20071026
 	LINUX_CAPABILITY_VERSION_3 = 0x20080522
 )
+
+const (
+	LO_FLAGS_READ_ONLY = 0x1
+	LO_FLAGS_AUTOCLEAR = 0x4
+	LO_FLAGS_PARTSCAN  = 0x8
+	LO_FLAGS_DIRECT_IO = 0x10
+)
+
+type LoopInfo struct {
+	Number           int32
+	Device           uint32
+	Inode            uint64
+	Rdevice          uint32
+	Offset           int32
+	Encrypt_type     int32
+	Encrypt_key_size int32
+	Flags            int32
+	Name             [64]int8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+	Reserved         [4]int8
+	_                [4]byte
+}
+type LoopInfo64 struct {
+	Device           uint64
+	Inode            uint64
+	Rdevice          uint64
+	Offset           uint64
+	Sizelimit        uint64
+	Number           uint32
+	Encrypt_type     uint32
+	Encrypt_key_size uint32
+	Flags            uint32
+	File_name        [64]uint8
+	Crypt_name       [64]uint8
+	Encrypt_key      [32]uint8
+	Init             [2]uint64
+}
diff --git a/vendor/golang.org/x/sys/windows/service.go b/vendor/golang.org/x/sys/windows/service.go
index 03383f1df..847e00bc9 100644
--- a/vendor/golang.org/x/sys/windows/service.go
+++ b/vendor/golang.org/x/sys/windows/service.go
@@ -159,6 +159,10 @@ type SERVICE_DESCRIPTION struct {
 	Description *uint16
 }
 
+type SERVICE_DELAYED_AUTO_START_INFO struct {
+	IsDelayedAutoStartUp uint32
+}
+
 type SERVICE_STATUS_PROCESS struct {
 	ServiceType             uint32
 	CurrentState            uint32
diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go
index 8a563f92b..1e3947f0f 100644
--- a/vendor/golang.org/x/sys/windows/types_windows.go
+++ b/vendor/golang.org/x/sys/windows/types_windows.go
@@ -197,8 +197,11 @@ const (
 	FILE_MAP_READ    = 0x04
 	FILE_MAP_EXECUTE = 0x20
 
-	CTRL_C_EVENT     = 0
-	CTRL_BREAK_EVENT = 1
+	CTRL_C_EVENT        = 0
+	CTRL_BREAK_EVENT    = 1
+	CTRL_CLOSE_EVENT    = 2
+	CTRL_LOGOFF_EVENT   = 5
+	CTRL_SHUTDOWN_EVENT = 6
 
 	// Windows reserves errors >= 1<<29 for application use.
 	APPLICATION_ERROR = 1 << 29
diff --git a/vendor/golang.org/x/tools/AUTHORS b/vendor/golang.org/x/tools/AUTHORS
new file mode 100644
index 000000000..15167cd74
--- /dev/null
+++ b/vendor/golang.org/x/tools/AUTHORS
@@ -0,0 +1,3 @@
+# This source code refers to The Go Authors for copyright purposes.
+# The master list of authors is in the main Go distribution,
+# visible at http://tip.golang.org/AUTHORS.
diff --git a/vendor/golang.org/x/tools/CONTRIBUTORS b/vendor/golang.org/x/tools/CONTRIBUTORS
new file mode 100644
index 000000000..1c4577e96
--- /dev/null
+++ b/vendor/golang.org/x/tools/CONTRIBUTORS
@@ -0,0 +1,3 @@
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at http://tip.golang.org/CONTRIBUTORS.
diff --git a/vendor/golang.org/x/tools/LICENSE b/vendor/golang.org/x/tools/LICENSE
new file mode 100644
index 000000000..6a66aea5e
--- /dev/null
+++ b/vendor/golang.org/x/tools/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google 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.
diff --git a/vendor/golang.org/x/tools/PATENTS b/vendor/golang.org/x/tools/PATENTS
new file mode 100644
index 000000000..733099041
--- /dev/null
+++ b/vendor/golang.org/x/tools/PATENTS
@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google 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,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
new file mode 100644
index 000000000..98b3987b9
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
@@ -0,0 +1,109 @@
+// Copyright 2016 The Go 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 gcexportdata provides functions for locating, reading, and
+// writing export data files containing type information produced by the
+// gc compiler.  This package supports go1.7 export data format and all
+// later versions.
+//
+// Although it might seem convenient for this package to live alongside
+// go/types in the standard library, this would cause version skew
+// problems for developer tools that use it, since they must be able to
+// consume the outputs of the gc compiler both before and after a Go
+// update such as from Go 1.7 to Go 1.8.  Because this package lives in
+// golang.org/x/tools, sites can update their version of this repo some
+// time before the Go 1.8 release and rebuild and redeploy their
+// developer tools, which will then be able to consume both Go 1.7 and
+// Go 1.8 export data files, so they will work before and after the
+// Go update. (See discussion at https://golang.org/issue/15651.)
+//
+package gcexportdata // import "golang.org/x/tools/go/gcexportdata"
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/token"
+	"go/types"
+	"io"
+	"io/ioutil"
+
+	"golang.org/x/tools/go/internal/gcimporter"
+)
+
+// Find returns the name of an object (.o) or archive (.a) file
+// containing type information for the specified import path,
+// using the workspace layout conventions of go/build.
+// If no file was found, an empty filename is returned.
+//
+// A relative srcDir is interpreted relative to the current working directory.
+//
+// Find also returns the package's resolved (canonical) import path,
+// reflecting the effects of srcDir and vendoring on importPath.
+func Find(importPath, srcDir string) (filename, path string) {
+	return gcimporter.FindPkg(importPath, srcDir)
+}
+
+// NewReader returns a reader for the export data section of an object
+// (.o) or archive (.a) file read from r.  The new reader may provide
+// additional trailing data beyond the end of the export data.
+func NewReader(r io.Reader) (io.Reader, error) {
+	buf := bufio.NewReader(r)
+	_, err := gcimporter.FindExportData(buf)
+	// If we ever switch to a zip-like archive format with the ToC
+	// at the end, we can return the correct portion of export data,
+	// but for now we must return the entire rest of the file.
+	return buf, err
+}
+
+// Read reads export data from in, decodes it, and returns type
+// information for the package.
+// The package name is specified by path.
+// File position information is added to fset.
+//
+// Read may inspect and add to the imports map to ensure that references
+// within the export data to other packages are consistent.  The caller
+// must ensure that imports[path] does not exist, or exists but is
+// incomplete (see types.Package.Complete), and Read inserts the
+// resulting package into this map entry.
+//
+// On return, the state of the reader is undefined.
+func Read(in io.Reader, fset *token.FileSet, imports map[string]*types.Package, path string) (*types.Package, error) {
+	data, err := ioutil.ReadAll(in)
+	if err != nil {
+		return nil, fmt.Errorf("reading export data for %q: %v", path, err)
+	}
+
+	if bytes.HasPrefix(data, []byte("!<arch>")) {
+		return nil, fmt.Errorf("can't read export data for %q directly from an archive file (call gcexportdata.NewReader first to extract export data)", path)
+	}
+
+	// The App Engine Go runtime v1.6 uses the old export data format.
+	// TODO(adonovan): delete once v1.7 has been around for a while.
+	if bytes.HasPrefix(data, []byte("package ")) {
+		return gcimporter.ImportData(imports, path, path, bytes.NewReader(data))
+	}
+
+	// The indexed export format starts with an 'i'; the older
+	// binary export format starts with a 'c', 'd', or 'v'
+	// (from "version"). Select appropriate importer.
+	if len(data) > 0 && data[0] == 'i' {
+		_, pkg, err := gcimporter.IImportData(fset, imports, data[1:], path)
+		return pkg, err
+	}
+
+	_, pkg, err := gcimporter.BImportData(fset, imports, data, path)
+	return pkg, err
+}
+
+// Write writes encoded type information for the specified package to out.
+// The FileSet provides file position information for named objects.
+func Write(out io.Writer, fset *token.FileSet, pkg *types.Package) error {
+	b, err := gcimporter.BExportData(fset, pkg)
+	if err != nil {
+		return err
+	}
+	_, err = out.Write(b)
+	return err
+}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/importer.go b/vendor/golang.org/x/tools/go/gcexportdata/importer.go
new file mode 100644
index 000000000..efe221e7e
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcexportdata/importer.go
@@ -0,0 +1,73 @@
+// Copyright 2016 The Go 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 gcexportdata
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+	"os"
+)
+
+// NewImporter returns a new instance of the types.Importer interface
+// that reads type information from export data files written by gc.
+// The Importer also satisfies types.ImporterFrom.
+//
+// Export data files are located using "go build" workspace conventions
+// and the build.Default context.
+//
+// Use this importer instead of go/importer.For("gc", ...) to avoid the
+// version-skew problems described in the documentation of this package,
+// or to control the FileSet or access the imports map populated during
+// package loading.
+//
+func NewImporter(fset *token.FileSet, imports map[string]*types.Package) types.ImporterFrom {
+	return importer{fset, imports}
+}
+
+type importer struct {
+	fset    *token.FileSet
+	imports map[string]*types.Package
+}
+
+func (imp importer) Import(importPath string) (*types.Package, error) {
+	return imp.ImportFrom(importPath, "", 0)
+}
+
+func (imp importer) ImportFrom(importPath, srcDir string, mode types.ImportMode) (_ *types.Package, err error) {
+	filename, path := Find(importPath, srcDir)
+	if filename == "" {
+		if importPath == "unsafe" {
+			// Even for unsafe, call Find first in case
+			// the package was vendored.
+			return types.Unsafe, nil
+		}
+		return nil, fmt.Errorf("can't find import: %s", importPath)
+	}
+
+	if pkg, ok := imp.imports[path]; ok && pkg.Complete() {
+		return pkg, nil // cache hit
+	}
+
+	// open file
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		f.Close()
+		if err != nil {
+			// add file name to error
+			err = fmt.Errorf("reading export data: %s: %v", filename, err)
+		}
+	}()
+
+	r, err := NewReader(f)
+	if err != nil {
+		return nil, err
+	}
+
+	return Read(r, imp.fset, imp.imports, path)
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gcimporter/bexport.go b/vendor/golang.org/x/tools/go/internal/gcimporter/bexport.go
new file mode 100644
index 000000000..a807d0aaa
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/bexport.go
@@ -0,0 +1,852 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Binary package export.
+// This file was derived from $GOROOT/src/cmd/compile/internal/gc/bexport.go;
+// see that file for specification of the format.
+
+package gcimporter
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"go/ast"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"math"
+	"math/big"
+	"sort"
+	"strings"
+)
+
+// If debugFormat is set, each integer and string value is preceded by a marker
+// and position information in the encoding. This mechanism permits an importer
+// to recognize immediately when it is out of sync. The importer recognizes this
+// mode automatically (i.e., it can import export data produced with debugging
+// support even if debugFormat is not set at the time of import). This mode will
+// lead to massively larger export data (by a factor of 2 to 3) and should only
+// be enabled during development and debugging.
+//
+// NOTE: This flag is the first flag to enable if importing dies because of
+// (suspected) format errors, and whenever a change is made to the format.
+const debugFormat = false // default: false
+
+// If trace is set, debugging output is printed to std out.
+const trace = false // default: false
+
+// Current export format version. Increase with each format change.
+// Note: The latest binary (non-indexed) export format is at version 6.
+//       This exporter is still at level 4, but it doesn't matter since
+//       the binary importer can handle older versions just fine.
+// 6: package height (CL 105038) -- NOT IMPLEMENTED HERE
+// 5: improved position encoding efficiency (issue 20080, CL 41619) -- NOT IMPLEMEMTED HERE
+// 4: type name objects support type aliases, uses aliasTag
+// 3: Go1.8 encoding (same as version 2, aliasTag defined but never used)
+// 2: removed unused bool in ODCL export (compiler only)
+// 1: header format change (more regular), export package for _ struct fields
+// 0: Go1.7 encoding
+const exportVersion = 4
+
+// trackAllTypes enables cycle tracking for all types, not just named
+// types. The existing compiler invariants assume that unnamed types
+// that are not completely set up are not used, or else there are spurious
+// errors.
+// If disabled, only named types are tracked, possibly leading to slightly
+// less efficient encoding in rare cases. It also prevents the export of
+// some corner-case type declarations (but those are not handled correctly
+// with with the textual export format either).
+// TODO(gri) enable and remove once issues caused by it are fixed
+const trackAllTypes = false
+
+type exporter struct {
+	fset *token.FileSet
+	out  bytes.Buffer
+
+	// object -> index maps, indexed in order of serialization
+	strIndex map[string]int
+	pkgIndex map[*types.Package]int
+	typIndex map[types.Type]int
+
+	// position encoding
+	posInfoFormat bool
+	prevFile      string
+	prevLine      int
+
+	// debugging support
+	written int // bytes written
+	indent  int // for trace
+}
+
+// internalError represents an error generated inside this package.
+type internalError string
+
+func (e internalError) Error() string { return "gcimporter: " + string(e) }
+
+func internalErrorf(format string, args ...interface{}) error {
+	return internalError(fmt.Sprintf(format, args...))
+}
+
+// BExportData returns binary export data for pkg.
+// If no file set is provided, position info will be missing.
+func BExportData(fset *token.FileSet, pkg *types.Package) (b []byte, err error) {
+	defer func() {
+		if e := recover(); e != nil {
+			if ierr, ok := e.(internalError); ok {
+				err = ierr
+				return
+			}
+			// Not an internal error; panic again.
+			panic(e)
+		}
+	}()
+
+	p := exporter{
+		fset:          fset,
+		strIndex:      map[string]int{"": 0}, // empty string is mapped to 0
+		pkgIndex:      make(map[*types.Package]int),
+		typIndex:      make(map[types.Type]int),
+		posInfoFormat: true, // TODO(gri) might become a flag, eventually
+	}
+
+	// write version info
+	// The version string must start with "version %d" where %d is the version
+	// number. Additional debugging information may follow after a blank; that
+	// text is ignored by the importer.
+	p.rawStringln(fmt.Sprintf("version %d", exportVersion))
+	var debug string
+	if debugFormat {
+		debug = "debug"
+	}
+	p.rawStringln(debug) // cannot use p.bool since it's affected by debugFormat; also want to see this clearly
+	p.bool(trackAllTypes)
+	p.bool(p.posInfoFormat)
+
+	// --- generic export data ---
+
+	// populate type map with predeclared "known" types
+	for index, typ := range predeclared() {
+		p.typIndex[typ] = index
+	}
+	if len(p.typIndex) != len(predeclared()) {
+		return nil, internalError("duplicate entries in type map?")
+	}
+
+	// write package data
+	p.pkg(pkg, true)
+	if trace {
+		p.tracef("\n")
+	}
+
+	// write objects
+	objcount := 0
+	scope := pkg.Scope()
+	for _, name := range scope.Names() {
+		if !ast.IsExported(name) {
+			continue
+		}
+		if trace {
+			p.tracef("\n")
+		}
+		p.obj(scope.Lookup(name))
+		objcount++
+	}
+
+	// indicate end of list
+	if trace {
+		p.tracef("\n")
+	}
+	p.tag(endTag)
+
+	// for self-verification only (redundant)
+	p.int(objcount)
+
+	if trace {
+		p.tracef("\n")
+	}
+
+	// --- end of export data ---
+
+	return p.out.Bytes(), nil
+}
+
+func (p *exporter) pkg(pkg *types.Package, emptypath bool) {
+	if pkg == nil {
+		panic(internalError("unexpected nil pkg"))
+	}
+
+	// if we saw the package before, write its index (>= 0)
+	if i, ok := p.pkgIndex[pkg]; ok {
+		p.index('P', i)
+		return
+	}
+
+	// otherwise, remember the package, write the package tag (< 0) and package data
+	if trace {
+		p.tracef("P%d = { ", len(p.pkgIndex))
+		defer p.tracef("} ")
+	}
+	p.pkgIndex[pkg] = len(p.pkgIndex)
+
+	p.tag(packageTag)
+	p.string(pkg.Name())
+	if emptypath {
+		p.string("")
+	} else {
+		p.string(pkg.Path())
+	}
+}
+
+func (p *exporter) obj(obj types.Object) {
+	switch obj := obj.(type) {
+	case *types.Const:
+		p.tag(constTag)
+		p.pos(obj)
+		p.qualifiedName(obj)
+		p.typ(obj.Type())
+		p.value(obj.Val())
+
+	case *types.TypeName:
+		if obj.IsAlias() {
+			p.tag(aliasTag)
+			p.pos(obj)
+			p.qualifiedName(obj)
+		} else {
+			p.tag(typeTag)
+		}
+		p.typ(obj.Type())
+
+	case *types.Var:
+		p.tag(varTag)
+		p.pos(obj)
+		p.qualifiedName(obj)
+		p.typ(obj.Type())
+
+	case *types.Func:
+		p.tag(funcTag)
+		p.pos(obj)
+		p.qualifiedName(obj)
+		sig := obj.Type().(*types.Signature)
+		p.paramList(sig.Params(), sig.Variadic())
+		p.paramList(sig.Results(), false)
+
+	default:
+		panic(internalErrorf("unexpected object %v (%T)", obj, obj))
+	}
+}
+
+func (p *exporter) pos(obj types.Object) {
+	if !p.posInfoFormat {
+		return
+	}
+
+	file, line := p.fileLine(obj)
+	if file == p.prevFile {
+		// common case: write line delta
+		// delta == 0 means different file or no line change
+		delta := line - p.prevLine
+		p.int(delta)
+		if delta == 0 {
+			p.int(-1) // -1 means no file change
+		}
+	} else {
+		// different file
+		p.int(0)
+		// Encode filename as length of common prefix with previous
+		// filename, followed by (possibly empty) suffix. Filenames
+		// frequently share path prefixes, so this can save a lot
+		// of space and make export data size less dependent on file
+		// path length. The suffix is unlikely to be empty because
+		// file names tend to end in ".go".
+		n := commonPrefixLen(p.prevFile, file)
+		p.int(n)           // n >= 0
+		p.string(file[n:]) // write suffix only
+		p.prevFile = file
+		p.int(line)
+	}
+	p.prevLine = line
+}
+
+func (p *exporter) fileLine(obj types.Object) (file string, line int) {
+	if p.fset != nil {
+		pos := p.fset.Position(obj.Pos())
+		file = pos.Filename
+		line = pos.Line
+	}
+	return
+}
+
+func commonPrefixLen(a, b string) int {
+	if len(a) > len(b) {
+		a, b = b, a
+	}
+	// len(a) <= len(b)
+	i := 0
+	for i < len(a) && a[i] == b[i] {
+		i++
+	}
+	return i
+}
+
+func (p *exporter) qualifiedName(obj types.Object) {
+	p.string(obj.Name())
+	p.pkg(obj.Pkg(), false)
+}
+
+func (p *exporter) typ(t types.Type) {
+	if t == nil {
+		panic(internalError("nil type"))
+	}
+
+	// Possible optimization: Anonymous pointer types *T where
+	// T is a named type are common. We could canonicalize all
+	// such types *T to a single type PT = *T. This would lead
+	// to at most one *T entry in typIndex, and all future *T's
+	// would be encoded as the respective index directly. Would
+	// save 1 byte (pointerTag) per *T and reduce the typIndex
+	// size (at the cost of a canonicalization map). We can do
+	// this later, without encoding format change.
+
+	// if we saw the type before, write its index (>= 0)
+	if i, ok := p.typIndex[t]; ok {
+		p.index('T', i)
+		return
+	}
+
+	// otherwise, remember the type, write the type tag (< 0) and type data
+	if trackAllTypes {
+		if trace {
+			p.tracef("T%d = {>\n", len(p.typIndex))
+			defer p.tracef("<\n} ")
+		}
+		p.typIndex[t] = len(p.typIndex)
+	}
+
+	switch t := t.(type) {
+	case *types.Named:
+		if !trackAllTypes {
+			// if we don't track all types, track named types now
+			p.typIndex[t] = len(p.typIndex)
+		}
+
+		p.tag(namedTag)
+		p.pos(t.Obj())
+		p.qualifiedName(t.Obj())
+		p.typ(t.Underlying())
+		if !types.IsInterface(t) {
+			p.assocMethods(t)
+		}
+
+	case *types.Array:
+		p.tag(arrayTag)
+		p.int64(t.Len())
+		p.typ(t.Elem())
+
+	case *types.Slice:
+		p.tag(sliceTag)
+		p.typ(t.Elem())
+
+	case *dddSlice:
+		p.tag(dddTag)
+		p.typ(t.elem)
+
+	case *types.Struct:
+		p.tag(structTag)
+		p.fieldList(t)
+
+	case *types.Pointer:
+		p.tag(pointerTag)
+		p.typ(t.Elem())
+
+	case *types.Signature:
+		p.tag(signatureTag)
+		p.paramList(t.Params(), t.Variadic())
+		p.paramList(t.Results(), false)
+
+	case *types.Interface:
+		p.tag(interfaceTag)
+		p.iface(t)
+
+	case *types.Map:
+		p.tag(mapTag)
+		p.typ(t.Key())
+		p.typ(t.Elem())
+
+	case *types.Chan:
+		p.tag(chanTag)
+		p.int(int(3 - t.Dir())) // hack
+		p.typ(t.Elem())
+
+	default:
+		panic(internalErrorf("unexpected type %T: %s", t, t))
+	}
+}
+
+func (p *exporter) assocMethods(named *types.Named) {
+	// Sort methods (for determinism).
+	var methods []*types.Func
+	for i := 0; i < named.NumMethods(); i++ {
+		methods = append(methods, named.Method(i))
+	}
+	sort.Sort(methodsByName(methods))
+
+	p.int(len(methods))
+
+	if trace && methods != nil {
+		p.tracef("associated methods {>\n")
+	}
+
+	for i, m := range methods {
+		if trace && i > 0 {
+			p.tracef("\n")
+		}
+
+		p.pos(m)
+		name := m.Name()
+		p.string(name)
+		if !exported(name) {
+			p.pkg(m.Pkg(), false)
+		}
+
+		sig := m.Type().(*types.Signature)
+		p.paramList(types.NewTuple(sig.Recv()), false)
+		p.paramList(sig.Params(), sig.Variadic())
+		p.paramList(sig.Results(), false)
+		p.int(0) // dummy value for go:nointerface pragma - ignored by importer
+	}
+
+	if trace && methods != nil {
+		p.tracef("<\n} ")
+	}
+}
+
+type methodsByName []*types.Func
+
+func (x methodsByName) Len() int           { return len(x) }
+func (x methodsByName) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+func (x methodsByName) Less(i, j int) bool { return x[i].Name() < x[j].Name() }
+
+func (p *exporter) fieldList(t *types.Struct) {
+	if trace && t.NumFields() > 0 {
+		p.tracef("fields {>\n")
+		defer p.tracef("<\n} ")
+	}
+
+	p.int(t.NumFields())
+	for i := 0; i < t.NumFields(); i++ {
+		if trace && i > 0 {
+			p.tracef("\n")
+		}
+		p.field(t.Field(i))
+		p.string(t.Tag(i))
+	}
+}
+
+func (p *exporter) field(f *types.Var) {
+	if !f.IsField() {
+		panic(internalError("field expected"))
+	}
+
+	p.pos(f)
+	p.fieldName(f)
+	p.typ(f.Type())
+}
+
+func (p *exporter) iface(t *types.Interface) {
+	// TODO(gri): enable importer to load embedded interfaces,
+	// then emit Embeddeds and ExplicitMethods separately here.
+	p.int(0)
+
+	n := t.NumMethods()
+	if trace && n > 0 {
+		p.tracef("methods {>\n")
+		defer p.tracef("<\n} ")
+	}
+	p.int(n)
+	for i := 0; i < n; i++ {
+		if trace && i > 0 {
+			p.tracef("\n")
+		}
+		p.method(t.Method(i))
+	}
+}
+
+func (p *exporter) method(m *types.Func) {
+	sig := m.Type().(*types.Signature)
+	if sig.Recv() == nil {
+		panic(internalError("method expected"))
+	}
+
+	p.pos(m)
+	p.string(m.Name())
+	if m.Name() != "_" && !ast.IsExported(m.Name()) {
+		p.pkg(m.Pkg(), false)
+	}
+
+	// interface method; no need to encode receiver.
+	p.paramList(sig.Params(), sig.Variadic())
+	p.paramList(sig.Results(), false)
+}
+
+func (p *exporter) fieldName(f *types.Var) {
+	name := f.Name()
+
+	if f.Anonymous() {
+		// anonymous field - we distinguish between 3 cases:
+		// 1) field name matches base type name and is exported
+		// 2) field name matches base type name and is not exported
+		// 3) field name doesn't match base type name (alias name)
+		bname := basetypeName(f.Type())
+		if name == bname {
+			if ast.IsExported(name) {
+				name = "" // 1) we don't need to know the field name or package
+			} else {
+				name = "?" // 2) use unexported name "?" to force package export
+			}
+		} else {
+			// 3) indicate alias and export name as is
+			// (this requires an extra "@" but this is a rare case)
+			p.string("@")
+		}
+	}
+
+	p.string(name)
+	if name != "" && !ast.IsExported(name) {
+		p.pkg(f.Pkg(), false)
+	}
+}
+
+func basetypeName(typ types.Type) string {
+	switch typ := deref(typ).(type) {
+	case *types.Basic:
+		return typ.Name()
+	case *types.Named:
+		return typ.Obj().Name()
+	default:
+		return "" // unnamed type
+	}
+}
+
+func (p *exporter) paramList(params *types.Tuple, variadic bool) {
+	// use negative length to indicate unnamed parameters
+	// (look at the first parameter only since either all
+	// names are present or all are absent)
+	n := params.Len()
+	if n > 0 && params.At(0).Name() == "" {
+		n = -n
+	}
+	p.int(n)
+	for i := 0; i < params.Len(); i++ {
+		q := params.At(i)
+		t := q.Type()
+		if variadic && i == params.Len()-1 {
+			t = &dddSlice{t.(*types.Slice).Elem()}
+		}
+		p.typ(t)
+		if n > 0 {
+			name := q.Name()
+			p.string(name)
+			if name != "_" {
+				p.pkg(q.Pkg(), false)
+			}
+		}
+		p.string("") // no compiler-specific info
+	}
+}
+
+func (p *exporter) value(x constant.Value) {
+	if trace {
+		p.tracef("= ")
+	}
+
+	switch x.Kind() {
+	case constant.Bool:
+		tag := falseTag
+		if constant.BoolVal(x) {
+			tag = trueTag
+		}
+		p.tag(tag)
+
+	case constant.Int:
+		if v, exact := constant.Int64Val(x); exact {
+			// common case: x fits into an int64 - use compact encoding
+			p.tag(int64Tag)
+			p.int64(v)
+			return
+		}
+		// uncommon case: large x - use float encoding
+		// (powers of 2 will be encoded efficiently with exponent)
+		p.tag(floatTag)
+		p.float(constant.ToFloat(x))
+
+	case constant.Float:
+		p.tag(floatTag)
+		p.float(x)
+
+	case constant.Complex:
+		p.tag(complexTag)
+		p.float(constant.Real(x))
+		p.float(constant.Imag(x))
+
+	case constant.String:
+		p.tag(stringTag)
+		p.string(constant.StringVal(x))
+
+	case constant.Unknown:
+		// package contains type errors
+		p.tag(unknownTag)
+
+	default:
+		panic(internalErrorf("unexpected value %v (%T)", x, x))
+	}
+}
+
+func (p *exporter) float(x constant.Value) {
+	if x.Kind() != constant.Float {
+		panic(internalErrorf("unexpected constant %v, want float", x))
+	}
+	// extract sign (there is no -0)
+	sign := constant.Sign(x)
+	if sign == 0 {
+		// x == 0
+		p.int(0)
+		return
+	}
+	// x != 0
+
+	var f big.Float
+	if v, exact := constant.Float64Val(x); exact {
+		// float64
+		f.SetFloat64(v)
+	} else if num, denom := constant.Num(x), constant.Denom(x); num.Kind() == constant.Int {
+		// TODO(gri): add big.Rat accessor to constant.Value.
+		r := valueToRat(num)
+		f.SetRat(r.Quo(r, valueToRat(denom)))
+	} else {
+		// Value too large to represent as a fraction => inaccessible.
+		// TODO(gri): add big.Float accessor to constant.Value.
+		f.SetFloat64(math.MaxFloat64) // FIXME
+	}
+
+	// extract exponent such that 0.5 <= m < 1.0
+	var m big.Float
+	exp := f.MantExp(&m)
+
+	// extract mantissa as *big.Int
+	// - set exponent large enough so mant satisfies mant.IsInt()
+	// - get *big.Int from mant
+	m.SetMantExp(&m, int(m.MinPrec()))
+	mant, acc := m.Int(nil)
+	if acc != big.Exact {
+		panic(internalError("internal error"))
+	}
+
+	p.int(sign)
+	p.int(exp)
+	p.string(string(mant.Bytes()))
+}
+
+func valueToRat(x constant.Value) *big.Rat {
+	// Convert little-endian to big-endian.
+	// I can't believe this is necessary.
+	bytes := constant.Bytes(x)
+	for i := 0; i < len(bytes)/2; i++ {
+		bytes[i], bytes[len(bytes)-1-i] = bytes[len(bytes)-1-i], bytes[i]
+	}
+	return new(big.Rat).SetInt(new(big.Int).SetBytes(bytes))
+}
+
+func (p *exporter) bool(b bool) bool {
+	if trace {
+		p.tracef("[")
+		defer p.tracef("= %v] ", b)
+	}
+
+	x := 0
+	if b {
+		x = 1
+	}
+	p.int(x)
+	return b
+}
+
+// ----------------------------------------------------------------------------
+// Low-level encoders
+
+func (p *exporter) index(marker byte, index int) {
+	if index < 0 {
+		panic(internalError("invalid index < 0"))
+	}
+	if debugFormat {
+		p.marker('t')
+	}
+	if trace {
+		p.tracef("%c%d ", marker, index)
+	}
+	p.rawInt64(int64(index))
+}
+
+func (p *exporter) tag(tag int) {
+	if tag >= 0 {
+		panic(internalError("invalid tag >= 0"))
+	}
+	if debugFormat {
+		p.marker('t')
+	}
+	if trace {
+		p.tracef("%s ", tagString[-tag])
+	}
+	p.rawInt64(int64(tag))
+}
+
+func (p *exporter) int(x int) {
+	p.int64(int64(x))
+}
+
+func (p *exporter) int64(x int64) {
+	if debugFormat {
+		p.marker('i')
+	}
+	if trace {
+		p.tracef("%d ", x)
+	}
+	p.rawInt64(x)
+}
+
+func (p *exporter) string(s string) {
+	if debugFormat {
+		p.marker('s')
+	}
+	if trace {
+		p.tracef("%q ", s)
+	}
+	// if we saw the string before, write its index (>= 0)
+	// (the empty string is mapped to 0)
+	if i, ok := p.strIndex[s]; ok {
+		p.rawInt64(int64(i))
+		return
+	}
+	// otherwise, remember string and write its negative length and bytes
+	p.strIndex[s] = len(p.strIndex)
+	p.rawInt64(-int64(len(s)))
+	for i := 0; i < len(s); i++ {
+		p.rawByte(s[i])
+	}
+}
+
+// marker emits a marker byte and position information which makes
+// it easy for a reader to detect if it is "out of sync". Used for
+// debugFormat format only.
+func (p *exporter) marker(m byte) {
+	p.rawByte(m)
+	// Enable this for help tracking down the location
+	// of an incorrect marker when running in debugFormat.
+	if false && trace {
+		p.tracef("#%d ", p.written)
+	}
+	p.rawInt64(int64(p.written))
+}
+
+// rawInt64 should only be used by low-level encoders.
+func (p *exporter) rawInt64(x int64) {
+	var tmp [binary.MaxVarintLen64]byte
+	n := binary.PutVarint(tmp[:], x)
+	for i := 0; i < n; i++ {
+		p.rawByte(tmp[i])
+	}
+}
+
+// rawStringln should only be used to emit the initial version string.
+func (p *exporter) rawStringln(s string) {
+	for i := 0; i < len(s); i++ {
+		p.rawByte(s[i])
+	}
+	p.rawByte('\n')
+}
+
+// rawByte is the bottleneck interface to write to p.out.
+// rawByte escapes b as follows (any encoding does that
+// hides '$'):
+//
+//	'$'  => '|' 'S'
+//	'|'  => '|' '|'
+//
+// Necessary so other tools can find the end of the
+// export data by searching for "$$".
+// rawByte should only be used by low-level encoders.
+func (p *exporter) rawByte(b byte) {
+	switch b {
+	case '$':
+		// write '$' as '|' 'S'
+		b = 'S'
+		fallthrough
+	case '|':
+		// write '|' as '|' '|'
+		p.out.WriteByte('|')
+		p.written++
+	}
+	p.out.WriteByte(b)
+	p.written++
+}
+
+// tracef is like fmt.Printf but it rewrites the format string
+// to take care of indentation.
+func (p *exporter) tracef(format string, args ...interface{}) {
+	if strings.ContainsAny(format, "<>\n") {
+		var buf bytes.Buffer
+		for i := 0; i < len(format); i++ {
+			// no need to deal with runes
+			ch := format[i]
+			switch ch {
+			case '>':
+				p.indent++
+				continue
+			case '<':
+				p.indent--
+				continue
+			}
+			buf.WriteByte(ch)
+			if ch == '\n' {
+				for j := p.indent; j > 0; j-- {
+					buf.WriteString(".  ")
+				}
+			}
+		}
+		format = buf.String()
+	}
+	fmt.Printf(format, args...)
+}
+
+// Debugging support.
+// (tagString is only used when tracing is enabled)
+var tagString = [...]string{
+	// Packages
+	-packageTag: "package",
+
+	// Types
+	-namedTag:     "named type",
+	-arrayTag:     "array",
+	-sliceTag:     "slice",
+	-dddTag:       "ddd",
+	-structTag:    "struct",
+	-pointerTag:   "pointer",
+	-signatureTag: "signature",
+	-interfaceTag: "interface",
+	-mapTag:       "map",
+	-chanTag:      "chan",
+
+	// Values
+	-falseTag:    "false",
+	-trueTag:     "true",
+	-int64Tag:    "int64",
+	-floatTag:    "float",
+	-fractionTag: "fraction",
+	-complexTag:  "complex",
+	-stringTag:   "string",
+	-unknownTag:  "unknown",
+
+	// Type aliases
+	-aliasTag: "alias",
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gcimporter/bimport.go b/vendor/golang.org/x/tools/go/internal/gcimporter/bimport.go
new file mode 100644
index 000000000..e3c310782
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/bimport.go
@@ -0,0 +1,1036 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/bimport.go.
+
+package gcimporter
+
+import (
+	"encoding/binary"
+	"fmt"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode"
+	"unicode/utf8"
+)
+
+type importer struct {
+	imports    map[string]*types.Package
+	data       []byte
+	importpath string
+	buf        []byte // for reading strings
+	version    int    // export format version
+
+	// object lists
+	strList       []string           // in order of appearance
+	pathList      []string           // in order of appearance
+	pkgList       []*types.Package   // in order of appearance
+	typList       []types.Type       // in order of appearance
+	interfaceList []*types.Interface // for delayed completion only
+	trackAllTypes bool
+
+	// position encoding
+	posInfoFormat bool
+	prevFile      string
+	prevLine      int
+	fake          fakeFileSet
+
+	// debugging support
+	debugFormat bool
+	read        int // bytes read
+}
+
+// BImportData imports a package from the serialized package data
+// and returns the number of bytes consumed and a reference to the package.
+// If the export data version is not recognized or the format is otherwise
+// compromised, an error is returned.
+func BImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
+	// catch panics and return them as errors
+	const currentVersion = 6
+	version := -1 // unknown version
+	defer func() {
+		if e := recover(); e != nil {
+			// Return a (possibly nil or incomplete) package unchanged (see #16088).
+			if version > currentVersion {
+				err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
+			} else {
+				err = fmt.Errorf("cannot import %q (%v), possibly version skew - reinstall package", path, e)
+			}
+		}
+	}()
+
+	p := importer{
+		imports:    imports,
+		data:       data,
+		importpath: path,
+		version:    version,
+		strList:    []string{""}, // empty string is mapped to 0
+		pathList:   []string{""}, // empty string is mapped to 0
+		fake: fakeFileSet{
+			fset:  fset,
+			files: make(map[string]*token.File),
+		},
+	}
+
+	// read version info
+	var versionstr string
+	if b := p.rawByte(); b == 'c' || b == 'd' {
+		// Go1.7 encoding; first byte encodes low-level
+		// encoding format (compact vs debug).
+		// For backward-compatibility only (avoid problems with
+		// old installed packages). Newly compiled packages use
+		// the extensible format string.
+		// TODO(gri) Remove this support eventually; after Go1.8.
+		if b == 'd' {
+			p.debugFormat = true
+		}
+		p.trackAllTypes = p.rawByte() == 'a'
+		p.posInfoFormat = p.int() != 0
+		versionstr = p.string()
+		if versionstr == "v1" {
+			version = 0
+		}
+	} else {
+		// Go1.8 extensible encoding
+		// read version string and extract version number (ignore anything after the version number)
+		versionstr = p.rawStringln(b)
+		if s := strings.SplitN(versionstr, " ", 3); len(s) >= 2 && s[0] == "version" {
+			if v, err := strconv.Atoi(s[1]); err == nil && v > 0 {
+				version = v
+			}
+		}
+	}
+	p.version = version
+
+	// read version specific flags - extend as necessary
+	switch p.version {
+	// case currentVersion:
+	// 	...
+	//	fallthrough
+	case currentVersion, 5, 4, 3, 2, 1:
+		p.debugFormat = p.rawStringln(p.rawByte()) == "debug"
+		p.trackAllTypes = p.int() != 0
+		p.posInfoFormat = p.int() != 0
+	case 0:
+		// Go1.7 encoding format - nothing to do here
+	default:
+		errorf("unknown bexport format version %d (%q)", p.version, versionstr)
+	}
+
+	// --- generic export data ---
+
+	// populate typList with predeclared "known" types
+	p.typList = append(p.typList, predeclared()...)
+
+	// read package data
+	pkg = p.pkg()
+
+	// read objects of phase 1 only (see cmd/compile/internal/gc/bexport.go)
+	objcount := 0
+	for {
+		tag := p.tagOrIndex()
+		if tag == endTag {
+			break
+		}
+		p.obj(tag)
+		objcount++
+	}
+
+	// self-verification
+	if count := p.int(); count != objcount {
+		errorf("got %d objects; want %d", objcount, count)
+	}
+
+	// ignore compiler-specific import data
+
+	// complete interfaces
+	// TODO(gri) re-investigate if we still need to do this in a delayed fashion
+	for _, typ := range p.interfaceList {
+		typ.Complete()
+	}
+
+	// record all referenced packages as imports
+	list := append(([]*types.Package)(nil), p.pkgList[1:]...)
+	sort.Sort(byPath(list))
+	pkg.SetImports(list)
+
+	// package was imported completely and without errors
+	pkg.MarkComplete()
+
+	return p.read, pkg, nil
+}
+
+func errorf(format string, args ...interface{}) {
+	panic(fmt.Sprintf(format, args...))
+}
+
+func (p *importer) pkg() *types.Package {
+	// if the package was seen before, i is its index (>= 0)
+	i := p.tagOrIndex()
+	if i >= 0 {
+		return p.pkgList[i]
+	}
+
+	// otherwise, i is the package tag (< 0)
+	if i != packageTag {
+		errorf("unexpected package tag %d version %d", i, p.version)
+	}
+
+	// read package data
+	name := p.string()
+	var path string
+	if p.version >= 5 {
+		path = p.path()
+	} else {
+		path = p.string()
+	}
+	if p.version >= 6 {
+		p.int() // package height; unused by go/types
+	}
+
+	// we should never see an empty package name
+	if name == "" {
+		errorf("empty package name in import")
+	}
+
+	// an empty path denotes the package we are currently importing;
+	// it must be the first package we see
+	if (path == "") != (len(p.pkgList) == 0) {
+		errorf("package path %q for pkg index %d", path, len(p.pkgList))
+	}
+
+	// if the package was imported before, use that one; otherwise create a new one
+	if path == "" {
+		path = p.importpath
+	}
+	pkg := p.imports[path]
+	if pkg == nil {
+		pkg = types.NewPackage(path, name)
+		p.imports[path] = pkg
+	} else if pkg.Name() != name {
+		errorf("conflicting names %s and %s for package %q", pkg.Name(), name, path)
+	}
+	p.pkgList = append(p.pkgList, pkg)
+
+	return pkg
+}
+
+// objTag returns the tag value for each object kind.
+func objTag(obj types.Object) int {
+	switch obj.(type) {
+	case *types.Const:
+		return constTag
+	case *types.TypeName:
+		return typeTag
+	case *types.Var:
+		return varTag
+	case *types.Func:
+		return funcTag
+	default:
+		errorf("unexpected object: %v (%T)", obj, obj) // panics
+		panic("unreachable")
+	}
+}
+
+func sameObj(a, b types.Object) bool {
+	// Because unnamed types are not canonicalized, we cannot simply compare types for
+	// (pointer) identity.
+	// Ideally we'd check equality of constant values as well, but this is good enough.
+	return objTag(a) == objTag(b) && types.Identical(a.Type(), b.Type())
+}
+
+func (p *importer) declare(obj types.Object) {
+	pkg := obj.Pkg()
+	if alt := pkg.Scope().Insert(obj); alt != nil {
+		// This can only trigger if we import a (non-type) object a second time.
+		// Excluding type aliases, this cannot happen because 1) we only import a package
+		// once; and b) we ignore compiler-specific export data which may contain
+		// functions whose inlined function bodies refer to other functions that
+		// were already imported.
+		// However, type aliases require reexporting the original type, so we need
+		// to allow it (see also the comment in cmd/compile/internal/gc/bimport.go,
+		// method importer.obj, switch case importing functions).
+		// TODO(gri) review/update this comment once the gc compiler handles type aliases.
+		if !sameObj(obj, alt) {
+			errorf("inconsistent import:\n\t%v\npreviously imported as:\n\t%v\n", obj, alt)
+		}
+	}
+}
+
+func (p *importer) obj(tag int) {
+	switch tag {
+	case constTag:
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		typ := p.typ(nil, nil)
+		val := p.value()
+		p.declare(types.NewConst(pos, pkg, name, typ, val))
+
+	case aliasTag:
+		// TODO(gri) verify type alias hookup is correct
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		typ := p.typ(nil, nil)
+		p.declare(types.NewTypeName(pos, pkg, name, typ))
+
+	case typeTag:
+		p.typ(nil, nil)
+
+	case varTag:
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		typ := p.typ(nil, nil)
+		p.declare(types.NewVar(pos, pkg, name, typ))
+
+	case funcTag:
+		pos := p.pos()
+		pkg, name := p.qualifiedName()
+		params, isddd := p.paramList()
+		result, _ := p.paramList()
+		sig := types.NewSignature(nil, params, result, isddd)
+		p.declare(types.NewFunc(pos, pkg, name, sig))
+
+	default:
+		errorf("unexpected object tag %d", tag)
+	}
+}
+
+const deltaNewFile = -64 // see cmd/compile/internal/gc/bexport.go
+
+func (p *importer) pos() token.Pos {
+	if !p.posInfoFormat {
+		return token.NoPos
+	}
+
+	file := p.prevFile
+	line := p.prevLine
+	delta := p.int()
+	line += delta
+	if p.version >= 5 {
+		if delta == deltaNewFile {
+			if n := p.int(); n >= 0 {
+				// file changed
+				file = p.path()
+				line = n
+			}
+		}
+	} else {
+		if delta == 0 {
+			if n := p.int(); n >= 0 {
+				// file changed
+				file = p.prevFile[:n] + p.string()
+				line = p.int()
+			}
+		}
+	}
+	p.prevFile = file
+	p.prevLine = line
+
+	return p.fake.pos(file, line)
+}
+
+// Synthesize a token.Pos
+type fakeFileSet struct {
+	fset  *token.FileSet
+	files map[string]*token.File
+}
+
+func (s *fakeFileSet) pos(file string, line int) token.Pos {
+	// Since we don't know the set of needed file positions, we
+	// reserve maxlines positions per file.
+	const maxlines = 64 * 1024
+	f := s.files[file]
+	if f == nil {
+		f = s.fset.AddFile(file, -1, maxlines)
+		s.files[file] = f
+		// Allocate the fake linebreak indices on first use.
+		// TODO(adonovan): opt: save ~512KB using a more complex scheme?
+		fakeLinesOnce.Do(func() {
+			fakeLines = make([]int, maxlines)
+			for i := range fakeLines {
+				fakeLines[i] = i
+			}
+		})
+		f.SetLines(fakeLines)
+	}
+
+	if line > maxlines {
+		line = 1
+	}
+
+	// Treat the file as if it contained only newlines
+	// and column=1: use the line number as the offset.
+	return f.Pos(line - 1)
+}
+
+var (
+	fakeLines     []int
+	fakeLinesOnce sync.Once
+)
+
+func (p *importer) qualifiedName() (pkg *types.Package, name string) {
+	name = p.string()
+	pkg = p.pkg()
+	return
+}
+
+func (p *importer) record(t types.Type) {
+	p.typList = append(p.typList, t)
+}
+
+// A dddSlice is a types.Type representing ...T parameters.
+// It only appears for parameter types and does not escape
+// the importer.
+type dddSlice struct {
+	elem types.Type
+}
+
+func (t *dddSlice) Underlying() types.Type { return t }
+func (t *dddSlice) String() string         { return "..." + t.elem.String() }
+
+// parent is the package which declared the type; parent == nil means
+// the package currently imported. The parent package is needed for
+// exported struct fields and interface methods which don't contain
+// explicit package information in the export data.
+//
+// A non-nil tname is used as the "owner" of the result type; i.e.,
+// the result type is the underlying type of tname. tname is used
+// to give interface methods a named receiver type where possible.
+func (p *importer) typ(parent *types.Package, tname *types.Named) types.Type {
+	// if the type was seen before, i is its index (>= 0)
+	i := p.tagOrIndex()
+	if i >= 0 {
+		return p.typList[i]
+	}
+
+	// otherwise, i is the type tag (< 0)
+	switch i {
+	case namedTag:
+		// read type object
+		pos := p.pos()
+		parent, name := p.qualifiedName()
+		scope := parent.Scope()
+		obj := scope.Lookup(name)
+
+		// if the object doesn't exist yet, create and insert it
+		if obj == nil {
+			obj = types.NewTypeName(pos, parent, name, nil)
+			scope.Insert(obj)
+		}
+
+		if _, ok := obj.(*types.TypeName); !ok {
+			errorf("pkg = %s, name = %s => %s", parent, name, obj)
+		}
+
+		// associate new named type with obj if it doesn't exist yet
+		t0 := types.NewNamed(obj.(*types.TypeName), nil, nil)
+
+		// but record the existing type, if any
+		tname := obj.Type().(*types.Named) // tname is either t0 or the existing type
+		p.record(tname)
+
+		// read underlying type
+		t0.SetUnderlying(p.typ(parent, t0))
+
+		// interfaces don't have associated methods
+		if types.IsInterface(t0) {
+			return tname
+		}
+
+		// read associated methods
+		for i := p.int(); i > 0; i-- {
+			// TODO(gri) replace this with something closer to fieldName
+			pos := p.pos()
+			name := p.string()
+			if !exported(name) {
+				p.pkg()
+			}
+
+			recv, _ := p.paramList() // TODO(gri) do we need a full param list for the receiver?
+			params, isddd := p.paramList()
+			result, _ := p.paramList()
+			p.int() // go:nointerface pragma - discarded
+
+			sig := types.NewSignature(recv.At(0), params, result, isddd)
+			t0.AddMethod(types.NewFunc(pos, parent, name, sig))
+		}
+
+		return tname
+
+	case arrayTag:
+		t := new(types.Array)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		n := p.int64()
+		*t = *types.NewArray(p.typ(parent, nil), n)
+		return t
+
+	case sliceTag:
+		t := new(types.Slice)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		*t = *types.NewSlice(p.typ(parent, nil))
+		return t
+
+	case dddTag:
+		t := new(dddSlice)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		t.elem = p.typ(parent, nil)
+		return t
+
+	case structTag:
+		t := new(types.Struct)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		*t = *types.NewStruct(p.fieldList(parent))
+		return t
+
+	case pointerTag:
+		t := new(types.Pointer)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		*t = *types.NewPointer(p.typ(parent, nil))
+		return t
+
+	case signatureTag:
+		t := new(types.Signature)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		params, isddd := p.paramList()
+		result, _ := p.paramList()
+		*t = *types.NewSignature(nil, params, result, isddd)
+		return t
+
+	case interfaceTag:
+		// Create a dummy entry in the type list. This is safe because we
+		// cannot expect the interface type to appear in a cycle, as any
+		// such cycle must contain a named type which would have been
+		// first defined earlier.
+		// TODO(gri) Is this still true now that we have type aliases?
+		// See issue #23225.
+		n := len(p.typList)
+		if p.trackAllTypes {
+			p.record(nil)
+		}
+
+		var embeddeds []types.Type
+		for n := p.int(); n > 0; n-- {
+			p.pos()
+			embeddeds = append(embeddeds, p.typ(parent, nil))
+		}
+
+		t := newInterface(p.methodList(parent, tname), embeddeds)
+		p.interfaceList = append(p.interfaceList, t)
+		if p.trackAllTypes {
+			p.typList[n] = t
+		}
+		return t
+
+	case mapTag:
+		t := new(types.Map)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		key := p.typ(parent, nil)
+		val := p.typ(parent, nil)
+		*t = *types.NewMap(key, val)
+		return t
+
+	case chanTag:
+		t := new(types.Chan)
+		if p.trackAllTypes {
+			p.record(t)
+		}
+
+		dir := chanDir(p.int())
+		val := p.typ(parent, nil)
+		*t = *types.NewChan(dir, val)
+		return t
+
+	default:
+		errorf("unexpected type tag %d", i) // panics
+		panic("unreachable")
+	}
+}
+
+func chanDir(d int) types.ChanDir {
+	// tag values must match the constants in cmd/compile/internal/gc/go.go
+	switch d {
+	case 1 /* Crecv */ :
+		return types.RecvOnly
+	case 2 /* Csend */ :
+		return types.SendOnly
+	case 3 /* Cboth */ :
+		return types.SendRecv
+	default:
+		errorf("unexpected channel dir %d", d)
+		return 0
+	}
+}
+
+func (p *importer) fieldList(parent *types.Package) (fields []*types.Var, tags []string) {
+	if n := p.int(); n > 0 {
+		fields = make([]*types.Var, n)
+		tags = make([]string, n)
+		for i := range fields {
+			fields[i], tags[i] = p.field(parent)
+		}
+	}
+	return
+}
+
+func (p *importer) field(parent *types.Package) (*types.Var, string) {
+	pos := p.pos()
+	pkg, name, alias := p.fieldName(parent)
+	typ := p.typ(parent, nil)
+	tag := p.string()
+
+	anonymous := false
+	if name == "" {
+		// anonymous field - typ must be T or *T and T must be a type name
+		switch typ := deref(typ).(type) {
+		case *types.Basic: // basic types are named types
+			pkg = nil // // objects defined in Universe scope have no package
+			name = typ.Name()
+		case *types.Named:
+			name = typ.Obj().Name()
+		default:
+			errorf("named base type expected")
+		}
+		anonymous = true
+	} else if alias {
+		// anonymous field: we have an explicit name because it's an alias
+		anonymous = true
+	}
+
+	return types.NewField(pos, pkg, name, typ, anonymous), tag
+}
+
+func (p *importer) methodList(parent *types.Package, baseType *types.Named) (methods []*types.Func) {
+	if n := p.int(); n > 0 {
+		methods = make([]*types.Func, n)
+		for i := range methods {
+			methods[i] = p.method(parent, baseType)
+		}
+	}
+	return
+}
+
+func (p *importer) method(parent *types.Package, baseType *types.Named) *types.Func {
+	pos := p.pos()
+	pkg, name, _ := p.fieldName(parent)
+	// If we don't have a baseType, use a nil receiver.
+	// A receiver using the actual interface type (which
+	// we don't know yet) will be filled in when we call
+	// types.Interface.Complete.
+	var recv *types.Var
+	if baseType != nil {
+		recv = types.NewVar(token.NoPos, parent, "", baseType)
+	}
+	params, isddd := p.paramList()
+	result, _ := p.paramList()
+	sig := types.NewSignature(recv, params, result, isddd)
+	return types.NewFunc(pos, pkg, name, sig)
+}
+
+func (p *importer) fieldName(parent *types.Package) (pkg *types.Package, name string, alias bool) {
+	name = p.string()
+	pkg = parent
+	if pkg == nil {
+		// use the imported package instead
+		pkg = p.pkgList[0]
+	}
+	if p.version == 0 && name == "_" {
+		// version 0 didn't export a package for _ fields
+		return
+	}
+	switch name {
+	case "":
+		// 1) field name matches base type name and is exported: nothing to do
+	case "?":
+		// 2) field name matches base type name and is not exported: need package
+		name = ""
+		pkg = p.pkg()
+	case "@":
+		// 3) field name doesn't match type name (alias)
+		name = p.string()
+		alias = true
+		fallthrough
+	default:
+		if !exported(name) {
+			pkg = p.pkg()
+		}
+	}
+	return
+}
+
+func (p *importer) paramList() (*types.Tuple, bool) {
+	n := p.int()
+	if n == 0 {
+		return nil, false
+	}
+	// negative length indicates unnamed parameters
+	named := true
+	if n < 0 {
+		n = -n
+		named = false
+	}
+	// n > 0
+	params := make([]*types.Var, n)
+	isddd := false
+	for i := range params {
+		params[i], isddd = p.param(named)
+	}
+	return types.NewTuple(params...), isddd
+}
+
+func (p *importer) param(named bool) (*types.Var, bool) {
+	t := p.typ(nil, nil)
+	td, isddd := t.(*dddSlice)
+	if isddd {
+		t = types.NewSlice(td.elem)
+	}
+
+	var pkg *types.Package
+	var name string
+	if named {
+		name = p.string()
+		if name == "" {
+			errorf("expected named parameter")
+		}
+		if name != "_" {
+			pkg = p.pkg()
+		}
+		if i := strings.Index(name, "·"); i > 0 {
+			name = name[:i] // cut off gc-specific parameter numbering
+		}
+	}
+
+	// read and discard compiler-specific info
+	p.string()
+
+	return types.NewVar(token.NoPos, pkg, name, t), isddd
+}
+
+func exported(name string) bool {
+	ch, _ := utf8.DecodeRuneInString(name)
+	return unicode.IsUpper(ch)
+}
+
+func (p *importer) value() constant.Value {
+	switch tag := p.tagOrIndex(); tag {
+	case falseTag:
+		return constant.MakeBool(false)
+	case trueTag:
+		return constant.MakeBool(true)
+	case int64Tag:
+		return constant.MakeInt64(p.int64())
+	case floatTag:
+		return p.float()
+	case complexTag:
+		re := p.float()
+		im := p.float()
+		return constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+	case stringTag:
+		return constant.MakeString(p.string())
+	case unknownTag:
+		return constant.MakeUnknown()
+	default:
+		errorf("unexpected value tag %d", tag) // panics
+		panic("unreachable")
+	}
+}
+
+func (p *importer) float() constant.Value {
+	sign := p.int()
+	if sign == 0 {
+		return constant.MakeInt64(0)
+	}
+
+	exp := p.int()
+	mant := []byte(p.string()) // big endian
+
+	// remove leading 0's if any
+	for len(mant) > 0 && mant[0] == 0 {
+		mant = mant[1:]
+	}
+
+	// convert to little endian
+	// TODO(gri) go/constant should have a more direct conversion function
+	//           (e.g., once it supports a big.Float based implementation)
+	for i, j := 0, len(mant)-1; i < j; i, j = i+1, j-1 {
+		mant[i], mant[j] = mant[j], mant[i]
+	}
+
+	// adjust exponent (constant.MakeFromBytes creates an integer value,
+	// but mant represents the mantissa bits such that 0.5 <= mant < 1.0)
+	exp -= len(mant) << 3
+	if len(mant) > 0 {
+		for msd := mant[len(mant)-1]; msd&0x80 == 0; msd <<= 1 {
+			exp++
+		}
+	}
+
+	x := constant.MakeFromBytes(mant)
+	switch {
+	case exp < 0:
+		d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
+		x = constant.BinaryOp(x, token.QUO, d)
+	case exp > 0:
+		x = constant.Shift(x, token.SHL, uint(exp))
+	}
+
+	if sign < 0 {
+		x = constant.UnaryOp(token.SUB, x, 0)
+	}
+	return x
+}
+
+// ----------------------------------------------------------------------------
+// Low-level decoders
+
+func (p *importer) tagOrIndex() int {
+	if p.debugFormat {
+		p.marker('t')
+	}
+
+	return int(p.rawInt64())
+}
+
+func (p *importer) int() int {
+	x := p.int64()
+	if int64(int(x)) != x {
+		errorf("exported integer too large")
+	}
+	return int(x)
+}
+
+func (p *importer) int64() int64 {
+	if p.debugFormat {
+		p.marker('i')
+	}
+
+	return p.rawInt64()
+}
+
+func (p *importer) path() string {
+	if p.debugFormat {
+		p.marker('p')
+	}
+	// if the path was seen before, i is its index (>= 0)
+	// (the empty string is at index 0)
+	i := p.rawInt64()
+	if i >= 0 {
+		return p.pathList[i]
+	}
+	// otherwise, i is the negative path length (< 0)
+	a := make([]string, -i)
+	for n := range a {
+		a[n] = p.string()
+	}
+	s := strings.Join(a, "/")
+	p.pathList = append(p.pathList, s)
+	return s
+}
+
+func (p *importer) string() string {
+	if p.debugFormat {
+		p.marker('s')
+	}
+	// if the string was seen before, i is its index (>= 0)
+	// (the empty string is at index 0)
+	i := p.rawInt64()
+	if i >= 0 {
+		return p.strList[i]
+	}
+	// otherwise, i is the negative string length (< 0)
+	if n := int(-i); n <= cap(p.buf) {
+		p.buf = p.buf[:n]
+	} else {
+		p.buf = make([]byte, n)
+	}
+	for i := range p.buf {
+		p.buf[i] = p.rawByte()
+	}
+	s := string(p.buf)
+	p.strList = append(p.strList, s)
+	return s
+}
+
+func (p *importer) marker(want byte) {
+	if got := p.rawByte(); got != want {
+		errorf("incorrect marker: got %c; want %c (pos = %d)", got, want, p.read)
+	}
+
+	pos := p.read
+	if n := int(p.rawInt64()); n != pos {
+		errorf("incorrect position: got %d; want %d", n, pos)
+	}
+}
+
+// rawInt64 should only be used by low-level decoders.
+func (p *importer) rawInt64() int64 {
+	i, err := binary.ReadVarint(p)
+	if err != nil {
+		errorf("read error: %v", err)
+	}
+	return i
+}
+
+// rawStringln should only be used to read the initial version string.
+func (p *importer) rawStringln(b byte) string {
+	p.buf = p.buf[:0]
+	for b != '\n' {
+		p.buf = append(p.buf, b)
+		b = p.rawByte()
+	}
+	return string(p.buf)
+}
+
+// needed for binary.ReadVarint in rawInt64
+func (p *importer) ReadByte() (byte, error) {
+	return p.rawByte(), nil
+}
+
+// byte is the bottleneck interface for reading p.data.
+// It unescapes '|' 'S' to '$' and '|' '|' to '|'.
+// rawByte should only be used by low-level decoders.
+func (p *importer) rawByte() byte {
+	b := p.data[0]
+	r := 1
+	if b == '|' {
+		b = p.data[1]
+		r = 2
+		switch b {
+		case 'S':
+			b = '$'
+		case '|':
+			// nothing to do
+		default:
+			errorf("unexpected escape sequence in export data")
+		}
+	}
+	p.data = p.data[r:]
+	p.read += r
+	return b
+
+}
+
+// ----------------------------------------------------------------------------
+// Export format
+
+// Tags. Must be < 0.
+const (
+	// Objects
+	packageTag = -(iota + 1)
+	constTag
+	typeTag
+	varTag
+	funcTag
+	endTag
+
+	// Types
+	namedTag
+	arrayTag
+	sliceTag
+	dddTag
+	structTag
+	pointerTag
+	signatureTag
+	interfaceTag
+	mapTag
+	chanTag
+
+	// Values
+	falseTag
+	trueTag
+	int64Tag
+	floatTag
+	fractionTag // not used by gc
+	complexTag
+	stringTag
+	nilTag     // only used by gc (appears in exported inlined function bodies)
+	unknownTag // not used by gc (only appears in packages with errors)
+
+	// Type aliases
+	aliasTag
+)
+
+var predecl []types.Type // initialized lazily
+
+func predeclared() []types.Type {
+	if predecl == nil {
+		// initialize lazily to be sure that all
+		// elements have been initialized before
+		predecl = []types.Type{ // basic types
+			types.Typ[types.Bool],
+			types.Typ[types.Int],
+			types.Typ[types.Int8],
+			types.Typ[types.Int16],
+			types.Typ[types.Int32],
+			types.Typ[types.Int64],
+			types.Typ[types.Uint],
+			types.Typ[types.Uint8],
+			types.Typ[types.Uint16],
+			types.Typ[types.Uint32],
+			types.Typ[types.Uint64],
+			types.Typ[types.Uintptr],
+			types.Typ[types.Float32],
+			types.Typ[types.Float64],
+			types.Typ[types.Complex64],
+			types.Typ[types.Complex128],
+			types.Typ[types.String],
+
+			// basic type aliases
+			types.Universe.Lookup("byte").Type(),
+			types.Universe.Lookup("rune").Type(),
+
+			// error
+			types.Universe.Lookup("error").Type(),
+
+			// untyped types
+			types.Typ[types.UntypedBool],
+			types.Typ[types.UntypedInt],
+			types.Typ[types.UntypedRune],
+			types.Typ[types.UntypedFloat],
+			types.Typ[types.UntypedComplex],
+			types.Typ[types.UntypedString],
+			types.Typ[types.UntypedNil],
+
+			// package unsafe
+			types.Typ[types.UnsafePointer],
+
+			// invalid type
+			types.Typ[types.Invalid], // only appears in packages with errors
+
+			// used internally by gc; never used by this package or in .a files
+			anyType{},
+		}
+	}
+	return predecl
+}
+
+type anyType struct{}
+
+func (t anyType) Underlying() types.Type { return t }
+func (t anyType) String() string         { return "any" }
diff --git a/vendor/golang.org/x/tools/go/internal/gcimporter/exportdata.go b/vendor/golang.org/x/tools/go/internal/gcimporter/exportdata.go
new file mode 100644
index 000000000..f33dc5613
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/exportdata.go
@@ -0,0 +1,93 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/exportdata.go.
+
+// This file implements FindExportData.
+
+package gcimporter
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+func readGopackHeader(r *bufio.Reader) (name string, size int, err error) {
+	// See $GOROOT/include/ar.h.
+	hdr := make([]byte, 16+12+6+6+8+10+2)
+	_, err = io.ReadFull(r, hdr)
+	if err != nil {
+		return
+	}
+	// leave for debugging
+	if false {
+		fmt.Printf("header: %s", hdr)
+	}
+	s := strings.TrimSpace(string(hdr[16+12+6+6+8:][:10]))
+	size, err = strconv.Atoi(s)
+	if err != nil || hdr[len(hdr)-2] != '`' || hdr[len(hdr)-1] != '\n' {
+		err = fmt.Errorf("invalid archive header")
+		return
+	}
+	name = strings.TrimSpace(string(hdr[:16]))
+	return
+}
+
+// FindExportData positions the reader r at the beginning of the
+// export data section of an underlying GC-created object/archive
+// file by reading from it. The reader must be positioned at the
+// start of the file before calling this function. The hdr result
+// is the string before the export data, either "$$" or "$$B".
+//
+func FindExportData(r *bufio.Reader) (hdr string, err error) {
+	// Read first line to make sure this is an object file.
+	line, err := r.ReadSlice('\n')
+	if err != nil {
+		err = fmt.Errorf("can't find export data (%v)", err)
+		return
+	}
+
+	if string(line) == "!<arch>\n" {
+		// Archive file. Scan to __.PKGDEF.
+		var name string
+		if name, _, err = readGopackHeader(r); err != nil {
+			return
+		}
+
+		// First entry should be __.PKGDEF.
+		if name != "__.PKGDEF" {
+			err = fmt.Errorf("go archive is missing __.PKGDEF")
+			return
+		}
+
+		// Read first line of __.PKGDEF data, so that line
+		// is once again the first line of the input.
+		if line, err = r.ReadSlice('\n'); err != nil {
+			err = fmt.Errorf("can't find export data (%v)", err)
+			return
+		}
+	}
+
+	// Now at __.PKGDEF in archive or still at beginning of file.
+	// Either way, line should begin with "go object ".
+	if !strings.HasPrefix(string(line), "go object ") {
+		err = fmt.Errorf("not a Go object file")
+		return
+	}
+
+	// Skip over object header to export data.
+	// Begins after first line starting with $$.
+	for line[0] != '$' {
+		if line, err = r.ReadSlice('\n'); err != nil {
+			err = fmt.Errorf("can't find export data (%v)", err)
+			return
+		}
+	}
+	hdr = string(line)
+
+	return
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gcimporter/gcimporter.go b/vendor/golang.org/x/tools/go/internal/gcimporter/gcimporter.go
new file mode 100644
index 000000000..9cf186605
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/gcimporter.go
@@ -0,0 +1,1078 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is a modified copy of $GOROOT/src/go/internal/gcimporter/gcimporter.go,
+// but it also contains the original source-based importer code for Go1.6.
+// Once we stop supporting 1.6, we can remove that code.
+
+// Package gcimporter provides various functions for reading
+// gc-generated object files that can be used to implement the
+// Importer interface defined by the Go 1.5 standard library package.
+package gcimporter // import "golang.org/x/tools/go/internal/gcimporter"
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"go/build"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"text/scanner"
+)
+
+// debugging/development support
+const debug = false
+
+var pkgExts = [...]string{".a", ".o"}
+
+// FindPkg returns the filename and unique package id for an import
+// path based on package information provided by build.Import (using
+// the build.Default build.Context). A relative srcDir is interpreted
+// relative to the current working directory.
+// If no file was found, an empty filename is returned.
+//
+func FindPkg(path, srcDir string) (filename, id string) {
+	if path == "" {
+		return
+	}
+
+	var noext string
+	switch {
+	default:
+		// "x" -> "$GOPATH/pkg/$GOOS_$GOARCH/x.ext", "x"
+		// Don't require the source files to be present.
+		if abs, err := filepath.Abs(srcDir); err == nil { // see issue 14282
+			srcDir = abs
+		}
+		bp, _ := build.Import(path, srcDir, build.FindOnly|build.AllowBinary)
+		if bp.PkgObj == "" {
+			id = path // make sure we have an id to print in error message
+			return
+		}
+		noext = strings.TrimSuffix(bp.PkgObj, ".a")
+		id = bp.ImportPath
+
+	case build.IsLocalImport(path):
+		// "./x" -> "/this/directory/x.ext", "/this/directory/x"
+		noext = filepath.Join(srcDir, path)
+		id = noext
+
+	case filepath.IsAbs(path):
+		// for completeness only - go/build.Import
+		// does not support absolute imports
+		// "/x" -> "/x.ext", "/x"
+		noext = path
+		id = path
+	}
+
+	if false { // for debugging
+		if path != id {
+			fmt.Printf("%s -> %s\n", path, id)
+		}
+	}
+
+	// try extensions
+	for _, ext := range pkgExts {
+		filename = noext + ext
+		if f, err := os.Stat(filename); err == nil && !f.IsDir() {
+			return
+		}
+	}
+
+	filename = "" // not found
+	return
+}
+
+// ImportData imports a package by reading the gc-generated export data,
+// adds the corresponding package object to the packages map indexed by id,
+// and returns the object.
+//
+// The packages map must contains all packages already imported. The data
+// reader position must be the beginning of the export data section. The
+// filename is only used in error messages.
+//
+// If packages[id] contains the completely imported package, that package
+// can be used directly, and there is no need to call this function (but
+// there is also no harm but for extra time used).
+//
+func ImportData(packages map[string]*types.Package, filename, id string, data io.Reader) (pkg *types.Package, err error) {
+	// support for parser error handling
+	defer func() {
+		switch r := recover().(type) {
+		case nil:
+			// nothing to do
+		case importError:
+			err = r
+		default:
+			panic(r) // internal error
+		}
+	}()
+
+	var p parser
+	p.init(filename, id, data, packages)
+	pkg = p.parseExport()
+
+	return
+}
+
+// Import imports a gc-generated package given its import path and srcDir, adds
+// the corresponding package object to the packages map, and returns the object.
+// The packages map must contain all packages already imported.
+//
+func Import(packages map[string]*types.Package, path, srcDir string, lookup func(path string) (io.ReadCloser, error)) (pkg *types.Package, err error) {
+	var rc io.ReadCloser
+	var filename, id string
+	if lookup != nil {
+		// With custom lookup specified, assume that caller has
+		// converted path to a canonical import path for use in the map.
+		if path == "unsafe" {
+			return types.Unsafe, nil
+		}
+		id = path
+
+		// No need to re-import if the package was imported completely before.
+		if pkg = packages[id]; pkg != nil && pkg.Complete() {
+			return
+		}
+		f, err := lookup(path)
+		if err != nil {
+			return nil, err
+		}
+		rc = f
+	} else {
+		filename, id = FindPkg(path, srcDir)
+		if filename == "" {
+			if path == "unsafe" {
+				return types.Unsafe, nil
+			}
+			return nil, fmt.Errorf("can't find import: %q", id)
+		}
+
+		// no need to re-import if the package was imported completely before
+		if pkg = packages[id]; pkg != nil && pkg.Complete() {
+			return
+		}
+
+		// open file
+		f, err := os.Open(filename)
+		if err != nil {
+			return nil, err
+		}
+		defer func() {
+			if err != nil {
+				// add file name to error
+				err = fmt.Errorf("%s: %v", filename, err)
+			}
+		}()
+		rc = f
+	}
+	defer rc.Close()
+
+	var hdr string
+	buf := bufio.NewReader(rc)
+	if hdr, err = FindExportData(buf); err != nil {
+		return
+	}
+
+	switch hdr {
+	case "$$\n":
+		// Work-around if we don't have a filename; happens only if lookup != nil.
+		// Either way, the filename is only needed for importer error messages, so
+		// this is fine.
+		if filename == "" {
+			filename = path
+		}
+		return ImportData(packages, filename, id, buf)
+
+	case "$$B\n":
+		var data []byte
+		data, err = ioutil.ReadAll(buf)
+		if err != nil {
+			break
+		}
+
+		// TODO(gri): allow clients of go/importer to provide a FileSet.
+		// Or, define a new standard go/types/gcexportdata package.
+		fset := token.NewFileSet()
+
+		// The indexed export format starts with an 'i'; the older
+		// binary export format starts with a 'c', 'd', or 'v'
+		// (from "version"). Select appropriate importer.
+		if len(data) > 0 && data[0] == 'i' {
+			_, pkg, err = IImportData(fset, packages, data[1:], id)
+		} else {
+			_, pkg, err = BImportData(fset, packages, data, id)
+		}
+
+	default:
+		err = fmt.Errorf("unknown export data header: %q", hdr)
+	}
+
+	return
+}
+
+// ----------------------------------------------------------------------------
+// Parser
+
+// TODO(gri) Imported objects don't have position information.
+//           Ideally use the debug table line info; alternatively
+//           create some fake position (or the position of the
+//           import). That way error messages referring to imported
+//           objects can print meaningful information.
+
+// parser parses the exports inside a gc compiler-produced
+// object/archive file and populates its scope with the results.
+type parser struct {
+	scanner    scanner.Scanner
+	tok        rune                      // current token
+	lit        string                    // literal string; only valid for Ident, Int, String tokens
+	id         string                    // package id of imported package
+	sharedPkgs map[string]*types.Package // package id -> package object (across importer)
+	localPkgs  map[string]*types.Package // package id -> package object (just this package)
+}
+
+func (p *parser) init(filename, id string, src io.Reader, packages map[string]*types.Package) {
+	p.scanner.Init(src)
+	p.scanner.Error = func(_ *scanner.Scanner, msg string) { p.error(msg) }
+	p.scanner.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanChars | scanner.ScanStrings | scanner.ScanComments | scanner.SkipComments
+	p.scanner.Whitespace = 1<<'\t' | 1<<' '
+	p.scanner.Filename = filename // for good error messages
+	p.next()
+	p.id = id
+	p.sharedPkgs = packages
+	if debug {
+		// check consistency of packages map
+		for _, pkg := range packages {
+			if pkg.Name() == "" {
+				fmt.Printf("no package name for %s\n", pkg.Path())
+			}
+		}
+	}
+}
+
+func (p *parser) next() {
+	p.tok = p.scanner.Scan()
+	switch p.tok {
+	case scanner.Ident, scanner.Int, scanner.Char, scanner.String, '·':
+		p.lit = p.scanner.TokenText()
+	default:
+		p.lit = ""
+	}
+	if debug {
+		fmt.Printf("%s: %q -> %q\n", scanner.TokenString(p.tok), p.scanner.TokenText(), p.lit)
+	}
+}
+
+func declTypeName(pkg *types.Package, name string) *types.TypeName {
+	scope := pkg.Scope()
+	if obj := scope.Lookup(name); obj != nil {
+		return obj.(*types.TypeName)
+	}
+	obj := types.NewTypeName(token.NoPos, pkg, name, nil)
+	// a named type may be referred to before the underlying type
+	// is known - set it up
+	types.NewNamed(obj, nil, nil)
+	scope.Insert(obj)
+	return obj
+}
+
+// ----------------------------------------------------------------------------
+// Error handling
+
+// Internal errors are boxed as importErrors.
+type importError struct {
+	pos scanner.Position
+	err error
+}
+
+func (e importError) Error() string {
+	return fmt.Sprintf("import error %s (byte offset = %d): %s", e.pos, e.pos.Offset, e.err)
+}
+
+func (p *parser) error(err interface{}) {
+	if s, ok := err.(string); ok {
+		err = errors.New(s)
+	}
+	// panic with a runtime.Error if err is not an error
+	panic(importError{p.scanner.Pos(), err.(error)})
+}
+
+func (p *parser) errorf(format string, args ...interface{}) {
+	p.error(fmt.Sprintf(format, args...))
+}
+
+func (p *parser) expect(tok rune) string {
+	lit := p.lit
+	if p.tok != tok {
+		p.errorf("expected %s, got %s (%s)", scanner.TokenString(tok), scanner.TokenString(p.tok), lit)
+	}
+	p.next()
+	return lit
+}
+
+func (p *parser) expectSpecial(tok string) {
+	sep := 'x' // not white space
+	i := 0
+	for i < len(tok) && p.tok == rune(tok[i]) && sep > ' ' {
+		sep = p.scanner.Peek() // if sep <= ' ', there is white space before the next token
+		p.next()
+		i++
+	}
+	if i < len(tok) {
+		p.errorf("expected %q, got %q", tok, tok[0:i])
+	}
+}
+
+func (p *parser) expectKeyword(keyword string) {
+	lit := p.expect(scanner.Ident)
+	if lit != keyword {
+		p.errorf("expected keyword %s, got %q", keyword, lit)
+	}
+}
+
+// ----------------------------------------------------------------------------
+// Qualified and unqualified names
+
+// PackageId = string_lit .
+//
+func (p *parser) parsePackageId() string {
+	id, err := strconv.Unquote(p.expect(scanner.String))
+	if err != nil {
+		p.error(err)
+	}
+	// id == "" stands for the imported package id
+	// (only known at time of package installation)
+	if id == "" {
+		id = p.id
+	}
+	return id
+}
+
+// PackageName = ident .
+//
+func (p *parser) parsePackageName() string {
+	return p.expect(scanner.Ident)
+}
+
+// dotIdentifier = ( ident | '·' ) { ident | int | '·' } .
+func (p *parser) parseDotIdent() string {
+	ident := ""
+	if p.tok != scanner.Int {
+		sep := 'x' // not white space
+		for (p.tok == scanner.Ident || p.tok == scanner.Int || p.tok == '·') && sep > ' ' {
+			ident += p.lit
+			sep = p.scanner.Peek() // if sep <= ' ', there is white space before the next token
+			p.next()
+		}
+	}
+	if ident == "" {
+		p.expect(scanner.Ident) // use expect() for error handling
+	}
+	return ident
+}
+
+// QualifiedName = "@" PackageId "." ( "?" | dotIdentifier ) .
+//
+func (p *parser) parseQualifiedName() (id, name string) {
+	p.expect('@')
+	id = p.parsePackageId()
+	p.expect('.')
+	// Per rev f280b8a485fd (10/2/2013), qualified names may be used for anonymous fields.
+	if p.tok == '?' {
+		p.next()
+	} else {
+		name = p.parseDotIdent()
+	}
+	return
+}
+
+// getPkg returns the package for a given id. If the package is
+// not found, create the package and add it to the p.localPkgs
+// and p.sharedPkgs maps. name is the (expected) name of the
+// package. If name == "", the package name is expected to be
+// set later via an import clause in the export data.
+//
+// id identifies a package, usually by a canonical package path like
+// "encoding/json" but possibly by a non-canonical import path like
+// "./json".
+//
+func (p *parser) getPkg(id, name string) *types.Package {
+	// package unsafe is not in the packages maps - handle explicitly
+	if id == "unsafe" {
+		return types.Unsafe
+	}
+
+	pkg := p.localPkgs[id]
+	if pkg == nil {
+		// first import of id from this package
+		pkg = p.sharedPkgs[id]
+		if pkg == nil {
+			// first import of id by this importer;
+			// add (possibly unnamed) pkg to shared packages
+			pkg = types.NewPackage(id, name)
+			p.sharedPkgs[id] = pkg
+		}
+		// add (possibly unnamed) pkg to local packages
+		if p.localPkgs == nil {
+			p.localPkgs = make(map[string]*types.Package)
+		}
+		p.localPkgs[id] = pkg
+	} else if name != "" {
+		// package exists already and we have an expected package name;
+		// make sure names match or set package name if necessary
+		if pname := pkg.Name(); pname == "" {
+			pkg.SetName(name)
+		} else if pname != name {
+			p.errorf("%s package name mismatch: %s (given) vs %s (expected)", id, pname, name)
+		}
+	}
+	return pkg
+}
+
+// parseExportedName is like parseQualifiedName, but
+// the package id is resolved to an imported *types.Package.
+//
+func (p *parser) parseExportedName() (pkg *types.Package, name string) {
+	id, name := p.parseQualifiedName()
+	pkg = p.getPkg(id, "")
+	return
+}
+
+// ----------------------------------------------------------------------------
+// Types
+
+// BasicType = identifier .
+//
+func (p *parser) parseBasicType() types.Type {
+	id := p.expect(scanner.Ident)
+	obj := types.Universe.Lookup(id)
+	if obj, ok := obj.(*types.TypeName); ok {
+		return obj.Type()
+	}
+	p.errorf("not a basic type: %s", id)
+	return nil
+}
+
+// ArrayType = "[" int_lit "]" Type .
+//
+func (p *parser) parseArrayType(parent *types.Package) types.Type {
+	// "[" already consumed and lookahead known not to be "]"
+	lit := p.expect(scanner.Int)
+	p.expect(']')
+	elem := p.parseType(parent)
+	n, err := strconv.ParseInt(lit, 10, 64)
+	if err != nil {
+		p.error(err)
+	}
+	return types.NewArray(elem, n)
+}
+
+// MapType = "map" "[" Type "]" Type .
+//
+func (p *parser) parseMapType(parent *types.Package) types.Type {
+	p.expectKeyword("map")
+	p.expect('[')
+	key := p.parseType(parent)
+	p.expect(']')
+	elem := p.parseType(parent)
+	return types.NewMap(key, elem)
+}
+
+// Name = identifier | "?" | QualifiedName .
+//
+// For unqualified and anonymous names, the returned package is the parent
+// package unless parent == nil, in which case the returned package is the
+// package being imported. (The parent package is not nil if the the name
+// is an unqualified struct field or interface method name belonging to a
+// type declared in another package.)
+//
+// For qualified names, the returned package is nil (and not created if
+// it doesn't exist yet) unless materializePkg is set (which creates an
+// unnamed package with valid package path). In the latter case, a
+// subsequent import clause is expected to provide a name for the package.
+//
+func (p *parser) parseName(parent *types.Package, materializePkg bool) (pkg *types.Package, name string) {
+	pkg = parent
+	if pkg == nil {
+		pkg = p.sharedPkgs[p.id]
+	}
+	switch p.tok {
+	case scanner.Ident:
+		name = p.lit
+		p.next()
+	case '?':
+		// anonymous
+		p.next()
+	case '@':
+		// exported name prefixed with package path
+		pkg = nil
+		var id string
+		id, name = p.parseQualifiedName()
+		if materializePkg {
+			pkg = p.getPkg(id, "")
+		}
+	default:
+		p.error("name expected")
+	}
+	return
+}
+
+func deref(typ types.Type) types.Type {
+	if p, _ := typ.(*types.Pointer); p != nil {
+		return p.Elem()
+	}
+	return typ
+}
+
+// Field = Name Type [ string_lit ] .
+//
+func (p *parser) parseField(parent *types.Package) (*types.Var, string) {
+	pkg, name := p.parseName(parent, true)
+
+	if name == "_" {
+		// Blank fields should be package-qualified because they
+		// are unexported identifiers, but gc does not qualify them.
+		// Assuming that the ident belongs to the current package
+		// causes types to change during re-exporting, leading
+		// to spurious "can't assign A to B" errors from go/types.
+		// As a workaround, pretend all blank fields belong
+		// to the same unique dummy package.
+		const blankpkg = "<_>"
+		pkg = p.getPkg(blankpkg, blankpkg)
+	}
+
+	typ := p.parseType(parent)
+	anonymous := false
+	if name == "" {
+		// anonymous field - typ must be T or *T and T must be a type name
+		switch typ := deref(typ).(type) {
+		case *types.Basic: // basic types are named types
+			pkg = nil // objects defined in Universe scope have no package
+			name = typ.Name()
+		case *types.Named:
+			name = typ.Obj().Name()
+		default:
+			p.errorf("anonymous field expected")
+		}
+		anonymous = true
+	}
+	tag := ""
+	if p.tok == scanner.String {
+		s := p.expect(scanner.String)
+		var err error
+		tag, err = strconv.Unquote(s)
+		if err != nil {
+			p.errorf("invalid struct tag %s: %s", s, err)
+		}
+	}
+	return types.NewField(token.NoPos, pkg, name, typ, anonymous), tag
+}
+
+// StructType = "struct" "{" [ FieldList ] "}" .
+// FieldList  = Field { ";" Field } .
+//
+func (p *parser) parseStructType(parent *types.Package) types.Type {
+	var fields []*types.Var
+	var tags []string
+
+	p.expectKeyword("struct")
+	p.expect('{')
+	for i := 0; p.tok != '}' && p.tok != scanner.EOF; i++ {
+		if i > 0 {
+			p.expect(';')
+		}
+		fld, tag := p.parseField(parent)
+		if tag != "" && tags == nil {
+			tags = make([]string, i)
+		}
+		if tags != nil {
+			tags = append(tags, tag)
+		}
+		fields = append(fields, fld)
+	}
+	p.expect('}')
+
+	return types.NewStruct(fields, tags)
+}
+
+// Parameter = ( identifier | "?" ) [ "..." ] Type [ string_lit ] .
+//
+func (p *parser) parseParameter() (par *types.Var, isVariadic bool) {
+	_, name := p.parseName(nil, false)
+	// remove gc-specific parameter numbering
+	if i := strings.Index(name, "·"); i >= 0 {
+		name = name[:i]
+	}
+	if p.tok == '.' {
+		p.expectSpecial("...")
+		isVariadic = true
+	}
+	typ := p.parseType(nil)
+	if isVariadic {
+		typ = types.NewSlice(typ)
+	}
+	// ignore argument tag (e.g. "noescape")
+	if p.tok == scanner.String {
+		p.next()
+	}
+	// TODO(gri) should we provide a package?
+	par = types.NewVar(token.NoPos, nil, name, typ)
+	return
+}
+
+// Parameters    = "(" [ ParameterList ] ")" .
+// ParameterList = { Parameter "," } Parameter .
+//
+func (p *parser) parseParameters() (list []*types.Var, isVariadic bool) {
+	p.expect('(')
+	for p.tok != ')' && p.tok != scanner.EOF {
+		if len(list) > 0 {
+			p.expect(',')
+		}
+		par, variadic := p.parseParameter()
+		list = append(list, par)
+		if variadic {
+			if isVariadic {
+				p.error("... not on final argument")
+			}
+			isVariadic = true
+		}
+	}
+	p.expect(')')
+
+	return
+}
+
+// Signature = Parameters [ Result ] .
+// Result    = Type | Parameters .
+//
+func (p *parser) parseSignature(recv *types.Var) *types.Signature {
+	params, isVariadic := p.parseParameters()
+
+	// optional result type
+	var results []*types.Var
+	if p.tok == '(' {
+		var variadic bool
+		results, variadic = p.parseParameters()
+		if variadic {
+			p.error("... not permitted on result type")
+		}
+	}
+
+	return types.NewSignature(recv, types.NewTuple(params...), types.NewTuple(results...), isVariadic)
+}
+
+// InterfaceType = "interface" "{" [ MethodList ] "}" .
+// MethodList    = Method { ";" Method } .
+// Method        = Name Signature .
+//
+// The methods of embedded interfaces are always "inlined"
+// by the compiler and thus embedded interfaces are never
+// visible in the export data.
+//
+func (p *parser) parseInterfaceType(parent *types.Package) types.Type {
+	var methods []*types.Func
+
+	p.expectKeyword("interface")
+	p.expect('{')
+	for i := 0; p.tok != '}' && p.tok != scanner.EOF; i++ {
+		if i > 0 {
+			p.expect(';')
+		}
+		pkg, name := p.parseName(parent, true)
+		sig := p.parseSignature(nil)
+		methods = append(methods, types.NewFunc(token.NoPos, pkg, name, sig))
+	}
+	p.expect('}')
+
+	// Complete requires the type's embedded interfaces to be fully defined,
+	// but we do not define any
+	return types.NewInterface(methods, nil).Complete()
+}
+
+// ChanType = ( "chan" [ "<-" ] | "<-" "chan" ) Type .
+//
+func (p *parser) parseChanType(parent *types.Package) types.Type {
+	dir := types.SendRecv
+	if p.tok == scanner.Ident {
+		p.expectKeyword("chan")
+		if p.tok == '<' {
+			p.expectSpecial("<-")
+			dir = types.SendOnly
+		}
+	} else {
+		p.expectSpecial("<-")
+		p.expectKeyword("chan")
+		dir = types.RecvOnly
+	}
+	elem := p.parseType(parent)
+	return types.NewChan(dir, elem)
+}
+
+// Type =
+//	BasicType | TypeName | ArrayType | SliceType | StructType |
+//      PointerType | FuncType | InterfaceType | MapType | ChanType |
+//      "(" Type ")" .
+//
+// BasicType   = ident .
+// TypeName    = ExportedName .
+// SliceType   = "[" "]" Type .
+// PointerType = "*" Type .
+// FuncType    = "func" Signature .
+//
+func (p *parser) parseType(parent *types.Package) types.Type {
+	switch p.tok {
+	case scanner.Ident:
+		switch p.lit {
+		default:
+			return p.parseBasicType()
+		case "struct":
+			return p.parseStructType(parent)
+		case "func":
+			// FuncType
+			p.next()
+			return p.parseSignature(nil)
+		case "interface":
+			return p.parseInterfaceType(parent)
+		case "map":
+			return p.parseMapType(parent)
+		case "chan":
+			return p.parseChanType(parent)
+		}
+	case '@':
+		// TypeName
+		pkg, name := p.parseExportedName()
+		return declTypeName(pkg, name).Type()
+	case '[':
+		p.next() // look ahead
+		if p.tok == ']' {
+			// SliceType
+			p.next()
+			return types.NewSlice(p.parseType(parent))
+		}
+		return p.parseArrayType(parent)
+	case '*':
+		// PointerType
+		p.next()
+		return types.NewPointer(p.parseType(parent))
+	case '<':
+		return p.parseChanType(parent)
+	case '(':
+		// "(" Type ")"
+		p.next()
+		typ := p.parseType(parent)
+		p.expect(')')
+		return typ
+	}
+	p.errorf("expected type, got %s (%q)", scanner.TokenString(p.tok), p.lit)
+	return nil
+}
+
+// ----------------------------------------------------------------------------
+// Declarations
+
+// ImportDecl = "import" PackageName PackageId .
+//
+func (p *parser) parseImportDecl() {
+	p.expectKeyword("import")
+	name := p.parsePackageName()
+	p.getPkg(p.parsePackageId(), name)
+}
+
+// int_lit = [ "+" | "-" ] { "0" ... "9" } .
+//
+func (p *parser) parseInt() string {
+	s := ""
+	switch p.tok {
+	case '-':
+		s = "-"
+		p.next()
+	case '+':
+		p.next()
+	}
+	return s + p.expect(scanner.Int)
+}
+
+// number = int_lit [ "p" int_lit ] .
+//
+func (p *parser) parseNumber() (typ *types.Basic, val constant.Value) {
+	// mantissa
+	mant := constant.MakeFromLiteral(p.parseInt(), token.INT, 0)
+	if mant == nil {
+		panic("invalid mantissa")
+	}
+
+	if p.lit == "p" {
+		// exponent (base 2)
+		p.next()
+		exp, err := strconv.ParseInt(p.parseInt(), 10, 0)
+		if err != nil {
+			p.error(err)
+		}
+		if exp < 0 {
+			denom := constant.MakeInt64(1)
+			denom = constant.Shift(denom, token.SHL, uint(-exp))
+			typ = types.Typ[types.UntypedFloat]
+			val = constant.BinaryOp(mant, token.QUO, denom)
+			return
+		}
+		if exp > 0 {
+			mant = constant.Shift(mant, token.SHL, uint(exp))
+		}
+		typ = types.Typ[types.UntypedFloat]
+		val = mant
+		return
+	}
+
+	typ = types.Typ[types.UntypedInt]
+	val = mant
+	return
+}
+
+// ConstDecl   = "const" ExportedName [ Type ] "=" Literal .
+// Literal     = bool_lit | int_lit | float_lit | complex_lit | rune_lit | string_lit .
+// bool_lit    = "true" | "false" .
+// complex_lit = "(" float_lit "+" float_lit "i" ")" .
+// rune_lit    = "(" int_lit "+" int_lit ")" .
+// string_lit  = `"` { unicode_char } `"` .
+//
+func (p *parser) parseConstDecl() {
+	p.expectKeyword("const")
+	pkg, name := p.parseExportedName()
+
+	var typ0 types.Type
+	if p.tok != '=' {
+		// constant types are never structured - no need for parent type
+		typ0 = p.parseType(nil)
+	}
+
+	p.expect('=')
+	var typ types.Type
+	var val constant.Value
+	switch p.tok {
+	case scanner.Ident:
+		// bool_lit
+		if p.lit != "true" && p.lit != "false" {
+			p.error("expected true or false")
+		}
+		typ = types.Typ[types.UntypedBool]
+		val = constant.MakeBool(p.lit == "true")
+		p.next()
+
+	case '-', scanner.Int:
+		// int_lit
+		typ, val = p.parseNumber()
+
+	case '(':
+		// complex_lit or rune_lit
+		p.next()
+		if p.tok == scanner.Char {
+			p.next()
+			p.expect('+')
+			typ = types.Typ[types.UntypedRune]
+			_, val = p.parseNumber()
+			p.expect(')')
+			break
+		}
+		_, re := p.parseNumber()
+		p.expect('+')
+		_, im := p.parseNumber()
+		p.expectKeyword("i")
+		p.expect(')')
+		typ = types.Typ[types.UntypedComplex]
+		val = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+
+	case scanner.Char:
+		// rune_lit
+		typ = types.Typ[types.UntypedRune]
+		val = constant.MakeFromLiteral(p.lit, token.CHAR, 0)
+		p.next()
+
+	case scanner.String:
+		// string_lit
+		typ = types.Typ[types.UntypedString]
+		val = constant.MakeFromLiteral(p.lit, token.STRING, 0)
+		p.next()
+
+	default:
+		p.errorf("expected literal got %s", scanner.TokenString(p.tok))
+	}
+
+	if typ0 == nil {
+		typ0 = typ
+	}
+
+	pkg.Scope().Insert(types.NewConst(token.NoPos, pkg, name, typ0, val))
+}
+
+// TypeDecl = "type" ExportedName Type .
+//
+func (p *parser) parseTypeDecl() {
+	p.expectKeyword("type")
+	pkg, name := p.parseExportedName()
+	obj := declTypeName(pkg, name)
+
+	// The type object may have been imported before and thus already
+	// have a type associated with it. We still need to parse the type
+	// structure, but throw it away if the object already has a type.
+	// This ensures that all imports refer to the same type object for
+	// a given type declaration.
+	typ := p.parseType(pkg)
+
+	if name := obj.Type().(*types.Named); name.Underlying() == nil {
+		name.SetUnderlying(typ)
+	}
+}
+
+// VarDecl = "var" ExportedName Type .
+//
+func (p *parser) parseVarDecl() {
+	p.expectKeyword("var")
+	pkg, name := p.parseExportedName()
+	typ := p.parseType(pkg)
+	pkg.Scope().Insert(types.NewVar(token.NoPos, pkg, name, typ))
+}
+
+// Func = Signature [ Body ] .
+// Body = "{" ... "}" .
+//
+func (p *parser) parseFunc(recv *types.Var) *types.Signature {
+	sig := p.parseSignature(recv)
+	if p.tok == '{' {
+		p.next()
+		for i := 1; i > 0; p.next() {
+			switch p.tok {
+			case '{':
+				i++
+			case '}':
+				i--
+			}
+		}
+	}
+	return sig
+}
+
+// MethodDecl = "func" Receiver Name Func .
+// Receiver   = "(" ( identifier | "?" ) [ "*" ] ExportedName ")" .
+//
+func (p *parser) parseMethodDecl() {
+	// "func" already consumed
+	p.expect('(')
+	recv, _ := p.parseParameter() // receiver
+	p.expect(')')
+
+	// determine receiver base type object
+	base := deref(recv.Type()).(*types.Named)
+
+	// parse method name, signature, and possibly inlined body
+	_, name := p.parseName(nil, false)
+	sig := p.parseFunc(recv)
+
+	// methods always belong to the same package as the base type object
+	pkg := base.Obj().Pkg()
+
+	// add method to type unless type was imported before
+	// and method exists already
+	// TODO(gri) This leads to a quadratic algorithm - ok for now because method counts are small.
+	base.AddMethod(types.NewFunc(token.NoPos, pkg, name, sig))
+}
+
+// FuncDecl = "func" ExportedName Func .
+//
+func (p *parser) parseFuncDecl() {
+	// "func" already consumed
+	pkg, name := p.parseExportedName()
+	typ := p.parseFunc(nil)
+	pkg.Scope().Insert(types.NewFunc(token.NoPos, pkg, name, typ))
+}
+
+// Decl = [ ImportDecl | ConstDecl | TypeDecl | VarDecl | FuncDecl | MethodDecl ] "\n" .
+//
+func (p *parser) parseDecl() {
+	if p.tok == scanner.Ident {
+		switch p.lit {
+		case "import":
+			p.parseImportDecl()
+		case "const":
+			p.parseConstDecl()
+		case "type":
+			p.parseTypeDecl()
+		case "var":
+			p.parseVarDecl()
+		case "func":
+			p.next() // look ahead
+			if p.tok == '(' {
+				p.parseMethodDecl()
+			} else {
+				p.parseFuncDecl()
+			}
+		}
+	}
+	p.expect('\n')
+}
+
+// ----------------------------------------------------------------------------
+// Export
+
+// Export        = "PackageClause { Decl } "$$" .
+// PackageClause = "package" PackageName [ "safe" ] "\n" .
+//
+func (p *parser) parseExport() *types.Package {
+	p.expectKeyword("package")
+	name := p.parsePackageName()
+	if p.tok == scanner.Ident && p.lit == "safe" {
+		// package was compiled with -u option - ignore
+		p.next()
+	}
+	p.expect('\n')
+
+	pkg := p.getPkg(p.id, name)
+
+	for p.tok != '$' && p.tok != scanner.EOF {
+		p.parseDecl()
+	}
+
+	if ch := p.scanner.Peek(); p.tok != '$' || ch != '$' {
+		// don't call next()/expect() since reading past the
+		// export data may cause scanner errors (e.g. NUL chars)
+		p.errorf("expected '$$', got %s %c", scanner.TokenString(p.tok), ch)
+	}
+
+	if n := p.scanner.ErrorCount; n != 0 {
+		p.errorf("expected no scanner errors, got %d", n)
+	}
+
+	// Record all locally referenced packages as imports.
+	var imports []*types.Package
+	for id, pkg2 := range p.localPkgs {
+		if pkg2.Name() == "" {
+			p.errorf("%s package has no name", id)
+		}
+		if id == p.id {
+			continue // avoid self-edge
+		}
+		imports = append(imports, pkg2)
+	}
+	sort.Sort(byPath(imports))
+	pkg.SetImports(imports)
+
+	// package was imported completely and without errors
+	pkg.MarkComplete()
+
+	return pkg
+}
+
+type byPath []*types.Package
+
+func (a byPath) Len() int           { return len(a) }
+func (a byPath) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a byPath) Less(i, j int) bool { return a[i].Path() < a[j].Path() }
diff --git a/vendor/golang.org/x/tools/go/internal/gcimporter/iexport.go b/vendor/golang.org/x/tools/go/internal/gcimporter/iexport.go
new file mode 100644
index 000000000..be671c79b
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/iexport.go
@@ -0,0 +1,723 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Indexed binary package export.
+// This file was derived from $GOROOT/src/cmd/compile/internal/gc/iexport.go;
+// see that file for specification of the format.
+
+// +build go1.11
+
+package gcimporter
+
+import (
+	"bytes"
+	"encoding/binary"
+	"go/ast"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"io"
+	"math/big"
+	"reflect"
+	"sort"
+)
+
+// Current indexed export format version. Increase with each format change.
+// 0: Go1.11 encoding
+const iexportVersion = 0
+
+// IExportData returns the binary export data for pkg.
+// If no file set is provided, position info will be missing.
+func IExportData(fset *token.FileSet, pkg *types.Package) (b []byte, err error) {
+	defer func() {
+		if e := recover(); e != nil {
+			if ierr, ok := e.(internalError); ok {
+				err = ierr
+				return
+			}
+			// Not an internal error; panic again.
+			panic(e)
+		}
+	}()
+
+	p := iexporter{
+		out:         bytes.NewBuffer(nil),
+		fset:        fset,
+		allPkgs:     map[*types.Package]bool{},
+		stringIndex: map[string]uint64{},
+		declIndex:   map[types.Object]uint64{},
+		typIndex:    map[types.Type]uint64{},
+	}
+
+	for i, pt := range predeclared() {
+		p.typIndex[pt] = uint64(i)
+	}
+	if len(p.typIndex) > predeclReserved {
+		panic(internalErrorf("too many predeclared types: %d > %d", len(p.typIndex), predeclReserved))
+	}
+
+	// Initialize work queue with exported declarations.
+	scope := pkg.Scope()
+	for _, name := range scope.Names() {
+		if ast.IsExported(name) {
+			p.pushDecl(scope.Lookup(name))
+		}
+	}
+
+	// Loop until no more work.
+	for !p.declTodo.empty() {
+		p.doDecl(p.declTodo.popHead())
+	}
+
+	// Append indices to data0 section.
+	dataLen := uint64(p.data0.Len())
+	w := p.newWriter()
+	w.writeIndex(p.declIndex, pkg)
+	w.flush()
+
+	// Assemble header.
+	var hdr intWriter
+	hdr.WriteByte('i')
+	hdr.uint64(iexportVersion)
+	hdr.uint64(uint64(p.strings.Len()))
+	hdr.uint64(dataLen)
+
+	// Flush output.
+	io.Copy(p.out, &hdr)
+	io.Copy(p.out, &p.strings)
+	io.Copy(p.out, &p.data0)
+
+	return p.out.Bytes(), nil
+}
+
+// writeIndex writes out an object index. mainIndex indicates whether
+// we're writing out the main index, which is also read by
+// non-compiler tools and includes a complete package description
+// (i.e., name and height).
+func (w *exportWriter) writeIndex(index map[types.Object]uint64, localpkg *types.Package) {
+	// Build a map from packages to objects from that package.
+	pkgObjs := map[*types.Package][]types.Object{}
+
+	// For the main index, make sure to include every package that
+	// we reference, even if we're not exporting (or reexporting)
+	// any symbols from it.
+	pkgObjs[localpkg] = nil
+	for pkg := range w.p.allPkgs {
+		pkgObjs[pkg] = nil
+	}
+
+	for obj := range index {
+		pkgObjs[obj.Pkg()] = append(pkgObjs[obj.Pkg()], obj)
+	}
+
+	var pkgs []*types.Package
+	for pkg, objs := range pkgObjs {
+		pkgs = append(pkgs, pkg)
+
+		sort.Slice(objs, func(i, j int) bool {
+			return objs[i].Name() < objs[j].Name()
+		})
+	}
+
+	sort.Slice(pkgs, func(i, j int) bool {
+		return pkgs[i].Path() < pkgs[j].Path()
+	})
+
+	w.uint64(uint64(len(pkgs)))
+	for _, pkg := range pkgs {
+		w.string(pkg.Path())
+		w.string(pkg.Name())
+		w.uint64(uint64(0)) // package height is not needed for go/types
+
+		objs := pkgObjs[pkg]
+		w.uint64(uint64(len(objs)))
+		for _, obj := range objs {
+			w.string(obj.Name())
+			w.uint64(index[obj])
+		}
+	}
+}
+
+type iexporter struct {
+	fset *token.FileSet
+	out  *bytes.Buffer
+
+	// allPkgs tracks all packages that have been referenced by
+	// the export data, so we can ensure to include them in the
+	// main index.
+	allPkgs map[*types.Package]bool
+
+	declTodo objQueue
+
+	strings     intWriter
+	stringIndex map[string]uint64
+
+	data0     intWriter
+	declIndex map[types.Object]uint64
+	typIndex  map[types.Type]uint64
+}
+
+// stringOff returns the offset of s within the string section.
+// If not already present, it's added to the end.
+func (p *iexporter) stringOff(s string) uint64 {
+	off, ok := p.stringIndex[s]
+	if !ok {
+		off = uint64(p.strings.Len())
+		p.stringIndex[s] = off
+
+		p.strings.uint64(uint64(len(s)))
+		p.strings.WriteString(s)
+	}
+	return off
+}
+
+// pushDecl adds n to the declaration work queue, if not already present.
+func (p *iexporter) pushDecl(obj types.Object) {
+	// Package unsafe is known to the compiler and predeclared.
+	assert(obj.Pkg() != types.Unsafe)
+
+	if _, ok := p.declIndex[obj]; ok {
+		return
+	}
+
+	p.declIndex[obj] = ^uint64(0) // mark n present in work queue
+	p.declTodo.pushTail(obj)
+}
+
+// exportWriter handles writing out individual data section chunks.
+type exportWriter struct {
+	p *iexporter
+
+	data     intWriter
+	currPkg  *types.Package
+	prevFile string
+	prevLine int64
+}
+
+func (p *iexporter) doDecl(obj types.Object) {
+	w := p.newWriter()
+	w.setPkg(obj.Pkg(), false)
+
+	switch obj := obj.(type) {
+	case *types.Var:
+		w.tag('V')
+		w.pos(obj.Pos())
+		w.typ(obj.Type(), obj.Pkg())
+
+	case *types.Func:
+		sig, _ := obj.Type().(*types.Signature)
+		if sig.Recv() != nil {
+			panic(internalErrorf("unexpected method: %v", sig))
+		}
+		w.tag('F')
+		w.pos(obj.Pos())
+		w.signature(sig)
+
+	case *types.Const:
+		w.tag('C')
+		w.pos(obj.Pos())
+		w.value(obj.Type(), obj.Val())
+
+	case *types.TypeName:
+		if obj.IsAlias() {
+			w.tag('A')
+			w.pos(obj.Pos())
+			w.typ(obj.Type(), obj.Pkg())
+			break
+		}
+
+		// Defined type.
+		w.tag('T')
+		w.pos(obj.Pos())
+
+		underlying := obj.Type().Underlying()
+		w.typ(underlying, obj.Pkg())
+
+		t := obj.Type()
+		if types.IsInterface(t) {
+			break
+		}
+
+		named, ok := t.(*types.Named)
+		if !ok {
+			panic(internalErrorf("%s is not a defined type", t))
+		}
+
+		n := named.NumMethods()
+		w.uint64(uint64(n))
+		for i := 0; i < n; i++ {
+			m := named.Method(i)
+			w.pos(m.Pos())
+			w.string(m.Name())
+			sig, _ := m.Type().(*types.Signature)
+			w.param(sig.Recv())
+			w.signature(sig)
+		}
+
+	default:
+		panic(internalErrorf("unexpected object: %v", obj))
+	}
+
+	p.declIndex[obj] = w.flush()
+}
+
+func (w *exportWriter) tag(tag byte) {
+	w.data.WriteByte(tag)
+}
+
+func (w *exportWriter) pos(pos token.Pos) {
+	p := w.p.fset.Position(pos)
+	file := p.Filename
+	line := int64(p.Line)
+
+	// When file is the same as the last position (common case),
+	// we can save a few bytes by delta encoding just the line
+	// number.
+	//
+	// Note: Because data objects may be read out of order (or not
+	// at all), we can only apply delta encoding within a single
+	// object. This is handled implicitly by tracking prevFile and
+	// prevLine as fields of exportWriter.
+
+	if file == w.prevFile {
+		delta := line - w.prevLine
+		w.int64(delta)
+		if delta == deltaNewFile {
+			w.int64(-1)
+		}
+	} else {
+		w.int64(deltaNewFile)
+		w.int64(line) // line >= 0
+		w.string(file)
+		w.prevFile = file
+	}
+	w.prevLine = line
+}
+
+func (w *exportWriter) pkg(pkg *types.Package) {
+	// Ensure any referenced packages are declared in the main index.
+	w.p.allPkgs[pkg] = true
+
+	w.string(pkg.Path())
+}
+
+func (w *exportWriter) qualifiedIdent(obj types.Object) {
+	// Ensure any referenced declarations are written out too.
+	w.p.pushDecl(obj)
+
+	w.string(obj.Name())
+	w.pkg(obj.Pkg())
+}
+
+func (w *exportWriter) typ(t types.Type, pkg *types.Package) {
+	w.data.uint64(w.p.typOff(t, pkg))
+}
+
+func (p *iexporter) newWriter() *exportWriter {
+	return &exportWriter{p: p}
+}
+
+func (w *exportWriter) flush() uint64 {
+	off := uint64(w.p.data0.Len())
+	io.Copy(&w.p.data0, &w.data)
+	return off
+}
+
+func (p *iexporter) typOff(t types.Type, pkg *types.Package) uint64 {
+	off, ok := p.typIndex[t]
+	if !ok {
+		w := p.newWriter()
+		w.doTyp(t, pkg)
+		off = predeclReserved + w.flush()
+		p.typIndex[t] = off
+	}
+	return off
+}
+
+func (w *exportWriter) startType(k itag) {
+	w.data.uint64(uint64(k))
+}
+
+func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
+	switch t := t.(type) {
+	case *types.Named:
+		w.startType(definedType)
+		w.qualifiedIdent(t.Obj())
+
+	case *types.Pointer:
+		w.startType(pointerType)
+		w.typ(t.Elem(), pkg)
+
+	case *types.Slice:
+		w.startType(sliceType)
+		w.typ(t.Elem(), pkg)
+
+	case *types.Array:
+		w.startType(arrayType)
+		w.uint64(uint64(t.Len()))
+		w.typ(t.Elem(), pkg)
+
+	case *types.Chan:
+		w.startType(chanType)
+		// 1 RecvOnly; 2 SendOnly; 3 SendRecv
+		var dir uint64
+		switch t.Dir() {
+		case types.RecvOnly:
+			dir = 1
+		case types.SendOnly:
+			dir = 2
+		case types.SendRecv:
+			dir = 3
+		}
+		w.uint64(dir)
+		w.typ(t.Elem(), pkg)
+
+	case *types.Map:
+		w.startType(mapType)
+		w.typ(t.Key(), pkg)
+		w.typ(t.Elem(), pkg)
+
+	case *types.Signature:
+		w.startType(signatureType)
+		w.setPkg(pkg, true)
+		w.signature(t)
+
+	case *types.Struct:
+		w.startType(structType)
+		w.setPkg(pkg, true)
+
+		n := t.NumFields()
+		w.uint64(uint64(n))
+		for i := 0; i < n; i++ {
+			f := t.Field(i)
+			w.pos(f.Pos())
+			w.string(f.Name())
+			w.typ(f.Type(), pkg)
+			w.bool(f.Embedded())
+			w.string(t.Tag(i)) // note (or tag)
+		}
+
+	case *types.Interface:
+		w.startType(interfaceType)
+		w.setPkg(pkg, true)
+
+		n := t.NumEmbeddeds()
+		w.uint64(uint64(n))
+		for i := 0; i < n; i++ {
+			f := t.Embedded(i)
+			w.pos(f.Obj().Pos())
+			w.typ(f.Obj().Type(), f.Obj().Pkg())
+		}
+
+		n = t.NumExplicitMethods()
+		w.uint64(uint64(n))
+		for i := 0; i < n; i++ {
+			m := t.ExplicitMethod(i)
+			w.pos(m.Pos())
+			w.string(m.Name())
+			sig, _ := m.Type().(*types.Signature)
+			w.signature(sig)
+		}
+
+	default:
+		panic(internalErrorf("unexpected type: %v, %v", t, reflect.TypeOf(t)))
+	}
+}
+
+func (w *exportWriter) setPkg(pkg *types.Package, write bool) {
+	if write {
+		w.pkg(pkg)
+	}
+
+	w.currPkg = pkg
+}
+
+func (w *exportWriter) signature(sig *types.Signature) {
+	w.paramList(sig.Params())
+	w.paramList(sig.Results())
+	if sig.Params().Len() > 0 {
+		w.bool(sig.Variadic())
+	}
+}
+
+func (w *exportWriter) paramList(tup *types.Tuple) {
+	n := tup.Len()
+	w.uint64(uint64(n))
+	for i := 0; i < n; i++ {
+		w.param(tup.At(i))
+	}
+}
+
+func (w *exportWriter) param(obj types.Object) {
+	w.pos(obj.Pos())
+	w.localIdent(obj)
+	w.typ(obj.Type(), obj.Pkg())
+}
+
+func (w *exportWriter) value(typ types.Type, v constant.Value) {
+	w.typ(typ, nil)
+
+	switch v.Kind() {
+	case constant.Bool:
+		w.bool(constant.BoolVal(v))
+	case constant.Int:
+		var i big.Int
+		if i64, exact := constant.Int64Val(v); exact {
+			i.SetInt64(i64)
+		} else if ui64, exact := constant.Uint64Val(v); exact {
+			i.SetUint64(ui64)
+		} else {
+			i.SetString(v.ExactString(), 10)
+		}
+		w.mpint(&i, typ)
+	case constant.Float:
+		f := constantToFloat(v)
+		w.mpfloat(f, typ)
+	case constant.Complex:
+		w.mpfloat(constantToFloat(constant.Real(v)), typ)
+		w.mpfloat(constantToFloat(constant.Imag(v)), typ)
+	case constant.String:
+		w.string(constant.StringVal(v))
+	case constant.Unknown:
+		// package contains type errors
+	default:
+		panic(internalErrorf("unexpected value %v (%T)", v, v))
+	}
+}
+
+// constantToFloat converts a constant.Value with kind constant.Float to a
+// big.Float.
+func constantToFloat(x constant.Value) *big.Float {
+	assert(x.Kind() == constant.Float)
+	// Use the same floating-point precision (512) as cmd/compile
+	// (see Mpprec in cmd/compile/internal/gc/mpfloat.go).
+	const mpprec = 512
+	var f big.Float
+	f.SetPrec(mpprec)
+	if v, exact := constant.Float64Val(x); exact {
+		// float64
+		f.SetFloat64(v)
+	} else if num, denom := constant.Num(x), constant.Denom(x); num.Kind() == constant.Int {
+		// TODO(gri): add big.Rat accessor to constant.Value.
+		n := valueToRat(num)
+		d := valueToRat(denom)
+		f.SetRat(n.Quo(n, d))
+	} else {
+		// Value too large to represent as a fraction => inaccessible.
+		// TODO(gri): add big.Float accessor to constant.Value.
+		_, ok := f.SetString(x.ExactString())
+		assert(ok)
+	}
+	return &f
+}
+
+// mpint exports a multi-precision integer.
+//
+// For unsigned types, small values are written out as a single
+// byte. Larger values are written out as a length-prefixed big-endian
+// byte string, where the length prefix is encoded as its complement.
+// For example, bytes 0, 1, and 2 directly represent the integer
+// values 0, 1, and 2; while bytes 255, 254, and 253 indicate a 1-,
+// 2-, and 3-byte big-endian string follow.
+//
+// Encoding for signed types use the same general approach as for
+// unsigned types, except small values use zig-zag encoding and the
+// bottom bit of length prefix byte for large values is reserved as a
+// sign bit.
+//
+// The exact boundary between small and large encodings varies
+// according to the maximum number of bytes needed to encode a value
+// of type typ. As a special case, 8-bit types are always encoded as a
+// single byte.
+//
+// TODO(mdempsky): Is this level of complexity really worthwhile?
+func (w *exportWriter) mpint(x *big.Int, typ types.Type) {
+	basic, ok := typ.Underlying().(*types.Basic)
+	if !ok {
+		panic(internalErrorf("unexpected type %v (%T)", typ.Underlying(), typ.Underlying()))
+	}
+
+	signed, maxBytes := intSize(basic)
+
+	negative := x.Sign() < 0
+	if !signed && negative {
+		panic(internalErrorf("negative unsigned integer; type %v, value %v", typ, x))
+	}
+
+	b := x.Bytes()
+	if len(b) > 0 && b[0] == 0 {
+		panic(internalErrorf("leading zeros"))
+	}
+	if uint(len(b)) > maxBytes {
+		panic(internalErrorf("bad mpint length: %d > %d (type %v, value %v)", len(b), maxBytes, typ, x))
+	}
+
+	maxSmall := 256 - maxBytes
+	if signed {
+		maxSmall = 256 - 2*maxBytes
+	}
+	if maxBytes == 1 {
+		maxSmall = 256
+	}
+
+	// Check if x can use small value encoding.
+	if len(b) <= 1 {
+		var ux uint
+		if len(b) == 1 {
+			ux = uint(b[0])
+		}
+		if signed {
+			ux <<= 1
+			if negative {
+				ux--
+			}
+		}
+		if ux < maxSmall {
+			w.data.WriteByte(byte(ux))
+			return
+		}
+	}
+
+	n := 256 - uint(len(b))
+	if signed {
+		n = 256 - 2*uint(len(b))
+		if negative {
+			n |= 1
+		}
+	}
+	if n < maxSmall || n >= 256 {
+		panic(internalErrorf("encoding mistake: %d, %v, %v => %d", len(b), signed, negative, n))
+	}
+
+	w.data.WriteByte(byte(n))
+	w.data.Write(b)
+}
+
+// mpfloat exports a multi-precision floating point number.
+//
+// The number's value is decomposed into mantissa × 2**exponent, where
+// mantissa is an integer. The value is written out as mantissa (as a
+// multi-precision integer) and then the exponent, except exponent is
+// omitted if mantissa is zero.
+func (w *exportWriter) mpfloat(f *big.Float, typ types.Type) {
+	if f.IsInf() {
+		panic("infinite constant")
+	}
+
+	// Break into f = mant × 2**exp, with 0.5 <= mant < 1.
+	var mant big.Float
+	exp := int64(f.MantExp(&mant))
+
+	// Scale so that mant is an integer.
+	prec := mant.MinPrec()
+	mant.SetMantExp(&mant, int(prec))
+	exp -= int64(prec)
+
+	manti, acc := mant.Int(nil)
+	if acc != big.Exact {
+		panic(internalErrorf("mantissa scaling failed for %f (%s)", f, acc))
+	}
+	w.mpint(manti, typ)
+	if manti.Sign() != 0 {
+		w.int64(exp)
+	}
+}
+
+func (w *exportWriter) bool(b bool) bool {
+	var x uint64
+	if b {
+		x = 1
+	}
+	w.uint64(x)
+	return b
+}
+
+func (w *exportWriter) int64(x int64)   { w.data.int64(x) }
+func (w *exportWriter) uint64(x uint64) { w.data.uint64(x) }
+func (w *exportWriter) string(s string) { w.uint64(w.p.stringOff(s)) }
+
+func (w *exportWriter) localIdent(obj types.Object) {
+	// Anonymous parameters.
+	if obj == nil {
+		w.string("")
+		return
+	}
+
+	name := obj.Name()
+	if name == "_" {
+		w.string("_")
+		return
+	}
+
+	w.string(name)
+}
+
+type intWriter struct {
+	bytes.Buffer
+}
+
+func (w *intWriter) int64(x int64) {
+	var buf [binary.MaxVarintLen64]byte
+	n := binary.PutVarint(buf[:], x)
+	w.Write(buf[:n])
+}
+
+func (w *intWriter) uint64(x uint64) {
+	var buf [binary.MaxVarintLen64]byte
+	n := binary.PutUvarint(buf[:], x)
+	w.Write(buf[:n])
+}
+
+func assert(cond bool) {
+	if !cond {
+		panic("internal error: assertion failed")
+	}
+}
+
+// The below is copied from go/src/cmd/compile/internal/gc/syntax.go.
+
+// objQueue is a FIFO queue of types.Object. The zero value of objQueue is
+// a ready-to-use empty queue.
+type objQueue struct {
+	ring       []types.Object
+	head, tail int
+}
+
+// empty returns true if q contains no Nodes.
+func (q *objQueue) empty() bool {
+	return q.head == q.tail
+}
+
+// pushTail appends n to the tail of the queue.
+func (q *objQueue) pushTail(obj types.Object) {
+	if len(q.ring) == 0 {
+		q.ring = make([]types.Object, 16)
+	} else if q.head+len(q.ring) == q.tail {
+		// Grow the ring.
+		nring := make([]types.Object, len(q.ring)*2)
+		// Copy the old elements.
+		part := q.ring[q.head%len(q.ring):]
+		if q.tail-q.head <= len(part) {
+			part = part[:q.tail-q.head]
+			copy(nring, part)
+		} else {
+			pos := copy(nring, part)
+			copy(nring[pos:], q.ring[:q.tail%len(q.ring)])
+		}
+		q.ring, q.head, q.tail = nring, 0, q.tail-q.head
+	}
+
+	q.ring[q.tail%len(q.ring)] = obj
+	q.tail++
+}
+
+// popHead pops a node from the head of the queue. It panics if q is empty.
+func (q *objQueue) popHead() types.Object {
+	if q.empty() {
+		panic("dequeue empty")
+	}
+	obj := q.ring[q.head%len(q.ring)]
+	q.head++
+	return obj
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gcimporter/iimport.go b/vendor/golang.org/x/tools/go/internal/gcimporter/iimport.go
new file mode 100644
index 000000000..3cb7ae5b9
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/iimport.go
@@ -0,0 +1,606 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Indexed package import.
+// See cmd/compile/internal/gc/iexport.go for the export data format.
+
+// This file is a copy of $GOROOT/src/go/internal/gcimporter/iimport.go.
+
+package gcimporter
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"go/constant"
+	"go/token"
+	"go/types"
+	"io"
+	"sort"
+)
+
+type intReader struct {
+	*bytes.Reader
+	path string
+}
+
+func (r *intReader) int64() int64 {
+	i, err := binary.ReadVarint(r.Reader)
+	if err != nil {
+		errorf("import %q: read varint error: %v", r.path, err)
+	}
+	return i
+}
+
+func (r *intReader) uint64() uint64 {
+	i, err := binary.ReadUvarint(r.Reader)
+	if err != nil {
+		errorf("import %q: read varint error: %v", r.path, err)
+	}
+	return i
+}
+
+const predeclReserved = 32
+
+type itag uint64
+
+const (
+	// Types
+	definedType itag = iota
+	pointerType
+	sliceType
+	arrayType
+	chanType
+	mapType
+	signatureType
+	structType
+	interfaceType
+)
+
+// IImportData imports a package from the serialized package data
+// and returns the number of bytes consumed and a reference to the package.
+// If the export data version is not recognized or the format is otherwise
+// compromised, an error is returned.
+func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
+	const currentVersion = 0
+	version := -1
+	defer func() {
+		if e := recover(); e != nil {
+			if version > currentVersion {
+				err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
+			} else {
+				err = fmt.Errorf("cannot import %q (%v), possibly version skew - reinstall package", path, e)
+			}
+		}
+	}()
+
+	r := &intReader{bytes.NewReader(data), path}
+
+	version = int(r.uint64())
+	switch version {
+	case currentVersion:
+	default:
+		errorf("unknown iexport format version %d", version)
+	}
+
+	sLen := int64(r.uint64())
+	dLen := int64(r.uint64())
+
+	whence, _ := r.Seek(0, io.SeekCurrent)
+	stringData := data[whence : whence+sLen]
+	declData := data[whence+sLen : whence+sLen+dLen]
+	r.Seek(sLen+dLen, io.SeekCurrent)
+
+	p := iimporter{
+		ipath: path,
+
+		stringData:  stringData,
+		stringCache: make(map[uint64]string),
+		pkgCache:    make(map[uint64]*types.Package),
+
+		declData: declData,
+		pkgIndex: make(map[*types.Package]map[string]uint64),
+		typCache: make(map[uint64]types.Type),
+
+		fake: fakeFileSet{
+			fset:  fset,
+			files: make(map[string]*token.File),
+		},
+	}
+
+	for i, pt := range predeclared() {
+		p.typCache[uint64(i)] = pt
+	}
+
+	pkgList := make([]*types.Package, r.uint64())
+	for i := range pkgList {
+		pkgPathOff := r.uint64()
+		pkgPath := p.stringAt(pkgPathOff)
+		pkgName := p.stringAt(r.uint64())
+		_ = r.uint64() // package height; unused by go/types
+
+		if pkgPath == "" {
+			pkgPath = path
+		}
+		pkg := imports[pkgPath]
+		if pkg == nil {
+			pkg = types.NewPackage(pkgPath, pkgName)
+			imports[pkgPath] = pkg
+		} else if pkg.Name() != pkgName {
+			errorf("conflicting names %s and %s for package %q", pkg.Name(), pkgName, path)
+		}
+
+		p.pkgCache[pkgPathOff] = pkg
+
+		nameIndex := make(map[string]uint64)
+		for nSyms := r.uint64(); nSyms > 0; nSyms-- {
+			name := p.stringAt(r.uint64())
+			nameIndex[name] = r.uint64()
+		}
+
+		p.pkgIndex[pkg] = nameIndex
+		pkgList[i] = pkg
+	}
+	var localpkg *types.Package
+	for _, pkg := range pkgList {
+		if pkg.Path() == path {
+			localpkg = pkg
+		}
+	}
+
+	names := make([]string, 0, len(p.pkgIndex[localpkg]))
+	for name := range p.pkgIndex[localpkg] {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		p.doDecl(localpkg, name)
+	}
+
+	for _, typ := range p.interfaceList {
+		typ.Complete()
+	}
+
+	// record all referenced packages as imports
+	list := append(([]*types.Package)(nil), pkgList[1:]...)
+	sort.Sort(byPath(list))
+	localpkg.SetImports(list)
+
+	// package was imported completely and without errors
+	localpkg.MarkComplete()
+
+	consumed, _ := r.Seek(0, io.SeekCurrent)
+	return int(consumed), localpkg, nil
+}
+
+type iimporter struct {
+	ipath string
+
+	stringData  []byte
+	stringCache map[uint64]string
+	pkgCache    map[uint64]*types.Package
+
+	declData []byte
+	pkgIndex map[*types.Package]map[string]uint64
+	typCache map[uint64]types.Type
+
+	fake          fakeFileSet
+	interfaceList []*types.Interface
+}
+
+func (p *iimporter) doDecl(pkg *types.Package, name string) {
+	// See if we've already imported this declaration.
+	if obj := pkg.Scope().Lookup(name); obj != nil {
+		return
+	}
+
+	off, ok := p.pkgIndex[pkg][name]
+	if !ok {
+		errorf("%v.%v not in index", pkg, name)
+	}
+
+	r := &importReader{p: p, currPkg: pkg}
+	r.declReader.Reset(p.declData[off:])
+
+	r.obj(name)
+}
+
+func (p *iimporter) stringAt(off uint64) string {
+	if s, ok := p.stringCache[off]; ok {
+		return s
+	}
+
+	slen, n := binary.Uvarint(p.stringData[off:])
+	if n <= 0 {
+		errorf("varint failed")
+	}
+	spos := off + uint64(n)
+	s := string(p.stringData[spos : spos+slen])
+	p.stringCache[off] = s
+	return s
+}
+
+func (p *iimporter) pkgAt(off uint64) *types.Package {
+	if pkg, ok := p.pkgCache[off]; ok {
+		return pkg
+	}
+	path := p.stringAt(off)
+	errorf("missing package %q in %q", path, p.ipath)
+	return nil
+}
+
+func (p *iimporter) typAt(off uint64, base *types.Named) types.Type {
+	if t, ok := p.typCache[off]; ok && (base == nil || !isInterface(t)) {
+		return t
+	}
+
+	if off < predeclReserved {
+		errorf("predeclared type missing from cache: %v", off)
+	}
+
+	r := &importReader{p: p}
+	r.declReader.Reset(p.declData[off-predeclReserved:])
+	t := r.doType(base)
+
+	if base == nil || !isInterface(t) {
+		p.typCache[off] = t
+	}
+	return t
+}
+
+type importReader struct {
+	p          *iimporter
+	declReader bytes.Reader
+	currPkg    *types.Package
+	prevFile   string
+	prevLine   int64
+}
+
+func (r *importReader) obj(name string) {
+	tag := r.byte()
+	pos := r.pos()
+
+	switch tag {
+	case 'A':
+		typ := r.typ()
+
+		r.declare(types.NewTypeName(pos, r.currPkg, name, typ))
+
+	case 'C':
+		typ, val := r.value()
+
+		r.declare(types.NewConst(pos, r.currPkg, name, typ, val))
+
+	case 'F':
+		sig := r.signature(nil)
+
+		r.declare(types.NewFunc(pos, r.currPkg, name, sig))
+
+	case 'T':
+		// Types can be recursive. We need to setup a stub
+		// declaration before recursing.
+		obj := types.NewTypeName(pos, r.currPkg, name, nil)
+		named := types.NewNamed(obj, nil, nil)
+		r.declare(obj)
+
+		underlying := r.p.typAt(r.uint64(), named).Underlying()
+		named.SetUnderlying(underlying)
+
+		if !isInterface(underlying) {
+			for n := r.uint64(); n > 0; n-- {
+				mpos := r.pos()
+				mname := r.ident()
+				recv := r.param()
+				msig := r.signature(recv)
+
+				named.AddMethod(types.NewFunc(mpos, r.currPkg, mname, msig))
+			}
+		}
+
+	case 'V':
+		typ := r.typ()
+
+		r.declare(types.NewVar(pos, r.currPkg, name, typ))
+
+	default:
+		errorf("unexpected tag: %v", tag)
+	}
+}
+
+func (r *importReader) declare(obj types.Object) {
+	obj.Pkg().Scope().Insert(obj)
+}
+
+func (r *importReader) value() (typ types.Type, val constant.Value) {
+	typ = r.typ()
+
+	switch b := typ.Underlying().(*types.Basic); b.Info() & types.IsConstType {
+	case types.IsBoolean:
+		val = constant.MakeBool(r.bool())
+
+	case types.IsString:
+		val = constant.MakeString(r.string())
+
+	case types.IsInteger:
+		val = r.mpint(b)
+
+	case types.IsFloat:
+		val = r.mpfloat(b)
+
+	case types.IsComplex:
+		re := r.mpfloat(b)
+		im := r.mpfloat(b)
+		val = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+
+	default:
+		if b.Kind() == types.Invalid {
+			val = constant.MakeUnknown()
+			return
+		}
+		errorf("unexpected type %v", typ) // panics
+		panic("unreachable")
+	}
+
+	return
+}
+
+func intSize(b *types.Basic) (signed bool, maxBytes uint) {
+	if (b.Info() & types.IsUntyped) != 0 {
+		return true, 64
+	}
+
+	switch b.Kind() {
+	case types.Float32, types.Complex64:
+		return true, 3
+	case types.Float64, types.Complex128:
+		return true, 7
+	}
+
+	signed = (b.Info() & types.IsUnsigned) == 0
+	switch b.Kind() {
+	case types.Int8, types.Uint8:
+		maxBytes = 1
+	case types.Int16, types.Uint16:
+		maxBytes = 2
+	case types.Int32, types.Uint32:
+		maxBytes = 4
+	default:
+		maxBytes = 8
+	}
+
+	return
+}
+
+func (r *importReader) mpint(b *types.Basic) constant.Value {
+	signed, maxBytes := intSize(b)
+
+	maxSmall := 256 - maxBytes
+	if signed {
+		maxSmall = 256 - 2*maxBytes
+	}
+	if maxBytes == 1 {
+		maxSmall = 256
+	}
+
+	n, _ := r.declReader.ReadByte()
+	if uint(n) < maxSmall {
+		v := int64(n)
+		if signed {
+			v >>= 1
+			if n&1 != 0 {
+				v = ^v
+			}
+		}
+		return constant.MakeInt64(v)
+	}
+
+	v := -n
+	if signed {
+		v = -(n &^ 1) >> 1
+	}
+	if v < 1 || uint(v) > maxBytes {
+		errorf("weird decoding: %v, %v => %v", n, signed, v)
+	}
+
+	buf := make([]byte, v)
+	io.ReadFull(&r.declReader, buf)
+
+	// convert to little endian
+	// TODO(gri) go/constant should have a more direct conversion function
+	//           (e.g., once it supports a big.Float based implementation)
+	for i, j := 0, len(buf)-1; i < j; i, j = i+1, j-1 {
+		buf[i], buf[j] = buf[j], buf[i]
+	}
+
+	x := constant.MakeFromBytes(buf)
+	if signed && n&1 != 0 {
+		x = constant.UnaryOp(token.SUB, x, 0)
+	}
+	return x
+}
+
+func (r *importReader) mpfloat(b *types.Basic) constant.Value {
+	x := r.mpint(b)
+	if constant.Sign(x) == 0 {
+		return x
+	}
+
+	exp := r.int64()
+	switch {
+	case exp > 0:
+		x = constant.Shift(x, token.SHL, uint(exp))
+	case exp < 0:
+		d := constant.Shift(constant.MakeInt64(1), token.SHL, uint(-exp))
+		x = constant.BinaryOp(x, token.QUO, d)
+	}
+	return x
+}
+
+func (r *importReader) ident() string {
+	return r.string()
+}
+
+func (r *importReader) qualifiedIdent() (*types.Package, string) {
+	name := r.string()
+	pkg := r.pkg()
+	return pkg, name
+}
+
+func (r *importReader) pos() token.Pos {
+	delta := r.int64()
+	if delta != deltaNewFile {
+		r.prevLine += delta
+	} else if l := r.int64(); l == -1 {
+		r.prevLine += deltaNewFile
+	} else {
+		r.prevFile = r.string()
+		r.prevLine = l
+	}
+
+	if r.prevFile == "" && r.prevLine == 0 {
+		return token.NoPos
+	}
+
+	return r.p.fake.pos(r.prevFile, int(r.prevLine))
+}
+
+func (r *importReader) typ() types.Type {
+	return r.p.typAt(r.uint64(), nil)
+}
+
+func isInterface(t types.Type) bool {
+	_, ok := t.(*types.Interface)
+	return ok
+}
+
+func (r *importReader) pkg() *types.Package { return r.p.pkgAt(r.uint64()) }
+func (r *importReader) string() string      { return r.p.stringAt(r.uint64()) }
+
+func (r *importReader) doType(base *types.Named) types.Type {
+	switch k := r.kind(); k {
+	default:
+		errorf("unexpected kind tag in %q: %v", r.p.ipath, k)
+		return nil
+
+	case definedType:
+		pkg, name := r.qualifiedIdent()
+		r.p.doDecl(pkg, name)
+		return pkg.Scope().Lookup(name).(*types.TypeName).Type()
+	case pointerType:
+		return types.NewPointer(r.typ())
+	case sliceType:
+		return types.NewSlice(r.typ())
+	case arrayType:
+		n := r.uint64()
+		return types.NewArray(r.typ(), int64(n))
+	case chanType:
+		dir := chanDir(int(r.uint64()))
+		return types.NewChan(dir, r.typ())
+	case mapType:
+		return types.NewMap(r.typ(), r.typ())
+	case signatureType:
+		r.currPkg = r.pkg()
+		return r.signature(nil)
+
+	case structType:
+		r.currPkg = r.pkg()
+
+		fields := make([]*types.Var, r.uint64())
+		tags := make([]string, len(fields))
+		for i := range fields {
+			fpos := r.pos()
+			fname := r.ident()
+			ftyp := r.typ()
+			emb := r.bool()
+			tag := r.string()
+
+			fields[i] = types.NewField(fpos, r.currPkg, fname, ftyp, emb)
+			tags[i] = tag
+		}
+		return types.NewStruct(fields, tags)
+
+	case interfaceType:
+		r.currPkg = r.pkg()
+
+		embeddeds := make([]types.Type, r.uint64())
+		for i := range embeddeds {
+			_ = r.pos()
+			embeddeds[i] = r.typ()
+		}
+
+		methods := make([]*types.Func, r.uint64())
+		for i := range methods {
+			mpos := r.pos()
+			mname := r.ident()
+
+			// TODO(mdempsky): Matches bimport.go, but I
+			// don't agree with this.
+			var recv *types.Var
+			if base != nil {
+				recv = types.NewVar(token.NoPos, r.currPkg, "", base)
+			}
+
+			msig := r.signature(recv)
+			methods[i] = types.NewFunc(mpos, r.currPkg, mname, msig)
+		}
+
+		typ := newInterface(methods, embeddeds)
+		r.p.interfaceList = append(r.p.interfaceList, typ)
+		return typ
+	}
+}
+
+func (r *importReader) kind() itag {
+	return itag(r.uint64())
+}
+
+func (r *importReader) signature(recv *types.Var) *types.Signature {
+	params := r.paramList()
+	results := r.paramList()
+	variadic := params.Len() > 0 && r.bool()
+	return types.NewSignature(recv, params, results, variadic)
+}
+
+func (r *importReader) paramList() *types.Tuple {
+	xs := make([]*types.Var, r.uint64())
+	for i := range xs {
+		xs[i] = r.param()
+	}
+	return types.NewTuple(xs...)
+}
+
+func (r *importReader) param() *types.Var {
+	pos := r.pos()
+	name := r.ident()
+	typ := r.typ()
+	return types.NewParam(pos, r.currPkg, name, typ)
+}
+
+func (r *importReader) bool() bool {
+	return r.uint64() != 0
+}
+
+func (r *importReader) int64() int64 {
+	n, err := binary.ReadVarint(&r.declReader)
+	if err != nil {
+		errorf("readVarint: %v", err)
+	}
+	return n
+}
+
+func (r *importReader) uint64() uint64 {
+	n, err := binary.ReadUvarint(&r.declReader)
+	if err != nil {
+		errorf("readUvarint: %v", err)
+	}
+	return n
+}
+
+func (r *importReader) byte() byte {
+	x, err := r.declReader.ReadByte()
+	if err != nil {
+		errorf("declReader.ReadByte: %v", err)
+	}
+	return x
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gcimporter/newInterface10.go b/vendor/golang.org/x/tools/go/internal/gcimporter/newInterface10.go
new file mode 100644
index 000000000..463f25227
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/newInterface10.go
@@ -0,0 +1,21 @@
+// Copyright 2018 The Go 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.11
+
+package gcimporter
+
+import "go/types"
+
+func newInterface(methods []*types.Func, embeddeds []types.Type) *types.Interface {
+	named := make([]*types.Named, len(embeddeds))
+	for i, e := range embeddeds {
+		var ok bool
+		named[i], ok = e.(*types.Named)
+		if !ok {
+			panic("embedding of non-defined interfaces in interfaces is not supported before Go 1.11")
+		}
+	}
+	return types.NewInterface(methods, named)
+}
diff --git a/vendor/golang.org/x/tools/go/internal/gcimporter/newInterface11.go b/vendor/golang.org/x/tools/go/internal/gcimporter/newInterface11.go
new file mode 100644
index 000000000..ab28b95cb
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/gcimporter/newInterface11.go
@@ -0,0 +1,13 @@
+// Copyright 2018 The Go 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.11
+
+package gcimporter
+
+import "go/types"
+
+func newInterface(methods []*types.Func, embeddeds []types.Type) *types.Interface {
+	return types.NewInterfaceType(methods, embeddeds)
+}
diff --git a/vendor/golang.org/x/tools/go/internal/packagesdriver/sizes.go b/vendor/golang.org/x/tools/go/internal/packagesdriver/sizes.go
new file mode 100644
index 000000000..fdc7da056
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/internal/packagesdriver/sizes.go
@@ -0,0 +1,160 @@
+// Copyright 2018 The Go 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 packagesdriver fetches type sizes for go/packages and go/analysis.
+package packagesdriver
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"go/types"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+var debug = false
+
+// GetSizes returns the sizes used by the underlying driver with the given parameters.
+func GetSizes(ctx context.Context, buildFlags, env []string, dir string, usesExportData bool) (types.Sizes, error) {
+	// TODO(matloob): Clean this up. This code is mostly a copy of packages.findExternalDriver.
+	const toolPrefix = "GOPACKAGESDRIVER="
+	tool := ""
+	for _, env := range env {
+		if val := strings.TrimPrefix(env, toolPrefix); val != env {
+			tool = val
+		}
+	}
+
+	if tool == "" {
+		var err error
+		tool, err = exec.LookPath("gopackagesdriver")
+		if err != nil {
+			// We did not find the driver, so use "go list".
+			tool = "off"
+		}
+	}
+
+	if tool == "off" {
+		return GetSizesGolist(ctx, buildFlags, env, dir, usesExportData)
+	}
+
+	req, err := json.Marshal(struct {
+		Command    string   `json:"command"`
+		Env        []string `json:"env"`
+		BuildFlags []string `json:"build_flags"`
+	}{
+		Command:    "sizes",
+		Env:        env,
+		BuildFlags: buildFlags,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to encode message to driver tool: %v", err)
+	}
+
+	buf := new(bytes.Buffer)
+	cmd := exec.CommandContext(ctx, tool)
+	cmd.Dir = dir
+	cmd.Env = env
+	cmd.Stdin = bytes.NewReader(req)
+	cmd.Stdout = buf
+	cmd.Stderr = new(bytes.Buffer)
+	if err := cmd.Run(); err != nil {
+		return nil, fmt.Errorf("%v: %v: %s", tool, err, cmd.Stderr)
+	}
+	var response struct {
+		// Sizes, if not nil, is the types.Sizes to use when type checking.
+		Sizes *types.StdSizes
+	}
+	if err := json.Unmarshal(buf.Bytes(), &response); err != nil {
+		return nil, err
+	}
+	return response.Sizes, nil
+}
+
+func GetSizesGolist(ctx context.Context, buildFlags, env []string, dir string, usesExportData bool) (types.Sizes, error) {
+	args := []string{"list", "-f", "{{context.GOARCH}} {{context.Compiler}}"}
+	args = append(args, buildFlags...)
+	args = append(args, "--", "unsafe")
+	stdout, err := InvokeGo(ctx, env, dir, usesExportData, args...)
+	if err != nil {
+		return nil, err
+	}
+	fields := strings.Fields(stdout.String())
+	if len(fields) < 2 {
+		return nil, fmt.Errorf("could not determine GOARCH and Go compiler")
+	}
+	goarch := fields[0]
+	compiler := fields[1]
+	return types.SizesFor(compiler, goarch), nil
+}
+
+// InvokeGo returns the stdout of a go command invocation.
+func InvokeGo(ctx context.Context, env []string, dir string, usesExportData bool, args ...string) (*bytes.Buffer, error) {
+	if debug {
+		defer func(start time.Time) { log.Printf("%s for %v", time.Since(start), cmdDebugStr(env, args...)) }(time.Now())
+	}
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+	cmd := exec.CommandContext(ctx, "go", args...)
+	// On darwin the cwd gets resolved to the real path, which breaks anything that
+	// expects the working directory to keep the original path, including the
+	// go command when dealing with modules.
+	// The Go stdlib has a special feature where if the cwd and the PWD are the
+	// same node then it trusts the PWD, so by setting it in the env for the child
+	// process we fix up all the paths returned by the go command.
+	cmd.Env = append(append([]string{}, env...), "PWD="+dir)
+	cmd.Dir = dir
+	cmd.Stdout = stdout
+	cmd.Stderr = stderr
+	if err := cmd.Run(); err != nil {
+		exitErr, ok := err.(*exec.ExitError)
+		if !ok {
+			// Catastrophic error:
+			// - executable not found
+			// - context cancellation
+			return nil, fmt.Errorf("couldn't exec 'go %v': %s %T", args, err, err)
+		}
+
+		// Export mode entails a build.
+		// If that build fails, errors appear on stderr
+		// (despite the -e flag) and the Export field is blank.
+		// Do not fail in that case.
+		if !usesExportData {
+			return nil, fmt.Errorf("go %v: %s: %s", args, exitErr, stderr)
+		}
+	}
+
+	// As of writing, go list -export prints some non-fatal compilation
+	// errors to stderr, even with -e set. We would prefer that it put
+	// them in the Package.Error JSON (see https://golang.org/issue/26319).
+	// In the meantime, there's nowhere good to put them, but they can
+	// be useful for debugging. Print them if $GOPACKAGESPRINTGOLISTERRORS
+	// is set.
+	if len(stderr.Bytes()) != 0 && os.Getenv("GOPACKAGESPRINTGOLISTERRORS") != "" {
+		fmt.Fprintf(os.Stderr, "%s stderr: <<%s>>\n", cmdDebugStr(env, args...), stderr)
+	}
+
+	// debugging
+	if false {
+		fmt.Fprintf(os.Stderr, "%s stdout: <<%s>>\n", cmdDebugStr(env, args...), stdout)
+	}
+
+	return stdout, nil
+}
+
+func cmdDebugStr(envlist []string, args ...string) string {
+	env := make(map[string]string)
+	for _, kv := range envlist {
+		split := strings.Split(kv, "=")
+		k, v := split[0], split[1]
+		env[k] = v
+	}
+
+	return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v PWD=%v go %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["PWD"], args)
+}
diff --git a/vendor/golang.org/x/tools/go/packages/doc.go b/vendor/golang.org/x/tools/go/packages/doc.go
new file mode 100644
index 000000000..3799f8ed8
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/doc.go
@@ -0,0 +1,222 @@
+// Copyright 2018 The Go 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 packages loads Go packages for inspection and analysis.
+
+The Load function takes as input a list of patterns and return a list of Package
+structs describing individual packages matched by those patterns.
+The LoadMode controls the amount of detail in the loaded packages.
+
+Load passes most patterns directly to the underlying build tool,
+but all patterns with the prefix "query=", where query is a
+non-empty string of letters from [a-z], are reserved and may be
+interpreted as query operators.
+
+Two query operators are currently supported: "file" and "pattern".
+
+The query "file=path/to/file.go" matches the package or packages enclosing
+the Go source file path/to/file.go.  For example "file=~/go/src/fmt/print.go"
+might return the packages "fmt" and "fmt [fmt.test]".
+
+The query "pattern=string" causes "string" to be passed directly to
+the underlying build tool. In most cases this is unnecessary,
+but an application can use Load("pattern=" + x) as an escaping mechanism
+to ensure that x is not interpreted as a query operator if it contains '='.
+
+All other query operators are reserved for future use and currently
+cause Load to report an error.
+
+The Package struct provides basic information about the package, including
+
+  - ID, a unique identifier for the package in the returned set;
+  - GoFiles, the names of the package's Go source files;
+  - Imports, a map from source import strings to the Packages they name;
+  - Types, the type information for the package's exported symbols;
+  - Syntax, the parsed syntax trees for the package's source code; and
+  - TypeInfo, the result of a complete type-check of the package syntax trees.
+
+(See the documentation for type Package for the complete list of fields
+and more detailed descriptions.)
+
+For example,
+
+	Load(nil, "bytes", "unicode...")
+
+returns four Package structs describing the standard library packages
+bytes, unicode, unicode/utf16, and unicode/utf8. Note that one pattern
+can match multiple packages and that a package might be matched by
+multiple patterns: in general it is not possible to determine which
+packages correspond to which patterns.
+
+Note that the list returned by Load contains only the packages matched
+by the patterns. Their dependencies can be found by walking the import
+graph using the Imports fields.
+
+The Load function can be configured by passing a pointer to a Config as
+the first argument. A nil Config is equivalent to the zero Config, which
+causes Load to run in LoadFiles mode, collecting minimal information.
+See the documentation for type Config for details.
+
+As noted earlier, the Config.Mode controls the amount of detail
+reported about the loaded packages, with each mode returning all the data of the
+previous mode with some extra added. See the documentation for type LoadMode
+for details.
+
+Most tools should pass their command-line arguments (after any flags)
+uninterpreted to the loader, so that the loader can interpret them
+according to the conventions of the underlying build system.
+See the Example function for typical usage.
+
+*/
+package packages // import "golang.org/x/tools/go/packages"
+
+/*
+
+Motivation and design considerations
+
+The new package's design solves problems addressed by two existing
+packages: go/build, which locates and describes packages, and
+golang.org/x/tools/go/loader, which loads, parses and type-checks them.
+The go/build.Package structure encodes too much of the 'go build' way
+of organizing projects, leaving us in need of a data type that describes a
+package of Go source code independent of the underlying build system.
+We wanted something that works equally well with go build and vgo, and
+also other build systems such as Bazel and Blaze, making it possible to
+construct analysis tools that work in all these environments.
+Tools such as errcheck and staticcheck were essentially unavailable to
+the Go community at Google, and some of Google's internal tools for Go
+are unavailable externally.
+This new package provides a uniform way to obtain package metadata by
+querying each of these build systems, optionally supporting their
+preferred command-line notations for packages, so that tools integrate
+neatly with users' build environments. The Metadata query function
+executes an external query tool appropriate to the current workspace.
+
+Loading packages always returns the complete import graph "all the way down",
+even if all you want is information about a single package, because the query
+mechanisms of all the build systems we currently support ({go,vgo} list, and
+blaze/bazel aspect-based query) cannot provide detailed information
+about one package without visiting all its dependencies too, so there is
+no additional asymptotic cost to providing transitive information.
+(This property might not be true of a hypothetical 5th build system.)
+
+In calls to TypeCheck, all initial packages, and any package that
+transitively depends on one of them, must be loaded from source.
+Consider A->B->C->D->E: if A,C are initial, A,B,C must be loaded from
+source; D may be loaded from export data, and E may not be loaded at all
+(though it's possible that D's export data mentions it, so a
+types.Package may be created for it and exposed.)
+
+The old loader had a feature to suppress type-checking of function
+bodies on a per-package basis, primarily intended to reduce the work of
+obtaining type information for imported packages. Now that imports are
+satisfied by export data, the optimization no longer seems necessary.
+
+Despite some early attempts, the old loader did not exploit export data,
+instead always using the equivalent of WholeProgram mode. This was due
+to the complexity of mixing source and export data packages (now
+resolved by the upward traversal mentioned above), and because export data
+files were nearly always missing or stale. Now that 'go build' supports
+caching, all the underlying build systems can guarantee to produce
+export data in a reasonable (amortized) time.
+
+Test "main" packages synthesized by the build system are now reported as
+first-class packages, avoiding the need for clients (such as go/ssa) to
+reinvent this generation logic.
+
+One way in which go/packages is simpler than the old loader is in its
+treatment of in-package tests. In-package tests are packages that
+consist of all the files of the library under test, plus the test files.
+The old loader constructed in-package tests by a two-phase process of
+mutation called "augmentation": first it would construct and type check
+all the ordinary library packages and type-check the packages that
+depend on them; then it would add more (test) files to the package and
+type-check again. This two-phase approach had four major problems:
+1) in processing the tests, the loader modified the library package,
+   leaving no way for a client application to see both the test
+   package and the library package; one would mutate into the other.
+2) because test files can declare additional methods on types defined in
+   the library portion of the package, the dispatch of method calls in
+   the library portion was affected by the presence of the test files.
+   This should have been a clue that the packages were logically
+   different.
+3) this model of "augmentation" assumed at most one in-package test
+   per library package, which is true of projects using 'go build',
+   but not other build systems.
+4) because of the two-phase nature of test processing, all packages that
+   import the library package had to be processed before augmentation,
+   forcing a "one-shot" API and preventing the client from calling Load
+   in several times in sequence as is now possible in WholeProgram mode.
+   (TypeCheck mode has a similar one-shot restriction for a different reason.)
+
+Early drafts of this package supported "multi-shot" operation.
+Although it allowed clients to make a sequence of calls (or concurrent
+calls) to Load, building up the graph of Packages incrementally,
+it was of marginal value: it complicated the API
+(since it allowed some options to vary across calls but not others),
+it complicated the implementation,
+it cannot be made to work in Types mode, as explained above,
+and it was less efficient than making one combined call (when this is possible).
+Among the clients we have inspected, none made multiple calls to load
+but could not be easily and satisfactorily modified to make only a single call.
+However, applications changes may be required.
+For example, the ssadump command loads the user-specified packages
+and in addition the runtime package.  It is tempting to simply append
+"runtime" to the user-provided list, but that does not work if the user
+specified an ad-hoc package such as [a.go b.go].
+Instead, ssadump no longer requests the runtime package,
+but seeks it among the dependencies of the user-specified packages,
+and emits an error if it is not found.
+
+Overlays: The Overlay field in the Config allows providing alternate contents
+for Go source files, by providing a mapping from file path to contents.
+go/packages will pull in new imports added in overlay files when go/packages
+is run in LoadImports mode or greater.
+Overlay support for the go list driver isn't complete yet: if the file doesn't
+exist on disk, it will only be recognized in an overlay if it is a non-test file
+and the package would be reported even without the overlay.
+
+Questions & Tasks
+
+- Add GOARCH/GOOS?
+  They are not portable concepts, but could be made portable.
+  Our goal has been to allow users to express themselves using the conventions
+  of the underlying build system: if the build system honors GOARCH
+  during a build and during a metadata query, then so should
+  applications built atop that query mechanism.
+  Conversely, if the target architecture of the build is determined by
+  command-line flags, the application can pass the relevant
+  flags through to the build system using a command such as:
+    myapp -query_flag="--cpu=amd64" -query_flag="--os=darwin"
+  However, this approach is low-level, unwieldy, and non-portable.
+  GOOS and GOARCH seem important enough to warrant a dedicated option.
+
+- How should we handle partial failures such as a mixture of good and
+  malformed patterns, existing and non-existent packages, successful and
+  failed builds, import failures, import cycles, and so on, in a call to
+  Load?
+
+- Support bazel, blaze, and go1.10 list, not just go1.11 list.
+
+- Handle (and test) various partial success cases, e.g.
+  a mixture of good packages and:
+  invalid patterns
+  nonexistent packages
+  empty packages
+  packages with malformed package or import declarations
+  unreadable files
+  import cycles
+  other parse errors
+  type errors
+  Make sure we record errors at the correct place in the graph.
+
+- Missing packages among initial arguments are not reported.
+  Return bogus packages for them, like golist does.
+
+- "undeclared name" errors (for example) are reported out of source file
+  order. I suspect this is due to the breadth-first resolution now used
+  by go/types. Is that a bug? Discuss with gri.
+
+*/
diff --git a/vendor/golang.org/x/tools/go/packages/external.go b/vendor/golang.org/x/tools/go/packages/external.go
new file mode 100644
index 000000000..22ff769ef
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/external.go
@@ -0,0 +1,79 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file enables an external tool to intercept package requests.
+// If the tool is present then its results are used in preference to
+// the go list command.
+
+package packages
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+// Driver
+type driverRequest struct {
+	Command    string            `json:"command"`
+	Mode       LoadMode          `json:"mode"`
+	Env        []string          `json:"env"`
+	BuildFlags []string          `json:"build_flags"`
+	Tests      bool              `json:"tests"`
+	Overlay    map[string][]byte `json:"overlay"`
+}
+
+// findExternalDriver returns the file path of a tool that supplies
+// the build system package structure, or "" if not found."
+// If GOPACKAGESDRIVER is set in the environment findExternalTool returns its
+// value, otherwise it searches for a binary named gopackagesdriver on the PATH.
+func findExternalDriver(cfg *Config) driver {
+	const toolPrefix = "GOPACKAGESDRIVER="
+	tool := ""
+	for _, env := range cfg.Env {
+		if val := strings.TrimPrefix(env, toolPrefix); val != env {
+			tool = val
+		}
+	}
+	if tool != "" && tool == "off" {
+		return nil
+	}
+	if tool == "" {
+		var err error
+		tool, err = exec.LookPath("gopackagesdriver")
+		if err != nil {
+			return nil
+		}
+	}
+	return func(cfg *Config, words ...string) (*driverResponse, error) {
+		req, err := json.Marshal(driverRequest{
+			Mode:       cfg.Mode,
+			Env:        cfg.Env,
+			BuildFlags: cfg.BuildFlags,
+			Tests:      cfg.Tests,
+			Overlay:    cfg.Overlay,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to encode message to driver tool: %v", err)
+		}
+
+		buf := new(bytes.Buffer)
+		cmd := exec.CommandContext(cfg.Context, tool, words...)
+		cmd.Dir = cfg.Dir
+		cmd.Env = cfg.Env
+		cmd.Stdin = bytes.NewReader(req)
+		cmd.Stdout = buf
+		cmd.Stderr = new(bytes.Buffer)
+		if err := cmd.Run(); err != nil {
+			return nil, fmt.Errorf("%v: %v: %s", tool, err, cmd.Stderr)
+		}
+		var response driverResponse
+		if err := json.Unmarshal(buf.Bytes(), &response); err != nil {
+			return nil, err
+		}
+		return &response, nil
+	}
+}
diff --git a/vendor/golang.org/x/tools/go/packages/golist.go b/vendor/golang.org/x/tools/go/packages/golist.go
new file mode 100644
index 000000000..00e21a755
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/golist.go
@@ -0,0 +1,870 @@
+// Copyright 2018 The Go 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 packages
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/types"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/tools/go/internal/packagesdriver"
+	"golang.org/x/tools/internal/gopathwalk"
+	"golang.org/x/tools/internal/semver"
+)
+
+// debug controls verbose logging.
+var debug, _ = strconv.ParseBool(os.Getenv("GOPACKAGESDEBUG"))
+
+// A goTooOldError reports that the go command
+// found by exec.LookPath is too old to use the new go list behavior.
+type goTooOldError struct {
+	error
+}
+
+// responseDeduper wraps a driverResponse, deduplicating its contents.
+type responseDeduper struct {
+	seenRoots    map[string]bool
+	seenPackages map[string]*Package
+	dr           *driverResponse
+}
+
+// init fills in r with a driverResponse.
+func (r *responseDeduper) init(dr *driverResponse) {
+	r.dr = dr
+	r.seenRoots = map[string]bool{}
+	r.seenPackages = map[string]*Package{}
+	for _, pkg := range dr.Packages {
+		r.seenPackages[pkg.ID] = pkg
+	}
+	for _, root := range dr.Roots {
+		r.seenRoots[root] = true
+	}
+}
+
+func (r *responseDeduper) addPackage(p *Package) {
+	if r.seenPackages[p.ID] != nil {
+		return
+	}
+	r.seenPackages[p.ID] = p
+	r.dr.Packages = append(r.dr.Packages, p)
+}
+
+func (r *responseDeduper) addRoot(id string) {
+	if r.seenRoots[id] {
+		return
+	}
+	r.seenRoots[id] = true
+	r.dr.Roots = append(r.dr.Roots, id)
+}
+
+// goListDriver uses the go list command to interpret the patterns and produce
+// the build system package structure.
+// See driver for more details.
+func goListDriver(cfg *Config, patterns ...string) (*driverResponse, error) {
+	var sizes types.Sizes
+	var sizeserr error
+	var sizeswg sync.WaitGroup
+	if cfg.Mode&NeedTypesSizes != 0 || cfg.Mode&NeedTypes != 0 {
+		sizeswg.Add(1)
+		go func() {
+			sizes, sizeserr = getSizes(cfg)
+			sizeswg.Done()
+		}()
+	}
+
+	// Determine files requested in contains patterns
+	var containFiles []string
+	var packagesNamed []string
+	restPatterns := make([]string, 0, len(patterns))
+	// Extract file= and other [querytype]= patterns. Report an error if querytype
+	// doesn't exist.
+extractQueries:
+	for _, pattern := range patterns {
+		eqidx := strings.Index(pattern, "=")
+		if eqidx < 0 {
+			restPatterns = append(restPatterns, pattern)
+		} else {
+			query, value := pattern[:eqidx], pattern[eqidx+len("="):]
+			switch query {
+			case "file":
+				containFiles = append(containFiles, value)
+			case "pattern":
+				restPatterns = append(restPatterns, value)
+			case "iamashamedtousethedisabledqueryname":
+				packagesNamed = append(packagesNamed, value)
+			case "": // not a reserved query
+				restPatterns = append(restPatterns, pattern)
+			default:
+				for _, rune := range query {
+					if rune < 'a' || rune > 'z' { // not a reserved query
+						restPatterns = append(restPatterns, pattern)
+						continue extractQueries
+					}
+				}
+				// Reject all other patterns containing "="
+				return nil, fmt.Errorf("invalid query type %q in query pattern %q", query, pattern)
+			}
+		}
+	}
+
+	response := &responseDeduper{}
+	var err error
+
+	// See if we have any patterns to pass through to go list. Zero initial
+	// patterns also requires a go list call, since it's the equivalent of
+	// ".".
+	if len(restPatterns) > 0 || len(patterns) == 0 {
+		dr, err := golistDriver(cfg, restPatterns...)
+		if err != nil {
+			return nil, err
+		}
+		response.init(dr)
+	} else {
+		response.init(&driverResponse{})
+	}
+
+	sizeswg.Wait()
+	if sizeserr != nil {
+		return nil, sizeserr
+	}
+	// types.SizesFor always returns nil or a *types.StdSizes
+	response.dr.Sizes, _ = sizes.(*types.StdSizes)
+
+	var containsCandidates []string
+
+	if len(containFiles) != 0 {
+		if err := runContainsQueries(cfg, golistDriver, response, containFiles); err != nil {
+			return nil, err
+		}
+	}
+
+	if len(packagesNamed) != 0 {
+		if err := runNamedQueries(cfg, golistDriver, response, packagesNamed); err != nil {
+			return nil, err
+		}
+	}
+
+	modifiedPkgs, needPkgs, err := processGolistOverlay(cfg, response)
+	if err != nil {
+		return nil, err
+	}
+	if len(containFiles) > 0 {
+		containsCandidates = append(containsCandidates, modifiedPkgs...)
+		containsCandidates = append(containsCandidates, needPkgs...)
+	}
+	if err := addNeededOverlayPackages(cfg, golistDriver, response, needPkgs); err != nil {
+		return nil, err
+	}
+	// Check candidate packages for containFiles.
+	if len(containFiles) > 0 {
+		for _, id := range containsCandidates {
+			pkg, ok := response.seenPackages[id]
+			if !ok {
+				response.addPackage(&Package{
+					ID: id,
+					Errors: []Error{
+						{
+							Kind: ListError,
+							Msg:  fmt.Sprintf("package %s expected but not seen", id),
+						},
+					},
+				})
+				continue
+			}
+			for _, f := range containFiles {
+				for _, g := range pkg.GoFiles {
+					if sameFile(f, g) {
+						response.addRoot(id)
+					}
+				}
+			}
+		}
+	}
+
+	return response.dr, nil
+}
+
+func addNeededOverlayPackages(cfg *Config, driver driver, response *responseDeduper, pkgs []string) error {
+	if len(pkgs) == 0 {
+		return nil
+	}
+	dr, err := driver(cfg, pkgs...)
+	if err != nil {
+		return err
+	}
+	for _, pkg := range dr.Packages {
+		response.addPackage(pkg)
+	}
+	_, needPkgs, err := processGolistOverlay(cfg, response)
+	if err != nil {
+		return err
+	}
+	if err := addNeededOverlayPackages(cfg, driver, response, needPkgs); err != nil {
+		return err
+	}
+	return nil
+}
+
+func runContainsQueries(cfg *Config, driver driver, response *responseDeduper, queries []string) error {
+	for _, query := range queries {
+		// TODO(matloob): Do only one query per directory.
+		fdir := filepath.Dir(query)
+		// Pass absolute path of directory to go list so that it knows to treat it as a directory,
+		// not a package path.
+		pattern, err := filepath.Abs(fdir)
+		if err != nil {
+			return fmt.Errorf("could not determine absolute path of file= query path %q: %v", query, err)
+		}
+		dirResponse, err := driver(cfg, pattern)
+		if err != nil || (len(dirResponse.Packages) == 1 && len(dirResponse.Packages[0].Errors) == 1) {
+			// There was an error loading the package. Try to load the file as an ad-hoc package.
+			// Usually the error will appear in a returned package, but may not if we're in modules mode
+			// and the ad-hoc is located outside a module.
+			var queryErr error
+			dirResponse, queryErr = driver(cfg, query)
+			if queryErr != nil {
+				// Return the original error if the attempt to fall back failed.
+				return err
+			}
+		}
+		isRoot := make(map[string]bool, len(dirResponse.Roots))
+		for _, root := range dirResponse.Roots {
+			isRoot[root] = true
+		}
+		for _, pkg := range dirResponse.Packages {
+			// Add any new packages to the main set
+			// We don't bother to filter packages that will be dropped by the changes of roots,
+			// that will happen anyway during graph construction outside this function.
+			// Over-reporting packages is not a problem.
+			response.addPackage(pkg)
+			// if the package was not a root one, it cannot have the file
+			if !isRoot[pkg.ID] {
+				continue
+			}
+			for _, pkgFile := range pkg.GoFiles {
+				if filepath.Base(query) == filepath.Base(pkgFile) {
+					response.addRoot(pkg.ID)
+					break
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// modCacheRegexp splits a path in a module cache into module, module version, and package.
+var modCacheRegexp = regexp.MustCompile(`(.*)@([^/\\]*)(.*)`)
+
+func runNamedQueries(cfg *Config, driver driver, response *responseDeduper, queries []string) error {
+	// calling `go env` isn't free; bail out if there's nothing to do.
+	if len(queries) == 0 {
+		return nil
+	}
+	// Determine which directories are relevant to scan.
+	roots, modRoot, err := roots(cfg)
+	if err != nil {
+		return err
+	}
+
+	// Scan the selected directories. Simple matches, from GOPATH/GOROOT
+	// or the local module, can simply be "go list"ed. Matches from the
+	// module cache need special treatment.
+	var matchesMu sync.Mutex
+	var simpleMatches, modCacheMatches []string
+	add := func(root gopathwalk.Root, dir string) {
+		// Walk calls this concurrently; protect the result slices.
+		matchesMu.Lock()
+		defer matchesMu.Unlock()
+
+		path := dir
+		if dir != root.Path {
+			path = dir[len(root.Path)+1:]
+		}
+		if pathMatchesQueries(path, queries) {
+			switch root.Type {
+			case gopathwalk.RootModuleCache:
+				modCacheMatches = append(modCacheMatches, path)
+			case gopathwalk.RootCurrentModule:
+				// We'd need to read go.mod to find the full
+				// import path. Relative's easier.
+				rel, err := filepath.Rel(cfg.Dir, dir)
+				if err != nil {
+					// This ought to be impossible, since
+					// we found dir in the current module.
+					panic(err)
+				}
+				simpleMatches = append(simpleMatches, "./"+rel)
+			case gopathwalk.RootGOPATH, gopathwalk.RootGOROOT:
+				simpleMatches = append(simpleMatches, path)
+			}
+		}
+	}
+
+	startWalk := time.Now()
+	gopathwalk.Walk(roots, add, gopathwalk.Options{ModulesEnabled: modRoot != "", Debug: debug})
+	if debug {
+		log.Printf("%v for walk", time.Since(startWalk))
+	}
+
+	// Weird special case: the top-level package in a module will be in
+	// whatever directory the user checked the repository out into. It's
+	// more reasonable for that to not match the package name. So, if there
+	// are any Go files in the mod root, query it just to be safe.
+	if modRoot != "" {
+		rel, err := filepath.Rel(cfg.Dir, modRoot)
+		if err != nil {
+			panic(err) // See above.
+		}
+
+		files, err := ioutil.ReadDir(modRoot)
+		for _, f := range files {
+			if strings.HasSuffix(f.Name(), ".go") {
+				simpleMatches = append(simpleMatches, rel)
+				break
+			}
+		}
+	}
+
+	addResponse := func(r *driverResponse) {
+		for _, pkg := range r.Packages {
+			response.addPackage(pkg)
+			for _, name := range queries {
+				if pkg.Name == name {
+					response.addRoot(pkg.ID)
+					break
+				}
+			}
+		}
+	}
+
+	if len(simpleMatches) != 0 {
+		resp, err := driver(cfg, simpleMatches...)
+		if err != nil {
+			return err
+		}
+		addResponse(resp)
+	}
+
+	// Module cache matches are tricky. We want to avoid downloading new
+	// versions of things, so we need to use the ones present in the cache.
+	// go list doesn't accept version specifiers, so we have to write out a
+	// temporary module, and do the list in that module.
+	if len(modCacheMatches) != 0 {
+		// Collect all the matches, deduplicating by major version
+		// and preferring the newest.
+		type modInfo struct {
+			mod   string
+			major string
+		}
+		mods := make(map[modInfo]string)
+		var imports []string
+		for _, modPath := range modCacheMatches {
+			matches := modCacheRegexp.FindStringSubmatch(modPath)
+			mod, ver := filepath.ToSlash(matches[1]), matches[2]
+			importPath := filepath.ToSlash(filepath.Join(matches[1], matches[3]))
+
+			major := semver.Major(ver)
+			if prevVer, ok := mods[modInfo{mod, major}]; !ok || semver.Compare(ver, prevVer) > 0 {
+				mods[modInfo{mod, major}] = ver
+			}
+
+			imports = append(imports, importPath)
+		}
+
+		// Build the temporary module.
+		var gomod bytes.Buffer
+		gomod.WriteString("module modquery\nrequire (\n")
+		for mod, version := range mods {
+			gomod.WriteString("\t" + mod.mod + " " + version + "\n")
+		}
+		gomod.WriteString(")\n")
+
+		tmpCfg := *cfg
+
+		// We're only trying to look at stuff in the module cache, so
+		// disable the network. This should speed things up, and has
+		// prevented errors in at least one case, #28518.
+		tmpCfg.Env = append(append([]string{"GOPROXY=off"}, cfg.Env...))
+
+		var err error
+		tmpCfg.Dir, err = ioutil.TempDir("", "gopackages-modquery")
+		if err != nil {
+			return err
+		}
+		defer os.RemoveAll(tmpCfg.Dir)
+
+		if err := ioutil.WriteFile(filepath.Join(tmpCfg.Dir, "go.mod"), gomod.Bytes(), 0777); err != nil {
+			return fmt.Errorf("writing go.mod for module cache query: %v", err)
+		}
+
+		// Run the query, using the import paths calculated from the matches above.
+		resp, err := driver(&tmpCfg, imports...)
+		if err != nil {
+			return fmt.Errorf("querying module cache matches: %v", err)
+		}
+		addResponse(resp)
+	}
+
+	return nil
+}
+
+func getSizes(cfg *Config) (types.Sizes, error) {
+	return packagesdriver.GetSizesGolist(cfg.Context, cfg.BuildFlags, cfg.Env, cfg.Dir, usesExportData(cfg))
+}
+
+// roots selects the appropriate paths to walk based on the passed-in configuration,
+// particularly the environment and the presence of a go.mod in cfg.Dir's parents.
+func roots(cfg *Config) ([]gopathwalk.Root, string, error) {
+	stdout, err := invokeGo(cfg, "env", "GOROOT", "GOPATH", "GOMOD")
+	if err != nil {
+		return nil, "", err
+	}
+
+	fields := strings.Split(stdout.String(), "\n")
+	if len(fields) != 4 || len(fields[3]) != 0 {
+		return nil, "", fmt.Errorf("go env returned unexpected output: %q", stdout.String())
+	}
+	goroot, gopath, gomod := fields[0], filepath.SplitList(fields[1]), fields[2]
+	var modDir string
+	if gomod != "" {
+		modDir = filepath.Dir(gomod)
+	}
+
+	var roots []gopathwalk.Root
+	// Always add GOROOT.
+	roots = append(roots, gopathwalk.Root{filepath.Join(goroot, "/src"), gopathwalk.RootGOROOT})
+	// If modules are enabled, scan the module dir.
+	if modDir != "" {
+		roots = append(roots, gopathwalk.Root{modDir, gopathwalk.RootCurrentModule})
+	}
+	// Add either GOPATH/src or GOPATH/pkg/mod, depending on module mode.
+	for _, p := range gopath {
+		if modDir != "" {
+			roots = append(roots, gopathwalk.Root{filepath.Join(p, "/pkg/mod"), gopathwalk.RootModuleCache})
+		} else {
+			roots = append(roots, gopathwalk.Root{filepath.Join(p, "/src"), gopathwalk.RootGOPATH})
+		}
+	}
+
+	return roots, modDir, nil
+}
+
+// These functions were copied from goimports. See further documentation there.
+
+// pathMatchesQueries is adapted from pkgIsCandidate.
+// TODO: is it reasonable to do Contains here, rather than an exact match on a path component?
+func pathMatchesQueries(path string, queries []string) bool {
+	lastTwo := lastTwoComponents(path)
+	for _, query := range queries {
+		if strings.Contains(lastTwo, query) {
+			return true
+		}
+		if hasHyphenOrUpperASCII(lastTwo) && !hasHyphenOrUpperASCII(query) {
+			lastTwo = lowerASCIIAndRemoveHyphen(lastTwo)
+			if strings.Contains(lastTwo, query) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// lastTwoComponents returns at most the last two path components
+// of v, using either / or \ as the path separator.
+func lastTwoComponents(v string) string {
+	nslash := 0
+	for i := len(v) - 1; i >= 0; i-- {
+		if v[i] == '/' || v[i] == '\\' {
+			nslash++
+			if nslash == 2 {
+				return v[i:]
+			}
+		}
+	}
+	return v
+}
+
+func hasHyphenOrUpperASCII(s string) bool {
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		if b == '-' || ('A' <= b && b <= 'Z') {
+			return true
+		}
+	}
+	return false
+}
+
+func lowerASCIIAndRemoveHyphen(s string) (ret string) {
+	buf := make([]byte, 0, len(s))
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		switch {
+		case b == '-':
+			continue
+		case 'A' <= b && b <= 'Z':
+			buf = append(buf, b+('a'-'A'))
+		default:
+			buf = append(buf, b)
+		}
+	}
+	return string(buf)
+}
+
+// Fields must match go list;
+// see $GOROOT/src/cmd/go/internal/load/pkg.go.
+type jsonPackage struct {
+	ImportPath      string
+	Dir             string
+	Name            string
+	Export          string
+	GoFiles         []string
+	CompiledGoFiles []string
+	CFiles          []string
+	CgoFiles        []string
+	CXXFiles        []string
+	MFiles          []string
+	HFiles          []string
+	FFiles          []string
+	SFiles          []string
+	SwigFiles       []string
+	SwigCXXFiles    []string
+	SysoFiles       []string
+	Imports         []string
+	ImportMap       map[string]string
+	Deps            []string
+	TestGoFiles     []string
+	TestImports     []string
+	XTestGoFiles    []string
+	XTestImports    []string
+	ForTest         string // q in a "p [q.test]" package, else ""
+	DepOnly         bool
+
+	Error *jsonPackageError
+}
+
+type jsonPackageError struct {
+	ImportStack []string
+	Pos         string
+	Err         string
+}
+
+func otherFiles(p *jsonPackage) [][]string {
+	return [][]string{p.CFiles, p.CXXFiles, p.MFiles, p.HFiles, p.FFiles, p.SFiles, p.SwigFiles, p.SwigCXXFiles, p.SysoFiles}
+}
+
+// golistDriver uses the "go list" command to expand the pattern
+// words and return metadata for the specified packages. dir may be
+// "" and env may be nil, as per os/exec.Command.
+func golistDriver(cfg *Config, words ...string) (*driverResponse, error) {
+	// go list uses the following identifiers in ImportPath and Imports:
+	//
+	// 	"p"			-- importable package or main (command)
+	//      "q.test"		-- q's test executable
+	// 	"p [q.test]"		-- variant of p as built for q's test executable
+	//	"q_test [q.test]"	-- q's external test package
+	//
+	// The packages p that are built differently for a test q.test
+	// are q itself, plus any helpers used by the external test q_test,
+	// typically including "testing" and all its dependencies.
+
+	// Run "go list" for complete
+	// information on the specified packages.
+	buf, err := invokeGo(cfg, golistargs(cfg, words)...)
+	if err != nil {
+		return nil, err
+	}
+	seen := make(map[string]*jsonPackage)
+	// Decode the JSON and convert it to Package form.
+	var response driverResponse
+	for dec := json.NewDecoder(buf); dec.More(); {
+		p := new(jsonPackage)
+		if err := dec.Decode(p); err != nil {
+			return nil, fmt.Errorf("JSON decoding failed: %v", err)
+		}
+
+		if p.ImportPath == "" {
+			// The documentation for go list says that “[e]rroneous packages will have
+			// a non-empty ImportPath”. If for some reason it comes back empty, we
+			// prefer to error out rather than silently discarding data or handing
+			// back a package without any way to refer to it.
+			if p.Error != nil {
+				return nil, Error{
+					Pos: p.Error.Pos,
+					Msg: p.Error.Err,
+				}
+			}
+			return nil, fmt.Errorf("package missing import path: %+v", p)
+		}
+
+		if old, found := seen[p.ImportPath]; found {
+			if !reflect.DeepEqual(p, old) {
+				return nil, fmt.Errorf("internal error: go list gives conflicting information for package %v", p.ImportPath)
+			}
+			// skip the duplicate
+			continue
+		}
+		seen[p.ImportPath] = p
+
+		pkg := &Package{
+			Name:            p.Name,
+			ID:              p.ImportPath,
+			GoFiles:         absJoin(p.Dir, p.GoFiles, p.CgoFiles),
+			CompiledGoFiles: absJoin(p.Dir, p.CompiledGoFiles),
+			OtherFiles:      absJoin(p.Dir, otherFiles(p)...),
+		}
+
+		// Work around https://golang.org/issue/28749:
+		// cmd/go puts assembly, C, and C++ files in CompiledGoFiles.
+		// Filter out any elements of CompiledGoFiles that are also in OtherFiles.
+		// We have to keep this workaround in place until go1.12 is a distant memory.
+		if len(pkg.OtherFiles) > 0 {
+			other := make(map[string]bool, len(pkg.OtherFiles))
+			for _, f := range pkg.OtherFiles {
+				other[f] = true
+			}
+
+			out := pkg.CompiledGoFiles[:0]
+			for _, f := range pkg.CompiledGoFiles {
+				if other[f] {
+					continue
+				}
+				out = append(out, f)
+			}
+			pkg.CompiledGoFiles = out
+		}
+
+		// Extract the PkgPath from the package's ID.
+		if i := strings.IndexByte(pkg.ID, ' '); i >= 0 {
+			pkg.PkgPath = pkg.ID[:i]
+		} else {
+			pkg.PkgPath = pkg.ID
+		}
+
+		if pkg.PkgPath == "unsafe" {
+			pkg.GoFiles = nil // ignore fake unsafe.go file
+		}
+
+		// Assume go list emits only absolute paths for Dir.
+		if p.Dir != "" && !filepath.IsAbs(p.Dir) {
+			log.Fatalf("internal error: go list returned non-absolute Package.Dir: %s", p.Dir)
+		}
+
+		if p.Export != "" && !filepath.IsAbs(p.Export) {
+			pkg.ExportFile = filepath.Join(p.Dir, p.Export)
+		} else {
+			pkg.ExportFile = p.Export
+		}
+
+		// imports
+		//
+		// Imports contains the IDs of all imported packages.
+		// ImportsMap records (path, ID) only where they differ.
+		ids := make(map[string]bool)
+		for _, id := range p.Imports {
+			ids[id] = true
+		}
+		pkg.Imports = make(map[string]*Package)
+		for path, id := range p.ImportMap {
+			pkg.Imports[path] = &Package{ID: id} // non-identity import
+			delete(ids, id)
+		}
+		for id := range ids {
+			if id == "C" {
+				continue
+			}
+
+			pkg.Imports[id] = &Package{ID: id} // identity import
+		}
+		if !p.DepOnly {
+			response.Roots = append(response.Roots, pkg.ID)
+		}
+
+		// Work around for pre-go.1.11 versions of go list.
+		// TODO(matloob): they should be handled by the fallback.
+		// Can we delete this?
+		if len(pkg.CompiledGoFiles) == 0 {
+			pkg.CompiledGoFiles = pkg.GoFiles
+		}
+
+		if p.Error != nil {
+			pkg.Errors = append(pkg.Errors, Error{
+				Pos: p.Error.Pos,
+				Msg: strings.TrimSpace(p.Error.Err), // Trim to work around golang.org/issue/32363.
+			})
+		}
+
+		response.Packages = append(response.Packages, pkg)
+	}
+
+	return &response, nil
+}
+
+// absJoin absolutizes and flattens the lists of files.
+func absJoin(dir string, fileses ...[]string) (res []string) {
+	for _, files := range fileses {
+		for _, file := range files {
+			if !filepath.IsAbs(file) {
+				file = filepath.Join(dir, file)
+			}
+			res = append(res, file)
+		}
+	}
+	return res
+}
+
+func golistargs(cfg *Config, words []string) []string {
+	const findFlags = NeedImports | NeedTypes | NeedSyntax | NeedTypesInfo
+	fullargs := []string{
+		"list", "-e", "-json",
+		fmt.Sprintf("-compiled=%t", cfg.Mode&(NeedCompiledGoFiles|NeedSyntax|NeedTypesInfo|NeedTypesSizes) != 0),
+		fmt.Sprintf("-test=%t", cfg.Tests),
+		fmt.Sprintf("-export=%t", usesExportData(cfg)),
+		fmt.Sprintf("-deps=%t", cfg.Mode&NeedDeps != 0),
+		// go list doesn't let you pass -test and -find together,
+		// probably because you'd just get the TestMain.
+		fmt.Sprintf("-find=%t", !cfg.Tests && cfg.Mode&findFlags == 0),
+	}
+	fullargs = append(fullargs, cfg.BuildFlags...)
+	fullargs = append(fullargs, "--")
+	fullargs = append(fullargs, words...)
+	return fullargs
+}
+
+// invokeGo returns the stdout of a go command invocation.
+func invokeGo(cfg *Config, args ...string) (*bytes.Buffer, error) {
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+	cmd := exec.CommandContext(cfg.Context, "go", args...)
+	// On darwin the cwd gets resolved to the real path, which breaks anything that
+	// expects the working directory to keep the original path, including the
+	// go command when dealing with modules.
+	// The Go stdlib has a special feature where if the cwd and the PWD are the
+	// same node then it trusts the PWD, so by setting it in the env for the child
+	// process we fix up all the paths returned by the go command.
+	cmd.Env = append(append([]string{}, cfg.Env...), "PWD="+cfg.Dir)
+	cmd.Dir = cfg.Dir
+	cmd.Stdout = stdout
+	cmd.Stderr = stderr
+	if debug {
+		defer func(start time.Time) {
+			log.Printf("%s for %v, stderr: <<%s>>\n", time.Since(start), cmdDebugStr(cmd, args...), stderr)
+		}(time.Now())
+	}
+
+	if err := cmd.Run(); err != nil {
+		// Check for 'go' executable not being found.
+		if ee, ok := err.(*exec.Error); ok && ee.Err == exec.ErrNotFound {
+			return nil, fmt.Errorf("'go list' driver requires 'go', but %s", exec.ErrNotFound)
+		}
+
+		exitErr, ok := err.(*exec.ExitError)
+		if !ok {
+			// Catastrophic error:
+			// - context cancellation
+			return nil, fmt.Errorf("couldn't exec 'go %v': %s %T", args, err, err)
+		}
+
+		// Old go version?
+		if strings.Contains(stderr.String(), "flag provided but not defined") {
+			return nil, goTooOldError{fmt.Errorf("unsupported version of go: %s: %s", exitErr, stderr)}
+		}
+
+		// This error only appears in stderr. See golang.org/cl/166398 for a fix in go list to show
+		// the error in the Err section of stdout in case -e option is provided.
+		// This fix is provided for backwards compatibility.
+		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "named files must be .go files") {
+			output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+				strings.Trim(stderr.String(), "\n"))
+			return bytes.NewBufferString(output), nil
+		}
+
+		// Workaround for #29280: go list -e has incorrect behavior when an ad-hoc package doesn't exist.
+		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "no such file or directory") {
+			output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+				strings.Trim(stderr.String(), "\n"))
+			return bytes.NewBufferString(output), nil
+		}
+
+		// Workaround for an instance of golang.org/issue/26755: go list -e  will return a non-zero exit
+		// status if there's a dependency on a package that doesn't exist. But it should return
+		// a zero exit status and set an error on that package.
+		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "no Go files in") {
+			// try to extract package name from string
+			stderrStr := stderr.String()
+			var importPath string
+			colon := strings.Index(stderrStr, ":")
+			if colon > 0 && strings.HasPrefix(stderrStr, "go build ") {
+				importPath = stderrStr[len("go build "):colon]
+			}
+			output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+				importPath, strings.Trim(stderrStr, "\n"))
+			return bytes.NewBufferString(output), nil
+		}
+
+		// Export mode entails a build.
+		// If that build fails, errors appear on stderr
+		// (despite the -e flag) and the Export field is blank.
+		// Do not fail in that case.
+		// The same is true if an ad-hoc package given to go list doesn't exist.
+		// TODO(matloob): Remove these once we can depend on go list to exit with a zero status with -e even when
+		// packages don't exist or a build fails.
+		if !usesExportData(cfg) && !containsGoFile(args) {
+			return nil, fmt.Errorf("go %v: %s: %s", args, exitErr, stderr)
+		}
+	}
+
+	// As of writing, go list -export prints some non-fatal compilation
+	// errors to stderr, even with -e set. We would prefer that it put
+	// them in the Package.Error JSON (see https://golang.org/issue/26319).
+	// In the meantime, there's nowhere good to put them, but they can
+	// be useful for debugging. Print them if $GOPACKAGESPRINTGOLISTERRORS
+	// is set.
+	if len(stderr.Bytes()) != 0 && os.Getenv("GOPACKAGESPRINTGOLISTERRORS") != "" {
+		fmt.Fprintf(os.Stderr, "%s stderr: <<%s>>\n", cmdDebugStr(cmd, args...), stderr)
+	}
+
+	// debugging
+	if false {
+		fmt.Fprintf(os.Stderr, "%s stdout: <<%s>>\n", cmdDebugStr(cmd, args...), stdout)
+	}
+
+	return stdout, nil
+}
+
+func containsGoFile(s []string) bool {
+	for _, f := range s {
+		if strings.HasSuffix(f, ".go") {
+			return true
+		}
+	}
+	return false
+}
+
+func cmdDebugStr(cmd *exec.Cmd, args ...string) string {
+	env := make(map[string]string)
+	for _, kv := range cmd.Env {
+		split := strings.Split(kv, "=")
+		k, v := split[0], split[1]
+		env[k] = v
+	}
+	var quotedArgs []string
+	for _, arg := range args {
+		quotedArgs = append(quotedArgs, strconv.Quote(arg))
+	}
+
+	return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v PWD=%v go %s", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["PWD"], strings.Join(quotedArgs, " "))
+}
diff --git a/vendor/golang.org/x/tools/go/packages/golist_overlay.go b/vendor/golang.org/x/tools/go/packages/golist_overlay.go
new file mode 100644
index 000000000..ffc7a367f
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/golist_overlay.go
@@ -0,0 +1,300 @@
+package packages
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/parser"
+	"go/token"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+// processGolistOverlay provides rudimentary support for adding
+// files that don't exist on disk to an overlay. The results can be
+// sometimes incorrect.
+// TODO(matloob): Handle unsupported cases, including the following:
+// - determining the correct package to add given a new import path
+func processGolistOverlay(cfg *Config, response *responseDeduper) (modifiedPkgs, needPkgs []string, err error) {
+	havePkgs := make(map[string]string) // importPath -> non-test package ID
+	needPkgsSet := make(map[string]bool)
+	modifiedPkgsSet := make(map[string]bool)
+
+	for _, pkg := range response.dr.Packages {
+		// This is an approximation of import path to id. This can be
+		// wrong for tests, vendored packages, and a number of other cases.
+		havePkgs[pkg.PkgPath] = pkg.ID
+	}
+
+	var rootDirs map[string]string
+	var onceGetRootDirs sync.Once
+
+	// If no new imports are added, it is safe to avoid loading any needPkgs.
+	// Otherwise, it's hard to tell which package is actually being loaded
+	// (due to vendoring) and whether any modified package will show up
+	// in the transitive set of dependencies (because new imports are added,
+	// potentially modifying the transitive set of dependencies).
+	var overlayAddsImports bool
+
+	for opath, contents := range cfg.Overlay {
+		base := filepath.Base(opath)
+		dir := filepath.Dir(opath)
+		var pkg *Package
+		var testVariantOf *Package // if opath is a test file, this is the package it is testing
+		var fileExists bool
+		isTest := strings.HasSuffix(opath, "_test.go")
+		pkgName, ok := extractPackageName(opath, contents)
+		if !ok {
+			// Don't bother adding a file that doesn't even have a parsable package statement
+			// to the overlay.
+			continue
+		}
+	nextPackage:
+		for _, p := range response.dr.Packages {
+			if pkgName != p.Name {
+				continue
+			}
+			for _, f := range p.GoFiles {
+				if !sameFile(filepath.Dir(f), dir) {
+					continue
+				}
+				if isTest && !hasTestFiles(p) {
+					// TODO(matloob): Are there packages other than the 'production' variant
+					// of a package that this can match? This shouldn't match the test main package
+					// because the file is generated in another directory.
+					testVariantOf = p
+					continue nextPackage
+				}
+				pkg = p
+				if filepath.Base(f) == base {
+					fileExists = true
+				}
+			}
+		}
+		// The overlay could have included an entirely new package.
+		if pkg == nil {
+			onceGetRootDirs.Do(func() {
+				rootDirs = determineRootDirs(cfg)
+			})
+			// Try to find the module or gopath dir the file is contained in.
+			// Then for modules, add the module opath to the beginning.
+			var pkgPath string
+			for rdir, rpath := range rootDirs {
+				// TODO(matloob): This doesn't properly handle symlinks.
+				r, err := filepath.Rel(rdir, dir)
+				if err != nil {
+					continue
+				}
+				pkgPath = filepath.ToSlash(r)
+				if rpath != "" {
+					pkgPath = path.Join(rpath, pkgPath)
+				}
+				// We only create one new package even it can belong in multiple modules or GOPATH entries.
+				// This is okay because tools (such as the LSP) that use overlays will recompute the overlay
+				// once the file is saved, and golist will do the right thing.
+				// TODO(matloob): Implement module tiebreaking?
+				break
+			}
+			if pkgPath == "" {
+				continue
+			}
+			isXTest := strings.HasSuffix(pkgName, "_test")
+			if isXTest {
+				pkgPath += "_test"
+			}
+			id := pkgPath
+			if isTest && !isXTest {
+				id = fmt.Sprintf("%s [%s.test]", pkgPath, pkgPath)
+			}
+			// Try to reclaim a package with the same id if it exists in the response.
+			for _, p := range response.dr.Packages {
+				if reclaimPackage(p, id, opath, contents) {
+					pkg = p
+					break
+				}
+			}
+			// Otherwise, create a new package
+			if pkg == nil {
+				pkg = &Package{PkgPath: pkgPath, ID: id, Name: pkgName, Imports: make(map[string]*Package)}
+				response.addPackage(pkg)
+				havePkgs[pkg.PkgPath] = id
+				// Add the production package's sources for a test variant.
+				if isTest && !isXTest && testVariantOf != nil {
+					pkg.GoFiles = append(pkg.GoFiles, testVariantOf.GoFiles...)
+					pkg.CompiledGoFiles = append(pkg.CompiledGoFiles, testVariantOf.CompiledGoFiles...)
+				}
+			}
+		}
+		if !fileExists {
+			pkg.GoFiles = append(pkg.GoFiles, opath)
+			// TODO(matloob): Adding the file to CompiledGoFiles can exhibit the wrong behavior
+			// if the file will be ignored due to its build tags.
+			pkg.CompiledGoFiles = append(pkg.CompiledGoFiles, opath)
+			modifiedPkgsSet[pkg.ID] = true
+		}
+		imports, err := extractImports(opath, contents)
+		if err != nil {
+			// Let the parser or type checker report errors later.
+			continue
+		}
+		for _, imp := range imports {
+			_, found := pkg.Imports[imp]
+			if !found {
+				overlayAddsImports = true
+				// TODO(matloob): Handle cases when the following block isn't correct.
+				// These include imports of test variants, imports of vendored packages, etc.
+				id, ok := havePkgs[imp]
+				if !ok {
+					id = imp
+				}
+				pkg.Imports[imp] = &Package{ID: id}
+			}
+		}
+		continue
+	}
+
+	// toPkgPath tries to guess the package path given the id.
+	// This isn't always correct -- it's certainly wrong for
+	// vendored packages' paths.
+	toPkgPath := func(id string) string {
+		// TODO(matloob): Handle vendor paths.
+		i := strings.IndexByte(id, ' ')
+		if i >= 0 {
+			return id[:i]
+		}
+		return id
+	}
+
+	// Do another pass now that new packages have been created to determine the
+	// set of missing packages.
+	for _, pkg := range response.dr.Packages {
+		for _, imp := range pkg.Imports {
+			pkgPath := toPkgPath(imp.ID)
+			if _, ok := havePkgs[pkgPath]; !ok {
+				needPkgsSet[pkgPath] = true
+			}
+		}
+	}
+
+	if overlayAddsImports {
+		needPkgs = make([]string, 0, len(needPkgsSet))
+		for pkg := range needPkgsSet {
+			needPkgs = append(needPkgs, pkg)
+		}
+	}
+	modifiedPkgs = make([]string, 0, len(modifiedPkgsSet))
+	for pkg := range modifiedPkgsSet {
+		modifiedPkgs = append(modifiedPkgs, pkg)
+	}
+	return modifiedPkgs, needPkgs, err
+}
+
+func hasTestFiles(p *Package) bool {
+	for _, f := range p.GoFiles {
+		if strings.HasSuffix(f, "_test.go") {
+			return true
+		}
+	}
+	return false
+}
+
+// determineRootDirs returns a mapping from directories code can be contained in to the
+// corresponding import path prefixes of those directories.
+// Its result is used to try to determine the import path for a package containing
+// an overlay file.
+func determineRootDirs(cfg *Config) map[string]string {
+	// Assume modules first:
+	out, err := invokeGo(cfg, "list", "-m", "-json", "all")
+	if err != nil {
+		return determineRootDirsGOPATH(cfg)
+	}
+	m := map[string]string{}
+	type jsonMod struct{ Path, Dir string }
+	for dec := json.NewDecoder(out); dec.More(); {
+		mod := new(jsonMod)
+		if err := dec.Decode(mod); err != nil {
+			return m // Give up and return an empty map. Package won't be found for overlay.
+		}
+		if mod.Dir != "" && mod.Path != "" {
+			// This is a valid module; add it to the map.
+			m[mod.Dir] = mod.Path
+		}
+	}
+	return m
+}
+
+func determineRootDirsGOPATH(cfg *Config) map[string]string {
+	m := map[string]string{}
+	out, err := invokeGo(cfg, "env", "GOPATH")
+	if err != nil {
+		// Could not determine root dir mapping. Everything is best-effort, so just return an empty map.
+		// When we try to find the import path for a directory, there will be no root-dir match and
+		// we'll give up.
+		return m
+	}
+	for _, p := range filepath.SplitList(string(bytes.TrimSpace(out.Bytes()))) {
+		m[filepath.Join(p, "src")] = ""
+	}
+	return m
+}
+
+func extractImports(filename string, contents []byte) ([]string, error) {
+	f, err := parser.ParseFile(token.NewFileSet(), filename, contents, parser.ImportsOnly) // TODO(matloob): reuse fileset?
+	if err != nil {
+		return nil, err
+	}
+	var res []string
+	for _, imp := range f.Imports {
+		quotedPath := imp.Path.Value
+		path, err := strconv.Unquote(quotedPath)
+		if err != nil {
+			return nil, err
+		}
+		res = append(res, path)
+	}
+	return res, nil
+}
+
+// reclaimPackage attempts to reuse a package that failed to load in an overlay.
+//
+// If the package has errors and has no Name, GoFiles, or Imports,
+// then it's possible that it doesn't yet exist on disk.
+func reclaimPackage(pkg *Package, id string, filename string, contents []byte) bool {
+	// TODO(rstambler): Check the message of the actual error?
+	// It differs between $GOPATH and module mode.
+	if pkg.ID != id {
+		return false
+	}
+	if len(pkg.Errors) != 1 {
+		return false
+	}
+	if pkg.Name != "" || pkg.ExportFile != "" {
+		return false
+	}
+	if len(pkg.GoFiles) > 0 || len(pkg.CompiledGoFiles) > 0 || len(pkg.OtherFiles) > 0 {
+		return false
+	}
+	if len(pkg.Imports) > 0 {
+		return false
+	}
+	pkgName, ok := extractPackageName(filename, contents)
+	if !ok {
+		return false
+	}
+	pkg.Name = pkgName
+	pkg.Errors = nil
+	return true
+}
+
+func extractPackageName(filename string, contents []byte) (string, bool) {
+	// TODO(rstambler): Check the message of the actual error?
+	// It differs between $GOPATH and module mode.
+	f, err := parser.ParseFile(token.NewFileSet(), filename, contents, parser.PackageClauseOnly) // TODO(matloob): reuse fileset?
+	if err != nil {
+		return "", false
+	}
+	return f.Name.Name, true
+}
diff --git a/vendor/golang.org/x/tools/go/packages/packages.go b/vendor/golang.org/x/tools/go/packages/packages.go
new file mode 100644
index 000000000..f20e444f4
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/packages.go
@@ -0,0 +1,1075 @@
+// Copyright 2018 The Go 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 packages
+
+// See doc.go for package documentation and implementation notes.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/scanner"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"golang.org/x/tools/go/gcexportdata"
+)
+
+// A LoadMode controls the amount of detail to return when loading.
+// The bits below can be combined to specify which fields should be
+// filled in the result packages.
+// The zero value is a special case, equivalent to combining
+// the NeedName, NeedFiles, and NeedCompiledGoFiles bits.
+// ID and Errors (if present) will always be filled.
+// Load may return more information than requested.
+type LoadMode int
+
+const (
+	// NeedName adds Name and PkgPath.
+	NeedName LoadMode = 1 << iota
+
+	// NeedFiles adds GoFiles and OtherFiles.
+	NeedFiles
+
+	// NeedCompiledGoFiles adds CompiledGoFiles.
+	NeedCompiledGoFiles
+
+	// NeedImports adds Imports. If NeedDeps is not set, the Imports field will contain
+	// "placeholder" Packages with only the ID set.
+	NeedImports
+
+	// NeedDeps adds the fields requested by the LoadMode in the packages in Imports. If NeedImports
+	// is not set NeedDeps has no effect.
+	NeedDeps
+
+	// NeedExportsFile adds ExportsFile.
+	NeedExportsFile
+
+	// NeedTypes adds Types, Fset, and IllTyped.
+	NeedTypes
+
+	// NeedSyntax adds Syntax.
+	NeedSyntax
+
+	// NeedTypesInfo adds TypesInfo.
+	NeedTypesInfo
+
+	// NeedTypesSizes adds TypesSizes.
+	NeedTypesSizes
+)
+
+const (
+	// Deprecated: LoadFiles exists for historical compatibility
+	// and should not be used. Please directly specify the needed fields using the Need values.
+	LoadFiles = NeedName | NeedFiles | NeedCompiledGoFiles
+
+	// Deprecated: LoadImports exists for historical compatibility
+	// and should not be used. Please directly specify the needed fields using the Need values.
+	LoadImports = LoadFiles | NeedImports | NeedDeps
+
+	// Deprecated: LoadTypes exists for historical compatibility
+	// and should not be used. Please directly specify the needed fields using the Need values.
+	LoadTypes = LoadImports | NeedTypes | NeedTypesSizes
+
+	// Deprecated: LoadSyntax exists for historical compatibility
+	// and should not be used. Please directly specify the needed fields using the Need values.
+	LoadSyntax = LoadTypes | NeedSyntax | NeedTypesInfo
+
+	// Deprecated: LoadAllSyntax exists for historical compatibility
+	// and should not be used. Please directly specify the needed fields using the Need values.
+	LoadAllSyntax = LoadSyntax
+)
+
+// A Config specifies details about how packages should be loaded.
+// The zero value is a valid configuration.
+// Calls to Load do not modify this struct.
+type Config struct {
+	// Mode controls the level of information returned for each package.
+	Mode LoadMode
+
+	// Context specifies the context for the load operation.
+	// If the context is cancelled, the loader may stop early
+	// and return an ErrCancelled error.
+	// If Context is nil, the load cannot be cancelled.
+	Context context.Context
+
+	// Dir is the directory in which to run the build system's query tool
+	// that provides information about the packages.
+	// If Dir is empty, the tool is run in the current directory.
+	Dir string
+
+	// Env is the environment to use when invoking the build system's query tool.
+	// If Env is nil, the current environment is used.
+	// As in os/exec's Cmd, only the last value in the slice for
+	// each environment key is used. To specify the setting of only
+	// a few variables, append to the current environment, as in:
+	//
+	//	opt.Env = append(os.Environ(), "GOOS=plan9", "GOARCH=386")
+	//
+	Env []string
+
+	// BuildFlags is a list of command-line flags to be passed through to
+	// the build system's query tool.
+	BuildFlags []string
+
+	// Fset provides source position information for syntax trees and types.
+	// If Fset is nil, Load will use a new fileset, but preserve Fset's value.
+	Fset *token.FileSet
+
+	// ParseFile is called to read and parse each file
+	// when preparing a package's type-checked syntax tree.
+	// It must be safe to call ParseFile simultaneously from multiple goroutines.
+	// If ParseFile is nil, the loader will uses parser.ParseFile.
+	//
+	// ParseFile should parse the source from src and use filename only for
+	// recording position information.
+	//
+	// An application may supply a custom implementation of ParseFile
+	// to change the effective file contents or the behavior of the parser,
+	// or to modify the syntax tree. For example, selectively eliminating
+	// unwanted function bodies can significantly accelerate type checking.
+	ParseFile func(fset *token.FileSet, filename string, src []byte) (*ast.File, error)
+
+	// If Tests is set, the loader includes not just the packages
+	// matching a particular pattern but also any related test packages,
+	// including test-only variants of the package and the test executable.
+	//
+	// For example, when using the go command, loading "fmt" with Tests=true
+	// returns four packages, with IDs "fmt" (the standard package),
+	// "fmt [fmt.test]" (the package as compiled for the test),
+	// "fmt_test" (the test functions from source files in package fmt_test),
+	// and "fmt.test" (the test binary).
+	//
+	// In build systems with explicit names for tests,
+	// setting Tests may have no effect.
+	Tests bool
+
+	// Overlay provides a mapping of absolute file paths to file contents.
+	// If the file  with the given path already exists, the parser will use the
+	// alternative file contents provided by the map.
+	//
+	// Overlays provide incomplete support for when a given file doesn't
+	// already exist on disk. See the package doc above for more details.
+	Overlay map[string][]byte
+}
+
+// driver is the type for functions that query the build system for the
+// packages named by the patterns.
+type driver func(cfg *Config, patterns ...string) (*driverResponse, error)
+
+// driverResponse contains the results for a driver query.
+type driverResponse struct {
+	// Sizes, if not nil, is the types.Sizes to use when type checking.
+	Sizes *types.StdSizes
+
+	// Roots is the set of package IDs that make up the root packages.
+	// We have to encode this separately because when we encode a single package
+	// we cannot know if it is one of the roots as that requires knowledge of the
+	// graph it is part of.
+	Roots []string `json:",omitempty"`
+
+	// Packages is the full set of packages in the graph.
+	// The packages are not connected into a graph.
+	// The Imports if populated will be stubs that only have their ID set.
+	// Imports will be connected and then type and syntax information added in a
+	// later pass (see refine).
+	Packages []*Package
+}
+
+// Load loads and returns the Go packages named by the given patterns.
+//
+// Config specifies loading options;
+// nil behaves the same as an empty Config.
+//
+// Load returns an error if any of the patterns was invalid
+// as defined by the underlying build system.
+// It may return an empty list of packages without an error,
+// for instance for an empty expansion of a valid wildcard.
+// Errors associated with a particular package are recorded in the
+// corresponding Package's Errors list, and do not cause Load to
+// return an error. Clients may need to handle such errors before
+// proceeding with further analysis. The PrintErrors function is
+// provided for convenient display of all errors.
+func Load(cfg *Config, patterns ...string) ([]*Package, error) {
+	l := newLoader(cfg)
+	response, err := defaultDriver(&l.Config, patterns...)
+	if err != nil {
+		return nil, err
+	}
+	l.sizes = response.Sizes
+	return l.refine(response.Roots, response.Packages...)
+}
+
+// defaultDriver is a driver that looks for an external driver binary, and if
+// it does not find it falls back to the built in go list driver.
+func defaultDriver(cfg *Config, patterns ...string) (*driverResponse, error) {
+	driver := findExternalDriver(cfg)
+	if driver == nil {
+		driver = goListDriver
+	}
+	return driver(cfg, patterns...)
+}
+
+// A Package describes a loaded Go package.
+type Package struct {
+	// ID is a unique identifier for a package,
+	// in a syntax provided by the underlying build system.
+	//
+	// Because the syntax varies based on the build system,
+	// clients should treat IDs as opaque and not attempt to
+	// interpret them.
+	ID string
+
+	// Name is the package name as it appears in the package source code.
+	Name string
+
+	// PkgPath is the package path as used by the go/types package.
+	PkgPath string
+
+	// Errors contains any errors encountered querying the metadata
+	// of the package, or while parsing or type-checking its files.
+	Errors []Error
+
+	// GoFiles lists the absolute file paths of the package's Go source files.
+	GoFiles []string
+
+	// CompiledGoFiles lists the absolute file paths of the package's source
+	// files that were presented to the compiler.
+	// This may differ from GoFiles if files are processed before compilation.
+	CompiledGoFiles []string
+
+	// OtherFiles lists the absolute file paths of the package's non-Go source files,
+	// including assembly, C, C++, Fortran, Objective-C, SWIG, and so on.
+	OtherFiles []string
+
+	// ExportFile is the absolute path to a file containing type
+	// information for the package as provided by the build system.
+	ExportFile string
+
+	// Imports maps import paths appearing in the package's Go source files
+	// to corresponding loaded Packages.
+	Imports map[string]*Package
+
+	// Types provides type information for the package.
+	// The NeedTypes LoadMode bit sets this field for packages matching the
+	// patterns; type information for dependencies may be missing or incomplete,
+	// unless NeedDeps and NeedImports are also set.
+	Types *types.Package
+
+	// Fset provides position information for Types, TypesInfo, and Syntax.
+	// It is set only when Types is set.
+	Fset *token.FileSet
+
+	// IllTyped indicates whether the package or any dependency contains errors.
+	// It is set only when Types is set.
+	IllTyped bool
+
+	// Syntax is the package's syntax trees, for the files listed in CompiledGoFiles.
+	//
+	// The NeedSyntax LoadMode bit populates this field for packages matching the patterns.
+	// If NeedDeps and NeedImports are also set, this field will also be populated
+	// for dependencies.
+	Syntax []*ast.File
+
+	// TypesInfo provides type information about the package's syntax trees.
+	// It is set only when Syntax is set.
+	TypesInfo *types.Info
+
+	// TypesSizes provides the effective size function for types in TypesInfo.
+	TypesSizes types.Sizes
+}
+
+// An Error describes a problem with a package's metadata, syntax, or types.
+type Error struct {
+	Pos  string // "file:line:col" or "file:line" or "" or "-"
+	Msg  string
+	Kind ErrorKind
+}
+
+// ErrorKind describes the source of the error, allowing the user to
+// differentiate between errors generated by the driver, the parser, or the
+// type-checker.
+type ErrorKind int
+
+const (
+	UnknownError ErrorKind = iota
+	ListError
+	ParseError
+	TypeError
+)
+
+func (err Error) Error() string {
+	pos := err.Pos
+	if pos == "" {
+		pos = "-" // like token.Position{}.String()
+	}
+	return pos + ": " + err.Msg
+}
+
+// flatPackage is the JSON form of Package
+// It drops all the type and syntax fields, and transforms the Imports
+//
+// TODO(adonovan): identify this struct with Package, effectively
+// publishing the JSON protocol.
+type flatPackage struct {
+	ID              string
+	Name            string            `json:",omitempty"`
+	PkgPath         string            `json:",omitempty"`
+	Errors          []Error           `json:",omitempty"`
+	GoFiles         []string          `json:",omitempty"`
+	CompiledGoFiles []string          `json:",omitempty"`
+	OtherFiles      []string          `json:",omitempty"`
+	ExportFile      string            `json:",omitempty"`
+	Imports         map[string]string `json:",omitempty"`
+}
+
+// MarshalJSON returns the Package in its JSON form.
+// For the most part, the structure fields are written out unmodified, and
+// the type and syntax fields are skipped.
+// The imports are written out as just a map of path to package id.
+// The errors are written using a custom type that tries to preserve the
+// structure of error types we know about.
+//
+// This method exists to enable support for additional build systems.  It is
+// not intended for use by clients of the API and we may change the format.
+func (p *Package) MarshalJSON() ([]byte, error) {
+	flat := &flatPackage{
+		ID:              p.ID,
+		Name:            p.Name,
+		PkgPath:         p.PkgPath,
+		Errors:          p.Errors,
+		GoFiles:         p.GoFiles,
+		CompiledGoFiles: p.CompiledGoFiles,
+		OtherFiles:      p.OtherFiles,
+		ExportFile:      p.ExportFile,
+	}
+	if len(p.Imports) > 0 {
+		flat.Imports = make(map[string]string, len(p.Imports))
+		for path, ipkg := range p.Imports {
+			flat.Imports[path] = ipkg.ID
+		}
+	}
+	return json.Marshal(flat)
+}
+
+// UnmarshalJSON reads in a Package from its JSON format.
+// See MarshalJSON for details about the format accepted.
+func (p *Package) UnmarshalJSON(b []byte) error {
+	flat := &flatPackage{}
+	if err := json.Unmarshal(b, &flat); err != nil {
+		return err
+	}
+	*p = Package{
+		ID:              flat.ID,
+		Name:            flat.Name,
+		PkgPath:         flat.PkgPath,
+		Errors:          flat.Errors,
+		GoFiles:         flat.GoFiles,
+		CompiledGoFiles: flat.CompiledGoFiles,
+		OtherFiles:      flat.OtherFiles,
+		ExportFile:      flat.ExportFile,
+	}
+	if len(flat.Imports) > 0 {
+		p.Imports = make(map[string]*Package, len(flat.Imports))
+		for path, id := range flat.Imports {
+			p.Imports[path] = &Package{ID: id}
+		}
+	}
+	return nil
+}
+
+func (p *Package) String() string { return p.ID }
+
+// loaderPackage augments Package with state used during the loading phase
+type loaderPackage struct {
+	*Package
+	importErrors map[string]error // maps each bad import to its error
+	loadOnce     sync.Once
+	color        uint8 // for cycle detection
+	needsrc      bool  // load from source (Mode >= LoadTypes)
+	needtypes    bool  // type information is either requested or depended on
+	initial      bool  // package was matched by a pattern
+}
+
+// loader holds the working state of a single call to load.
+type loader struct {
+	pkgs map[string]*loaderPackage
+	Config
+	sizes        types.Sizes
+	parseCache   map[string]*parseValue
+	parseCacheMu sync.Mutex
+	exportMu     sync.Mutex // enforces mutual exclusion of exportdata operations
+
+	// TODO(matloob): Add an implied mode here and use that instead of mode.
+	// Implied mode would contain all the fields we need the data for so we can
+	// get the actually requested fields. We'll zero them out before returning
+	// packages to the user. This will make it easier for us to get the conditions
+	// where we need certain modes right.
+}
+
+type parseValue struct {
+	f     *ast.File
+	err   error
+	ready chan struct{}
+}
+
+func newLoader(cfg *Config) *loader {
+	ld := &loader{
+		parseCache: map[string]*parseValue{},
+	}
+	if cfg != nil {
+		ld.Config = *cfg
+	}
+	if ld.Config.Mode == 0 {
+		ld.Config.Mode = NeedName | NeedFiles | NeedCompiledGoFiles // Preserve zero behavior of Mode for backwards compatibility.
+	}
+	if ld.Config.Env == nil {
+		ld.Config.Env = os.Environ()
+	}
+	if ld.Context == nil {
+		ld.Context = context.Background()
+	}
+	if ld.Dir == "" {
+		if dir, err := os.Getwd(); err == nil {
+			ld.Dir = dir
+		}
+	}
+
+	if ld.Mode&NeedTypes != 0 {
+		if ld.Fset == nil {
+			ld.Fset = token.NewFileSet()
+		}
+
+		// ParseFile is required even in LoadTypes mode
+		// because we load source if export data is missing.
+		if ld.ParseFile == nil {
+			ld.ParseFile = func(fset *token.FileSet, filename string, src []byte) (*ast.File, error) {
+				const mode = parser.AllErrors | parser.ParseComments
+				return parser.ParseFile(fset, filename, src, mode)
+			}
+		}
+	}
+	return ld
+}
+
+// refine connects the supplied packages into a graph and then adds type and
+// and syntax information as requested by the LoadMode.
+func (ld *loader) refine(roots []string, list ...*Package) ([]*Package, error) {
+	rootMap := make(map[string]int, len(roots))
+	for i, root := range roots {
+		rootMap[root] = i
+	}
+	ld.pkgs = make(map[string]*loaderPackage)
+	// first pass, fixup and build the map and roots
+	var initial = make([]*loaderPackage, len(roots))
+	for _, pkg := range list {
+		rootIndex := -1
+		if i, found := rootMap[pkg.ID]; found {
+			rootIndex = i
+		}
+		lpkg := &loaderPackage{
+			Package:   pkg,
+			needtypes: (ld.Mode&(NeedTypes|NeedTypesInfo) != 0 && rootIndex < 0) || rootIndex >= 0,
+			needsrc: (ld.Mode&(NeedSyntax|NeedTypesInfo) != 0 && rootIndex < 0) || rootIndex >= 0 ||
+				len(ld.Overlay) > 0 || // Overlays can invalidate export data. TODO(matloob): make this check fine-grained based on dependencies on overlaid files
+				pkg.ExportFile == "" && pkg.PkgPath != "unsafe",
+		}
+		ld.pkgs[lpkg.ID] = lpkg
+		if rootIndex >= 0 {
+			initial[rootIndex] = lpkg
+			lpkg.initial = true
+		}
+	}
+	for i, root := range roots {
+		if initial[i] == nil {
+			return nil, fmt.Errorf("root package %v is missing", root)
+		}
+	}
+
+	// Materialize the import graph.
+
+	const (
+		white = 0 // new
+		grey  = 1 // in progress
+		black = 2 // complete
+	)
+
+	// visit traverses the import graph, depth-first,
+	// and materializes the graph as Packages.Imports.
+	//
+	// Valid imports are saved in the Packages.Import map.
+	// Invalid imports (cycles and missing nodes) are saved in the importErrors map.
+	// Thus, even in the presence of both kinds of errors, the Import graph remains a DAG.
+	//
+	// visit returns whether the package needs src or has a transitive
+	// dependency on a package that does. These are the only packages
+	// for which we load source code.
+	var stack []*loaderPackage
+	var visit func(lpkg *loaderPackage) bool
+	var srcPkgs []*loaderPackage
+	visit = func(lpkg *loaderPackage) bool {
+		switch lpkg.color {
+		case black:
+			return lpkg.needsrc
+		case grey:
+			panic("internal error: grey node")
+		}
+		lpkg.color = grey
+		stack = append(stack, lpkg) // push
+		stubs := lpkg.Imports       // the structure form has only stubs with the ID in the Imports
+		// If NeedImports isn't set, the imports fields will all be zeroed out.
+		// If NeedDeps isn't also set we want to keep the stubs.
+		if ld.Mode&NeedImports != 0 && ld.Mode&NeedDeps != 0 {
+			lpkg.Imports = make(map[string]*Package, len(stubs))
+			for importPath, ipkg := range stubs {
+				var importErr error
+				imp := ld.pkgs[ipkg.ID]
+				if imp == nil {
+					// (includes package "C" when DisableCgo)
+					importErr = fmt.Errorf("missing package: %q", ipkg.ID)
+				} else if imp.color == grey {
+					importErr = fmt.Errorf("import cycle: %s", stack)
+				}
+				if importErr != nil {
+					if lpkg.importErrors == nil {
+						lpkg.importErrors = make(map[string]error)
+					}
+					lpkg.importErrors[importPath] = importErr
+					continue
+				}
+
+				if visit(imp) {
+					lpkg.needsrc = true
+				}
+				lpkg.Imports[importPath] = imp.Package
+			}
+		}
+		if lpkg.needsrc {
+			srcPkgs = append(srcPkgs, lpkg)
+		}
+		if ld.Mode&NeedTypesSizes != 0 {
+			lpkg.TypesSizes = ld.sizes
+		}
+		stack = stack[:len(stack)-1] // pop
+		lpkg.color = black
+
+		return lpkg.needsrc
+	}
+
+	if ld.Mode&(NeedImports|NeedDeps) == 0 {
+		// We do this to drop the stub import packages that we are not even going to try to resolve.
+		for _, lpkg := range initial {
+			lpkg.Imports = nil
+		}
+	} else {
+		// For each initial package, create its import DAG.
+		for _, lpkg := range initial {
+			visit(lpkg)
+		}
+	}
+	if ld.Mode&NeedDeps != 0 { // TODO(matloob): This is only the case if NeedTypes is also set, right?
+		for _, lpkg := range srcPkgs {
+			// Complete type information is required for the
+			// immediate dependencies of each source package.
+			for _, ipkg := range lpkg.Imports {
+				imp := ld.pkgs[ipkg.ID]
+				imp.needtypes = true
+			}
+		}
+	}
+	// Load type data if needed, starting at
+	// the initial packages (roots of the import DAG).
+	if ld.Mode&NeedTypes != 0 {
+		var wg sync.WaitGroup
+		for _, lpkg := range initial {
+			wg.Add(1)
+			go func(lpkg *loaderPackage) {
+				ld.loadRecursive(lpkg)
+				wg.Done()
+			}(lpkg)
+		}
+		wg.Wait()
+	}
+
+	result := make([]*Package, len(initial))
+	importPlaceholders := make(map[string]*Package)
+	for i, lpkg := range initial {
+		result[i] = lpkg.Package
+	}
+	for i := range ld.pkgs {
+		// Clear all unrequested fields, for extra de-Hyrum-ization.
+		if ld.Mode&NeedName == 0 {
+			ld.pkgs[i].Name = ""
+			ld.pkgs[i].PkgPath = ""
+		}
+		if ld.Mode&NeedFiles == 0 {
+			ld.pkgs[i].GoFiles = nil
+			ld.pkgs[i].OtherFiles = nil
+		}
+		if ld.Mode&NeedCompiledGoFiles == 0 {
+			ld.pkgs[i].CompiledGoFiles = nil
+		}
+		if ld.Mode&NeedImports == 0 {
+			ld.pkgs[i].Imports = nil
+		}
+		if ld.Mode&NeedExportsFile == 0 {
+			ld.pkgs[i].ExportFile = ""
+		}
+		if ld.Mode&NeedTypes == 0 {
+			ld.pkgs[i].Types = nil
+			ld.pkgs[i].Fset = nil
+			ld.pkgs[i].IllTyped = false
+		}
+		if ld.Mode&NeedSyntax == 0 {
+			ld.pkgs[i].Syntax = nil
+		}
+		if ld.Mode&NeedTypesInfo == 0 {
+			ld.pkgs[i].TypesInfo = nil
+		}
+		if ld.Mode&NeedTypesSizes == 0 {
+			ld.pkgs[i].TypesSizes = nil
+		}
+		if ld.Mode&NeedDeps == 0 {
+			for j, pkg := range ld.pkgs[i].Imports {
+				ph, ok := importPlaceholders[pkg.ID]
+				if !ok {
+					ph = &Package{ID: pkg.ID}
+					importPlaceholders[pkg.ID] = ph
+				}
+				ld.pkgs[i].Imports[j] = ph
+			}
+		}
+	}
+	return result, nil
+}
+
+// loadRecursive loads the specified package and its dependencies,
+// recursively, in parallel, in topological order.
+// It is atomic and idempotent.
+// Precondition: ld.Mode&NeedTypes.
+func (ld *loader) loadRecursive(lpkg *loaderPackage) {
+	lpkg.loadOnce.Do(func() {
+		// Load the direct dependencies, in parallel.
+		var wg sync.WaitGroup
+		for _, ipkg := range lpkg.Imports {
+			imp := ld.pkgs[ipkg.ID]
+			wg.Add(1)
+			go func(imp *loaderPackage) {
+				ld.loadRecursive(imp)
+				wg.Done()
+			}(imp)
+		}
+		wg.Wait()
+
+		ld.loadPackage(lpkg)
+	})
+}
+
+// loadPackage loads the specified package.
+// It must be called only once per Package,
+// after immediate dependencies are loaded.
+// Precondition: ld.Mode & NeedTypes.
+func (ld *loader) loadPackage(lpkg *loaderPackage) {
+	if lpkg.PkgPath == "unsafe" {
+		// Fill in the blanks to avoid surprises.
+		lpkg.Types = types.Unsafe
+		lpkg.Fset = ld.Fset
+		lpkg.Syntax = []*ast.File{}
+		lpkg.TypesInfo = new(types.Info)
+		lpkg.TypesSizes = ld.sizes
+		return
+	}
+
+	// Call NewPackage directly with explicit name.
+	// This avoids skew between golist and go/types when the files'
+	// package declarations are inconsistent.
+	lpkg.Types = types.NewPackage(lpkg.PkgPath, lpkg.Name)
+	lpkg.Fset = ld.Fset
+
+	// Subtle: we populate all Types fields with an empty Package
+	// before loading export data so that export data processing
+	// never has to create a types.Package for an indirect dependency,
+	// which would then require that such created packages be explicitly
+	// inserted back into the Import graph as a final step after export data loading.
+	// The Diamond test exercises this case.
+	if !lpkg.needtypes {
+		return
+	}
+	if !lpkg.needsrc {
+		ld.loadFromExportData(lpkg)
+		return // not a source package, don't get syntax trees
+	}
+
+	appendError := func(err error) {
+		// Convert various error types into the one true Error.
+		var errs []Error
+		switch err := err.(type) {
+		case Error:
+			// from driver
+			errs = append(errs, err)
+
+		case *os.PathError:
+			// from parser
+			errs = append(errs, Error{
+				Pos:  err.Path + ":1",
+				Msg:  err.Err.Error(),
+				Kind: ParseError,
+			})
+
+		case scanner.ErrorList:
+			// from parser
+			for _, err := range err {
+				errs = append(errs, Error{
+					Pos:  err.Pos.String(),
+					Msg:  err.Msg,
+					Kind: ParseError,
+				})
+			}
+
+		case types.Error:
+			// from type checker
+			errs = append(errs, Error{
+				Pos:  err.Fset.Position(err.Pos).String(),
+				Msg:  err.Msg,
+				Kind: TypeError,
+			})
+
+		default:
+			// unexpected impoverished error from parser?
+			errs = append(errs, Error{
+				Pos:  "-",
+				Msg:  err.Error(),
+				Kind: UnknownError,
+			})
+
+			// If you see this error message, please file a bug.
+			log.Printf("internal error: error %q (%T) without position", err, err)
+		}
+
+		lpkg.Errors = append(lpkg.Errors, errs...)
+	}
+
+	files, errs := ld.parseFiles(lpkg.CompiledGoFiles)
+	for _, err := range errs {
+		appendError(err)
+	}
+
+	lpkg.Syntax = files
+
+	lpkg.TypesInfo = &types.Info{
+		Types:      make(map[ast.Expr]types.TypeAndValue),
+		Defs:       make(map[*ast.Ident]types.Object),
+		Uses:       make(map[*ast.Ident]types.Object),
+		Implicits:  make(map[ast.Node]types.Object),
+		Scopes:     make(map[ast.Node]*types.Scope),
+		Selections: make(map[*ast.SelectorExpr]*types.Selection),
+	}
+	lpkg.TypesSizes = ld.sizes
+
+	importer := importerFunc(func(path string) (*types.Package, error) {
+		if path == "unsafe" {
+			return types.Unsafe, nil
+		}
+
+		// The imports map is keyed by import path.
+		ipkg := lpkg.Imports[path]
+		if ipkg == nil {
+			if err := lpkg.importErrors[path]; err != nil {
+				return nil, err
+			}
+			// There was skew between the metadata and the
+			// import declarations, likely due to an edit
+			// race, or because the ParseFile feature was
+			// used to supply alternative file contents.
+			return nil, fmt.Errorf("no metadata for %s", path)
+		}
+
+		if ipkg.Types != nil && ipkg.Types.Complete() {
+			return ipkg.Types, nil
+		}
+		log.Fatalf("internal error: nil Pkg importing %q from %q", path, lpkg)
+		panic("unreachable")
+	})
+
+	// type-check
+	tc := &types.Config{
+		Importer: importer,
+
+		// Type-check bodies of functions only in non-initial packages.
+		// Example: for import graph A->B->C and initial packages {A,C},
+		// we can ignore function bodies in B.
+		IgnoreFuncBodies: (ld.Mode&(NeedDeps|NeedTypesInfo) == 0) && !lpkg.initial,
+
+		Error: appendError,
+		Sizes: ld.sizes,
+	}
+	types.NewChecker(tc, ld.Fset, lpkg.Types, lpkg.TypesInfo).Files(lpkg.Syntax)
+
+	lpkg.importErrors = nil // no longer needed
+
+	// If !Cgo, the type-checker uses FakeImportC mode, so
+	// it doesn't invoke the importer for import "C",
+	// nor report an error for the import,
+	// or for any undefined C.f reference.
+	// We must detect this explicitly and correctly
+	// mark the package as IllTyped (by reporting an error).
+	// TODO(adonovan): if these errors are annoying,
+	// we could just set IllTyped quietly.
+	if tc.FakeImportC {
+	outer:
+		for _, f := range lpkg.Syntax {
+			for _, imp := range f.Imports {
+				if imp.Path.Value == `"C"` {
+					err := types.Error{Fset: ld.Fset, Pos: imp.Pos(), Msg: `import "C" ignored`}
+					appendError(err)
+					break outer
+				}
+			}
+		}
+	}
+
+	// Record accumulated errors.
+	illTyped := len(lpkg.Errors) > 0
+	if !illTyped {
+		for _, imp := range lpkg.Imports {
+			if imp.IllTyped {
+				illTyped = true
+				break
+			}
+		}
+	}
+	lpkg.IllTyped = illTyped
+}
+
+// An importFunc is an implementation of the single-method
+// types.Importer interface based on a function value.
+type importerFunc func(path string) (*types.Package, error)
+
+func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }
+
+// We use a counting semaphore to limit
+// the number of parallel I/O calls per process.
+var ioLimit = make(chan bool, 20)
+
+func (ld *loader) parseFile(filename string) (*ast.File, error) {
+	ld.parseCacheMu.Lock()
+	v, ok := ld.parseCache[filename]
+	if ok {
+		// cache hit
+		ld.parseCacheMu.Unlock()
+		<-v.ready
+	} else {
+		// cache miss
+		v = &parseValue{ready: make(chan struct{})}
+		ld.parseCache[filename] = v
+		ld.parseCacheMu.Unlock()
+
+		var src []byte
+		for f, contents := range ld.Config.Overlay {
+			if sameFile(f, filename) {
+				src = contents
+			}
+		}
+		var err error
+		if src == nil {
+			ioLimit <- true // wait
+			src, err = ioutil.ReadFile(filename)
+			<-ioLimit // signal
+		}
+		if err != nil {
+			v.err = err
+		} else {
+			v.f, v.err = ld.ParseFile(ld.Fset, filename, src)
+		}
+
+		close(v.ready)
+	}
+	return v.f, v.err
+}
+
+// parseFiles reads and parses the Go source files and returns the ASTs
+// of the ones that could be at least partially parsed, along with a
+// list of I/O and parse errors encountered.
+//
+// Because files are scanned in parallel, the token.Pos
+// positions of the resulting ast.Files are not ordered.
+//
+func (ld *loader) parseFiles(filenames []string) ([]*ast.File, []error) {
+	var wg sync.WaitGroup
+	n := len(filenames)
+	parsed := make([]*ast.File, n)
+	errors := make([]error, n)
+	for i, file := range filenames {
+		if ld.Config.Context.Err() != nil {
+			parsed[i] = nil
+			errors[i] = ld.Config.Context.Err()
+			continue
+		}
+		wg.Add(1)
+		go func(i int, filename string) {
+			parsed[i], errors[i] = ld.parseFile(filename)
+			wg.Done()
+		}(i, file)
+	}
+	wg.Wait()
+
+	// Eliminate nils, preserving order.
+	var o int
+	for _, f := range parsed {
+		if f != nil {
+			parsed[o] = f
+			o++
+		}
+	}
+	parsed = parsed[:o]
+
+	o = 0
+	for _, err := range errors {
+		if err != nil {
+			errors[o] = err
+			o++
+		}
+	}
+	errors = errors[:o]
+
+	return parsed, errors
+}
+
+// sameFile returns true if x and y have the same basename and denote
+// the same file.
+//
+func sameFile(x, y string) bool {
+	if x == y {
+		// It could be the case that y doesn't exist.
+		// For instance, it may be an overlay file that
+		// hasn't been written to disk. To handle that case
+		// let x == y through. (We added the exact absolute path
+		// string to the CompiledGoFiles list, so the unwritten
+		// overlay case implies x==y.)
+		return true
+	}
+	if strings.EqualFold(filepath.Base(x), filepath.Base(y)) { // (optimisation)
+		if xi, err := os.Stat(x); err == nil {
+			if yi, err := os.Stat(y); err == nil {
+				return os.SameFile(xi, yi)
+			}
+		}
+	}
+	return false
+}
+
+// loadFromExportData returns type information for the specified
+// package, loading it from an export data file on the first request.
+func (ld *loader) loadFromExportData(lpkg *loaderPackage) (*types.Package, error) {
+	if lpkg.PkgPath == "" {
+		log.Fatalf("internal error: Package %s has no PkgPath", lpkg)
+	}
+
+	// Because gcexportdata.Read has the potential to create or
+	// modify the types.Package for each node in the transitive
+	// closure of dependencies of lpkg, all exportdata operations
+	// must be sequential. (Finer-grained locking would require
+	// changes to the gcexportdata API.)
+	//
+	// The exportMu lock guards the Package.Pkg field and the
+	// types.Package it points to, for each Package in the graph.
+	//
+	// Not all accesses to Package.Pkg need to be protected by exportMu:
+	// graph ordering ensures that direct dependencies of source
+	// packages are fully loaded before the importer reads their Pkg field.
+	ld.exportMu.Lock()
+	defer ld.exportMu.Unlock()
+
+	if tpkg := lpkg.Types; tpkg != nil && tpkg.Complete() {
+		return tpkg, nil // cache hit
+	}
+
+	lpkg.IllTyped = true // fail safe
+
+	if lpkg.ExportFile == "" {
+		// Errors while building export data will have been printed to stderr.
+		return nil, fmt.Errorf("no export data file")
+	}
+	f, err := os.Open(lpkg.ExportFile)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	// Read gc export data.
+	//
+	// We don't currently support gccgo export data because all
+	// underlying workspaces use the gc toolchain. (Even build
+	// systems that support gccgo don't use it for workspace
+	// queries.)
+	r, err := gcexportdata.NewReader(f)
+	if err != nil {
+		return nil, fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
+	}
+
+	// Build the view.
+	//
+	// The gcexportdata machinery has no concept of package ID.
+	// It identifies packages by their PkgPath, which although not
+	// globally unique is unique within the scope of one invocation
+	// of the linker, type-checker, or gcexportdata.
+	//
+	// So, we must build a PkgPath-keyed view of the global
+	// (conceptually ID-keyed) cache of packages and pass it to
+	// gcexportdata. The view must contain every existing
+	// package that might possibly be mentioned by the
+	// current package---its transitive closure.
+	//
+	// In loadPackage, we unconditionally create a types.Package for
+	// each dependency so that export data loading does not
+	// create new ones.
+	//
+	// TODO(adonovan): it would be simpler and more efficient
+	// if the export data machinery invoked a callback to
+	// get-or-create a package instead of a map.
+	//
+	view := make(map[string]*types.Package) // view seen by gcexportdata
+	seen := make(map[*loaderPackage]bool)   // all visited packages
+	var visit func(pkgs map[string]*Package)
+	visit = func(pkgs map[string]*Package) {
+		for _, p := range pkgs {
+			lpkg := ld.pkgs[p.ID]
+			if !seen[lpkg] {
+				seen[lpkg] = true
+				view[lpkg.PkgPath] = lpkg.Types
+				visit(lpkg.Imports)
+			}
+		}
+	}
+	visit(lpkg.Imports)
+
+	viewLen := len(view) + 1 // adding the self package
+	// Parse the export data.
+	// (May modify incomplete packages in view but not create new ones.)
+	tpkg, err := gcexportdata.Read(r, ld.Fset, view, lpkg.PkgPath)
+	if err != nil {
+		return nil, fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
+	}
+	if viewLen != len(view) {
+		log.Fatalf("Unexpected package creation during export data loading")
+	}
+
+	lpkg.Types = tpkg
+	lpkg.IllTyped = false
+
+	return tpkg, nil
+}
+
+func usesExportData(cfg *Config) bool {
+	return cfg.Mode&NeedExportsFile != 0 || cfg.Mode&NeedTypes != 0 && cfg.Mode&NeedTypesInfo == 0
+}
diff --git a/vendor/golang.org/x/tools/go/packages/visit.go b/vendor/golang.org/x/tools/go/packages/visit.go
new file mode 100644
index 000000000..b13cb081f
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/visit.go
@@ -0,0 +1,55 @@
+package packages
+
+import (
+	"fmt"
+	"os"
+	"sort"
+)
+
+// Visit visits all the packages in the import graph whose roots are
+// pkgs, calling the optional pre function the first time each package
+// is encountered (preorder), and the optional post function after a
+// package's dependencies have been visited (postorder).
+// The boolean result of pre(pkg) determines whether
+// the imports of package pkg are visited.
+func Visit(pkgs []*Package, pre func(*Package) bool, post func(*Package)) {
+	seen := make(map[*Package]bool)
+	var visit func(*Package)
+	visit = func(pkg *Package) {
+		if !seen[pkg] {
+			seen[pkg] = true
+
+			if pre == nil || pre(pkg) {
+				paths := make([]string, 0, len(pkg.Imports))
+				for path := range pkg.Imports {
+					paths = append(paths, path)
+				}
+				sort.Strings(paths) // Imports is a map, this makes visit stable
+				for _, path := range paths {
+					visit(pkg.Imports[path])
+				}
+			}
+
+			if post != nil {
+				post(pkg)
+			}
+		}
+	}
+	for _, pkg := range pkgs {
+		visit(pkg)
+	}
+}
+
+// PrintErrors prints to os.Stderr the accumulated errors of all
+// packages in the import graph rooted at pkgs, dependencies first.
+// PrintErrors returns the number of errors printed.
+func PrintErrors(pkgs []*Package) int {
+	var n int
+	Visit(pkgs, nil, func(pkg *Package) {
+		for _, err := range pkg.Errors {
+			fmt.Fprintln(os.Stderr, err)
+			n++
+		}
+	})
+	return n
+}
diff --git a/vendor/golang.org/x/tools/internal/fastwalk/fastwalk.go b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk.go
new file mode 100644
index 000000000..7219c8e9f
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk.go
@@ -0,0 +1,196 @@
+// Copyright 2016 The Go 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 fastwalk provides a faster version of filepath.Walk for file system
+// scanning tools.
+package fastwalk
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
+)
+
+// TraverseLink is used as a return value from WalkFuncs to indicate that the
+// symlink named in the call may be traversed.
+var TraverseLink = errors.New("fastwalk: traverse symlink, assuming target is a directory")
+
+// SkipFiles is a used as a return value from WalkFuncs to indicate that the
+// callback should not be called for any other files in the current directory.
+// Child directories will still be traversed.
+var SkipFiles = errors.New("fastwalk: skip remaining files in directory")
+
+// Walk is a faster implementation of filepath.Walk.
+//
+// filepath.Walk's design necessarily calls os.Lstat on each file,
+// even if the caller needs less info.
+// Many tools need only the type of each file.
+// On some platforms, this information is provided directly by the readdir
+// system call, avoiding the need to stat each file individually.
+// fastwalk_unix.go contains a fork of the syscall routines.
+//
+// See golang.org/issue/16399
+//
+// Walk walks the file tree rooted at root, calling walkFn for
+// each file or directory in the tree, including root.
+//
+// If fastWalk returns filepath.SkipDir, the directory is skipped.
+//
+// Unlike filepath.Walk:
+//   * file stat calls must be done by the user.
+//     The only provided metadata is the file type, which does not include
+//     any permission bits.
+//   * multiple goroutines stat the filesystem concurrently. The provided
+//     walkFn must be safe for concurrent use.
+//   * fastWalk can follow symlinks if walkFn returns the TraverseLink
+//     sentinel error. It is the walkFn's responsibility to prevent
+//     fastWalk from going into symlink cycles.
+func Walk(root string, walkFn func(path string, typ os.FileMode) error) error {
+	// TODO(bradfitz): make numWorkers configurable? We used a
+	// minimum of 4 to give the kernel more info about multiple
+	// things we want, in hopes its I/O scheduling can take
+	// advantage of that. Hopefully most are in cache. Maybe 4 is
+	// even too low of a minimum. Profile more.
+	numWorkers := 4
+	if n := runtime.NumCPU(); n > numWorkers {
+		numWorkers = n
+	}
+
+	// Make sure to wait for all workers to finish, otherwise
+	// walkFn could still be called after returning. This Wait call
+	// runs after close(e.donec) below.
+	var wg sync.WaitGroup
+	defer wg.Wait()
+
+	w := &walker{
+		fn:       walkFn,
+		enqueuec: make(chan walkItem, numWorkers), // buffered for performance
+		workc:    make(chan walkItem, numWorkers), // buffered for performance
+		donec:    make(chan struct{}),
+
+		// buffered for correctness & not leaking goroutines:
+		resc: make(chan error, numWorkers),
+	}
+	defer close(w.donec)
+
+	for i := 0; i < numWorkers; i++ {
+		wg.Add(1)
+		go w.doWork(&wg)
+	}
+	todo := []walkItem{{dir: root}}
+	out := 0
+	for {
+		workc := w.workc
+		var workItem walkItem
+		if len(todo) == 0 {
+			workc = nil
+		} else {
+			workItem = todo[len(todo)-1]
+		}
+		select {
+		case workc <- workItem:
+			todo = todo[:len(todo)-1]
+			out++
+		case it := <-w.enqueuec:
+			todo = append(todo, it)
+		case err := <-w.resc:
+			out--
+			if err != nil {
+				return err
+			}
+			if out == 0 && len(todo) == 0 {
+				// It's safe to quit here, as long as the buffered
+				// enqueue channel isn't also readable, which might
+				// happen if the worker sends both another unit of
+				// work and its result before the other select was
+				// scheduled and both w.resc and w.enqueuec were
+				// readable.
+				select {
+				case it := <-w.enqueuec:
+					todo = append(todo, it)
+				default:
+					return nil
+				}
+			}
+		}
+	}
+}
+
+// doWork reads directories as instructed (via workc) and runs the
+// user's callback function.
+func (w *walker) doWork(wg *sync.WaitGroup) {
+	defer wg.Done()
+	for {
+		select {
+		case <-w.donec:
+			return
+		case it := <-w.workc:
+			select {
+			case <-w.donec:
+				return
+			case w.resc <- w.walk(it.dir, !it.callbackDone):
+			}
+		}
+	}
+}
+
+type walker struct {
+	fn func(path string, typ os.FileMode) error
+
+	donec    chan struct{} // closed on fastWalk's return
+	workc    chan walkItem // to workers
+	enqueuec chan walkItem // from workers
+	resc     chan error    // from workers
+}
+
+type walkItem struct {
+	dir          string
+	callbackDone bool // callback already called; don't do it again
+}
+
+func (w *walker) enqueue(it walkItem) {
+	select {
+	case w.enqueuec <- it:
+	case <-w.donec:
+	}
+}
+
+func (w *walker) onDirEnt(dirName, baseName string, typ os.FileMode) error {
+	joined := dirName + string(os.PathSeparator) + baseName
+	if typ == os.ModeDir {
+		w.enqueue(walkItem{dir: joined})
+		return nil
+	}
+
+	err := w.fn(joined, typ)
+	if typ == os.ModeSymlink {
+		if err == TraverseLink {
+			// Set callbackDone so we don't call it twice for both the
+			// symlink-as-symlink and the symlink-as-directory later:
+			w.enqueue(walkItem{dir: joined, callbackDone: true})
+			return nil
+		}
+		if err == filepath.SkipDir {
+			// Permit SkipDir on symlinks too.
+			return nil
+		}
+	}
+	return err
+}
+
+func (w *walker) walk(root string, runUserCallback bool) error {
+	if runUserCallback {
+		err := w.fn(root, os.ModeDir)
+		if err == filepath.SkipDir {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+	}
+
+	return readDir(root, w.onDirEnt)
+}
diff --git a/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_fileno.go b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_fileno.go
new file mode 100644
index 000000000..ccffec5ad
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_fileno.go
@@ -0,0 +1,13 @@
+// Copyright 2016 The Go 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 freebsd openbsd netbsd
+
+package fastwalk
+
+import "syscall"
+
+func direntInode(dirent *syscall.Dirent) uint64 {
+	return uint64(dirent.Fileno)
+}
diff --git a/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_ino.go b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_ino.go
new file mode 100644
index 000000000..ab7fbc0a9
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_ino.go
@@ -0,0 +1,14 @@
+// Copyright 2016 The Go 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 linux darwin
+// +build !appengine
+
+package fastwalk
+
+import "syscall"
+
+func direntInode(dirent *syscall.Dirent) uint64 {
+	return uint64(dirent.Ino)
+}
diff --git a/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_namlen_bsd.go b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_namlen_bsd.go
new file mode 100644
index 000000000..a3b26a7ba
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_namlen_bsd.go
@@ -0,0 +1,13 @@
+// Copyright 2018 The Go 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 darwin freebsd openbsd netbsd
+
+package fastwalk
+
+import "syscall"
+
+func direntNamlen(dirent *syscall.Dirent) uint64 {
+	return uint64(dirent.Namlen)
+}
diff --git a/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_namlen_linux.go b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_namlen_linux.go
new file mode 100644
index 000000000..e880d358b
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_dirent_namlen_linux.go
@@ -0,0 +1,29 @@
+// Copyright 2018 The Go 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 linux
+// +build !appengine
+
+package fastwalk
+
+import (
+	"bytes"
+	"syscall"
+	"unsafe"
+)
+
+func direntNamlen(dirent *syscall.Dirent) uint64 {
+	const fixedHdr = uint16(unsafe.Offsetof(syscall.Dirent{}.Name))
+	nameBuf := (*[unsafe.Sizeof(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
+	const nameBufLen = uint16(len(nameBuf))
+	limit := dirent.Reclen - fixedHdr
+	if limit > nameBufLen {
+		limit = nameBufLen
+	}
+	nameLen := bytes.IndexByte(nameBuf[:limit], 0)
+	if nameLen < 0 {
+		panic("failed to find terminating 0 byte in dirent")
+	}
+	return uint64(nameLen)
+}
diff --git a/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_portable.go b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_portable.go
new file mode 100644
index 000000000..a906b8759
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_portable.go
@@ -0,0 +1,37 @@
+// Copyright 2016 The Go 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 !linux,!darwin,!freebsd,!openbsd,!netbsd
+
+package fastwalk
+
+import (
+	"io/ioutil"
+	"os"
+)
+
+// readDir calls fn for each directory entry in dirName.
+// It does not descend into directories or follow symlinks.
+// If fn returns a non-nil error, readDir returns with that error
+// immediately.
+func readDir(dirName string, fn func(dirName, entName string, typ os.FileMode) error) error {
+	fis, err := ioutil.ReadDir(dirName)
+	if err != nil {
+		return err
+	}
+	skipFiles := false
+	for _, fi := range fis {
+		if fi.Mode().IsRegular() && skipFiles {
+			continue
+		}
+		if err := fn(dirName, fi.Name(), fi.Mode()&os.ModeType); err != nil {
+			if err == SkipFiles {
+				skipFiles = true
+				continue
+			}
+			return err
+		}
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_unix.go b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_unix.go
new file mode 100644
index 000000000..3369b1a0b
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/fastwalk/fastwalk_unix.go
@@ -0,0 +1,127 @@
+// Copyright 2016 The Go 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 linux darwin freebsd openbsd netbsd
+// +build !appengine
+
+package fastwalk
+
+import (
+	"fmt"
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+const blockSize = 8 << 10
+
+// unknownFileMode is a sentinel (and bogus) os.FileMode
+// value used to represent a syscall.DT_UNKNOWN Dirent.Type.
+const unknownFileMode os.FileMode = os.ModeNamedPipe | os.ModeSocket | os.ModeDevice
+
+func readDir(dirName string, fn func(dirName, entName string, typ os.FileMode) error) error {
+	fd, err := syscall.Open(dirName, 0, 0)
+	if err != nil {
+		return &os.PathError{Op: "open", Path: dirName, Err: err}
+	}
+	defer syscall.Close(fd)
+
+	// The buffer must be at least a block long.
+	buf := make([]byte, blockSize) // stack-allocated; doesn't escape
+	bufp := 0                      // starting read position in buf
+	nbuf := 0                      // end valid data in buf
+	skipFiles := false
+	for {
+		if bufp >= nbuf {
+			bufp = 0
+			nbuf, err = syscall.ReadDirent(fd, buf)
+			if err != nil {
+				return os.NewSyscallError("readdirent", err)
+			}
+			if nbuf <= 0 {
+				return nil
+			}
+		}
+		consumed, name, typ := parseDirEnt(buf[bufp:nbuf])
+		bufp += consumed
+		if name == "" || name == "." || name == ".." {
+			continue
+		}
+		// Fallback for filesystems (like old XFS) that don't
+		// support Dirent.Type and have DT_UNKNOWN (0) there
+		// instead.
+		if typ == unknownFileMode {
+			fi, err := os.Lstat(dirName + "/" + name)
+			if err != nil {
+				// It got deleted in the meantime.
+				if os.IsNotExist(err) {
+					continue
+				}
+				return err
+			}
+			typ = fi.Mode() & os.ModeType
+		}
+		if skipFiles && typ.IsRegular() {
+			continue
+		}
+		if err := fn(dirName, name, typ); err != nil {
+			if err == SkipFiles {
+				skipFiles = true
+				continue
+			}
+			return err
+		}
+	}
+}
+
+func parseDirEnt(buf []byte) (consumed int, name string, typ os.FileMode) {
+	// golang.org/issue/15653
+	dirent := (*syscall.Dirent)(unsafe.Pointer(&buf[0]))
+	if v := unsafe.Offsetof(dirent.Reclen) + unsafe.Sizeof(dirent.Reclen); uintptr(len(buf)) < v {
+		panic(fmt.Sprintf("buf size of %d smaller than dirent header size %d", len(buf), v))
+	}
+	if len(buf) < int(dirent.Reclen) {
+		panic(fmt.Sprintf("buf size %d < record length %d", len(buf), dirent.Reclen))
+	}
+	consumed = int(dirent.Reclen)
+	if direntInode(dirent) == 0 { // File absent in directory.
+		return
+	}
+	switch dirent.Type {
+	case syscall.DT_REG:
+		typ = 0
+	case syscall.DT_DIR:
+		typ = os.ModeDir
+	case syscall.DT_LNK:
+		typ = os.ModeSymlink
+	case syscall.DT_BLK:
+		typ = os.ModeDevice
+	case syscall.DT_FIFO:
+		typ = os.ModeNamedPipe
+	case syscall.DT_SOCK:
+		typ = os.ModeSocket
+	case syscall.DT_UNKNOWN:
+		typ = unknownFileMode
+	default:
+		// Skip weird things.
+		// It's probably a DT_WHT (http://lwn.net/Articles/325369/)
+		// or something. Revisit if/when this package is moved outside
+		// of goimports. goimports only cares about regular files,
+		// symlinks, and directories.
+		return
+	}
+
+	nameBuf := (*[unsafe.Sizeof(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
+	nameLen := direntNamlen(dirent)
+
+	// Special cases for common things:
+	if nameLen == 1 && nameBuf[0] == '.' {
+		name = "."
+	} else if nameLen == 2 && nameBuf[0] == '.' && nameBuf[1] == '.' {
+		name = ".."
+	} else {
+		name = string(nameBuf[:nameLen])
+	}
+	return
+}
diff --git a/vendor/golang.org/x/tools/internal/gopathwalk/walk.go b/vendor/golang.org/x/tools/internal/gopathwalk/walk.go
new file mode 100644
index 000000000..04bb96a36
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gopathwalk/walk.go
@@ -0,0 +1,250 @@
+// Copyright 2018 The Go 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 gopathwalk is like filepath.Walk but specialized for finding Go
+// packages, particularly in $GOPATH and $GOROOT.
+package gopathwalk
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/tools/internal/fastwalk"
+)
+
+// Options controls the behavior of a Walk call.
+type Options struct {
+	Debug          bool // Enable debug logging
+	ModulesEnabled bool // Search module caches. Also disables legacy goimports ignore rules.
+}
+
+// RootType indicates the type of a Root.
+type RootType int
+
+const (
+	RootUnknown RootType = iota
+	RootGOROOT
+	RootGOPATH
+	RootCurrentModule
+	RootModuleCache
+	RootOther
+)
+
+// A Root is a starting point for a Walk.
+type Root struct {
+	Path string
+	Type RootType
+}
+
+// SrcDirsRoots returns the roots from build.Default.SrcDirs(). Not modules-compatible.
+func SrcDirsRoots(ctx *build.Context) []Root {
+	var roots []Root
+	roots = append(roots, Root{filepath.Join(ctx.GOROOT, "src"), RootGOROOT})
+	for _, p := range filepath.SplitList(ctx.GOPATH) {
+		roots = append(roots, Root{filepath.Join(p, "src"), RootGOPATH})
+	}
+	return roots
+}
+
+// Walk walks Go source directories ($GOROOT, $GOPATH, etc) to find packages.
+// For each package found, add will be called (concurrently) with the absolute
+// paths of the containing source directory and the package directory.
+// add will be called concurrently.
+func Walk(roots []Root, add func(root Root, dir string), opts Options) {
+	for _, root := range roots {
+		walkDir(root, add, opts)
+	}
+}
+
+func walkDir(root Root, add func(Root, string), opts Options) {
+	if _, err := os.Stat(root.Path); os.IsNotExist(err) {
+		if opts.Debug {
+			log.Printf("skipping nonexistant directory: %v", root.Path)
+		}
+		return
+	}
+	if opts.Debug {
+		log.Printf("scanning %s", root.Path)
+	}
+	w := &walker{
+		root: root,
+		add:  add,
+		opts: opts,
+	}
+	w.init()
+	if err := fastwalk.Walk(root.Path, w.walk); err != nil {
+		log.Printf("gopathwalk: scanning directory %v: %v", root.Path, err)
+	}
+
+	if opts.Debug {
+		log.Printf("scanned %s", root.Path)
+	}
+}
+
+// walker is the callback for fastwalk.Walk.
+type walker struct {
+	root Root               // The source directory to scan.
+	add  func(Root, string) // The callback that will be invoked for every possible Go package dir.
+	opts Options            // Options passed to Walk by the user.
+
+	ignoredDirs []os.FileInfo // The ignored directories, loaded from .goimportsignore files.
+}
+
+// init initializes the walker based on its Options.
+func (w *walker) init() {
+	var ignoredPaths []string
+	if w.root.Type == RootModuleCache {
+		ignoredPaths = []string{"cache"}
+	}
+	if !w.opts.ModulesEnabled && w.root.Type == RootGOPATH {
+		ignoredPaths = w.getIgnoredDirs(w.root.Path)
+		ignoredPaths = append(ignoredPaths, "v", "mod")
+	}
+
+	for _, p := range ignoredPaths {
+		full := filepath.Join(w.root.Path, p)
+		if fi, err := os.Stat(full); err == nil {
+			w.ignoredDirs = append(w.ignoredDirs, fi)
+			if w.opts.Debug {
+				log.Printf("Directory added to ignore list: %s", full)
+			}
+		} else if w.opts.Debug {
+			log.Printf("Error statting ignored directory: %v", err)
+		}
+	}
+}
+
+// getIgnoredDirs reads an optional config file at <path>/.goimportsignore
+// of relative directories to ignore when scanning for go files.
+// The provided path is one of the $GOPATH entries with "src" appended.
+func (w *walker) getIgnoredDirs(path string) []string {
+	file := filepath.Join(path, ".goimportsignore")
+	slurp, err := ioutil.ReadFile(file)
+	if w.opts.Debug {
+		if err != nil {
+			log.Print(err)
+		} else {
+			log.Printf("Read %s", file)
+		}
+	}
+	if err != nil {
+		return nil
+	}
+
+	var ignoredDirs []string
+	bs := bufio.NewScanner(bytes.NewReader(slurp))
+	for bs.Scan() {
+		line := strings.TrimSpace(bs.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		ignoredDirs = append(ignoredDirs, line)
+	}
+	return ignoredDirs
+}
+
+func (w *walker) shouldSkipDir(fi os.FileInfo) bool {
+	for _, ignoredDir := range w.ignoredDirs {
+		if os.SameFile(fi, ignoredDir) {
+			return true
+		}
+	}
+	return false
+}
+
+func (w *walker) walk(path string, typ os.FileMode) error {
+	dir := filepath.Dir(path)
+	if typ.IsRegular() {
+		if dir == w.root.Path && (w.root.Type == RootGOROOT || w.root.Type == RootGOPATH) {
+			// Doesn't make sense to have regular files
+			// directly in your $GOPATH/src or $GOROOT/src.
+			return fastwalk.SkipFiles
+		}
+		if !strings.HasSuffix(path, ".go") {
+			return nil
+		}
+
+		w.add(w.root, dir)
+		return fastwalk.SkipFiles
+	}
+	if typ == os.ModeDir {
+		base := filepath.Base(path)
+		if base == "" || base[0] == '.' || base[0] == '_' ||
+			base == "testdata" ||
+			(w.root.Type == RootGOROOT && w.opts.ModulesEnabled && base == "vendor") ||
+			(!w.opts.ModulesEnabled && base == "node_modules") {
+			return filepath.SkipDir
+		}
+		fi, err := os.Lstat(path)
+		if err == nil && w.shouldSkipDir(fi) {
+			return filepath.SkipDir
+		}
+		return nil
+	}
+	if typ == os.ModeSymlink {
+		base := filepath.Base(path)
+		if strings.HasPrefix(base, ".#") {
+			// Emacs noise.
+			return nil
+		}
+		fi, err := os.Lstat(path)
+		if err != nil {
+			// Just ignore it.
+			return nil
+		}
+		if w.shouldTraverse(dir, fi) {
+			return fastwalk.TraverseLink
+		}
+	}
+	return nil
+}
+
+// shouldTraverse reports whether the symlink fi, found in dir,
+// should be followed.  It makes sure symlinks were never visited
+// before to avoid symlink loops.
+func (w *walker) shouldTraverse(dir string, fi os.FileInfo) bool {
+	path := filepath.Join(dir, fi.Name())
+	target, err := filepath.EvalSymlinks(path)
+	if err != nil {
+		return false
+	}
+	ts, err := os.Stat(target)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return false
+	}
+	if !ts.IsDir() {
+		return false
+	}
+	if w.shouldSkipDir(ts) {
+		return false
+	}
+	// Check for symlink loops by statting each directory component
+	// and seeing if any are the same file as ts.
+	for {
+		parent := filepath.Dir(path)
+		if parent == path {
+			// Made it to the root without seeing a cycle.
+			// Use this symlink.
+			return true
+		}
+		parentInfo, err := os.Stat(parent)
+		if err != nil {
+			return false
+		}
+		if os.SameFile(ts, parentInfo) {
+			// Cycle. Don't traverse.
+			return false
+		}
+		path = parent
+	}
+
+}
diff --git a/vendor/golang.org/x/tools/internal/semver/semver.go b/vendor/golang.org/x/tools/internal/semver/semver.go
new file mode 100644
index 000000000..4af7118e5
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/semver/semver.go
@@ -0,0 +1,388 @@
+// Copyright 2018 The Go 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 semver implements comparison of semantic version strings.
+// In this package, semantic version strings must begin with a leading "v",
+// as in "v1.0.0".
+//
+// The general form of a semantic version string accepted by this package is
+//
+//	vMAJOR[.MINOR[.PATCH[-PRERELEASE][+BUILD]]]
+//
+// where square brackets indicate optional parts of the syntax;
+// MAJOR, MINOR, and PATCH are decimal integers without extra leading zeros;
+// PRERELEASE and BUILD are each a series of non-empty dot-separated identifiers
+// using only alphanumeric characters and hyphens; and
+// all-numeric PRERELEASE identifiers must not have leading zeros.
+//
+// This package follows Semantic Versioning 2.0.0 (see semver.org)
+// with two exceptions. First, it requires the "v" prefix. Second, it recognizes
+// vMAJOR and vMAJOR.MINOR (with no prerelease or build suffixes)
+// as shorthands for vMAJOR.0.0 and vMAJOR.MINOR.0.
+package semver
+
+// parsed returns the parsed form of a semantic version string.
+type parsed struct {
+	major      string
+	minor      string
+	patch      string
+	short      string
+	prerelease string
+	build      string
+	err        string
+}
+
+// IsValid reports whether v is a valid semantic version string.
+func IsValid(v string) bool {
+	_, ok := parse(v)
+	return ok
+}
+
+// Canonical returns the canonical formatting of the semantic version v.
+// It fills in any missing .MINOR or .PATCH and discards build metadata.
+// Two semantic versions compare equal only if their canonical formattings
+// are identical strings.
+// The canonical invalid semantic version is the empty string.
+func Canonical(v string) string {
+	p, ok := parse(v)
+	if !ok {
+		return ""
+	}
+	if p.build != "" {
+		return v[:len(v)-len(p.build)]
+	}
+	if p.short != "" {
+		return v + p.short
+	}
+	return v
+}
+
+// Major returns the major version prefix of the semantic version v.
+// For example, Major("v2.1.0") == "v2".
+// If v is an invalid semantic version string, Major returns the empty string.
+func Major(v string) string {
+	pv, ok := parse(v)
+	if !ok {
+		return ""
+	}
+	return v[:1+len(pv.major)]
+}
+
+// MajorMinor returns the major.minor version prefix of the semantic version v.
+// For example, MajorMinor("v2.1.0") == "v2.1".
+// If v is an invalid semantic version string, MajorMinor returns the empty string.
+func MajorMinor(v string) string {
+	pv, ok := parse(v)
+	if !ok {
+		return ""
+	}
+	i := 1 + len(pv.major)
+	if j := i + 1 + len(pv.minor); j <= len(v) && v[i] == '.' && v[i+1:j] == pv.minor {
+		return v[:j]
+	}
+	return v[:i] + "." + pv.minor
+}
+
+// Prerelease returns the prerelease suffix of the semantic version v.
+// For example, Prerelease("v2.1.0-pre+meta") == "-pre".
+// If v is an invalid semantic version string, Prerelease returns the empty string.
+func Prerelease(v string) string {
+	pv, ok := parse(v)
+	if !ok {
+		return ""
+	}
+	return pv.prerelease
+}
+
+// Build returns the build suffix of the semantic version v.
+// For example, Build("v2.1.0+meta") == "+meta".
+// If v is an invalid semantic version string, Build returns the empty string.
+func Build(v string) string {
+	pv, ok := parse(v)
+	if !ok {
+		return ""
+	}
+	return pv.build
+}
+
+// Compare returns an integer comparing two versions according to
+// according to semantic version precedence.
+// The result will be 0 if v == w, -1 if v < w, or +1 if v > w.
+//
+// An invalid semantic version string is considered less than a valid one.
+// All invalid semantic version strings compare equal to each other.
+func Compare(v, w string) int {
+	pv, ok1 := parse(v)
+	pw, ok2 := parse(w)
+	if !ok1 && !ok2 {
+		return 0
+	}
+	if !ok1 {
+		return -1
+	}
+	if !ok2 {
+		return +1
+	}
+	if c := compareInt(pv.major, pw.major); c != 0 {
+		return c
+	}
+	if c := compareInt(pv.minor, pw.minor); c != 0 {
+		return c
+	}
+	if c := compareInt(pv.patch, pw.patch); c != 0 {
+		return c
+	}
+	return comparePrerelease(pv.prerelease, pw.prerelease)
+}
+
+// Max canonicalizes its arguments and then returns the version string
+// that compares greater.
+func Max(v, w string) string {
+	v = Canonical(v)
+	w = Canonical(w)
+	if Compare(v, w) > 0 {
+		return v
+	}
+	return w
+}
+
+func parse(v string) (p parsed, ok bool) {
+	if v == "" || v[0] != 'v' {
+		p.err = "missing v prefix"
+		return
+	}
+	p.major, v, ok = parseInt(v[1:])
+	if !ok {
+		p.err = "bad major version"
+		return
+	}
+	if v == "" {
+		p.minor = "0"
+		p.patch = "0"
+		p.short = ".0.0"
+		return
+	}
+	if v[0] != '.' {
+		p.err = "bad minor prefix"
+		ok = false
+		return
+	}
+	p.minor, v, ok = parseInt(v[1:])
+	if !ok {
+		p.err = "bad minor version"
+		return
+	}
+	if v == "" {
+		p.patch = "0"
+		p.short = ".0"
+		return
+	}
+	if v[0] != '.' {
+		p.err = "bad patch prefix"
+		ok = false
+		return
+	}
+	p.patch, v, ok = parseInt(v[1:])
+	if !ok {
+		p.err = "bad patch version"
+		return
+	}
+	if len(v) > 0 && v[0] == '-' {
+		p.prerelease, v, ok = parsePrerelease(v)
+		if !ok {
+			p.err = "bad prerelease"
+			return
+		}
+	}
+	if len(v) > 0 && v[0] == '+' {
+		p.build, v, ok = parseBuild(v)
+		if !ok {
+			p.err = "bad build"
+			return
+		}
+	}
+	if v != "" {
+		p.err = "junk on end"
+		ok = false
+		return
+	}
+	ok = true
+	return
+}
+
+func parseInt(v string) (t, rest string, ok bool) {
+	if v == "" {
+		return
+	}
+	if v[0] < '0' || '9' < v[0] {
+		return
+	}
+	i := 1
+	for i < len(v) && '0' <= v[i] && v[i] <= '9' {
+		i++
+	}
+	if v[0] == '0' && i != 1 {
+		return
+	}
+	return v[:i], v[i:], true
+}
+
+func parsePrerelease(v string) (t, rest string, ok bool) {
+	// "A pre-release version MAY be denoted by appending a hyphen and
+	// a series of dot separated identifiers immediately following the patch version.
+	// Identifiers MUST comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-].
+	// Identifiers MUST NOT be empty. Numeric identifiers MUST NOT include leading zeroes."
+	if v == "" || v[0] != '-' {
+		return
+	}
+	i := 1
+	start := 1
+	for i < len(v) && v[i] != '+' {
+		if !isIdentChar(v[i]) && v[i] != '.' {
+			return
+		}
+		if v[i] == '.' {
+			if start == i || isBadNum(v[start:i]) {
+				return
+			}
+			start = i + 1
+		}
+		i++
+	}
+	if start == i || isBadNum(v[start:i]) {
+		return
+	}
+	return v[:i], v[i:], true
+}
+
+func parseBuild(v string) (t, rest string, ok bool) {
+	if v == "" || v[0] != '+' {
+		return
+	}
+	i := 1
+	start := 1
+	for i < len(v) {
+		if !isIdentChar(v[i]) {
+			return
+		}
+		if v[i] == '.' {
+			if start == i {
+				return
+			}
+			start = i + 1
+		}
+		i++
+	}
+	if start == i {
+		return
+	}
+	return v[:i], v[i:], true
+}
+
+func isIdentChar(c byte) bool {
+	return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '-'
+}
+
+func isBadNum(v string) bool {
+	i := 0
+	for i < len(v) && '0' <= v[i] && v[i] <= '9' {
+		i++
+	}
+	return i == len(v) && i > 1 && v[0] == '0'
+}
+
+func isNum(v string) bool {
+	i := 0
+	for i < len(v) && '0' <= v[i] && v[i] <= '9' {
+		i++
+	}
+	return i == len(v)
+}
+
+func compareInt(x, y string) int {
+	if x == y {
+		return 0
+	}
+	if len(x) < len(y) {
+		return -1
+	}
+	if len(x) > len(y) {
+		return +1
+	}
+	if x < y {
+		return -1
+	} else {
+		return +1
+	}
+}
+
+func comparePrerelease(x, y string) int {
+	// "When major, minor, and patch are equal, a pre-release version has
+	// lower precedence than a normal version.
+	// Example: 1.0.0-alpha < 1.0.0.
+	// Precedence for two pre-release versions with the same major, minor,
+	// and patch version MUST be determined by comparing each dot separated
+	// identifier from left to right until a difference is found as follows:
+	// identifiers consisting of only digits are compared numerically and
+	// identifiers with letters or hyphens are compared lexically in ASCII
+	// sort order. Numeric identifiers always have lower precedence than
+	// non-numeric identifiers. A larger set of pre-release fields has a
+	// higher precedence than a smaller set, if all of the preceding
+	// identifiers are equal.
+	// Example: 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta <
+	// 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0."
+	if x == y {
+		return 0
+	}
+	if x == "" {
+		return +1
+	}
+	if y == "" {
+		return -1
+	}
+	for x != "" && y != "" {
+		x = x[1:] // skip - or .
+		y = y[1:] // skip - or .
+		var dx, dy string
+		dx, x = nextIdent(x)
+		dy, y = nextIdent(y)
+		if dx != dy {
+			ix := isNum(dx)
+			iy := isNum(dy)
+			if ix != iy {
+				if ix {
+					return -1
+				} else {
+					return +1
+				}
+			}
+			if ix {
+				if len(dx) < len(dy) {
+					return -1
+				}
+				if len(dx) > len(dy) {
+					return +1
+				}
+			}
+			if dx < dy {
+				return -1
+			} else {
+				return +1
+			}
+		}
+	}
+	if x == "" {
+		return -1
+	} else {
+		return +1
+	}
+}
+
+func nextIdent(x string) (dx, rest string) {
+	i := 0
+	for i < len(x) && x[i] != '.' {
+		i++
+	}
+	return x[:i], x[i:]
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 9446197b2..b487e83fd 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -30,21 +30,21 @@ github.com/Azure/go-autorest/logger
 github.com/Azure/go-autorest/tracing
 # github.com/Azure/go-ntlmssp v0.0.0-20180810175552-4a21cbd618b4
 github.com/Azure/go-ntlmssp
-# github.com/ChrisTrenkamp/goxpath v0.0.0-20170625215350-4fe035839290
+# github.com/ChrisTrenkamp/goxpath v0.0.0-20170922090931-c385f95c6022
 github.com/ChrisTrenkamp/goxpath
 github.com/ChrisTrenkamp/goxpath/internal/execxp
-github.com/ChrisTrenkamp/goxpath/internal/lexer
-github.com/ChrisTrenkamp/goxpath/internal/parser
-github.com/ChrisTrenkamp/goxpath/internal/parser/findutil
-github.com/ChrisTrenkamp/goxpath/internal/parser/intfns
-github.com/ChrisTrenkamp/goxpath/internal/parser/pathexpr
-github.com/ChrisTrenkamp/goxpath/internal/xconst
+github.com/ChrisTrenkamp/goxpath/internal/execxp/findutil
+github.com/ChrisTrenkamp/goxpath/internal/execxp/intfns
 github.com/ChrisTrenkamp/goxpath/internal/xsort
+github.com/ChrisTrenkamp/goxpath/lexer
+github.com/ChrisTrenkamp/goxpath/parser
+github.com/ChrisTrenkamp/goxpath/parser/pathexpr
 github.com/ChrisTrenkamp/goxpath/tree
 github.com/ChrisTrenkamp/goxpath/tree/xmltree
 github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlbuilder
 github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlele
 github.com/ChrisTrenkamp/goxpath/tree/xmltree/xmlnode
+github.com/ChrisTrenkamp/goxpath/xconst
 # github.com/NaverCloudPlatform/ncloud-sdk-go v0.0.0-20180110055012-c2e73f942591
 github.com/NaverCloudPlatform/ncloud-sdk-go/common
 github.com/NaverCloudPlatform/ncloud-sdk-go/oauth
@@ -56,6 +56,8 @@ github.com/PuerkitoBio/goquery
 github.com/StackExchange/wmi
 # github.com/Telmate/proxmox-api-go v0.0.0-20190815172943-ef9222844e60
 github.com/Telmate/proxmox-api-go/proxmox
+# github.com/agext/levenshtein v1.2.2
+github.com/agext/levenshtein
 # github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190418113227-25233c783f4e
 github.com/aliyun/alibaba-cloud-sdk-go/sdk
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth
@@ -69,7 +71,7 @@ github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses
 github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils
 github.com/aliyun/alibaba-cloud-sdk-go/services/ecs
 github.com/aliyun/alibaba-cloud-sdk-go/services/ram
-# github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20170113022742-e6dbea820a9f
+# github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20190103054945-8205d1f41e70
 github.com/aliyun/aliyun-oss-go-sdk/oss
 # github.com/andybalholm/cascadia v1.0.0
 github.com/andybalholm/cascadia
@@ -77,12 +79,14 @@ github.com/andybalholm/cascadia
 github.com/antchfx/htmlquery
 # github.com/antchfx/xmlquery v1.0.0
 github.com/antchfx/xmlquery
-# github.com/antchfx/xpath v0.0.0-20170728053731-b5c552e1acbd
+# github.com/antchfx/xpath v0.0.0-20190129040759-c8489ed3251e
 github.com/antchfx/xpath
-# github.com/antchfx/xquery v0.0.0-20170730121040-eb8c3c172607
+# github.com/antchfx/xquery v0.0.0-20180515051857-ad5b8c7a47b0
 github.com/antchfx/xquery/xml
 # github.com/antihax/optional v0.0.0-20180407024304-ca021399b1a6
 github.com/antihax/optional
+# github.com/apparentlymart/go-textseg v1.0.0
+github.com/apparentlymart/go-textseg/textseg
 # github.com/approvals/go-approval-tests v0.0.0-20160714161514-ad96e53bea43
 github.com/approvals/go-approval-tests
 github.com/approvals/go-approval-tests/reporters
@@ -175,7 +179,7 @@ github.com/docker/docker/pkg/namesgenerator
 github.com/dustin/go-humanize
 # github.com/dylanmei/iso8601 v0.1.0
 github.com/dylanmei/iso8601
-# github.com/dylanmei/winrmtest v0.0.0-20170819153634-c2fbb09e6c08
+# github.com/dylanmei/winrmtest v0.0.0-20190225150635-99b7fe2fddf1
 github.com/dylanmei/winrmtest
 # github.com/exoscale/egoscale v0.18.1
 github.com/exoscale/egoscale
@@ -229,6 +233,7 @@ github.com/golang/protobuf/ptypes/wrappers
 github.com/golang/snappy
 # github.com/google/go-cmp v0.3.0
 github.com/google/go-cmp/cmp
+github.com/google/go-cmp/cmp/cmpopts
 github.com/google/go-cmp/cmp/internal/diff
 github.com/google/go-cmp/cmp/internal/flags
 github.com/google/go-cmp/cmp/internal/function
@@ -237,7 +242,7 @@ github.com/google/go-cmp/cmp/internal/value
 github.com/google/go-querystring/query
 # github.com/google/shlex v0.0.0-20150127133951-6f45313302b9
 github.com/google/shlex
-# github.com/google/uuid v1.0.0
+# github.com/google/uuid v1.1.1
 github.com/google/uuid
 # github.com/googleapis/gax-go/v2 v2.0.5
 github.com/googleapis/gax-go/v2
@@ -264,9 +269,9 @@ github.com/gophercloud/gophercloud/openstack/networking/v2/extensions/layer3/flo
 github.com/gophercloud/gophercloud/openstack/networking/v2/networks
 github.com/gophercloud/gophercloud/openstack/utils
 github.com/gophercloud/gophercloud/pagination
-# github.com/gophercloud/utils v0.0.0-20190124192022-a5c25e7a53a6
+# github.com/gophercloud/utils v0.0.0-20190128072930-fbb6ab446f01
 github.com/gophercloud/utils/openstack/clientconfig
-# github.com/gorilla/websocket v0.0.0-20170319172727-a91eba7f9777
+# github.com/gorilla/websocket v1.4.0
 github.com/gorilla/websocket
 # github.com/grpc-ecosystem/go-grpc-middleware v1.1.0
 github.com/grpc-ecosystem/go-grpc-middleware
@@ -278,11 +283,11 @@ github.com/grpc-ecosystem/grpc-gateway/utilities
 github.com/hashicorp/consul/api
 # github.com/hashicorp/errwrap v1.0.0
 github.com/hashicorp/errwrap
-# github.com/hashicorp/go-checkpoint v0.0.0-20171009173528-1545e56e46de
+# github.com/hashicorp/go-checkpoint v0.5.0
 github.com/hashicorp/go-checkpoint
 # github.com/hashicorp/go-cleanhttp v0.5.0
 github.com/hashicorp/go-cleanhttp
-# github.com/hashicorp/go-getter v1.3.1-0.20190906090232-a0f878cb75da
+# github.com/hashicorp/go-getter v1.4.0
 github.com/hashicorp/go-getter
 github.com/hashicorp/go-getter/helper/url
 # github.com/hashicorp/go-immutable-radix v1.0.0
@@ -295,7 +300,7 @@ github.com/hashicorp/go-oracle-terraform/compute
 github.com/hashicorp/go-oracle-terraform/opc
 # github.com/hashicorp/go-retryablehttp v0.5.2
 github.com/hashicorp/go-retryablehttp
-# github.com/hashicorp/go-rootcerts v0.0.0-20160503143440-6bb64b370b90
+# github.com/hashicorp/go-rootcerts v1.0.0
 github.com/hashicorp/go-rootcerts
 # github.com/hashicorp/go-safetemp v1.0.0
 github.com/hashicorp/go-safetemp
@@ -317,6 +322,14 @@ github.com/hashicorp/hcl/hcl/token
 github.com/hashicorp/hcl/json/parser
 github.com/hashicorp/hcl/json/scanner
 github.com/hashicorp/hcl/json/token
+# github.com/hashicorp/hcl/v2 v2.0.0
+github.com/hashicorp/hcl/v2
+github.com/hashicorp/hcl/v2/gohcl
+github.com/hashicorp/hcl/v2/hcldec
+github.com/hashicorp/hcl/v2/hclparse
+github.com/hashicorp/hcl/v2/hclsyntax
+github.com/hashicorp/hcl/v2/hclwrite
+github.com/hashicorp/hcl/v2/json
 # github.com/hashicorp/serf v0.8.2
 github.com/hashicorp/serf/coordinate
 # github.com/hashicorp/vault v1.1.0
@@ -358,7 +371,7 @@ github.com/joyent/triton-go/errors
 github.com/joyent/triton-go/network
 # github.com/json-iterator/go v1.1.6
 github.com/json-iterator/go
-# github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1
+# github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0
 github.com/kardianos/osext
 # github.com/kennygrant/sanitize v1.2.4
 github.com/kennygrant/sanitize
@@ -376,17 +389,14 @@ github.com/konsorten/go-windows-terminal-sequences
 github.com/kr/fs
 # github.com/linode/linodego v0.7.1
 github.com/linode/linodego
-# github.com/masterzen/azure-sdk-for-go v0.0.0-20161014135628-ee4f0065d00c
-github.com/masterzen/azure-sdk-for-go/core/http
-github.com/masterzen/azure-sdk-for-go/core/tls
 # github.com/masterzen/simplexml v0.0.0-20190410153822-31eea3082786
 github.com/masterzen/simplexml/dom
-# github.com/masterzen/winrm v0.0.0-20180224160350-7e40f93ae939
+# github.com/masterzen/winrm v0.0.0-20190223112901-5e5c9a7fe54b
 github.com/masterzen/winrm
 github.com/masterzen/winrm/soap
-# github.com/mattn/go-colorable v0.0.9
+# github.com/mattn/go-colorable v0.1.1
 github.com/mattn/go-colorable
-# github.com/mattn/go-isatty v0.0.4
+# github.com/mattn/go-isatty v0.0.5
 github.com/mattn/go-isatty
 # github.com/mattn/go-runewidth v0.0.4
 github.com/mattn/go-runewidth
@@ -397,19 +407,21 @@ github.com/mitchellh/cli
 # github.com/mitchellh/go-fs v0.0.0-20180402234041-7b48fa161ea7
 github.com/mitchellh/go-fs
 github.com/mitchellh/go-fs/fat
-# github.com/mitchellh/go-homedir v1.0.0
+# github.com/mitchellh/go-homedir v1.1.0
 github.com/mitchellh/go-homedir
 # github.com/mitchellh/go-testing-interface v1.0.0
 github.com/mitchellh/go-testing-interface
 # github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed
 github.com/mitchellh/go-vnc
+# github.com/mitchellh/go-wordwrap v1.0.0
+github.com/mitchellh/go-wordwrap
 # github.com/mitchellh/iochan v1.0.0
 github.com/mitchellh/iochan
 # github.com/mitchellh/mapstructure v0.0.0-20180111000720-b4575eea38cc
 github.com/mitchellh/mapstructure
-# github.com/mitchellh/panicwrap v0.0.0-20170106182340-fce601fe5557
+# github.com/mitchellh/panicwrap v0.0.0-20190213213626-17011010aaa4
 github.com/mitchellh/panicwrap
-# github.com/mitchellh/prefixedio v0.0.0-20151214002211-6e6954073784
+# github.com/mitchellh/prefixedio v0.0.0-20190213213902-5733675afd51
 github.com/mitchellh/prefixedio
 # github.com/mitchellh/reflectwalk v1.0.0
 github.com/mitchellh/reflectwalk
@@ -442,7 +454,7 @@ github.com/pkg/errors
 github.com/pkg/sftp
 # github.com/pmezard/go-difflib v1.0.0
 github.com/pmezard/go-difflib/difflib
-# github.com/posener/complete v1.1.1
+# github.com/posener/complete v1.2.1
 github.com/posener/complete
 github.com/posener/complete/cmd
 github.com/posener/complete/cmd/install
@@ -498,7 +510,7 @@ github.com/ucloud/ucloud-sdk-go/ucloud/log
 github.com/ucloud/ucloud-sdk-go/ucloud/request
 github.com/ucloud/ucloud-sdk-go/ucloud/response
 github.com/ucloud/ucloud-sdk-go/ucloud/version
-# github.com/ugorji/go v0.0.0-20151218193438-646ae4a518c1
+# github.com/ugorji/go v0.0.0-20180813092308-00b869d2f4a5
 github.com/ugorji/go/codec
 # github.com/ulikunitz/xz v0.5.5
 github.com/ulikunitz/xz
@@ -579,6 +591,14 @@ github.com/yandex-cloud/go-sdk/pkg/retry
 github.com/yandex-cloud/go-sdk/pkg/sdkerrors
 github.com/yandex-cloud/go-sdk/pkg/singleflight
 github.com/yandex-cloud/go-sdk/sdkresolvers
+# github.com/zclconf/go-cty v1.1.0
+github.com/zclconf/go-cty/cty
+github.com/zclconf/go-cty/cty/convert
+github.com/zclconf/go-cty/cty/function
+github.com/zclconf/go-cty/cty/function/stdlib
+github.com/zclconf/go-cty/cty/gocty
+github.com/zclconf/go-cty/cty/json
+github.com/zclconf/go-cty/cty/set
 # go.opencensus.io v0.22.0
 go.opencensus.io
 go.opencensus.io/internal
@@ -598,7 +618,7 @@ go.opencensus.io/trace
 go.opencensus.io/trace/internal
 go.opencensus.io/trace/propagation
 go.opencensus.io/trace/tracestate
-# golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5
+# golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4
 golang.org/x/crypto/curve25519
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
@@ -633,7 +653,7 @@ golang.org/x/oauth2/jwt
 # golang.org/x/sync v0.0.0-20190423024810-112230192c58
 golang.org/x/sync/errgroup
 golang.org/x/sync/semaphore
-# golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0
+# golang.org/x/sys v0.0.0-20190804053845-51ab0e2deafa
 golang.org/x/sys/cpu
 golang.org/x/sys/unix
 golang.org/x/sys/windows
@@ -660,6 +680,14 @@ golang.org/x/text/unicode/bidi
 golang.org/x/text/unicode/norm
 # golang.org/x/time v0.0.0-20190308202827-9d24e82272b4
 golang.org/x/time/rate
+# golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0
+golang.org/x/tools/go/gcexportdata
+golang.org/x/tools/go/internal/gcimporter
+golang.org/x/tools/go/internal/packagesdriver
+golang.org/x/tools/go/packages
+golang.org/x/tools/internal/fastwalk
+golang.org/x/tools/internal/gopathwalk
+golang.org/x/tools/internal/semver
 # google.golang.org/api v0.9.0
 google.golang.org/api/compute/v1
 google.golang.org/api/gensupport

From a8b2918d0e39f2a03bd8f5e36508d16e3c5297b4 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Mon, 14 Oct 2019 17:13:02 +0200
Subject: [PATCH 081/155] remote duplicate
 gob.Register(new(map[string]interface{}))

otherwise this panics
---
 packer/rpc/init.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packer/rpc/init.go b/packer/rpc/init.go
index 2d763d83b..f08e76494 100644
--- a/packer/rpc/init.go
+++ b/packer/rpc/init.go
@@ -3,7 +3,6 @@ package rpc
 import "encoding/gob"
 
 func init() {
-	gob.Register(new(map[string]interface{}))
 	gob.Register(new(map[string]string))
 	gob.Register(make([]interface{}, 0))
 	gob.Register(new(BasicError))

From 1158eeb46d3e722530d43fe644909a4b95fa067d Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Tue, 15 Oct 2019 11:12:39 +0200
Subject: [PATCH 082/155] Update Makefile

to @go install ./cmd/mapstructure-to-hcl2 so that we can `make generate` and tests that generated code is what it should be
---
 Makefile | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Makefile b/Makefile
index f35c6656f..0a9d7cf85 100644
--- a/Makefile
+++ b/Makefile
@@ -53,6 +53,7 @@ install-gen-deps: ## Install dependencies for code generation
 	@(cd $(TEMPDIR) && GO111MODULE=on go get github.com/mna/pigeon@master)
 	@(cd $(TEMPDIR) && GO111MODULE=on go get github.com/alvaroloes/enumer@master)
 	@go install ./cmd/struct-markdown
+	@go install ./cmd/mapstructure-to-hcl2
 
 dev: ## Build and install a development build
 	@grep 'const VersionPrerelease = ""' version/version.go > /dev/null ; if [ $$? -eq 0 ]; then \
@@ -97,6 +98,8 @@ fmt-examples:
 generate: install-gen-deps ## Generate dynamically generated code
 	@echo "==> removing autogenerated markdown..."
 	@find website/source/ -type f | xargs grep -l '^<!-- Code generated' | xargs rm
+	@echo "==> removing autogenerated code..."
+	@find find post-processor common helper template builder provisioner -type f | xargs grep -l '^// Code generated' | xargs rm
 	go generate ./...
 	go fmt common/bootcommand/boot_command.go
 	go fmt command/plugin.go

From 21a0cbffba1f88267b7d8f4f6ef8ecb45918f97b Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Tue, 15 Oct 2019 11:34:26 +0200
Subject: [PATCH 083/155] fmt

---
 builder/vmware/common/export_config.go | 1 -
 builder/vmware/common/hw_config.go     | 1 -
 builder/vmware/common/output_config.go | 1 -
 builder/vmware/common/ssh_config.go    | 1 -
 builder/vmware/common/tools_config.go  | 1 -
 hcl2template/config_load.go            | 2 +-
 hcl2template/types.build.from.go       | 2 +-
 hcl2template/types.variable.go         | 2 +-
 8 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/builder/vmware/common/export_config.go b/builder/vmware/common/export_config.go
index 225d140fa..1ae85d759 100644
--- a/builder/vmware/common/export_config.go
+++ b/builder/vmware/common/export_config.go
@@ -1,6 +1,5 @@
 //go:generate struct-markdown
 
-
 package common
 
 import (
diff --git a/builder/vmware/common/hw_config.go b/builder/vmware/common/hw_config.go
index ba288f57c..114227ab3 100644
--- a/builder/vmware/common/hw_config.go
+++ b/builder/vmware/common/hw_config.go
@@ -1,6 +1,5 @@
 //go:generate struct-markdown
 
-
 package common
 
 import (
diff --git a/builder/vmware/common/output_config.go b/builder/vmware/common/output_config.go
index acc81fa1f..e99919dcb 100644
--- a/builder/vmware/common/output_config.go
+++ b/builder/vmware/common/output_config.go
@@ -1,6 +1,5 @@
 //go:generate struct-markdown
 
-
 package common
 
 import (
diff --git a/builder/vmware/common/ssh_config.go b/builder/vmware/common/ssh_config.go
index 6b0072b5e..8c59cdedc 100644
--- a/builder/vmware/common/ssh_config.go
+++ b/builder/vmware/common/ssh_config.go
@@ -1,6 +1,5 @@
 //go:generate struct-markdown
 
-
 package common
 
 import (
diff --git a/builder/vmware/common/tools_config.go b/builder/vmware/common/tools_config.go
index 3c76ee2a0..4830ff30c 100644
--- a/builder/vmware/common/tools_config.go
+++ b/builder/vmware/common/tools_config.go
@@ -1,6 +1,5 @@
 //go:generate struct-markdown
 
-
 package common
 
 import (
diff --git a/hcl2template/config_load.go b/hcl2template/config_load.go
index 1be7928c4..61bd281aa 100644
--- a/hcl2template/config_load.go
+++ b/hcl2template/config_load.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/hashicorp/hcl/v2"
 	"github.com/zclconf/go-cty/cty"
-) 
+)
 
 type Artifacts map[ArtifactRef]*Artifact
 
diff --git a/hcl2template/types.build.from.go b/hcl2template/types.build.from.go
index 3d1d8d383..66d3b7645 100644
--- a/hcl2template/types.build.from.go
+++ b/hcl2template/types.build.from.go
@@ -3,8 +3,8 @@ package hcl2template
 import (
 	"strings"
 
-	"github.com/hashicorp/hcl/v2/gohcl"
 	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/gohcl"
 	"github.com/hashicorp/hcl/v2/hclsyntax"
 )
 
diff --git a/hcl2template/types.variable.go b/hcl2template/types.variable.go
index e03462ff5..bbf349700 100644
--- a/hcl2template/types.variable.go
+++ b/hcl2template/types.variable.go
@@ -1,8 +1,8 @@
 package hcl2template
 
 import (
-	"github.com/hashicorp/hcl/v2/gohcl"
 	"github.com/hashicorp/hcl/v2"
+	"github.com/hashicorp/hcl/v2/gohcl"
 	"github.com/hashicorp/packer/template"
 )
 

From 0e4fec03d7c09bd3c105e24318a845288076620c Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Tue, 15 Oct 2019 12:47:59 +0200
Subject: [PATCH 084/155] make complete tests files link as windows can't
 handle synlinks

---
 hcl2template/testdata/complete/build.pkr.hcl  | 67 ++++++++++++++++++-
 .../testdata/complete/communicator.pkr.hcl    | 28 +++++++-
 .../testdata/complete/sources.pkr.hcl         | 38 ++++++++++-
 .../testdata/complete/variables.pkr.hcl       |  7 +-
 4 files changed, 136 insertions(+), 4 deletions(-)
 mode change 120000 => 100644 hcl2template/testdata/complete/build.pkr.hcl
 mode change 120000 => 100644 hcl2template/testdata/complete/communicator.pkr.hcl
 mode change 120000 => 100644 hcl2template/testdata/complete/sources.pkr.hcl
 mode change 120000 => 100644 hcl2template/testdata/complete/variables.pkr.hcl

diff --git a/hcl2template/testdata/complete/build.pkr.hcl b/hcl2template/testdata/complete/build.pkr.hcl
deleted file mode 120000
index bf17682ed..000000000
--- a/hcl2template/testdata/complete/build.pkr.hcl
+++ /dev/null
@@ -1 +0,0 @@
-../build/basic.pkr.hcl
\ No newline at end of file
diff --git a/hcl2template/testdata/complete/build.pkr.hcl b/hcl2template/testdata/complete/build.pkr.hcl
new file mode 100644
index 000000000..c48847c94
--- /dev/null
+++ b/hcl2template/testdata/complete/build.pkr.hcl
@@ -0,0 +1,66 @@
+
+// starts resources to provision them.
+build {
+    from "src.amazon-ebs.ubuntu-1604" {
+        ami_name = "that-ubuntu-1.0"
+    }
+
+    from "src.virtualbox-iso.ubuntu-1204" {
+        // build name is defaulted from the label "src.virtualbox-iso.ubuntu-1204"
+        outout_dir = "path/"
+    }
+
+    provision {
+        communicator = "comm.ssh.vagrant"
+
+        shell {
+            inline = [
+                "echo '{{user `my_secret`}}' :D"
+            ]
+        }
+
+        shell {
+            valid_exit_codes = [
+                0,
+                42,
+            ]
+            scripts = [
+                "script-1.sh",
+                "script-2.sh",
+            ]
+            // override "vmware-iso" { // TODO(azr): handle common fields
+            //     execute_command = "echo 'password' | sudo -S bash {{.Path}}"
+            // }
+        }
+
+        file {
+            source = "app.tar.gz"
+            destination = "/tmp/app.tar.gz"
+            // timeout = "5s" // TODO(azr): handle common fields
+        }
+
+    }
+
+    post_provision {
+        amazon-import {
+            // only = ["src.virtualbox-iso.ubuntu-1204"] // TODO(azr): handle common fields
+            ami_name = "that-ubuntu-1.0"
+        }
+    }
+}
+
+build {
+    // build an ami using the ami from the previous build block.
+    from "src.amazon.that-ubuntu-1.0" {
+        ami_name = "fooooobaaaar"
+    }
+
+    provision {
+
+        shell {
+            inline = [
+                "echo HOLY GUACAMOLE !"
+            ]
+        }
+    }
+}
\ No newline at end of file
diff --git a/hcl2template/testdata/complete/communicator.pkr.hcl b/hcl2template/testdata/complete/communicator.pkr.hcl
deleted file mode 120000
index 2a350af04..000000000
--- a/hcl2template/testdata/complete/communicator.pkr.hcl
+++ /dev/null
@@ -1 +0,0 @@
-../communicator/basic.pkr.hcl
\ No newline at end of file
diff --git a/hcl2template/testdata/complete/communicator.pkr.hcl b/hcl2template/testdata/complete/communicator.pkr.hcl
new file mode 100644
index 000000000..b752333e9
--- /dev/null
+++ b/hcl2template/testdata/complete/communicator.pkr.hcl
@@ -0,0 +1,27 @@
+
+communicator "ssh" "vagrant" {
+  ssh_password                 = "s3cr4t"
+  ssh_username                 = "vagrant"
+  ssh_agent_auth               = false
+  ssh_bastion_agent_auth       = true
+  ssh_bastion_host             = ""
+  ssh_bastion_password         = ""
+  ssh_bastion_port             = 0
+  ssh_bastion_private_key_file = ""
+  ssh_bastion_username         = ""
+  ssh_clear_authorized_keys    = true
+  ssh_disable_agent_forwarding = true
+  ssh_file_transfer_method     = "scp"
+  ssh_handshake_attempts       = 32
+  ssh_host                     = "sssssh.hashicorp.io"
+  ssh_port                     = 42
+  ssh_keep_alive_interval      = "10s"
+  ssh_private_key_file         = "file.pem"
+  ssh_proxy_host               = "ninja-potatoes.com"
+  ssh_proxy_password           = "pickle-rick"
+  ssh_proxy_port               = "42"
+  ssh_proxy_username           = "dark-father"
+  ssh_pty                      = false
+  ssh_read_write_timeout       = "5m"
+  ssh_timeout                  = "5m"
+}
diff --git a/hcl2template/testdata/complete/sources.pkr.hcl b/hcl2template/testdata/complete/sources.pkr.hcl
deleted file mode 120000
index 68b98eaa6..000000000
--- a/hcl2template/testdata/complete/sources.pkr.hcl
+++ /dev/null
@@ -1 +0,0 @@
-../sources/basic.pkr.hcl
\ No newline at end of file
diff --git a/hcl2template/testdata/complete/sources.pkr.hcl b/hcl2template/testdata/complete/sources.pkr.hcl
new file mode 100644
index 000000000..43e3af082
--- /dev/null
+++ b/hcl2template/testdata/complete/sources.pkr.hcl
@@ -0,0 +1,37 @@
+// a source represents a reusable setting for a system boot/start.
+source "virtualbox-iso" "ubuntu-1204" {
+    iso_url = "http://releases.ubuntu.com/12.04/ubuntu-12.04.5-server-amd64.iso"
+    iso_checksum = "769474248a3897f4865817446f9a4a53"
+    iso_checksum_type = "md5"
+
+    boot_wait = "10s"
+    http_directory = "xxx"
+    boot_command = ["..."]
+
+    shutdown_command = "echo 'vagrant' | sudo -S shutdown -P now"
+}
+
+source "amazon-ebs" "ubuntu-1604" {
+    instance_type = "t2.micro"
+    encrypt_boot = true
+    region = "eu-west-3"
+    source_ami_filter {
+        filters {
+            virtualization-type = "hvm"
+            name = "ubuntu/images/*ubuntu-xenial-{16.04}-amd64-server-*"
+            root-device-type = "ebs"
+        }
+        owners = [
+            "099720109477"
+        ]
+    }
+}
+
+source "amazon-ebs" "that-ubuntu-1.0" {
+    instance_type = "t2.micro"
+    encrypt_boot = true
+    region = "eu-west-3"
+    source_ami_filter {
+        most_recent = true
+    }
+}
diff --git a/hcl2template/testdata/complete/variables.pkr.hcl b/hcl2template/testdata/complete/variables.pkr.hcl
deleted file mode 120000
index c8296b22b..000000000
--- a/hcl2template/testdata/complete/variables.pkr.hcl
+++ /dev/null
@@ -1 +0,0 @@
-../variables/basic.pkr.hcl
\ No newline at end of file
diff --git a/hcl2template/testdata/complete/variables.pkr.hcl b/hcl2template/testdata/complete/variables.pkr.hcl
new file mode 100644
index 000000000..d4e651247
--- /dev/null
+++ b/hcl2template/testdata/complete/variables.pkr.hcl
@@ -0,0 +1,6 @@
+
+variables {
+    key = "value"
+    my_secret = "foo"
+    image_name = "foo-image-{{user `my_secret`}}"
+}

From d6994df188c52b67e9ba833b8714642b6748f90d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr?= <machv@users.noreply.github.com>
Date: Tue, 15 Oct 2019 15:14:22 +0200
Subject: [PATCH 085/155] Select first adapter attached to host OS's switch

If more than one vNic is attached to vmSwitch, use the first one only.
---
 common/powershell/hyperv/hyperv.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/powershell/hyperv/hyperv.go b/common/powershell/hyperv/hyperv.go
index ecfb40ec2..b1dd6f47d 100644
--- a/common/powershell/hyperv/hyperv.go
+++ b/common/powershell/hyperv/hyperv.go
@@ -32,7 +32,7 @@ type scriptOptions struct {
 func GetHostAdapterIpAddressForSwitch(switchName string) (string, error) {
 	var script = `
 param([string]$switchName, [int]$addressIndex)
-$HostVMAdapter = Hyper-V\Get-VMNetworkAdapter -ManagementOS -SwitchName $switchName
+$HostVMAdapter = Hyper-V\Get-VMNetworkAdapter -ManagementOS -SwitchName $switchName | Select-Object -First 1
 if ($HostVMAdapter){
   $HostNetAdapter = Get-NetAdapter | Where-Object { $_.DeviceId -eq $HostVMAdapter.DeviceId }
   if ($HostNetAdapter){

From 71f80e2ad2254aee905d64f77581f6341b14f267 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Tue, 15 Oct 2019 15:17:05 +0200
Subject: [PATCH 086/155] Update amazon-chroot.html.md.erb

unlink removed type
---
 website/source/docs/builders/amazon-chroot.html.md.erb | 1 -
 1 file changed, 1 deletion(-)

diff --git a/website/source/docs/builders/amazon-chroot.html.md.erb b/website/source/docs/builders/amazon-chroot.html.md.erb
index 3dcacbb3d..010c1806c 100644
--- a/website/source/docs/builders/amazon-chroot.html.md.erb
+++ b/website/source/docs/builders/amazon-chroot.html.md.erb
@@ -89,7 +89,6 @@ Block devices can be nested in the
 
 #### Optional:
 <%= partial "partials/builder/amazon/common/BlockDevice-not-required" %>
-<%= partial "partials/builder/amazon/chroot/BlockDevice-not-required" %>
 
 ### Acces Config Configuration
 

From 9dac7908a53896984a4329a54ab22762ccdcf4e6 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Tue, 15 Oct 2019 15:21:33 +0200
Subject: [PATCH 087/155] Update mapstructure-to-hcl2.go

better comments
---
 cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go b/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go
index 51017843b..bc6cf41b2 100644
--- a/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go
+++ b/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go
@@ -1,24 +1,24 @@
 // mapstructure-to-hcl2 fills the gaps between hcl2 and mapstructure for Packer
-
+//
 // By generating a struct that the HCL2 ecosystem understands making use of
 // mapstructure tags.
-
+//
 // Packer heavily uses the mapstructure decoding library to load/parse user
 // config files. Packer now needs to move to HCL2.
-
+//
 // Here are a few differences/gaps betweens hcl2 and mapstructure:
-
+//
 //  * in HCL2 all basic struct fields (string/int/struct) that are not pointers
 //   are required ( must be set ). In mapstructure everything is optional.
-
+//
 //  * mapstructure allows to 'squash' fields
 //  (ex: Field CommonStructType `mapstructure:",squash"`) this allows to
 //  decorate structs and reuse configuration code. HCL2 parsing libs don't have
 //  anything similar.
-
+//
 // mapstructure-to-hcl2 will parse Packer's config files and generate the HCL2
 // compliant code that will allow to not change any of the current builders in
-// order to move to HCL2 to softly move to HCL2.
+// order to softly move to HCL2.
 package main
 
 import (

From 6c486c4ab8f722328adb03bf009e94e42c52ab1b Mon Sep 17 00:00:00 2001
From: "Jonathan Walker (Keenan)" <xorith@gmail.com>
Date: Tue, 15 Oct 2019 15:42:43 -0400
Subject: [PATCH 088/155] Fix "Acces" typo in amazon-ebs.html.md.erb

Found and fixed a typo in the Amazon EBS documentation for "Access"
---
 website/source/docs/builders/amazon-ebs.html.md.erb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/website/source/docs/builders/amazon-ebs.html.md.erb b/website/source/docs/builders/amazon-ebs.html.md.erb
index e5cb1c4fa..bf079ee48 100644
--- a/website/source/docs/builders/amazon-ebs.html.md.erb
+++ b/website/source/docs/builders/amazon-ebs.html.md.erb
@@ -39,7 +39,7 @@ There are many configuration options available for the builder. In addition to
 the items listed here, you will want to look at the general configuration
 references for [AMI](#ami-configuration),
 [BlockDevices](#block-devices-configuration),
-[Access](#acces-configuration),
+[Access](#access-configuration),
 [Run](#run-configuration) and
 [Communicator](#communicator-configuration)
 configuration references, which are
@@ -59,7 +59,7 @@ necessary for this build to succeed and can be found further down the page.
 #### Optional:
 <%= partial "partials/builder/amazon/common/AMIConfig-not-required" %>
 
-### Acces Configuration
+### Access Configuration
 
 #### Required:
 

From 72fdce09ba80487d015a76d99a1ee783bf40b895 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 25 Sep 2019 21:12:33 +0000
Subject: [PATCH 089/155] Allow GetServicePrincipalToken to be called
 independently

---
 builder/azure/common/client/config.go | 50 +++++++++++++++------------
 1 file changed, 27 insertions(+), 23 deletions(-)

diff --git a/builder/azure/common/client/config.go b/builder/azure/common/client/config.go
index 9a4a736e8..230188eb5 100644
--- a/builder/azure/common/client/config.go
+++ b/builder/azure/common/client/config.go
@@ -198,60 +198,64 @@ func (c Config) UseMSI() bool {
 		c.TenantID == ""
 }
 
-func (c Config) GetServicePrincipalTokens(
-	say func(string)) (
+func (c Config) GetServicePrincipalTokens(say func(string)) (
 	servicePrincipalToken *adal.ServicePrincipalToken,
 	servicePrincipalTokenVault *adal.ServicePrincipalToken,
 	err error) {
 
-	tenantID := c.TenantID
+	servicePrincipalToken, err = c.GetServicePrincipalToken(say,
+		c.CloudEnvironment.ResourceManagerEndpoint)
+	if err != nil {
+		return nil, nil, err
+	}
+	servicePrincipalTokenVault, err = c.GetServicePrincipalToken(say,
+		strings.TrimRight(c.CloudEnvironment.KeyVaultEndpoint, "/"))
+	if err != nil {
+		return nil, nil, err
+	}
+	return servicePrincipalToken, servicePrincipalTokenVault, nil
+}
+
+func (c Config) GetServicePrincipalToken(
+	say func(string), forResource string) (
+	servicePrincipalToken *adal.ServicePrincipalToken,
+	err error) {
 
 	var auth oAuthTokenProvider
 	switch c.authType {
 	case authTypeDeviceLogin:
 		say("Getting tokens using device flow")
-		auth = NewDeviceFlowOAuthTokenProvider(*c.CloudEnvironment, say, tenantID)
+		auth = NewDeviceFlowOAuthTokenProvider(*c.CloudEnvironment, say, c.TenantID)
 	case authTypeMSI:
 		say("Getting tokens using Managed Identity for Azure")
 		auth = NewMSIOAuthTokenProvider(*c.CloudEnvironment)
 	case authTypeClientSecret:
 		say("Getting tokens using client secret")
-		auth = NewSecretOAuthTokenProvider(*c.CloudEnvironment, c.ClientID, c.ClientSecret, tenantID)
+		auth = NewSecretOAuthTokenProvider(*c.CloudEnvironment, c.ClientID, c.ClientSecret, c.TenantID)
 	case authTypeClientCert:
 		say("Getting tokens using client certificate")
-		auth, err = NewCertOAuthTokenProvider(*c.CloudEnvironment, c.ClientID, c.ClientCertPath, tenantID)
+		auth, err = NewCertOAuthTokenProvider(*c.CloudEnvironment, c.ClientID, c.ClientCertPath, c.TenantID)
 		if err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 	case authTypeClientBearerJWT:
 		say("Getting tokens using client bearer JWT")
-		auth = NewJWTOAuthTokenProvider(*c.CloudEnvironment, c.ClientID, c.ClientJWT, tenantID)
+		auth = NewJWTOAuthTokenProvider(*c.CloudEnvironment, c.ClientID, c.ClientJWT, c.TenantID)
 	default:
 		panic("authType not set, call FillParameters, or set explicitly")
 	}
 
-	servicePrincipalToken, err = auth.getServicePrincipalToken()
+	servicePrincipalToken, err = auth.getServicePrincipalTokenWithResource(forResource)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	err = servicePrincipalToken.EnsureFresh()
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
-	servicePrincipalTokenVault, err = auth.getServicePrincipalTokenWithResource(
-		strings.TrimRight(c.CloudEnvironment.KeyVaultEndpoint, "/"))
-	if err != nil {
-		return nil, nil, err
-	}
-
-	err = servicePrincipalTokenVault.EnsureFresh()
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return servicePrincipalToken, servicePrincipalTokenVault, nil
+	return servicePrincipalToken, nil
 }
 
 // FillParameters capture the user intent from the supplied parameter set in authType, retrieves the TenantID and CloudEnvironment if not specified.

From 2ded8f25ecf7c435ea12006d69303084f3adbe5c Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 25 Sep 2019 21:13:09 +0000
Subject: [PATCH 090/155] Add metadata client

---
 builder/azure/common/client/metadata.go      | 81 ++++++++++++++++++++
 builder/azure/common/client/metadata_test.go | 33 ++++++++
 2 files changed, 114 insertions(+)
 create mode 100644 builder/azure/common/client/metadata.go
 create mode 100644 builder/azure/common/client/metadata_test.go

diff --git a/builder/azure/common/client/metadata.go b/builder/azure/common/client/metadata.go
new file mode 100644
index 000000000..ad76cb007
--- /dev/null
+++ b/builder/azure/common/client/metadata.go
@@ -0,0 +1,81 @@
+package client
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/azure"
+)
+
+// DefaultMetadataClient is the default instance metadata client for Azure. Replace this variable for testing purposes only
+var DefaultMetadataClient = NewMetadataClient()
+
+// MetadataClient holds methods that Packer uses to get information about the current VM
+type MetadataClientAPI interface {
+	GetComputeInfo() (*ComputeInfo, error)
+}
+
+type ComputeInfo struct{
+	Name              string
+	ResourceGroupName string
+	SubscriptionID    string
+Location string
+}
+
+// metadataClient implements MetadataClient
+type metadataClient struct {
+	autorest.Sender
+}
+
+var _ MetadataClientAPI = metadataClient{}
+
+const imdsURL = "http://169.254.169.254/metadata/instance?api-version=2017-08-01"
+
+// VMResourceID returns the resource ID of the current VM
+func (client metadataClient) GetComputeInfo() (*ComputeInfo, error) {
+	req, err := autorest.CreatePreparer(
+		autorest.AsGet(),
+		autorest.WithHeader("Metadata", "true"),
+		autorest.WithBaseURL(imdsURL),
+	).Prepare((&http.Request{}))
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := autorest.SendWithSender(client, req,
+		autorest.DoRetryForDuration(1*time.Minute, 5*time.Second))
+	if err != nil {
+		return nil, err
+	}
+
+	var vminfo struct {
+		ComputeInfo `json:"compute"`
+	}
+
+	err = autorest.Respond(
+		res,
+		azure.WithErrorUnlessStatusCode(http.StatusOK),
+		autorest.ByUnmarshallingJSON(&vminfo),
+		autorest.ByClosing())
+	if err != nil {
+		return nil, err
+	}
+	return &vminfo.ComputeInfo, nil
+}
+
+func(ci ComputeInfo) ResourceID() string{
+	return fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/virtualMachines/%s",
+		ci.SubscriptionID,
+		ci.ResourceGroupName,
+		ci.Name,
+	)
+}
+
+// NewMetadataClient creates a new instance metadata client
+func NewMetadataClient() MetadataClientAPI {
+	return metadataClient{
+		Sender: autorest.CreateSender(),
+	}
+}
diff --git a/builder/azure/common/client/metadata_test.go b/builder/azure/common/client/metadata_test.go
new file mode 100644
index 000000000..dddc9a2a0
--- /dev/null
+++ b/builder/azure/common/client/metadata_test.go
@@ -0,0 +1,33 @@
+package client
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/Azure/go-autorest/autorest/azure"
+
+	"github.com/hashicorp/packer/builder/azure/common"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_MetadataReturnsComputeInfo(t *testing.T) {
+	if !common.IsAzure() {
+		t.Skipf("Not running on Azure, skipping live IMDS test")
+	}
+	mdc := NewMetadataClient()
+	info, err := mdc.GetComputeInfo()
+	assert.Nil(t, err)
+
+	vm, err := azure.ParseResourceID(fmt.Sprintf(
+		"/subscriptions/%s"+
+			"/resourceGroups/%s"+
+			"/providers/Microsoft.Compute"+
+			"/virtualMachines/%s",
+		info.SubscriptionID,
+		info.ResourceGroupName,
+		info.Name))
+	assert.Nil(t, err, "%q is not parsable as an Azure resource info", info)
+
+	assert.Regexp(t, "^[0-9a-fA-F-]{36}$", vm.SubscriptionID)
+	t.Logf("VM: %+v", vm)
+}

From f106adbd12cb7d45aa76194c3011a2874a4179b3 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 25 Sep 2019 21:13:23 +0000
Subject: [PATCH 091/155] Add Azure client set for chroot builder

---
 .../azure/common/client/azure_client_set.go   | 90 +++++++++++++++++++
 builder/azure/common/client/platform_image.go | 57 ++++++++++++
 .../common/client/platform_image_test.go      | 30 +++++++
 builder/azure/common/client/testclient.go     | 31 +++++++
 4 files changed, 208 insertions(+)
 create mode 100644 builder/azure/common/client/azure_client_set.go
 create mode 100644 builder/azure/common/client/platform_image.go
 create mode 100644 builder/azure/common/client/platform_image_test.go
 create mode 100644 builder/azure/common/client/testclient.go

diff --git a/builder/azure/common/client/azure_client_set.go b/builder/azure/common/client/azure_client_set.go
new file mode 100644
index 000000000..c0dfb12e8
--- /dev/null
+++ b/builder/azure/common/client/azure_client_set.go
@@ -0,0 +1,90 @@
+package client
+
+import (
+	"net/http"
+	"regexp"
+	"time"
+
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/computeapi"
+	"github.com/Azure/go-autorest/autorest"
+)
+
+type AzureClientSet interface {
+	MetadataClient() MetadataClientAPI
+
+	DisksClient() computeapi.DisksClientAPI
+	ImagesClient() computeapi.ImagesClientAPI
+	VirtualMachinesClient() computeapi.VirtualMachinesClientAPI
+	VirtualMachineImagesClient() VirtualMachineImagesClientAPI
+
+	PollClient() autorest.Client
+}
+
+var subscriptionPathRegex = regexp.MustCompile(`/subscriptions/([[:xdigit:]]{8}(-[[:xdigit:]]{4}){3}-[[:xdigit:]]{12})`)
+
+var _ AzureClientSet = &azureClientSet{}
+
+type azureClientSet struct {
+	sender         autorest.Sender
+	authorizer     autorest.Authorizer
+	subscriptionID string
+	PollingDelay   time.Duration
+}
+
+func New(c Config, say func(string)) (AzureClientSet, error) {
+	token, err := c.GetServicePrincipalToken(say, c.CloudEnvironment.ResourceManagerEndpoint)
+	if err != nil {
+		return nil, err
+	}
+	return &azureClientSet{
+		authorizer:     autorest.NewBearerAuthorizer(token),
+		subscriptionID: c.SubscriptionID,
+		sender:         http.DefaultClient,
+		PollingDelay:   time.Second,
+	}, nil
+}
+
+func (s azureClientSet) configureAutorestClient(c *autorest.Client) {
+	c.Authorizer = s.authorizer
+	c.Sender = s.sender
+}
+
+func (s azureClientSet) MetadataClient() MetadataClientAPI {
+	return metadataClient{s.sender}
+}
+
+func (s azureClientSet) DisksClient() computeapi.DisksClientAPI {
+	c := compute.NewDisksClient(s.subscriptionID)
+	s.configureAutorestClient(&c.Client)
+	c.PollingDelay = s.PollingDelay
+	return c
+}
+
+func (s azureClientSet) ImagesClient() computeapi.ImagesClientAPI {
+	c := compute.NewImagesClient(s.subscriptionID)
+	s.configureAutorestClient(&c.Client)
+	c.PollingDelay = s.PollingDelay
+	return c
+}
+
+func (s azureClientSet) VirtualMachinesClient() computeapi.VirtualMachinesClientAPI {
+	c := compute.NewVirtualMachinesClient(s.subscriptionID)
+	s.configureAutorestClient(&c.Client)
+	c.PollingDelay = s.PollingDelay
+	return c
+}
+
+func (s azureClientSet) VirtualMachineImagesClient() VirtualMachineImagesClientAPI {
+	c := compute.NewVirtualMachineImagesClient(s.subscriptionID)
+	s.configureAutorestClient(&c.Client)
+	c.PollingDelay = s.PollingDelay
+	return virtualMachineImagesClientAPI{c}
+}
+
+func (s azureClientSet) PollClient() autorest.Client {
+	c := autorest.NewClientWithUserAgent("Packer-Azure-ClientSet")
+	s.configureAutorestClient(&c)
+	c.PollingDelay = time.Second / 3
+	return c
+}
diff --git a/builder/azure/common/client/platform_image.go b/builder/azure/common/client/platform_image.go
new file mode 100644
index 000000000..ac11ec935
--- /dev/null
+++ b/builder/azure/common/client/platform_image.go
@@ -0,0 +1,57 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/computeapi"
+	"github.com/Azure/go-autorest/autorest/to"
+	"regexp"
+	"strings"
+)
+
+var platformImageRegex = regexp.MustCompile(`^[-_.a-zA-Z0-9]+:[-_.a-zA-Z0-9]+:[-_.a-zA-Z0-9]+:[-_.a-zA-Z0-9]+$`)
+
+type VirtualMachineImagesClientAPI interface {
+	computeapi.VirtualMachineImagesClientAPI
+	// extensions
+	GetLatest(ctx context.Context, publisher, offer, sku, location string) (*compute.VirtualMachineImageResource, error)
+}
+
+var _ VirtualMachineImagesClientAPI = virtualMachineImagesClientAPI{}
+
+type virtualMachineImagesClientAPI struct {
+	computeapi.VirtualMachineImagesClientAPI
+}
+
+func ParsePlatformImageURN(urn string) (image *PlatformImage, err error) {
+	if !platformImageRegex.Match([]byte(urn)) {
+		return nil, fmt.Errorf("%q is not a valid platform image specifier", urn)
+	}
+	parts := strings.Split(urn, ":")
+	return &PlatformImage{parts[0], parts[1], parts[2], parts[3]}, nil
+}
+
+func (c virtualMachineImagesClientAPI) GetLatest(ctx context.Context, publisher, offer, sku, location string) (*compute.VirtualMachineImageResource, error) {
+	result, err := c.List(ctx, location, publisher, offer, sku, "", to.Int32Ptr(1), "name desc")
+	if err != nil {
+		return nil, err
+	}
+	if result.Value == nil || len(*result.Value) == 0 {
+		return nil, fmt.Errorf("%s:%s:%s:latest could not be found in location %s", publisher, offer, sku, location)
+	}
+
+	return &(*result.Value)[0], nil
+}
+
+type PlatformImage struct {
+	Publisher, Offer, Sku, Version string
+}
+
+func (pi PlatformImage) URN() string {
+	return fmt.Sprintf("%s:%s:%s:%s",
+		pi.Publisher,
+		pi.Offer,
+		pi.Sku,
+		pi.Version)
+}
diff --git a/builder/azure/common/client/platform_image_test.go b/builder/azure/common/client/platform_image_test.go
new file mode 100644
index 000000000..981031d45
--- /dev/null
+++ b/builder/azure/common/client/platform_image_test.go
@@ -0,0 +1,30 @@
+package client
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_platformImageRegex(t *testing.T) {
+	for i, v := range []string{
+		"Publisher:Offer:Sku:Versions",
+		"Publisher:Offer-name:2.0_alpha:2.0.2019060122",
+	} {
+		t.Run(fmt.Sprintf("should_match_%d", i), func(t *testing.T) {
+			if !platformImageRegex.Match([]byte(v)) {
+				t.Fatalf("expected %q to match", v)
+			}
+		})
+	}
+
+	for i, v := range []string{
+		"Publ isher:Offer:Sku:Versions",
+		"Publ/isher:Offer-name:2.0_alpha:2.0.2019060122",
+	} {
+		t.Run(fmt.Sprintf("should_not_match_%d", i), func(t *testing.T) {
+			if platformImageRegex.Match([]byte(v)) {
+				t.Fatalf("did not expected %q to match", v)
+			}
+		})
+	}
+}
diff --git a/builder/azure/common/client/testclient.go b/builder/azure/common/client/testclient.go
new file mode 100644
index 000000000..964e04795
--- /dev/null
+++ b/builder/azure/common/client/testclient.go
@@ -0,0 +1,31 @@
+package client
+
+import (
+	"os"
+	"testing"
+	"net/http"
+	"errors"
+
+	"github.com/Azure/go-autorest/autorest/azure/auth"
+)
+
+func GetTestClientSet(t *testing.T) (AzureClientSet, error) {
+	if (os.Getenv("AZURE_INTEGRATION_TEST") == "") {
+		t.Skip("AZURE_INTEGRATION_TEST not set")		
+	} else {
+		a, err := auth.NewAuthorizerFromEnvironment()
+		if err == nil {
+			cli := azureClientSet{}
+		cli.authorizer = a
+			cli.subscriptionID = os.Getenv("AZURE_SUBSCRIPTION_ID")
+			cli.PollingDelay = 0
+			cli.sender = http.DefaultClient
+			return cli, nil
+					} else {
+			t.Skipf("Could not create Azure client: %v", err)
+		}
+	}
+
+	return nil, errors.New("Couldn't create client set")
+}
+

From 113dc1234617d748152fe039c24511de3cf3e2fc Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 25 Sep 2019 21:15:25 +0000
Subject: [PATCH 092/155] Add function to detect whether Packer is running on
 Azure

---
 builder/azure/common/detect_azure.go          |  8 +++++
 builder/azure/common/detect_azure_linux.go    | 23 +++++++++++++++
 .../azure/common/detect_azure_linux_test.go   | 29 +++++++++++++++++++
 3 files changed, 60 insertions(+)
 create mode 100644 builder/azure/common/detect_azure.go
 create mode 100644 builder/azure/common/detect_azure_linux.go
 create mode 100644 builder/azure/common/detect_azure_linux_test.go

diff --git a/builder/azure/common/detect_azure.go b/builder/azure/common/detect_azure.go
new file mode 100644
index 000000000..001ca1b4f
--- /dev/null
+++ b/builder/azure/common/detect_azure.go
@@ -0,0 +1,8 @@
+// +build !linux
+
+package common
+
+// IsAzure returns true if Packer is running on Azure (currently only works on Linux)
+func IsAzure() bool {
+	return false
+}
diff --git a/builder/azure/common/detect_azure_linux.go b/builder/azure/common/detect_azure_linux.go
new file mode 100644
index 000000000..f57eb42b9
--- /dev/null
+++ b/builder/azure/common/detect_azure_linux.go
@@ -0,0 +1,23 @@
+package common
+
+import (
+	"bytes"
+	"io/ioutil"
+)
+
+var (
+	smbiosAssetTagFile = "/sys/class/dmi/id/chassis_asset_tag"
+	azureAssetTag      = []byte("7783-7084-3265-9085-8269-3286-77\n")
+)
+
+// IsAzure returns true if Packer is running on Azure
+func IsAzure() bool {
+	return isAzureAssetTag(smbiosAssetTagFile)
+}
+
+func isAzureAssetTag(filename string) bool {
+	if d, err := ioutil.ReadFile(filename); err == nil {
+		return bytes.Compare(d, azureAssetTag) == 0
+	}
+	return false
+}
diff --git a/builder/azure/common/detect_azure_linux_test.go b/builder/azure/common/detect_azure_linux_test.go
new file mode 100644
index 000000000..9d755cfd9
--- /dev/null
+++ b/builder/azure/common/detect_azure_linux_test.go
@@ -0,0 +1,29 @@
+package common
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsAzure(t *testing.T) {
+	f, err := ioutil.TempFile("", "TestIsAzure*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(f.Name())
+
+	f.Seek(0, 0)
+	f.Truncate(0)
+	f.Write([]byte("not the azure assettag"))
+
+	assert.False(t, isAzureAssetTag(f.Name()), "asset tag is not Azure's")
+
+	f.Seek(0, 0)
+	f.Truncate(0)
+	f.Write(azureAssetTag)
+
+	assert.True(t, isAzureAssetTag(f.Name()), "asset tag is Azure's")
+}

From 3c33aa4fc52c80ace98b3979d60f220e366dcfc2 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 19 Apr 2019 22:39:24 +0000
Subject: [PATCH 093/155] Add metadata client

---
 builder/azure/chroot/metadata.go      | 71 +++++++++++++++++++++++++++
 builder/azure/chroot/metadata_test.go | 24 +++++++++
 2 files changed, 95 insertions(+)
 create mode 100644 builder/azure/chroot/metadata.go
 create mode 100644 builder/azure/chroot/metadata_test.go

diff --git a/builder/azure/chroot/metadata.go b/builder/azure/chroot/metadata.go
new file mode 100644
index 000000000..6dea16017
--- /dev/null
+++ b/builder/azure/chroot/metadata.go
@@ -0,0 +1,71 @@
+package chroot
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/hashicorp/go-retryablehttp"
+)
+
+// DefaultMetadataClient is the default instance metadata client for Azure. Replace this variable for testing purposes only
+var DefaultMetadataClient = NewMetadataClient()
+
+// MetadataClient holds methods that Packer uses to get information about the current VM
+type MetadataClient interface {
+	VMResourceID() (string, error)
+}
+
+// metadataClient implements MetadataClient
+type metadataClient struct{}
+
+const imdsURL = "http://169.254.169.254/metadata/instance?api-version=2017-08-01"
+
+// VMResourceID returns the resource ID of the current VM
+func (metadataClient) VMResourceID() (string, error) {
+	wc := retryablehttp.NewClient()
+	wc.RetryMax = 5
+
+	req, err := retryablehttp.NewRequest(http.MethodGet, imdsURL, nil)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Add("Metadata", "true")
+
+	res, err := wc.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer res.Body.Close()
+
+	d, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", err
+	}
+
+	var vminfo struct {
+		Compute struct {
+			Name              string
+			ResourceGroupName string
+			SubscriptionID    string
+		}
+	}
+
+	err = json.Unmarshal(d, &vminfo)
+	if err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/virtualMachines/%s",
+		vminfo.Compute.Name,
+		vminfo.Compute.ResourceGroupName,
+		vminfo.Compute.SubscriptionID,
+	), nil
+
+}
+
+// NewMetadataClient creates a new instance metadata client
+func NewMetadataClient() MetadataClient {
+	return metadataClient{}
+}
diff --git a/builder/azure/chroot/metadata_test.go b/builder/azure/chroot/metadata_test.go
new file mode 100644
index 000000000..a707ea3ae
--- /dev/null
+++ b/builder/azure/chroot/metadata_test.go
@@ -0,0 +1,24 @@
+package chroot
+
+import (
+	"testing"
+
+	"github.com/Azure/go-autorest/autorest/azure"
+
+	"github.com/hashicorp/packer/builder/azure/common"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_MetadataReturnsVMResourceID(t *testing.T) {
+	if !common.IsAzure() {
+		t.Skipf("Not running on Azure, skipping live IMDS test")
+	}
+	mdc := NewMetadataClient()
+	id, err := mdc.VMResourceID()
+	assert.Nil(t, err)
+	assert.NotEqual(t, id, "", "Expected VMResourceID to return non-empty string because we are running on Azure")
+
+	vm, err := azure.ParseResourceID(id)
+	assert.Nil(t, err, "%q is not parsable as an Azure resource id", id)
+	t.Logf("VM: %+v", vm)
+}

From 369ec9a84cac22f980531b2cd7b08f65c805a7c0 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Thu, 25 Apr 2019 23:12:18 +0000
Subject: [PATCH 094/155] Create disk attacher component

---
 builder/azure/chroot/diskattacher.go      | 182 ++++++++++++++++++++++
 builder/azure/chroot/diskattacher_test.go |  86 ++++++++++
 builder/azure/chroot/metadata.go          |  71 ---------
 builder/azure/chroot/metadata_test.go     |  24 ---
 4 files changed, 268 insertions(+), 95 deletions(-)
 create mode 100644 builder/azure/chroot/diskattacher.go
 create mode 100644 builder/azure/chroot/diskattacher_test.go
 delete mode 100644 builder/azure/chroot/metadata.go
 delete mode 100644 builder/azure/chroot/metadata_test.go

diff --git a/builder/azure/chroot/diskattacher.go b/builder/azure/chroot/diskattacher.go
new file mode 100644
index 000000000..2f21ebf45
--- /dev/null
+++ b/builder/azure/chroot/diskattacher.go
@@ -0,0 +1,182 @@
+package chroot
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/packer/builder/azure/common/client"
+
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/to"
+)
+
+type VirtualMachinesClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, VMName string, parameters compute.VirtualMachine) (
+		result compute.VirtualMachinesCreateOrUpdateFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, VMName string, expand compute.InstanceViewTypes) (
+		result compute.VirtualMachine, err error)
+}
+
+type DiskAttacher interface {
+	AttachDisk(ctx context.Context, disk string) (lun int32, err error)
+	DetachDisk(ctx context.Context, disk string) (err error)
+	WaitForDevice(ctx context.Context, i int32) (device string, err error)
+}
+
+func NewDiskAttacher(azureClient client.AzureClientSet) DiskAttacher {
+	return diskAttacher{azureClient}
+}
+
+type diskAttacher struct {
+	azcli client.AzureClientSet
+}
+
+func (da diskAttacher) WaitForDevice(ctx context.Context, i int32) (device string, err error) {
+	path := fmt.Sprintf("/dev/disk/azure/scsi1/lun%d", i)
+
+	for {
+		l, err := os.Readlink(path)
+		if err == nil {
+			return filepath.Abs("/dev/disk/azure/scsi1/" + l)
+		}
+		if err != nil && err != os.ErrNotExist {
+			return "", err
+		}
+		select {
+		case <-time.After(100 * time.Millisecond):
+			// continue
+		case <-ctx.Done():
+			return "", ctx.Err()
+		}
+	}
+}
+
+func (da diskAttacher) DetachDisk(ctx context.Context, diskID string) error {
+	currentDisks, err := da.getDisks(ctx)
+	if err != nil {
+		return err
+	}
+
+	// copy all disks to new array that not match diskID
+	newDisks := []compute.DataDisk{}
+	for _, disk := range currentDisks {
+		if disk.ManagedDisk != nil &&
+			!strings.EqualFold(to.String(disk.ManagedDisk.ID), diskID) {
+			newDisks = append(newDisks, disk)
+		}
+	}
+	if len(currentDisks) == len(newDisks) {
+		return DiskNotFoundError
+	}
+
+	return da.setDisks(ctx, newDisks)
+}
+
+var DiskNotFoundError = errors.New("Disk not found")
+
+func (da diskAttacher) AttachDisk(ctx context.Context, diskID string) (int32, error) {
+	dataDisks, err := da.getDisks(ctx)
+	if err != nil {
+		return -1, err
+	}
+
+	// check to see if disk is already attached, remember lun if found
+	var lun int32 = -1
+	for _, disk := range dataDisks {
+		if disk.ManagedDisk != nil &&
+			strings.EqualFold(to.String(disk.ManagedDisk.ID), diskID) {
+			// disk is already attached, just take this lun
+			if disk.Lun != nil {
+				lun = to.Int32(disk.Lun)
+				break
+			}
+		}
+	}
+
+	if lun == -1 {
+		// disk was not found on VM, go and actually attach it
+
+	findFreeLun:
+		for lun = 0; lun < 64; lun++ {
+			for _, v := range dataDisks {
+				if to.Int32(v.Lun) == lun {
+					continue findFreeLun
+				}
+			}
+			// no datadisk is using this lun
+			break
+		}
+
+		// append new data disk to collection
+		dataDisks = append(dataDisks, compute.DataDisk{
+			CreateOption: compute.DiskCreateOptionTypesAttach,
+			ManagedDisk: &compute.ManagedDiskParameters{
+				ID: to.StringPtr(diskID),
+			},
+			Lun: to.Int32Ptr(lun),
+		})
+
+		// prepare resource object for update operation
+		err = da.setDisks(ctx, dataDisks)
+		if err != nil {
+			return -1, err
+		}
+	}
+	return lun, nil
+}
+
+func (da diskAttacher) getThisVM(ctx context.Context) (compute.VirtualMachine, error) {
+	// getting resource info for this VM
+	vm, err := da.azcli.MetadataClient().GetComputeInfo()
+	if err != nil {
+		return compute.VirtualMachine{}, err
+	}
+
+	// retrieve actual VM
+	vmResource, err := da.azcli.VirtualMachinesClient().Get(ctx, vm.ResourceGroupName, vm.Name, "")
+	if err != nil {
+		return compute.VirtualMachine{}, err
+	}
+	if vmResource.StorageProfile == nil {
+		return compute.VirtualMachine{}, errors.New("properties.storageProfile is not set on VM, this is unexpected")
+	}
+
+	return vmResource, nil
+}
+
+func (da diskAttacher) getDisks(ctx context.Context) ([]compute.DataDisk, error) {
+	vmResource, err := da.getThisVM(ctx)
+	if err != nil {
+		return []compute.DataDisk{}, err
+	}
+
+	return *vmResource.StorageProfile.DataDisks, nil
+}
+
+func (da diskAttacher) setDisks(ctx context.Context, disks []compute.DataDisk) error {
+	vmResource, err := da.getThisVM(ctx)
+	if err != nil {
+		return err
+	}
+
+	id, err := azure.ParseResourceID(to.String(vmResource.ID))
+	if err != nil {
+		return err
+	}
+
+	vmResource.StorageProfile.DataDisks = &disks
+	vmResource.Resources = nil
+
+	// update the VM resource, attaching disk
+	f, err := da.azcli.VirtualMachinesClient().CreateOrUpdate(ctx, id.ResourceGroup, id.ResourceName, vmResource)
+	if err == nil {
+		err = f.WaitForCompletionRef(ctx, da.azcli.PollClient())
+	}
+	return err
+}
diff --git a/builder/azure/chroot/diskattacher_test.go b/builder/azure/chroot/diskattacher_test.go
new file mode 100644
index 000000000..fbdc359ed
--- /dev/null
+++ b/builder/azure/chroot/diskattacher_test.go
@@ -0,0 +1,86 @@
+package chroot
+
+import (
+	"context"
+	"github.com/Azure/go-autorest/autorest/to"
+	"testing"
+
+	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute"
+	"github.com/hashicorp/packer/builder/azure/chroot/client"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	testvm   = "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/testGroup/Microsoft.Compute/virtualMachines/testVM"
+	testdisk = "/subscriptions/00000000-0000-0000-0000-000000000001/resourceGroups/testGroup2/Microsoft.Compute/disks/testDisk"
+)
+
+// Tests assume current machine is capable of running chroot builder (i.e. an Azure VM)
+
+func Test_DiskAttacherAttachesDiskToVM(t *testing.T) {
+	azcli, err := client.GetTestClientSet(t)
+	require.Nil(t, err)
+	da := NewDiskAttacher(azcli)
+	testDiskName := t.Name()
+
+	vm, err := azcli.MetadataClient().GetComputeInfo()
+	require.Nil(t, err, "Test needs to run on an Azure VM, unable to retrieve VM information")
+	t.Log("Creating new disk '", testDiskName, "' in ", vm.ResourceGroupName)
+
+	disk, err := azcli.DisksClient().Get(context.TODO(), vm.ResourceGroupName, testDiskName)
+	if err == nil {
+		t.Log("Disk already exists")
+		if disk.DiskState == compute.Attached {
+			t.Log("Disk is attached, assuming to this machine, trying to detach")
+			err = da.DetachDisk(context.TODO(), to.String(disk.ID))
+			require.Nil(t, err)
+		}
+		t.Log("Deleting disk")
+		result, err := azcli.DisksClient().Delete(context.TODO(), vm.ResourceGroupName, testDiskName)
+		require.Nil(t, err)
+		err = result.WaitForCompletionRef(context.TODO(), azcli.PollClient())
+		require.Nil(t, err)
+	}
+
+	t.Log("Creating disk")
+	r, err := azcli.DisksClient().CreateOrUpdate(context.TODO(), vm.ResourceGroupName, testDiskName, compute.Disk{
+		Location: to.StringPtr(vm.Location),
+		Sku: &compute.DiskSku{
+			Name: compute.StandardLRS,
+		},
+		DiskProperties: &compute.DiskProperties{
+			DiskSizeGB:   to.Int32Ptr(30),
+			CreationData: &compute.CreationData{CreateOption: compute.Empty},
+		},
+	})
+	require.Nil(t, err)
+	err = r.WaitForCompletionRef(context.TODO(), azcli.PollClient())
+	require.Nil(t, err)
+
+	t.Log("Retrieving disk properties")
+	d, err := azcli.DisksClient().Get(context.TODO(), vm.ResourceGroupName, testDiskName)
+	require.Nil(t, err)
+	assert.NotNil(t, d)
+
+	t.Log("Attaching disk")
+	lun, err := da.AttachDisk(context.TODO(), to.String(d.ID))
+	assert.Nil(t, err)
+
+	t.Log("Waiting for device")
+	dev, err := da.WaitForDevice(context.TODO(), lun)
+	assert.Nil(t, err)
+
+	t.Log("Device path:", dev)
+
+	t.Log("Detaching disk")
+	err = da.DetachDisk(context.TODO(), to.String(d.ID))
+	require.Nil(t, err)
+
+	t.Log("Deleting disk")
+	result, err := azcli.DisksClient().Delete(context.TODO(), vm.ResourceGroupName, testDiskName)
+	if err == nil {
+		err = result.WaitForCompletionRef(context.TODO(), azcli.PollClient())
+	}
+	require.Nil(t, err)
+}
diff --git a/builder/azure/chroot/metadata.go b/builder/azure/chroot/metadata.go
deleted file mode 100644
index 6dea16017..000000000
--- a/builder/azure/chroot/metadata.go
+++ /dev/null
@@ -1,71 +0,0 @@
-package chroot
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/hashicorp/go-retryablehttp"
-)
-
-// DefaultMetadataClient is the default instance metadata client for Azure. Replace this variable for testing purposes only
-var DefaultMetadataClient = NewMetadataClient()
-
-// MetadataClient holds methods that Packer uses to get information about the current VM
-type MetadataClient interface {
-	VMResourceID() (string, error)
-}
-
-// metadataClient implements MetadataClient
-type metadataClient struct{}
-
-const imdsURL = "http://169.254.169.254/metadata/instance?api-version=2017-08-01"
-
-// VMResourceID returns the resource ID of the current VM
-func (metadataClient) VMResourceID() (string, error) {
-	wc := retryablehttp.NewClient()
-	wc.RetryMax = 5
-
-	req, err := retryablehttp.NewRequest(http.MethodGet, imdsURL, nil)
-	if err != nil {
-		return "", err
-	}
-	req.Header.Add("Metadata", "true")
-
-	res, err := wc.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer res.Body.Close()
-
-	d, err := ioutil.ReadAll(res.Body)
-	if err != nil {
-		return "", err
-	}
-
-	var vminfo struct {
-		Compute struct {
-			Name              string
-			ResourceGroupName string
-			SubscriptionID    string
-		}
-	}
-
-	err = json.Unmarshal(d, &vminfo)
-	if err != nil {
-		return "", err
-	}
-
-	return fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/virtualMachines/%s",
-		vminfo.Compute.Name,
-		vminfo.Compute.ResourceGroupName,
-		vminfo.Compute.SubscriptionID,
-	), nil
-
-}
-
-// NewMetadataClient creates a new instance metadata client
-func NewMetadataClient() MetadataClient {
-	return metadataClient{}
-}
diff --git a/builder/azure/chroot/metadata_test.go b/builder/azure/chroot/metadata_test.go
deleted file mode 100644
index a707ea3ae..000000000
--- a/builder/azure/chroot/metadata_test.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package chroot
-
-import (
-	"testing"
-
-	"github.com/Azure/go-autorest/autorest/azure"
-
-	"github.com/hashicorp/packer/builder/azure/common"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_MetadataReturnsVMResourceID(t *testing.T) {
-	if !common.IsAzure() {
-		t.Skipf("Not running on Azure, skipping live IMDS test")
-	}
-	mdc := NewMetadataClient()
-	id, err := mdc.VMResourceID()
-	assert.Nil(t, err)
-	assert.NotEqual(t, id, "", "Expected VMResourceID to return non-empty string because we are running on Azure")
-
-	vm, err := azure.ParseResourceID(id)
-	assert.Nil(t, err, "%q is not parsable as an Azure resource id", id)
-	t.Logf("VM: %+v", vm)
-}

From 3d329cf87d7b87842ebcca00a72513823ce36921 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 17 May 2019 00:24:53 +0000
Subject: [PATCH 095/155] Add chroot builder framework

---
 builder/azure/chroot/builder.go | 75 +++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 builder/azure/chroot/builder.go

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
new file mode 100644
index 000000000..073c13aac
--- /dev/null
+++ b/builder/azure/chroot/builder.go
@@ -0,0 +1,75 @@
+package chroot
+
+import (
+	"context"
+	"errors"
+	"runtime"
+
+	azcommon "github.com/hashicorp/packer/builder/azure/common"
+	"github.com/hashicorp/packer/common"
+	"github.com/hashicorp/packer/helper/config"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+	"github.com/hashicorp/packer/template/interpolate"
+)
+
+type Config struct {
+	common.PackerConfig `mapstructure:",squash"`
+
+	ctx interpolate.Context
+}
+
+type Builder struct {
+	config Config
+	runner multistep.Runner
+}
+
+func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+	b.config.ctx.Funcs = azcommon.TemplateFuncs
+	err := config.Decode(&b.config, &config.DecodeOpts{
+		Interpolate:        true,
+		InterpolateContext: &b.config.ctx,
+		InterpolateFilter: &interpolate.RenderFilter{
+			Exclude: []string{
+				// fields to exclude from interpolation
+			},
+		},
+	}, raws...)
+
+	// checks, accumulate any errors or warnings
+	var errs *packer.MultiError
+	var warns []string
+
+	if err != nil {
+		return nil, err
+	}
+	return warns, errs
+}
+
+func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
+	if runtime.GOOS != "linux" {
+		return nil, errors.New("The azure-chroot builder only works on Linux environments.")
+	}
+
+	// Setup the state bag and initial state for the steps
+	state := new(multistep.BasicStateBag)
+	state.Put("config", &b.config)
+	state.Put("hook", hook)
+	state.Put("ui", ui)
+
+	// Build the steps
+	var steps []multistep.Step
+
+	// Run!
+	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
+	b.runner.Run(ctx, state)
+
+	// If there was an error, return that
+	if rawErr, ok := state.GetOk("error"); ok {
+		return nil, rawErr.(error)
+	}
+
+	return nil, nil
+}
+
+var _ packer.Builder = &Builder{}

From 45d3f28c67c5aeff32316e1652beeaa3ab548238 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Mon, 27 May 2019 06:20:11 +0000
Subject: [PATCH 096/155] Add StepCreateNewDisk

---
 builder/azure/chroot/builder.go              | 55 ++++++++++++
 builder/azure/chroot/step_create_new_disk.go | 88 ++++++++++++++++++++
 2 files changed, 143 insertions(+)
 create mode 100644 builder/azure/chroot/step_create_new_disk.go

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index 073c13aac..add0a04c6 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -3,9 +3,13 @@ package chroot
 import (
 	"context"
 	"errors"
+	"fmt"
+	"log"
 	"runtime"
 
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
 	azcommon "github.com/hashicorp/packer/builder/azure/common"
+	"github.com/hashicorp/packer/builder/azure/common/client"
 	"github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/config"
 	"github.com/hashicorp/packer/helper/multistep"
@@ -16,6 +20,11 @@ import (
 type Config struct {
 	common.PackerConfig `mapstructure:",squash"`
 
+	FromScratch bool `mapstructure:"from_scratch"`
+
+	OSDiskSizeGB             int32  `mapstructure:"osdisk_size_gb"`
+	OSDiskStorageAccountType string `mapstructure:"osdisk_storageaccounttype"`
+
 	ctx interpolate.Context
 }
 
@@ -36,10 +45,22 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		},
 	}, raws...)
 
+	// defaults
+	if b.config.OSDiskStorageAccountType == "" {
+		b.config.OSDiskStorageAccountType = string(compute.PremiumLRS)
+	}
+
 	// checks, accumulate any errors or warnings
 	var errs *packer.MultiError
 	var warns []string
 
+	if b.config.FromScratch {
+		if b.config.OSDiskSizeGB == 0 {
+			errs = packer.MultiErrorAppend(
+				errs, errors.New("osdisk_size_gb is required with from_scratch."))
+		}
+	}
+
 	if err != nil {
 		return nil, err
 	}
@@ -51,15 +72,49 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		return nil, errors.New("The azure-chroot builder only works on Linux environments.")
 	}
 
+	var azcli client.AzureClientSet
+
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
 
+	info, err := azcli.MetadataClient().GetComputeInfo()
+	if err != nil {
+		log.Printf("MetadataClient().GetComputeInfo(): error: %+v", err)
+		err := fmt.Errorf(
+			"Error retrieving information ARM resource ID and location" +
+				"of the VM that Packer is running on.\n" +
+				"Please verify that Packer is running on a proper Azure VM.")
+		ui.Error(err.Error())
+		return nil, err
+	}
+
+	osDiskName := "PackerBuiltOsDisk"
+
+	state.Put("instance", info)
+	if err != nil {
+		return nil, err
+	}
+
 	// Build the steps
 	var steps []multistep.Step
 
+	if !b.config.FromScratch {
+		panic("Only from_scratch is currently implemented")
+		// create disk from PIR / managed image (warn on non-linux images)
+	} else {
+		steps = append(steps,
+			&StepCreateNewDisk{
+				SubscriptionID:         info.SubscriptionID,
+				ResourceGroup:          info.ResourceGroupName,
+				DiskName:               osDiskName,
+				DiskSizeGB:             b.config.OSDiskSizeGB,
+				DiskStorageAccountType: b.config.OSDiskStorageAccountType,
+			})
+	}
+
 	// Run!
 	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
 	b.runner.Run(ctx, state)
diff --git a/builder/azure/chroot/step_create_new_disk.go b/builder/azure/chroot/step_create_new_disk.go
new file mode 100644
index 000000000..098adb25f
--- /dev/null
+++ b/builder/azure/chroot/step_create_new_disk.go
@@ -0,0 +1,88 @@
+package chroot
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute"
+	"github.com/Azure/go-autorest/autorest/to"
+	"github.com/hashicorp/packer/builder/azure/common/client"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+)
+
+var _ multistep.Step = &StepCreateNewDisk{}
+
+type StepCreateNewDisk struct {
+	SubscriptionID, ResourceGroup, DiskName string
+	DiskSizeGB                              int32  // optional, ignored if 0
+	DiskStorageAccountType                  string // from compute.DiskStorageAccountTypes
+}
+
+func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	azcli := state.Get("azureclient").(client.AzureClientSet)
+	ui := state.Get("ui").(packer.Ui)
+
+	diskResourceID := fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/disks/%s",
+		s.SubscriptionID,
+		s.ResourceGroup,
+		s.DiskName)
+	state.Put("os_disk_resource_id", diskResourceID)
+	ui.Say(fmt.Sprintf("Creating disk '%s'", diskResourceID))
+
+	disk := compute.Disk{
+		Sku: &compute.DiskSku{
+			Name: "",
+		},
+		//Zones: nil,
+		DiskProperties: &compute.DiskProperties{
+			OsType:           "",
+			HyperVGeneration: "",
+			CreationData: &compute.CreationData{
+				CreateOption: compute.Empty,
+			},
+			DiskSizeGB: to.Int32Ptr(s.DiskSizeGB),
+		},
+		//Tags: map[string]*string{
+	}
+
+	if s.DiskSizeGB > 0 {
+		disk.DiskProperties.DiskSizeGB = to.Int32Ptr(s.DiskSizeGB)
+	}
+
+	f, err := azcli.DisksClient().CreateOrUpdate(ctx, s.ResourceGroup, s.DiskName, disk)
+	if err == nil {
+		err = f.WaitForCompletionRef(ctx, azcli.PollClient())
+	}
+	if err != nil {
+		log.Printf("StepCreateNewDisk.Run: error: %+v", err)
+		err := fmt.Errorf(
+			"error creating new disk '%s': %v", diskResourceID, err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s StepCreateNewDisk) Cleanup(state multistep.StateBag) {
+	azcli := state.Get("azureclient").(client.AzureClientSet)
+	ui := state.Get("ui").(packer.Ui)
+
+	diskResourceID := fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/disks/%s",
+		s.SubscriptionID,
+		s.ResourceGroup,
+		s.DiskName)
+	ui.Say(fmt.Sprintf("Deleting disk '%s'", diskResourceID))
+
+	f, err := azcli.DisksClient().Delete(context.TODO(), s.ResourceGroup, s.DiskName)
+	if err == nil {
+		err = f.WaitForCompletionRef(context.TODO(), azcli.PollClient())
+	}
+	if err != nil {
+		log.Printf("StepCreateNewDisk.Cleanup: error: %+v", err)
+		ui.Error(fmt.Sprintf("Error deleting new disk '%s': %v.", diskResourceID, err))
+	}
+}

From 4d750ddefa7c79365c53dfa4943866df352c6614 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 29 May 2019 00:40:44 +0000
Subject: [PATCH 097/155] Reuse amazon/chroot/step_pre_mount_commands.go

---
 builder/amazon/chroot/builder.go              |  8 +++++++
 .../amazon/chroot/step_pre_mount_commands.go  |  4 ++--
 builder/azure/chroot/builder.go               | 22 +++++++++++++++++++
 3 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/builder/amazon/chroot/builder.go b/builder/amazon/chroot/builder.go
index f51ae9255..21eeefc13 100644
--- a/builder/amazon/chroot/builder.go
+++ b/builder/amazon/chroot/builder.go
@@ -168,6 +168,14 @@ type Config struct {
 	ctx interpolate.Context
 }
 
+func (c *Config) GetContext() interpolate.Context {
+	return c.ctx
+}
+
+type interpolateContextProvider interface {
+	GetContext() interpolate.Context
+}
+
 type wrappedCommandTemplate struct {
 	Command string
 }
diff --git a/builder/amazon/chroot/step_pre_mount_commands.go b/builder/amazon/chroot/step_pre_mount_commands.go
index 9a60256fe..635ee84d0 100644
--- a/builder/amazon/chroot/step_pre_mount_commands.go
+++ b/builder/amazon/chroot/step_pre_mount_commands.go
@@ -17,7 +17,7 @@ type StepPreMountCommands struct {
 }
 
 func (s *StepPreMountCommands) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(interpolateContextProvider)
 	device := state.Get("device").(string)
 	ui := state.Get("ui").(packer.Ui)
 	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
@@ -26,7 +26,7 @@ func (s *StepPreMountCommands) Run(ctx context.Context, state multistep.StateBag
 		return multistep.ActionContinue
 	}
 
-	ictx := config.ctx
+	ictx := config.GetContext()
 	ictx.Data = &preMountCommandsData{Device: device}
 
 	ui.Say("Running device setup commands...")
diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index add0a04c6..a91fb3035 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -8,6 +8,7 @@ import (
 	"runtime"
 
 	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
+	amznchroot "github.com/hashicorp/packer/builder/amazon/chroot"
 	azcommon "github.com/hashicorp/packer/builder/azure/common"
 	"github.com/hashicorp/packer/builder/azure/common/client"
 	"github.com/hashicorp/packer/common"
@@ -22,6 +23,9 @@ type Config struct {
 
 	FromScratch bool `mapstructure:"from_scratch"`
 
+	CommandWrapper   string   `mapstructure:"command_wrapper"`
+	PreMountCommands []string `mapstructure:"pre_mount_commands"`
+
 	OSDiskSizeGB             int32  `mapstructure:"osdisk_size_gb"`
 	OSDiskStorageAccountType string `mapstructure:"osdisk_storageaccounttype"`
 
@@ -59,6 +63,10 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			errs = packer.MultiErrorAppend(
 				errs, errors.New("osdisk_size_gb is required with from_scratch."))
 		}
+		if len(b.config.PreMountCommands) == 0 {
+			errs = packer.MultiErrorAppend(
+				errs, errors.New("pre_mount_commands is required with from_scratch."))
+		}
 	}
 
 	if err != nil {
@@ -74,11 +82,18 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 
 	var azcli client.AzureClientSet
 
+	wrappedCommand := func(command string) (string, error) {
+		ictx := b.config.ctx
+		ictx.Data = &struct{ Command string }{Command: command}
+		return interpolate.Render(b.config.CommandWrapper, &ictx)
+	}
+
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
+	state.Put("wrappedCommand", amznchroot.CommandWrapper(wrappedCommand))
 
 	info, err := azcli.MetadataClient().GetComputeInfo()
 	if err != nil {
@@ -115,6 +130,13 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			})
 	}
 
+	steps = append(steps,
+		//&StepAttachDisk{},
+		&amznchroot.StepPreMountCommands{
+			Commands: b.config.PreMountCommands,
+		},
+	)
+
 	// Run!
 	b.runner = common.NewRunner(steps, b.config.PackerConfig, ui)
 	b.runner.Run(ctx, state)

From d1f8b8545dad133ea772ef44f370a09b866e4a15 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 29 May 2019 18:00:04 +0000
Subject: [PATCH 098/155] Add StepAttachDisk

---
 builder/azure/chroot/builder.go           |  6 ++-
 builder/azure/chroot/diskattacher_test.go |  2 +-
 builder/azure/chroot/step_attach_disk.go  | 65 +++++++++++++++++++++++
 3 files changed, 71 insertions(+), 2 deletions(-)
 create mode 100644 builder/azure/chroot/step_attach_disk.go

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index a91fb3035..4454ffd55 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -131,7 +131,11 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	}
 
 	steps = append(steps,
-		//&StepAttachDisk{},
+		&StepAttachDisk{ // sets 'device' in stateBag
+			SubscriptionID: info.SubscriptionID,
+			ResourceGroup:  info.ResourceGroupName,
+			DiskName:       osDiskName,
+		},
 		&amznchroot.StepPreMountCommands{
 			Commands: b.config.PreMountCommands,
 		},
diff --git a/builder/azure/chroot/diskattacher_test.go b/builder/azure/chroot/diskattacher_test.go
index fbdc359ed..088dbd147 100644
--- a/builder/azure/chroot/diskattacher_test.go
+++ b/builder/azure/chroot/diskattacher_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute"
-	"github.com/hashicorp/packer/builder/azure/chroot/client"
+	"github.com/hashicorp/packer/builder/azure/common/client"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/builder/azure/chroot/step_attach_disk.go b/builder/azure/chroot/step_attach_disk.go
new file mode 100644
index 000000000..9f05592b2
--- /dev/null
+++ b/builder/azure/chroot/step_attach_disk.go
@@ -0,0 +1,65 @@
+package chroot
+
+import (
+	"context"
+	"fmt"
+	"github.com/hashicorp/packer/builder/azure/common/client"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+	"log"
+	"time"
+)
+
+var _ multistep.Step = &StepAttachDisk{}
+
+type StepAttachDisk struct {
+	SubscriptionID, ResourceGroup, DiskName string
+}
+
+func (s StepAttachDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	azcli := state.Get("azureclient").(client.AzureClientSet)
+	ui := state.Get("ui").(packer.Ui)
+
+	diskResourceID := fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/disks/%s",
+		s.SubscriptionID,
+		s.ResourceGroup,
+		s.DiskName)
+	ui.Say(fmt.Sprintf("Attaching disk '%s'", diskResourceID))
+
+	da := NewDiskAttacher(azcli)
+	lun, err := da.AttachDisk(ctx, diskResourceID)
+	if err != nil {
+		log.Printf("StepAttachDisk.Run: error: %+v", err)
+		err := fmt.Errorf(
+			"error attaching disk '%s': %v", diskResourceID, err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	ui.Say("Disk attached, waiting for device to show up")
+	ctx, cancel := context.WithTimeout(ctx, time.Minute*3) // in case is not configured correctly
+	defer cancel()
+	device, err := da.WaitForDevice(ctx, lun)
+
+	ui.Say(fmt.Sprintf("Disk available at %q", device))
+	state.Put("device", device)
+	return multistep.ActionContinue
+}
+
+func (s StepAttachDisk) Cleanup(state multistep.StateBag) {
+	azcli := state.Get("azureclient").(client.AzureClientSet)
+	ui := state.Get("ui").(packer.Ui)
+
+	diskResourceID := fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/disks/%s",
+		s.SubscriptionID,
+		s.ResourceGroup,
+		s.DiskName)
+	ui.Say(fmt.Sprintf("Detaching disk '%s'", diskResourceID))
+
+	da := NewDiskAttacher(azcli)
+	err := da.DetachDisk(context.Background(), diskResourceID)
+	if err != nil {
+		ui.Error(fmt.Sprintf("error detaching %q: %v", diskResourceID, err))
+	}
+}

From addbdedea966433c674e6664e8a01f641fc0b231 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 31 May 2019 18:39:43 +0000
Subject: [PATCH 099/155] Add StepPostMountCommands

---
 .../amazon/chroot/step_post_mount_commands.go |   4 +-
 builder/azure/chroot/builder.go               |  22 ++-
 builder/azure/chroot/step_mount_device.go     | 132 ++++++++++++++++++
 3 files changed, 151 insertions(+), 7 deletions(-)
 create mode 100644 builder/azure/chroot/step_mount_device.go

diff --git a/builder/amazon/chroot/step_post_mount_commands.go b/builder/amazon/chroot/step_post_mount_commands.go
index 704af428f..c152d409f 100644
--- a/builder/amazon/chroot/step_post_mount_commands.go
+++ b/builder/amazon/chroot/step_post_mount_commands.go
@@ -19,7 +19,7 @@ type StepPostMountCommands struct {
 }
 
 func (s *StepPostMountCommands) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
+	config := state.Get("config").(interpolateContextProvider)
 	device := state.Get("device").(string)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)
@@ -29,7 +29,7 @@ func (s *StepPostMountCommands) Run(ctx context.Context, state multistep.StateBa
 		return multistep.ActionContinue
 	}
 
-	ictx := config.ctx
+	ictx := config.GetContext()
 	ictx.Data = &postMountCommandsData{
 		Device:    device,
 		MountPath: mountPath,
diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index 4454ffd55..d1ca610c8 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -8,7 +8,7 @@ import (
 	"runtime"
 
 	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
-	amznchroot "github.com/hashicorp/packer/builder/amazon/chroot"
+	"github.com/hashicorp/packer/builder/amazon/chroot"
 	azcommon "github.com/hashicorp/packer/builder/azure/common"
 	"github.com/hashicorp/packer/builder/azure/common/client"
 	"github.com/hashicorp/packer/common"
@@ -23,8 +23,12 @@ type Config struct {
 
 	FromScratch bool `mapstructure:"from_scratch"`
 
-	CommandWrapper   string   `mapstructure:"command_wrapper"`
-	PreMountCommands []string `mapstructure:"pre_mount_commands"`
+	CommandWrapper    string   `mapstructure:"command_wrapper"`
+	MountOptions      []string `mapstructure:"mount_options"`
+	MountPartition    string   `mapstructure:"mount_partition"`
+	MountPath         string   `mapstructure:"mount_path"`
+	PreMountCommands  []string `mapstructure:"pre_mount_commands"`
+	PostMountCommands []string `mapstructure:"post_mount_commands"`
 
 	OSDiskSizeGB             int32  `mapstructure:"osdisk_size_gb"`
 	OSDiskStorageAccountType string `mapstructure:"osdisk_storageaccounttype"`
@@ -93,7 +97,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	state.Put("config", &b.config)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
-	state.Put("wrappedCommand", amznchroot.CommandWrapper(wrappedCommand))
+	state.Put("wrappedCommand", chroot.CommandWrapper(wrappedCommand))
 
 	info, err := azcli.MetadataClient().GetComputeInfo()
 	if err != nil {
@@ -136,9 +140,17 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			ResourceGroup:  info.ResourceGroupName,
 			DiskName:       osDiskName,
 		},
-		&amznchroot.StepPreMountCommands{
+		&chroot.StepPreMountCommands{
 			Commands: b.config.PreMountCommands,
 		},
+		&StepMountDevice{
+			MountOptions:   b.config.MountOptions,
+			MountPartition: b.config.MountPartition,
+			MountPath:      b.config.MountPath,
+		},
+		&chroot.StepPostMountCommands{
+			Commands: b.config.PostMountCommands,
+		},
 	)
 
 	// Run!
diff --git a/builder/azure/chroot/step_mount_device.go b/builder/azure/chroot/step_mount_device.go
new file mode 100644
index 000000000..7c197fbea
--- /dev/null
+++ b/builder/azure/chroot/step_mount_device.go
@@ -0,0 +1,132 @@
+package chroot
+
+// mostly borrowed from ./builder/amazon/chroot/step_mount_device.go
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"github.com/hashicorp/packer/builder/amazon/chroot"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+	"github.com/hashicorp/packer/template/interpolate"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var _ multistep.Step = &StepMountDevice{}
+
+type StepMountDevice struct {
+	MountOptions   []string
+	MountPartition string
+	MountPath      string
+
+	mountPath string
+}
+
+func (s *StepMountDevice) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	ui := state.Get("ui").(packer.Ui)
+	device := state.Get("device").(string)
+	config := state.Get("config").(*Config)
+	wrappedCommand := state.Get("wrappedCommand").(chroot.CommandWrapper)
+
+	ictx := config.ctx
+
+	ictx.Data = &struct{ Device string }{Device: filepath.Base(device)}
+	mountPath, err := interpolate.Render(s.MountPath, &ictx)
+
+	if err != nil {
+		err := fmt.Errorf("error preparing mount directory: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	mountPath, err = filepath.Abs(mountPath)
+	if err != nil {
+		err := fmt.Errorf("error preparing mount directory: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	log.Printf("Mount path: %s", mountPath)
+
+	if err := os.MkdirAll(mountPath, 0755); err != nil {
+		err := fmt.Errorf("error creating mount directory: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	deviceMount := fmt.Sprintf("%s%s", device, s.MountPartition)
+
+	state.Put("deviceMount", deviceMount)
+
+	ui.Say("Mounting the root device...")
+	stderr := new(bytes.Buffer)
+
+	// build mount options from mount_options config, useful for nouuid options
+	// or other specific device type settings for mount
+	opts := ""
+	if len(s.MountOptions) > 0 {
+		opts = "-o " + strings.Join(s.MountOptions, " -o ")
+	}
+	mountCommand, err := wrappedCommand(
+		fmt.Sprintf("mount %s %s %s", opts, deviceMount, mountPath))
+	if err != nil {
+		err := fmt.Errorf("error creating mount command: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+	log.Printf("[DEBUG] (step mount) mount command is %s", mountCommand)
+	cmd := chroot.ShellCommand(mountCommand)
+	cmd.Stderr = stderr
+	if err := cmd.Run(); err != nil {
+		err := fmt.Errorf(
+			"error mounting root volume: %s\nStderr: %s", err, stderr.String())
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Set the mount path so we remember to unmount it later
+	s.mountPath = mountPath
+	state.Put("mount_path", s.mountPath)
+	state.Put("mount_device_cleanup", s)
+
+	return multistep.ActionContinue
+}
+
+func (s *StepMountDevice) Cleanup(state multistep.StateBag) {
+	ui := state.Get("ui").(packer.Ui)
+	if err := s.CleanupFunc(state); err != nil {
+		ui.Error(err.Error())
+	}
+}
+
+func (s *StepMountDevice) CleanupFunc(state multistep.StateBag) error {
+	if s.mountPath == "" {
+		return nil
+	}
+
+	ui := state.Get("ui").(packer.Ui)
+	wrappedCommand := state.Get("wrappedCommand").(chroot.CommandWrapper)
+
+	ui.Say("Unmounting the root device...")
+	unmountCommand, err := wrappedCommand(fmt.Sprintf("umount %s", s.mountPath))
+	if err != nil {
+		return fmt.Errorf("error creating unmount command: %s", err)
+	}
+
+	cmd := chroot.ShellCommand(unmountCommand)
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("error unmounting root device: %s", err)
+	}
+
+	s.mountPath = ""
+	return nil
+}

From 9a3e6661b10d0af6176ac97723360cf35f3d448b Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 31 May 2019 18:49:35 +0000
Subject: [PATCH 100/155] Add StepMountExtra

---
 builder/amazon/chroot/builder.go          |  4 +++-
 builder/amazon/chroot/step_mount_extra.go |  8 +++----
 builder/azure/chroot/builder.go           | 29 +++++++++++++++--------
 3 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/builder/amazon/chroot/builder.go b/builder/amazon/chroot/builder.go
index 21eeefc13..0b336c64e 100644
--- a/builder/amazon/chroot/builder.go
+++ b/builder/amazon/chroot/builder.go
@@ -400,7 +400,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&StepPostMountCommands{
 			Commands: b.config.PostMountCommands,
 		},
-		&StepMountExtra{},
+		&StepMountExtra{
+			ChrootMounts: b.config.ChrootMounts,
+		},
 		&StepCopyFiles{},
 		&StepChrootProvision{},
 		&StepEarlyCleanup{},
diff --git a/builder/amazon/chroot/step_mount_extra.go b/builder/amazon/chroot/step_mount_extra.go
index 089bf7e75..e1b03abbb 100644
--- a/builder/amazon/chroot/step_mount_extra.go
+++ b/builder/amazon/chroot/step_mount_extra.go
@@ -17,19 +17,19 @@ import (
 // Produces:
 //   mount_extra_cleanup CleanupFunc - To perform early cleanup
 type StepMountExtra struct {
-	mounts []string
+	ChrootMounts [][]string
+	mounts       []string
 }
 
 func (s *StepMountExtra) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)
 	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
 
-	s.mounts = make([]string, 0, len(config.ChrootMounts))
+	s.mounts = make([]string, 0, len(s.ChrootMounts))
 
 	ui.Say("Mounting additional paths within the chroot...")
-	for _, mountInfo := range config.ChrootMounts {
+	for _, mountInfo := range s.ChrootMounts {
 		innerPath := mountPath + mountInfo[2]
 
 		if err := os.MkdirAll(innerPath, 0755); err != nil {
diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index d1ca610c8..24a128ce2 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -23,12 +23,13 @@ type Config struct {
 
 	FromScratch bool `mapstructure:"from_scratch"`
 
-	CommandWrapper    string   `mapstructure:"command_wrapper"`
-	MountOptions      []string `mapstructure:"mount_options"`
-	MountPartition    string   `mapstructure:"mount_partition"`
-	MountPath         string   `mapstructure:"mount_path"`
-	PreMountCommands  []string `mapstructure:"pre_mount_commands"`
-	PostMountCommands []string `mapstructure:"post_mount_commands"`
+	CommandWrapper    string     `mapstructure:"command_wrapper"`
+	PreMountCommands  []string   `mapstructure:"pre_mount_commands"`
+	MountOptions      []string   `mapstructure:"mount_options"`
+	MountPartition    string     `mapstructure:"mount_partition"`
+	MountPath         string     `mapstructure:"mount_path"`
+	PostMountCommands []string   `mapstructure:"post_mount_commands"`
+	ChrootMounts      [][]string `mapstructure:"chroot_mounts"`
 
 	OSDiskSizeGB             int32  `mapstructure:"osdisk_size_gb"`
 	OSDiskStorageAccountType string `mapstructure:"osdisk_storageaccounttype"`
@@ -48,7 +49,12 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		InterpolateContext: &b.config.ctx,
 		InterpolateFilter: &interpolate.RenderFilter{
 			Exclude: []string{
-				// fields to exclude from interpolation
+				// these fields are interpolated in the steps,
+				// when more information is available
+				"command_wrapper",
+				"post_mount_commands",
+				"pre_mount_commands",
+				"mount_path",
 			},
 		},
 	}, raws...)
@@ -65,11 +71,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	if b.config.FromScratch {
 		if b.config.OSDiskSizeGB == 0 {
 			errs = packer.MultiErrorAppend(
-				errs, errors.New("osdisk_size_gb is required with from_scratch."))
+				errs, errors.New("osdisk_size_gb is required with from_scratch"))
 		}
 		if len(b.config.PreMountCommands) == 0 {
 			errs = packer.MultiErrorAppend(
-				errs, errors.New("pre_mount_commands is required with from_scratch."))
+				errs, errors.New("pre_mount_commands is required with from_scratch"))
 		}
 	}
 
@@ -81,7 +87,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 
 func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
 	if runtime.GOOS != "linux" {
-		return nil, errors.New("The azure-chroot builder only works on Linux environments.")
+		return nil, errors.New("the azure-chroot builder only works on Linux environments")
 	}
 
 	var azcli client.AzureClientSet
@@ -151,6 +157,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&chroot.StepPostMountCommands{
 			Commands: b.config.PostMountCommands,
 		},
+		&chroot.StepMountExtra{
+			ChrootMounts: b.config.ChrootMounts,
+		},
 	)
 
 	// Run!

From 977ca5be1c24bd0f1ff5ec234bca0e1287b9ede5 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 31 May 2019 18:55:58 +0000
Subject: [PATCH 101/155] Add StepCopyFiles and StepChrootProvision

---
 builder/amazon/chroot/builder.go         | 4 +++-
 builder/amazon/chroot/step_copy_files.go | 8 ++++----
 builder/azure/chroot/builder.go          | 5 +++++
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/builder/amazon/chroot/builder.go b/builder/amazon/chroot/builder.go
index 0b336c64e..59b2fbed1 100644
--- a/builder/amazon/chroot/builder.go
+++ b/builder/amazon/chroot/builder.go
@@ -403,7 +403,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&StepMountExtra{
 			ChrootMounts: b.config.ChrootMounts,
 		},
-		&StepCopyFiles{},
+		&StepCopyFiles{
+			Files: b.config.CopyFiles,
+		},
 		&StepChrootProvision{},
 		&StepEarlyCleanup{},
 		&StepSnapshot{},
diff --git a/builder/amazon/chroot/step_copy_files.go b/builder/amazon/chroot/step_copy_files.go
index 78625a8d3..af5766386 100644
--- a/builder/amazon/chroot/step_copy_files.go
+++ b/builder/amazon/chroot/step_copy_files.go
@@ -17,20 +17,20 @@ import (
 //   copy_files_cleanup CleanupFunc - A function to clean up the copied files
 //   early.
 type StepCopyFiles struct {
+	Files []string
 	files []string
 }
 
 func (s *StepCopyFiles) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
 	mountPath := state.Get("mount_path").(string)
 	ui := state.Get("ui").(packer.Ui)
 	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
 	stderr := new(bytes.Buffer)
 
-	s.files = make([]string, 0, len(config.CopyFiles))
-	if len(config.CopyFiles) > 0 {
+	s.files = make([]string, 0, len(s.Files))
+	if len(s.Files) > 0 {
 		ui.Say("Copying files from host to chroot...")
-		for _, path := range config.CopyFiles {
+		for _, path := range s.Files {
 			ui.Message(path)
 			chrootPath := filepath.Join(mountPath, path)
 			log.Printf("Copying '%s' to '%s'", path, chrootPath)
diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index 24a128ce2..37f486c0e 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -30,6 +30,7 @@ type Config struct {
 	MountPath         string     `mapstructure:"mount_path"`
 	PostMountCommands []string   `mapstructure:"post_mount_commands"`
 	ChrootMounts      [][]string `mapstructure:"chroot_mounts"`
+	CopyFiles         []string   `mapstructure:"copy_files"`
 
 	OSDiskSizeGB             int32  `mapstructure:"osdisk_size_gb"`
 	OSDiskStorageAccountType string `mapstructure:"osdisk_storageaccounttype"`
@@ -160,6 +161,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&chroot.StepMountExtra{
 			ChrootMounts: b.config.ChrootMounts,
 		},
+		&chroot.StepCopyFiles{
+			Files: b.config.CopyFiles,
+		},
+		&chroot.StepChrootProvision{},
 	)
 
 	// Run!

From 77b782c5b51b7f9a08b630d47af0392df1187f5d Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 31 May 2019 19:01:47 +0000
Subject: [PATCH 102/155] Add StepEarlyCleanup

---
 builder/azure/chroot/builder.go          |  1 +
 builder/azure/chroot/step_attach_disk.go | 11 ++++++++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index 37f486c0e..b0364ceb2 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -165,6 +165,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			Files: b.config.CopyFiles,
 		},
 		&chroot.StepChrootProvision{},
+		&chroot.StepEarlyCleanup{},
 	)
 
 	// Run!
diff --git a/builder/azure/chroot/step_attach_disk.go b/builder/azure/chroot/step_attach_disk.go
index 9f05592b2..c090f2e42 100644
--- a/builder/azure/chroot/step_attach_disk.go
+++ b/builder/azure/chroot/step_attach_disk.go
@@ -44,10 +44,18 @@ func (s StepAttachDisk) Run(ctx context.Context, state multistep.StateBag) multi
 
 	ui.Say(fmt.Sprintf("Disk available at %q", device))
 	state.Put("device", device)
+	state.Put("attach_cleanup", s)
 	return multistep.ActionContinue
 }
 
 func (s StepAttachDisk) Cleanup(state multistep.StateBag) {
+	ui := state.Get("ui").(packer.Ui)
+	if err := s.CleanupFunc(state); err != nil {
+		ui.Error(err.Error())
+	}
+}
+
+func (s *StepAttachDisk) CleanupFunc(state multistep.StateBag) error {
 	azcli := state.Get("azureclient").(client.AzureClientSet)
 	ui := state.Get("ui").(packer.Ui)
 
@@ -60,6 +68,7 @@ func (s StepAttachDisk) Cleanup(state multistep.StateBag) {
 	da := NewDiskAttacher(azcli)
 	err := da.DetachDisk(context.Background(), diskResourceID)
 	if err != nil {
-		ui.Error(fmt.Sprintf("error detaching %q: %v", diskResourceID, err))
+		return fmt.Errorf("error detaching %q: %v", diskResourceID, err)
 	}
+	return nil
 }

From e11a5bdb40847a57a14bd7d4a9e6fe6a016fcf20 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 31 May 2019 20:02:25 +0000
Subject: [PATCH 103/155] Put os disk id in state

---
 builder/azure/chroot/builder.go           |  64 ++++++++++++--
 builder/azure/chroot/step_attach_disk.go  |  16 ++--
 builder/azure/chroot/step_create_image.go | 101 ++++++++++++++++++++++
 3 files changed, 161 insertions(+), 20 deletions(-)
 create mode 100644 builder/azure/chroot/step_create_image.go

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index b0364ceb2..df57330e6 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -7,7 +7,6 @@ import (
 	"log"
 	"runtime"
 
-	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
 	"github.com/hashicorp/packer/builder/amazon/chroot"
 	azcommon "github.com/hashicorp/packer/builder/azure/common"
 	"github.com/hashicorp/packer/builder/azure/common/client"
@@ -16,6 +15,8 @@ import (
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
 	"github.com/hashicorp/packer/template/interpolate"
+
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
 )
 
 type Config struct {
@@ -32,8 +33,12 @@ type Config struct {
 	ChrootMounts      [][]string `mapstructure:"chroot_mounts"`
 	CopyFiles         []string   `mapstructure:"copy_files"`
 
-	OSDiskSizeGB             int32  `mapstructure:"osdisk_size_gb"`
-	OSDiskStorageAccountType string `mapstructure:"osdisk_storageaccounttype"`
+	OSDiskSizeGB             int32  `mapstructure:"os_disk_size_gb"`
+	OSDiskStorageAccountType string `mapstructure:"os_disk_storage_account_type"`
+	OSDiskCacheType          string `mapstructure:"os_disk_cache_type"`
+
+	ImageResourceID string `mapstructure:"image_resource_id"`
+	ImageOSState    string `mapstructure:"image_os_state"`
 
 	ctx interpolate.Context
 }
@@ -60,11 +65,48 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		},
 	}, raws...)
 
-	// defaults
+	// Defaults
+	if b.config.ChrootMounts == nil {
+		b.config.ChrootMounts = make([][]string, 0)
+	}
+
+	if len(b.config.ChrootMounts) == 0 {
+		b.config.ChrootMounts = [][]string{
+			{"proc", "proc", "/proc"},
+			{"sysfs", "sysfs", "/sys"},
+			{"bind", "/dev", "/dev"},
+			{"devpts", "devpts", "/dev/pts"},
+			{"binfmt_misc", "binfmt_misc", "/proc/sys/fs/binfmt_misc"},
+		}
+	}
+
+	// set default copy file if we're not giving our own
+	if b.config.CopyFiles == nil {
+		if !b.config.FromScratch {
+			b.config.CopyFiles = []string{"/etc/resolv.conf"}
+		}
+	}
+
+	if b.config.CommandWrapper == "" {
+		b.config.CommandWrapper = "{{.Command}}"
+	}
+
+	if b.config.MountPath == "" {
+		b.config.MountPath = "/mnt/packer-amazon-chroot-volumes/{{.Device}}"
+	}
+
+	if b.config.MountPartition == "" {
+		b.config.MountPartition = "1"
+	}
+
 	if b.config.OSDiskStorageAccountType == "" {
 		b.config.OSDiskStorageAccountType = string(compute.PremiumLRS)
 	}
 
+	if b.config.OSDiskCacheType == "" {
+		b.config.OSDiskCacheType = string(compute.CachingTypesReadOnly)
+	}
+
 	// checks, accumulate any errors or warnings
 	var errs *packer.MultiError
 	var warns []string
@@ -91,6 +133,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		return nil, errors.New("the azure-chroot builder only works on Linux environments")
 	}
 
+	// todo: instantiate Azure client
 	var azcli client.AzureClientSet
 
 	wrappedCommand := func(command string) (string, error) {
@@ -104,6 +147,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	state.Put("config", &b.config)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
+	state.Put("azureclient", azcli)
 	state.Put("wrappedCommand", chroot.CommandWrapper(wrappedCommand))
 
 	info, err := azcli.MetadataClient().GetComputeInfo()
@@ -142,11 +186,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	}
 
 	steps = append(steps,
-		&StepAttachDisk{ // sets 'device' in stateBag
-			SubscriptionID: info.SubscriptionID,
-			ResourceGroup:  info.ResourceGroupName,
-			DiskName:       osDiskName,
-		},
+		&StepAttachDisk{}, // uses os_disk_resource_id and sets 'device' in stateBag
 		&chroot.StepPreMountCommands{
 			Commands: b.config.PreMountCommands,
 		},
@@ -166,6 +206,12 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		},
 		&chroot.StepChrootProvision{},
 		&chroot.StepEarlyCleanup{},
+		&StepCreateImage{
+			ImageResourceID:          b.config.ImageResourceID,
+			ImageOSState:             b.config.ImageOSState,
+			OSDiskCacheType:          b.config.OSDiskCacheType,
+			OSDiskStorageAccountType: b.config.OSDiskStorageAccountType,
+		},
 	)
 
 	// Run!
diff --git a/builder/azure/chroot/step_attach_disk.go b/builder/azure/chroot/step_attach_disk.go
index c090f2e42..87f4e5c9b 100644
--- a/builder/azure/chroot/step_attach_disk.go
+++ b/builder/azure/chroot/step_attach_disk.go
@@ -3,27 +3,24 @@ package chroot
 import (
 	"context"
 	"fmt"
+	"log"
+	"time"
+
 	"github.com/hashicorp/packer/builder/azure/common/client"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"log"
-	"time"
 )
 
 var _ multistep.Step = &StepAttachDisk{}
 
 type StepAttachDisk struct {
-	SubscriptionID, ResourceGroup, DiskName string
 }
 
 func (s StepAttachDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	azcli := state.Get("azureclient").(client.AzureClientSet)
 	ui := state.Get("ui").(packer.Ui)
+	diskResourceID := state.Get("os_disk_resource_id").(string)
 
-	diskResourceID := fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/disks/%s",
-		s.SubscriptionID,
-		s.ResourceGroup,
-		s.DiskName)
 	ui.Say(fmt.Sprintf("Attaching disk '%s'", diskResourceID))
 
 	da := NewDiskAttacher(azcli)
@@ -58,11 +55,8 @@ func (s StepAttachDisk) Cleanup(state multistep.StateBag) {
 func (s *StepAttachDisk) CleanupFunc(state multistep.StateBag) error {
 	azcli := state.Get("azureclient").(client.AzureClientSet)
 	ui := state.Get("ui").(packer.Ui)
+	diskResourceID := state.Get("os_disk_resource_id").(string)
 
-	diskResourceID := fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/disks/%s",
-		s.SubscriptionID,
-		s.ResourceGroup,
-		s.DiskName)
 	ui.Say(fmt.Sprintf("Detaching disk '%s'", diskResourceID))
 
 	da := NewDiskAttacher(azcli)
diff --git a/builder/azure/chroot/step_create_image.go b/builder/azure/chroot/step_create_image.go
new file mode 100644
index 000000000..ad05b85ac
--- /dev/null
+++ b/builder/azure/chroot/step_create_image.go
@@ -0,0 +1,101 @@
+package chroot
+
+import (
+	"context"
+	"fmt"
+	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/hashicorp/packer/builder/azure/common/client"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+	"log"
+)
+
+var _ multistep.Step = &StepCreateImage{}
+
+type StepCreateImage struct {
+	ImageResourceID          string
+	ImageOSState             string
+	OSDiskStorageAccountType string
+	OSDiskCacheType          string
+
+	imageResource azure.Resource
+}
+
+func (s *StepCreateImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	azcli := state.Get("azureclient").(client.AzureClientSet)
+	ui := state.Get("ui").(packer.Ui)
+	diskResourceID := state.Get("os_disk_resource_id").(string)
+
+	ui.Say(fmt.Sprintf("Creating image %s\n   using %s for os disk.",
+		s.ImageResourceID,
+		diskResourceID))
+
+	var err error
+	s.imageResource, err = azure.ParseResourceID(s.ImageResourceID)
+
+	if err != nil {
+		log.Printf("StepCreateImage.Run: error: %+v", err)
+		err := fmt.Errorf(
+			"error parsing image resource id '%s': %v", s.ImageResourceID, err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	image := compute.Image{
+		ImageProperties: &compute.ImageProperties{
+			StorageProfile: &compute.ImageStorageProfile{
+				OsDisk: &compute.ImageOSDisk{
+					OsType:  "Linux",
+					OsState: compute.OperatingSystemStateTypes(s.ImageOSState),
+					ManagedDisk: &compute.SubResource{
+						ID: &diskResourceID,
+					},
+					Caching:            compute.CachingTypes(s.OSDiskCacheType),
+					StorageAccountType: compute.StorageAccountTypes(s.OSDiskStorageAccountType),
+				},
+				//	DataDisks:     nil,
+				//	ZoneResilient: nil,
+			},
+		},
+		//		Tags:            nil,
+	}
+	f, err := azcli.ImagesClient().CreateOrUpdate(
+		ctx,
+		s.imageResource.ResourceGroup,
+		s.imageResource.ResourceName,
+		image)
+	if err == nil {
+		err = f.WaitForCompletionRef(ctx, azcli.PollClient())
+	}
+	if err != nil {
+		log.Printf("StepCreateImage.Run: error: %+v", err)
+		err := fmt.Errorf(
+			"error creating image '%s': %v", s.ImageResourceID, err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *StepCreateImage) Cleanup(state multistep.StateBag) {
+	azcli := state.Get("azureclient").(client.AzureClientSet)
+	ui := state.Get("ui").(packer.Ui)
+
+	ctx := context.Background()
+	f, err := azcli.ImagesClient().Delete(
+		ctx,
+		s.imageResource.ResourceGroup,
+		s.imageResource.ResourceName)
+	if err == nil {
+		err = f.WaitForCompletionRef(ctx, azcli.PollClient())
+	}
+	if err != nil {
+		log.Printf("StepCreateImage.Cleanup: error: %+v", err)
+		ui.Error(fmt.Sprintf(
+			"error deleting image '%s': %v", s.ImageResourceID, err))
+	}
+}

From b4d0865548e2388bd6c8cf4d7e3c232743b1bc07 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 31 May 2019 22:15:56 +0000
Subject: [PATCH 104/155] Update azure-chroot builder

---
 builder/azure/chroot/builder.go | 79 ++++++++++++++++++++++++++++-----
 1 file changed, 69 insertions(+), 10 deletions(-)

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index df57330e6..d5446fa4d 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -22,6 +22,8 @@ import (
 type Config struct {
 	common.PackerConfig `mapstructure:",squash"`
 
+	ClientConfig client.Config `mapstructure:",squash"`
+
 	FromScratch bool `mapstructure:"from_scratch"`
 
 	CommandWrapper    string     `mapstructure:"command_wrapper"`
@@ -66,6 +68,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}, raws...)
 
 	// Defaults
+	err = b.config.ClientConfig.SetDefaultValues()
+	if err != nil {
+		return nil, err
+	}
+
 	if b.config.ChrootMounts == nil {
 		b.config.ChrootMounts = make([][]string, 0)
 	}
@@ -92,7 +99,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	if b.config.MountPath == "" {
-		b.config.MountPath = "/mnt/packer-amazon-chroot-volumes/{{.Device}}"
+		b.config.MountPath = "/mnt/packer-azure-chroot-disks/{{.Device}}"
 	}
 
 	if b.config.MountPartition == "" {
@@ -107,6 +114,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.OSDiskCacheType = string(compute.CachingTypesReadOnly)
 	}
 
+	if b.config.ImageOSState == "" {
+		b.config.ImageOSState = string(compute.Generalized)
+
+	}
+
 	// checks, accumulate any errors or warnings
 	var errs *packer.MultiError
 	var warns []string
@@ -114,18 +126,62 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	if b.config.FromScratch {
 		if b.config.OSDiskSizeGB == 0 {
 			errs = packer.MultiErrorAppend(
-				errs, errors.New("osdisk_size_gb is required with from_scratch"))
+				errs, errors.New("os_disk_size_gb is required with from_scratch"))
 		}
 		if len(b.config.PreMountCommands) == 0 {
 			errs = packer.MultiErrorAppend(
 				errs, errors.New("pre_mount_commands is required with from_scratch"))
 		}
+	} else {
+		errs = packer.MultiErrorAppend(errors.New("only 'from_scratch'=true is supported right now"))
 	}
 
-	if err != nil {
-		return nil, err
+	if err := checkOSState(b.config.ImageOSState); err != nil {
+		errs = packer.MultiErrorAppend(errs, fmt.Errorf("image_os_state: %v", err))
 	}
-	return warns, errs
+	if err := checkDiskCacheType(b.config.OSDiskCacheType); err != nil {
+		errs = packer.MultiErrorAppend(errs, fmt.Errorf("os_disk_cache_type: %v", err))
+	}
+	if err := checkStorageAccountType(b.config.OSDiskStorageAccountType); err != nil {
+		errs = packer.MultiErrorAppend(errs, fmt.Errorf("os_disk_storage_account_type: %v", err))
+	}
+
+	if errs != nil {
+		return warns, errs
+	}
+
+	packer.LogSecretFilter.Set(b.config.ClientConfig.ClientSecret, b.config.ClientConfig.ClientJWT)
+	return warns, nil
+}
+
+func checkOSState(s string) interface{} {
+	for _, v := range compute.PossibleOperatingSystemStateTypesValues() {
+		if compute.OperatingSystemStateTypes(s) == v {
+			return nil
+		}
+	}
+	return fmt.Errorf("%q is not a valid value (%v)",
+		s, compute.PossibleOperatingSystemStateTypesValues())
+}
+
+func checkDiskCacheType(s string) interface{} {
+	for _, v := range compute.PossibleCachingTypesValues() {
+		if compute.CachingTypes(s) == v {
+			return nil
+		}
+	}
+	return fmt.Errorf("%q is not a valid value (%v)",
+		s, compute.PossibleCachingTypesValues())
+}
+
+func checkStorageAccountType(s string) interface{} {
+	for _, v := range compute.PossibleStorageAccountTypesValues() {
+		if compute.StorageAccountTypes(s) == v {
+			return nil
+		}
+	}
+	return fmt.Errorf("%q is not a valid value (%v)",
+		s, compute.PossibleStorageAccountTypesValues())
 }
 
 func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
@@ -133,8 +189,14 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		return nil, errors.New("the azure-chroot builder only works on Linux environments")
 	}
 
-	// todo: instantiate Azure client
-	var azcli client.AzureClientSet
+	err := b.config.ClientConfig.FillParameters()
+	if err != nil {
+		return nil, fmt.Errorf("error setting Azure client defaults: %v", err)
+	}
+	azcli, err := client.New(b.config.ClientConfig, ui.Say)
+	if err != nil {
+		return nil, fmt.Errorf("error creating Azure client: %v", err)
+	}
 
 	wrappedCommand := func(command string) (string, error) {
 		ictx := b.config.ctx
@@ -164,9 +226,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	osDiskName := "PackerBuiltOsDisk"
 
 	state.Put("instance", info)
-	if err != nil {
-		return nil, err
-	}
 
 	// Build the steps
 	var steps []multistep.Step

From 7297d74c98f9340f63fef31d9f8ce19660dafcc7 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Sun, 2 Jun 2019 19:26:03 +0000
Subject: [PATCH 105/155] Add azure-chroot builder plugin

---
 command/plugin.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/command/plugin.go b/command/plugin.go
index 81dcc4ec1..277685a9b 100644
--- a/command/plugin.go
+++ b/command/plugin.go
@@ -20,6 +20,7 @@ import (
 	amazonebsvolumebuilder "github.com/hashicorp/packer/builder/amazon/ebsvolume"
 	amazoninstancebuilder "github.com/hashicorp/packer/builder/amazon/instance"
 	azurearmbuilder "github.com/hashicorp/packer/builder/azure/arm"
+	azurechrootbuilder "github.com/hashicorp/packer/builder/azure/chroot"
 	cloudstackbuilder "github.com/hashicorp/packer/builder/cloudstack"
 	digitaloceanbuilder "github.com/hashicorp/packer/builder/digitalocean"
 	dockerbuilder "github.com/hashicorp/packer/builder/docker"
@@ -109,6 +110,7 @@ var Builders = map[string]packer.Builder{
 	"amazon-ebsvolume":    new(amazonebsvolumebuilder.Builder),
 	"amazon-instance":     new(amazoninstancebuilder.Builder),
 	"azure-arm":           new(azurearmbuilder.Builder),
+	"azure-chroot":        new(azurechrootbuilder.Builder),
 	"cloudstack":          new(cloudstackbuilder.Builder),
 	"digitalocean":        new(digitaloceanbuilder.Builder),
 	"docker":              new(dockerbuilder.Builder),

From b9b5bb2951864d05c1d03448fc92c3c82c345716 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Sun, 2 Jun 2019 19:29:45 +0000
Subject: [PATCH 106/155] Use DiskStorageAccountTypes

---
 builder/azure/chroot/builder.go              | 6 +++---
 builder/azure/chroot/step_create_new_disk.go | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index d5446fa4d..8023db7f5 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -175,13 +175,13 @@ func checkDiskCacheType(s string) interface{} {
 }
 
 func checkStorageAccountType(s string) interface{} {
-	for _, v := range compute.PossibleStorageAccountTypesValues() {
-		if compute.StorageAccountTypes(s) == v {
+	for _, v := range compute.PossibleDiskStorageAccountTypesValues() {
+		if compute.DiskStorageAccountTypes(s) == v {
 			return nil
 		}
 	}
 	return fmt.Errorf("%q is not a valid value (%v)",
-		s, compute.PossibleStorageAccountTypesValues())
+		s, compute.PossibleDiskStorageAccountTypesValues())
 }
 
 func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
diff --git a/builder/azure/chroot/step_create_new_disk.go b/builder/azure/chroot/step_create_new_disk.go
index 098adb25f..c2eb15ca3 100644
--- a/builder/azure/chroot/step_create_new_disk.go
+++ b/builder/azure/chroot/step_create_new_disk.go
@@ -33,7 +33,7 @@ func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) mu
 
 	disk := compute.Disk{
 		Sku: &compute.DiskSku{
-			Name: "",
+			Name: compute.DiskStorageAccountTypes(s.DiskStorageAccountType),
 		},
 		//Zones: nil,
 		DiskProperties: &compute.DiskProperties{

From b5401d552a3a698f8e9067c5b798ba539cdfbe47 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Mon, 3 Jun 2019 05:27:33 +0000
Subject: [PATCH 107/155] Make from_scratch work

---
 builder/azure/chroot/builder.go              |  66 ++++++--
 builder/azure/chroot/diskattacher.go         | 159 ++++++++++++-------
 builder/azure/chroot/step_attach_disk.go     |  35 ++--
 builder/azure/chroot/step_create_image.go    |  27 +---
 builder/azure/chroot/step_create_new_disk.go |  14 +-
 5 files changed, 191 insertions(+), 110 deletions(-)

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index 8023db7f5..b2ac901f9 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -4,8 +4,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/Azure/go-autorest/autorest/azure"
 	"log"
 	"runtime"
+	"strings"
 
 	"github.com/hashicorp/packer/builder/amazon/chroot"
 	azcommon "github.com/hashicorp/packer/builder/azure/common"
@@ -35,16 +37,22 @@ type Config struct {
 	ChrootMounts      [][]string `mapstructure:"chroot_mounts"`
 	CopyFiles         []string   `mapstructure:"copy_files"`
 
+	TemporaryOSDiskName      string `mapstructure:"temporary_os_disk_name"`
 	OSDiskSizeGB             int32  `mapstructure:"os_disk_size_gb"`
 	OSDiskStorageAccountType string `mapstructure:"os_disk_storage_account_type"`
 	OSDiskCacheType          string `mapstructure:"os_disk_cache_type"`
 
-	ImageResourceID string `mapstructure:"image_resource_id"`
-	ImageOSState    string `mapstructure:"image_os_state"`
+	ImageResourceID       string `mapstructure:"image_resource_id"`
+	ImageOSState          string `mapstructure:"image_os_state"`
+	ImageHyperVGeneration string `mapstructure:"image_hyperv_generation"`
 
 	ctx interpolate.Context
 }
 
+func (c *Config) GetContext() interpolate.Context {
+	return c.ctx
+}
+
 type Builder struct {
 	config Config
 	runner multistep.Runner
@@ -106,6 +114,10 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.MountPartition = "1"
 	}
 
+	if b.config.TemporaryOSDiskName == "" {
+		b.config.TemporaryOSDiskName = "PackerTemp-{{timestamp}}"
+	}
+
 	if b.config.OSDiskStorageAccountType == "" {
 		b.config.OSDiskStorageAccountType = string(compute.PremiumLRS)
 	}
@@ -116,7 +128,10 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 
 	if b.config.ImageOSState == "" {
 		b.config.ImageOSState = string(compute.Generalized)
+	}
 
+	if b.config.ImageHyperVGeneration == "" {
+		b.config.ImageHyperVGeneration = string(compute.V1)
 	}
 
 	// checks, accumulate any errors or warnings
@@ -136,16 +151,34 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		errs = packer.MultiErrorAppend(errors.New("only 'from_scratch'=true is supported right now"))
 	}
 
-	if err := checkOSState(b.config.ImageOSState); err != nil {
-		errs = packer.MultiErrorAppend(errs, fmt.Errorf("image_os_state: %v", err))
-	}
 	if err := checkDiskCacheType(b.config.OSDiskCacheType); err != nil {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("os_disk_cache_type: %v", err))
 	}
+
 	if err := checkStorageAccountType(b.config.OSDiskStorageAccountType); err != nil {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("os_disk_storage_account_type: %v", err))
 	}
 
+	if b.config.ImageResourceID == "" {
+		errs = packer.MultiErrorAppend(errs, errors.New("image_resource_id is required"))
+	} else {
+		r, err := azure.ParseResourceID(b.config.ImageResourceID)
+		if err != nil ||
+			!strings.EqualFold(r.Provider, "Microsoft.Compute") ||
+			!strings.EqualFold(r.ResourceType, "images") {
+			errs = packer.MultiErrorAppend(fmt.Errorf(
+				"image_resource_id: %q is not a valid image resource id", b.config.ImageResourceID))
+		}
+	}
+
+	if err := checkOSState(b.config.ImageOSState); err != nil {
+		errs = packer.MultiErrorAppend(errs, fmt.Errorf("image_os_state: %v", err))
+	}
+
+	if err := checkHyperVGeneration(b.config.ImageHyperVGeneration); err != nil {
+		errs = packer.MultiErrorAppend(errs, fmt.Errorf("image_hyperv_generation: %v", err))
+	}
+
 	if errs != nil {
 		return warns, errs
 	}
@@ -160,7 +193,7 @@ func checkOSState(s string) interface{} {
 			return nil
 		}
 	}
-	return fmt.Errorf("%q is not a valid value (%v)",
+	return fmt.Errorf("%q is not a valid value %v",
 		s, compute.PossibleOperatingSystemStateTypesValues())
 }
 
@@ -170,7 +203,7 @@ func checkDiskCacheType(s string) interface{} {
 			return nil
 		}
 	}
-	return fmt.Errorf("%q is not a valid value (%v)",
+	return fmt.Errorf("%q is not a valid value %v",
 		s, compute.PossibleCachingTypesValues())
 }
 
@@ -180,10 +213,20 @@ func checkStorageAccountType(s string) interface{} {
 			return nil
 		}
 	}
-	return fmt.Errorf("%q is not a valid value (%v)",
+	return fmt.Errorf("%q is not a valid value %v",
 		s, compute.PossibleDiskStorageAccountTypesValues())
 }
 
+func checkHyperVGeneration(s string) interface{} {
+	for _, v := range compute.PossibleHyperVGenerationValues() {
+		if compute.HyperVGeneration(s) == v {
+			return nil
+		}
+	}
+	return fmt.Errorf("%q is not a valid value %v",
+		s, compute.PossibleHyperVGenerationValues())
+}
+
 func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error) {
 	if runtime.GOOS != "linux" {
 		return nil, errors.New("the azure-chroot builder only works on Linux environments")
@@ -223,8 +266,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		return nil, err
 	}
 
-	osDiskName := "PackerBuiltOsDisk"
-
 	state.Put("instance", info)
 
 	// Build the steps
@@ -238,9 +279,11 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			&StepCreateNewDisk{
 				SubscriptionID:         info.SubscriptionID,
 				ResourceGroup:          info.ResourceGroupName,
-				DiskName:               osDiskName,
+				DiskName:               b.config.TemporaryOSDiskName,
 				DiskSizeGB:             b.config.OSDiskSizeGB,
 				DiskStorageAccountType: b.config.OSDiskStorageAccountType,
+				HyperVGeneration:       b.config.ImageHyperVGeneration,
+				Location:               info.Location,
 			})
 	}
 
@@ -270,6 +313,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			ImageOSState:             b.config.ImageOSState,
 			OSDiskCacheType:          b.config.OSDiskCacheType,
 			OSDiskStorageAccountType: b.config.OSDiskStorageAccountType,
+			Location:                 info.Location,
 		},
 	)
 
diff --git a/builder/azure/chroot/diskattacher.go b/builder/azure/chroot/diskattacher.go
index 2f21ebf45..97ba4174c 100644
--- a/builder/azure/chroot/diskattacher.go
+++ b/builder/azure/chroot/diskattacher.go
@@ -4,9 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log"
 	"os"
 	"path/filepath"
 	"strings"
+	"syscall"
 	"time"
 
 	"github.com/hashicorp/packer/builder/azure/common/client"
@@ -16,38 +18,43 @@ import (
 	"github.com/Azure/go-autorest/autorest/to"
 )
 
-type VirtualMachinesClientAPI interface {
-	CreateOrUpdate(ctx context.Context, resourceGroupName string, VMName string, parameters compute.VirtualMachine) (
-		result compute.VirtualMachinesCreateOrUpdateFuture, err error)
-	Get(ctx context.Context, resourceGroupName string, VMName string, expand compute.InstanceViewTypes) (
-		result compute.VirtualMachine, err error)
-}
-
 type DiskAttacher interface {
 	AttachDisk(ctx context.Context, disk string) (lun int32, err error)
 	DetachDisk(ctx context.Context, disk string) (err error)
 	WaitForDevice(ctx context.Context, i int32) (device string, err error)
+	DiskPathForLun(lun int32) string
 }
 
 func NewDiskAttacher(azureClient client.AzureClientSet) DiskAttacher {
-	return diskAttacher{azureClient}
+	return &diskAttacher{
+		azcli: azureClient,
+	}
 }
 
 type diskAttacher struct {
 	azcli client.AzureClientSet
+
+	vm *client.ComputeInfo // store info about this VM so that we don't have to ask metadata service on every call
 }
 
-func (da diskAttacher) WaitForDevice(ctx context.Context, i int32) (device string, err error) {
-	path := fmt.Sprintf("/dev/disk/azure/scsi1/lun%d", i)
+func (diskAttacher) DiskPathForLun(lun int32) string {
+	return fmt.Sprintf("/dev/disk/azure/scsi1/lun%d", lun)
+}
+
+func (da diskAttacher) WaitForDevice(ctx context.Context, lun int32) (device string, err error) {
+	path := da.DiskPathForLun(lun)
 
 	for {
-		l, err := os.Readlink(path)
+		link, err := os.Readlink(path)
 		if err == nil {
-			return filepath.Abs("/dev/disk/azure/scsi1/" + l)
+			return filepath.Abs("/dev/disk/azure/scsi1/" + link)
 		}
 		if err != nil && err != os.ErrNotExist {
-			return "", err
+			if pe, ok := err.(*os.PathError); ok && pe.Err != syscall.ENOENT {
+				return "", err
+			}
 		}
+
 		select {
 		case <-time.After(100 * time.Millisecond):
 			// continue
@@ -57,13 +64,14 @@ func (da diskAttacher) WaitForDevice(ctx context.Context, i int32) (device strin
 	}
 }
 
-func (da diskAttacher) DetachDisk(ctx context.Context, diskID string) error {
+func (da *diskAttacher) DetachDisk(ctx context.Context, diskID string) error {
+	log.Println("Fetching list of disks currently attached to VM")
 	currentDisks, err := da.getDisks(ctx)
 	if err != nil {
 		return err
 	}
 
-	// copy all disks to new array that not match diskID
+	log.Printf("Removing %q from list of disks currently attached to VM", diskID)
 	newDisks := []compute.DataDisk{}
 	for _, disk := range currentDisks {
 		if disk.ManagedDisk != nil &&
@@ -75,71 +83,92 @@ func (da diskAttacher) DetachDisk(ctx context.Context, diskID string) error {
 		return DiskNotFoundError
 	}
 
-	return da.setDisks(ctx, newDisks)
+	log.Println("Updating new list of disks attached to VM")
+	err = da.setDisks(ctx, newDisks)
+	if err != nil {
+		return err
+	}
+
+	// waiting for VM update to finish takes way to long
+	for { // loop until disk is not attached, timeout or error
+		list, err := da.getDisks(ctx)
+		if err != nil {
+			return err
+		}
+		if findDiskInList(list, diskID) == nil {
+			log.Println("Disk is no longer in VM model, assuming detached")
+			return nil
+		}
+
+		select {
+		case <-time.After(time.Second): //continue
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
 }
 
 var DiskNotFoundError = errors.New("Disk not found")
 
-func (da diskAttacher) AttachDisk(ctx context.Context, diskID string) (int32, error) {
+func (da *diskAttacher) AttachDisk(ctx context.Context, diskID string) (int32, error) {
 	dataDisks, err := da.getDisks(ctx)
 	if err != nil {
 		return -1, err
 	}
 
 	// check to see if disk is already attached, remember lun if found
+	if disk := findDiskInList(dataDisks, diskID); disk != nil {
+		// disk is already attached, just take this lun
+		if disk.Lun == nil {
+			return -1, errors.New("disk is attached, but lun was not set in VM model (possibly an error in the Azure APIs)")
+		}
+		return to.Int32(disk.Lun), nil
+	}
+
+	// disk was not found on VM, go and actually attach it
+
 	var lun int32 = -1
-	for _, disk := range dataDisks {
-		if disk.ManagedDisk != nil &&
-			strings.EqualFold(to.String(disk.ManagedDisk.ID), diskID) {
-			// disk is already attached, just take this lun
-			if disk.Lun != nil {
-				lun = to.Int32(disk.Lun)
-				break
+findFreeLun:
+	for lun = 0; lun < 64; lun++ {
+		for _, v := range dataDisks {
+			if to.Int32(v.Lun) == lun {
+				continue findFreeLun
 			}
 		}
+		// no datadisk is using this lun
+		break
 	}
 
-	if lun == -1 {
-		// disk was not found on VM, go and actually attach it
+	// append new data disk to collection
+	dataDisks = append(dataDisks, compute.DataDisk{
+		CreateOption: compute.DiskCreateOptionTypesAttach,
+		ManagedDisk: &compute.ManagedDiskParameters{
+			ID: to.StringPtr(diskID),
+		},
+		Lun: to.Int32Ptr(lun),
+	})
 
-	findFreeLun:
-		for lun = 0; lun < 64; lun++ {
-			for _, v := range dataDisks {
-				if to.Int32(v.Lun) == lun {
-					continue findFreeLun
-				}
-			}
-			// no datadisk is using this lun
-			break
-		}
-
-		// append new data disk to collection
-		dataDisks = append(dataDisks, compute.DataDisk{
-			CreateOption: compute.DiskCreateOptionTypesAttach,
-			ManagedDisk: &compute.ManagedDiskParameters{
-				ID: to.StringPtr(diskID),
-			},
-			Lun: to.Int32Ptr(lun),
-		})
-
-		// prepare resource object for update operation
-		err = da.setDisks(ctx, dataDisks)
-		if err != nil {
-			return -1, err
-		}
+	// prepare resource object for update operation
+	err = da.setDisks(ctx, dataDisks)
+	if err != nil {
+		return -1, err
 	}
+
 	return lun, nil
 }
 
-func (da diskAttacher) getThisVM(ctx context.Context) (compute.VirtualMachine, error) {
+func (da *diskAttacher) getThisVM(ctx context.Context) (compute.VirtualMachine, error) {
 	// getting resource info for this VM
-	vm, err := da.azcli.MetadataClient().GetComputeInfo()
-	if err != nil {
-		return compute.VirtualMachine{}, err
+	if da.vm == nil {
+		vm, err := da.azcli.MetadataClient().GetComputeInfo()
+		if err != nil {
+			return compute.VirtualMachine{}, err
+		}
+		da.vm = vm
 	}
 
 	// retrieve actual VM
-	vmResource, err := da.azcli.VirtualMachinesClient().Get(ctx, vm.ResourceGroupName, vm.Name, "")
+	vmResource, err := da.azcli.VirtualMachinesClient().Get(ctx, da.vm.ResourceGroupName, da.vm.Name, "")
 	if err != nil {
 		return compute.VirtualMachine{}, err
 	}
@@ -173,10 +202,18 @@ func (da diskAttacher) setDisks(ctx context.Context, disks []compute.DataDisk) e
 	vmResource.StorageProfile.DataDisks = &disks
 	vmResource.Resources = nil
 
-	// update the VM resource, attaching disk
-	f, err := da.azcli.VirtualMachinesClient().CreateOrUpdate(ctx, id.ResourceGroup, id.ResourceName, vmResource)
-	if err == nil {
-		err = f.WaitForCompletionRef(ctx, da.azcli.PollClient())
-	}
+	// update the VM resource, attach disk
+	_, err = da.azcli.VirtualMachinesClient().CreateOrUpdate(ctx, id.ResourceGroup, id.ResourceName, vmResource)
+
 	return err
 }
+
+func findDiskInList(list []compute.DataDisk, diskID string) *compute.DataDisk {
+	for _, disk := range list {
+		if disk.ManagedDisk != nil &&
+			strings.EqualFold(to.String(disk.ManagedDisk.ID), diskID) {
+			return &disk
+		}
+	}
+	return nil
+}
diff --git a/builder/azure/chroot/step_attach_disk.go b/builder/azure/chroot/step_attach_disk.go
index 87f4e5c9b..286c01af1 100644
--- a/builder/azure/chroot/step_attach_disk.go
+++ b/builder/azure/chroot/step_attach_disk.go
@@ -14,9 +14,10 @@ import (
 var _ multistep.Step = &StepAttachDisk{}
 
 type StepAttachDisk struct {
+	attached bool
 }
 
-func (s StepAttachDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+func (s *StepAttachDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	azcli := state.Get("azureclient").(client.AzureClientSet)
 	ui := state.Get("ui").(packer.Ui)
 	diskResourceID := state.Get("os_disk_resource_id").(string)
@@ -38,14 +39,23 @@ func (s StepAttachDisk) Run(ctx context.Context, state multistep.StateBag) multi
 	ctx, cancel := context.WithTimeout(ctx, time.Minute*3) // in case is not configured correctly
 	defer cancel()
 	device, err := da.WaitForDevice(ctx, lun)
+	if err != nil {
+		log.Printf("StepAttachDisk.Run: error: %+v", err)
+		err := fmt.Errorf(
+			"error attaching disk '%s': %v", diskResourceID, err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
 
 	ui.Say(fmt.Sprintf("Disk available at %q", device))
+	s.attached = true
 	state.Put("device", device)
 	state.Put("attach_cleanup", s)
 	return multistep.ActionContinue
 }
 
-func (s StepAttachDisk) Cleanup(state multistep.StateBag) {
+func (s *StepAttachDisk) Cleanup(state multistep.StateBag) {
 	ui := state.Get("ui").(packer.Ui)
 	if err := s.CleanupFunc(state); err != nil {
 		ui.Error(err.Error())
@@ -53,16 +63,21 @@ func (s StepAttachDisk) Cleanup(state multistep.StateBag) {
 }
 
 func (s *StepAttachDisk) CleanupFunc(state multistep.StateBag) error {
-	azcli := state.Get("azureclient").(client.AzureClientSet)
-	ui := state.Get("ui").(packer.Ui)
-	diskResourceID := state.Get("os_disk_resource_id").(string)
 
-	ui.Say(fmt.Sprintf("Detaching disk '%s'", diskResourceID))
+	if s.attached {
+		azcli := state.Get("azureclient").(client.AzureClientSet)
+		ui := state.Get("ui").(packer.Ui)
+		diskResourceID := state.Get("os_disk_resource_id").(string)
 
-	da := NewDiskAttacher(azcli)
-	err := da.DetachDisk(context.Background(), diskResourceID)
-	if err != nil {
-		return fmt.Errorf("error detaching %q: %v", diskResourceID, err)
+		ui.Say(fmt.Sprintf("Detaching disk '%s'", diskResourceID))
+
+		da := NewDiskAttacher(azcli)
+		err := da.DetachDisk(context.Background(), diskResourceID)
+		if err != nil {
+			return fmt.Errorf("error detaching %q: %v", diskResourceID, err)
+		}
+		s.attached = false
 	}
+
 	return nil
 }
diff --git a/builder/azure/chroot/step_create_image.go b/builder/azure/chroot/step_create_image.go
index ad05b85ac..bd869470c 100644
--- a/builder/azure/chroot/step_create_image.go
+++ b/builder/azure/chroot/step_create_image.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute"
 	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/to"
 	"github.com/hashicorp/packer/builder/azure/common/client"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
@@ -18,6 +19,7 @@ type StepCreateImage struct {
 	ImageOSState             string
 	OSDiskStorageAccountType string
 	OSDiskCacheType          string
+	Location                 string
 
 	imageResource azure.Resource
 }
@@ -44,16 +46,14 @@ func (s *StepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
 	}
 
 	image := compute.Image{
+		Location: to.StringPtr(s.Location),
 		ImageProperties: &compute.ImageProperties{
 			StorageProfile: &compute.ImageStorageProfile{
 				OsDisk: &compute.ImageOSDisk{
-					OsType:  "Linux",
 					OsState: compute.OperatingSystemStateTypes(s.ImageOSState),
 					ManagedDisk: &compute.SubResource{
 						ID: &diskResourceID,
 					},
-					Caching:            compute.CachingTypes(s.OSDiskCacheType),
-					StorageAccountType: compute.StorageAccountTypes(s.OSDiskStorageAccountType),
 				},
 				//	DataDisks:     nil,
 				//	ZoneResilient: nil,
@@ -67,6 +67,7 @@ func (s *StepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
 		s.imageResource.ResourceName,
 		image)
 	if err == nil {
+		log.Println("Image creation in process...")
 		err = f.WaitForCompletionRef(ctx, azcli.PollClient())
 	}
 	if err != nil {
@@ -77,25 +78,9 @@ func (s *StepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
+	log.Printf("Image creation complete: %s", f.Status())
 
 	return multistep.ActionContinue
 }
 
-func (s *StepCreateImage) Cleanup(state multistep.StateBag) {
-	azcli := state.Get("azureclient").(client.AzureClientSet)
-	ui := state.Get("ui").(packer.Ui)
-
-	ctx := context.Background()
-	f, err := azcli.ImagesClient().Delete(
-		ctx,
-		s.imageResource.ResourceGroup,
-		s.imageResource.ResourceName)
-	if err == nil {
-		err = f.WaitForCompletionRef(ctx, azcli.PollClient())
-	}
-	if err != nil {
-		log.Printf("StepCreateImage.Cleanup: error: %+v", err)
-		ui.Error(fmt.Sprintf(
-			"error deleting image '%s': %v", s.ImageResourceID, err))
-	}
-}
+func (*StepCreateImage) Cleanup(bag multistep.StateBag) {} // this is the final artifact, don't delete
diff --git a/builder/azure/chroot/step_create_new_disk.go b/builder/azure/chroot/step_create_new_disk.go
index c2eb15ca3..8187bb7dc 100644
--- a/builder/azure/chroot/step_create_new_disk.go
+++ b/builder/azure/chroot/step_create_new_disk.go
@@ -18,6 +18,8 @@ type StepCreateNewDisk struct {
 	SubscriptionID, ResourceGroup, DiskName string
 	DiskSizeGB                              int32  // optional, ignored if 0
 	DiskStorageAccountType                  string // from compute.DiskStorageAccountTypes
+	HyperVGeneration                        string
+	Location                                string
 }
 
 func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
@@ -32,13 +34,14 @@ func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) mu
 	ui.Say(fmt.Sprintf("Creating disk '%s'", diskResourceID))
 
 	disk := compute.Disk{
+		Location: to.StringPtr(s.Location),
 		Sku: &compute.DiskSku{
 			Name: compute.DiskStorageAccountTypes(s.DiskStorageAccountType),
 		},
 		//Zones: nil,
 		DiskProperties: &compute.DiskProperties{
-			OsType:           "",
-			HyperVGeneration: "",
+			OsType:           "Linux",
+			HyperVGeneration: compute.HyperVGeneration(s.HyperVGeneration),
 			CreationData: &compute.CreationData{
 				CreateOption: compute.Empty,
 			},
@@ -70,11 +73,8 @@ func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) mu
 func (s StepCreateNewDisk) Cleanup(state multistep.StateBag) {
 	azcli := state.Get("azureclient").(client.AzureClientSet)
 	ui := state.Get("ui").(packer.Ui)
+	diskResourceID := state.Get("os_disk_resource_id")
 
-	diskResourceID := fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/disks/%s",
-		s.SubscriptionID,
-		s.ResourceGroup,
-		s.DiskName)
 	ui.Say(fmt.Sprintf("Deleting disk '%s'", diskResourceID))
 
 	f, err := azcli.DisksClient().Delete(context.TODO(), s.ResourceGroup, s.DiskName)
@@ -83,6 +83,6 @@ func (s StepCreateNewDisk) Cleanup(state multistep.StateBag) {
 	}
 	if err != nil {
 		log.Printf("StepCreateNewDisk.Cleanup: error: %+v", err)
-		ui.Error(fmt.Sprintf("Error deleting new disk '%s': %v.", diskResourceID, err))
+		ui.Error(fmt.Sprintf("error deleting new disk '%s': %v.", diskResourceID, err))
 	}
 }

From bbac79f0a428a483687ddf94d45aa3cbcee29573 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Mon, 3 Jun 2019 08:33:31 +0000
Subject: [PATCH 108/155] Make PIR images work

---
 builder/azure/chroot/builder.go              | 57 ++++++++++++++++----
 builder/azure/chroot/step_create_image.go    |  3 ++
 builder/azure/chroot/step_create_new_disk.go | 18 +++++--
 3 files changed, 65 insertions(+), 13 deletions(-)

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index b2ac901f9..abc75d677 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/to"
 	"log"
 	"runtime"
 	"strings"
@@ -26,7 +27,8 @@ type Config struct {
 
 	ClientConfig client.Config `mapstructure:",squash"`
 
-	FromScratch bool `mapstructure:"from_scratch"`
+	FromScratch bool   `mapstructure:"from_scratch"`
+	Source      string `mapstructure:"source"`
 
 	CommandWrapper    string     `mapstructure:"command_wrapper"`
 	PreMountCommands  []string   `mapstructure:"pre_mount_commands"`
@@ -75,6 +77,9 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		},
 	}, raws...)
 
+	var errs *packer.MultiError
+	var warns []string
+
 	// Defaults
 	err = b.config.ClientConfig.SetDefaultValues()
 	if err != nil {
@@ -115,7 +120,12 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	if b.config.TemporaryOSDiskName == "" {
-		b.config.TemporaryOSDiskName = "PackerTemp-{{timestamp}}"
+
+		if def, err := interpolate.Render("PackerTemp-{{timestamp}}", &b.config.ctx); err == nil {
+			b.config.TemporaryOSDiskName = def
+		} else {
+			errs = packer.MultiErrorAppend(errs, fmt.Errorf("unable to render temporary disk name: %s", err))
+		}
 	}
 
 	if b.config.OSDiskStorageAccountType == "" {
@@ -135,10 +145,12 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	// checks, accumulate any errors or warnings
-	var errs *packer.MultiError
-	var warns []string
 
 	if b.config.FromScratch {
+		if b.config.Source != "" {
+			errs = packer.MultiErrorAppend(
+				errs, errors.New("source cannot be specified when building from_scratch"))
+		}
 		if b.config.OSDiskSizeGB == 0 {
 			errs = packer.MultiErrorAppend(
 				errs, errors.New("os_disk_size_gb is required with from_scratch"))
@@ -148,7 +160,12 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 				errs, errors.New("pre_mount_commands is required with from_scratch"))
 		}
 	} else {
-		errs = packer.MultiErrorAppend(errors.New("only 'from_scratch'=true is supported right now"))
+		if _, err := client.ParsePlatformImageURN(b.config.Source); err == nil {
+			log.Println("Source is platform image:", b.config.Source)
+		} else {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("source: %q is not a valid platform image specifier", b.config.Source))
+		}
 	}
 
 	if err := checkDiskCacheType(b.config.OSDiskCacheType); err != nil {
@@ -271,10 +288,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	// Build the steps
 	var steps []multistep.Step
 
-	if !b.config.FromScratch {
-		panic("Only from_scratch is currently implemented")
-		// create disk from PIR / managed image (warn on non-linux images)
-	} else {
+	if b.config.FromScratch {
 		steps = append(steps,
 			&StepCreateNewDisk{
 				SubscriptionID:         info.SubscriptionID,
@@ -285,6 +299,31 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 				HyperVGeneration:       b.config.ImageHyperVGeneration,
 				Location:               info.Location,
 			})
+	} else {
+		if pi, err := client.ParsePlatformImageURN(b.config.Source); err == nil {
+			if strings.EqualFold(pi.Version, "latest") {
+
+				vmi, err := azcli.VirtualMachineImagesClient().GetLatest(ctx, pi.Publisher, pi.Offer, pi.Sku, info.Location)
+				if err != nil {
+					return nil, fmt.Errorf("error retieving latest version of %q: %v", b.config.Source, err)
+				}
+				pi.Version = to.String(vmi.Name)
+				log.Println("Resolved latest version of source image:", pi.Version)
+			}
+			steps = append(steps,
+				&StepCreateNewDisk{
+					SubscriptionID:         info.SubscriptionID,
+					ResourceGroup:          info.ResourceGroupName,
+					DiskName:               b.config.TemporaryOSDiskName,
+					DiskSizeGB:             b.config.OSDiskSizeGB,
+					DiskStorageAccountType: b.config.OSDiskStorageAccountType,
+					HyperVGeneration:       b.config.ImageHyperVGeneration,
+					Location:               info.Location,
+					PlatformImage:          pi,
+				})
+		} else {
+			panic("Unknown image source: " + b.config.Source)
+		}
 	}
 
 	steps = append(steps,
diff --git a/builder/azure/chroot/step_create_image.go b/builder/azure/chroot/step_create_image.go
index bd869470c..4ae90d2fe 100644
--- a/builder/azure/chroot/step_create_image.go
+++ b/builder/azure/chroot/step_create_image.go
@@ -51,9 +51,12 @@ func (s *StepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
 			StorageProfile: &compute.ImageStorageProfile{
 				OsDisk: &compute.ImageOSDisk{
 					OsState: compute.OperatingSystemStateTypes(s.ImageOSState),
+					OsType:  compute.Linux,
 					ManagedDisk: &compute.SubResource{
 						ID: &diskResourceID,
 					},
+					StorageAccountType: compute.StorageAccountTypes(s.OSDiskStorageAccountType),
+					Caching:            compute.CachingTypes(s.OSDiskCacheType),
 				},
 				//	DataDisks:     nil,
 				//	ZoneResilient: nil,
diff --git a/builder/azure/chroot/step_create_new_disk.go b/builder/azure/chroot/step_create_new_disk.go
index 8187bb7dc..6873c827a 100644
--- a/builder/azure/chroot/step_create_new_disk.go
+++ b/builder/azure/chroot/step_create_new_disk.go
@@ -20,6 +20,7 @@ type StepCreateNewDisk struct {
 	DiskStorageAccountType                  string // from compute.DiskStorageAccountTypes
 	HyperVGeneration                        string
 	Location                                string
+	PlatformImage                           *client.PlatformImage
 }
 
 func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
@@ -42,10 +43,8 @@ func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) mu
 		DiskProperties: &compute.DiskProperties{
 			OsType:           "Linux",
 			HyperVGeneration: compute.HyperVGeneration(s.HyperVGeneration),
-			CreationData: &compute.CreationData{
-				CreateOption: compute.Empty,
-			},
-			DiskSizeGB: to.Int32Ptr(s.DiskSizeGB),
+			CreationData:     &compute.CreationData{},
+			DiskSizeGB:       to.Int32Ptr(s.DiskSizeGB),
 		},
 		//Tags: map[string]*string{
 	}
@@ -54,6 +53,17 @@ func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) mu
 		disk.DiskProperties.DiskSizeGB = to.Int32Ptr(s.DiskSizeGB)
 	}
 
+	if s.PlatformImage == nil {
+		disk.CreationData.CreateOption = compute.Empty
+	} else {
+		disk.CreationData.CreateOption = compute.FromImage
+		disk.CreationData.ImageReference = &compute.ImageDiskReference{
+			ID: to.StringPtr(fmt.Sprintf(
+				"/subscriptions/%s/providers/Microsoft.Compute/locations/%s/publishers/%s/artifacttypes/vmimage/offers/%s/skus/%s/versions/%s",
+				s.SubscriptionID, s.Location, s.PlatformImage.Publisher, s.PlatformImage.Offer, s.PlatformImage.Sku, s.PlatformImage.Version)),
+		}
+	}
+
 	f, err := azcli.DisksClient().CreateOrUpdate(ctx, s.ResourceGroup, s.DiskName, disk)
 	if err == nil {
 		err = f.WaitForCompletionRef(ctx, azcli.PollClient())

From 6dee4d2d323485768c461cab6a98a5a858c249a7 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Mon, 3 Jun 2019 23:01:53 +0000
Subject: [PATCH 109/155] Wait for detach optimization

---
 builder/azure/chroot/diskattacher.go         | 10 +++++++---
 builder/azure/chroot/step_create_new_disk.go |  7 +++++--
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/builder/azure/chroot/diskattacher.go b/builder/azure/chroot/diskattacher.go
index 97ba4174c..c52e294eb 100644
--- a/builder/azure/chroot/diskattacher.go
+++ b/builder/azure/chroot/diskattacher.go
@@ -20,9 +20,10 @@ import (
 
 type DiskAttacher interface {
 	AttachDisk(ctx context.Context, disk string) (lun int32, err error)
-	DetachDisk(ctx context.Context, disk string) (err error)
-	WaitForDevice(ctx context.Context, i int32) (device string, err error)
 	DiskPathForLun(lun int32) string
+	WaitForDevice(ctx context.Context, i int32) (device string, err error)
+	DetachDisk(ctx context.Context, disk string) (err error)
+	WaitForDetach(ctx context.Context, diskID string) error
 }
 
 func NewDiskAttacher(azureClient client.AzureClientSet) DiskAttacher {
@@ -89,7 +90,10 @@ func (da *diskAttacher) DetachDisk(ctx context.Context, diskID string) error {
 		return err
 	}
 
-	// waiting for VM update to finish takes way to long
+	return nil
+}
+
+func (da *diskAttacher) WaitForDetach(ctx context.Context, diskID string) error {
 	for { // loop until disk is not attached, timeout or error
 		list, err := da.getDisks(ctx)
 		if err != nil {
diff --git a/builder/azure/chroot/step_create_new_disk.go b/builder/azure/chroot/step_create_new_disk.go
index 6873c827a..8d334a76a 100644
--- a/builder/azure/chroot/step_create_new_disk.go
+++ b/builder/azure/chroot/step_create_new_disk.go
@@ -83,9 +83,12 @@ func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) mu
 func (s StepCreateNewDisk) Cleanup(state multistep.StateBag) {
 	azcli := state.Get("azureclient").(client.AzureClientSet)
 	ui := state.Get("ui").(packer.Ui)
-	diskResourceID := state.Get("os_disk_resource_id")
+	diskResourceID := state.Get("os_disk_resource_id").(string)
 
-	ui.Say(fmt.Sprintf("Deleting disk '%s'", diskResourceID))
+	ui.Say(fmt.Sprintf("Waiting for disk %q detach to complete", diskResourceID))
+	err := NewDiskAttacher(azcli).WaitForDetach(context.Background(), diskResourceID)
+
+	ui.Say(fmt.Sprintf("Deleting disk %q", diskResourceID))
 
 	f, err := azcli.DisksClient().Delete(context.TODO(), s.ResourceGroup, s.DiskName)
 	if err == nil {

From 57cff8961a1b565e2f26a111281a92d8ecba6a95 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Mon, 3 Jun 2019 23:06:19 +0000
Subject: [PATCH 110/155] Allow skipping OSDisk cleanup

---
 builder/azure/chroot/builder.go              |  3 ++
 builder/azure/chroot/step_create_new_disk.go | 30 +++++++++++---------
 2 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index abc75d677..398b2230e 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -43,6 +43,7 @@ type Config struct {
 	OSDiskSizeGB             int32  `mapstructure:"os_disk_size_gb"`
 	OSDiskStorageAccountType string `mapstructure:"os_disk_storage_account_type"`
 	OSDiskCacheType          string `mapstructure:"os_disk_cache_type"`
+	OSDiskSkipCleanup        bool   `mapstructure:"os_disk_skip_cleanup"`
 
 	ImageResourceID       string `mapstructure:"image_resource_id"`
 	ImageOSState          string `mapstructure:"image_os_state"`
@@ -320,6 +321,8 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 					HyperVGeneration:       b.config.ImageHyperVGeneration,
 					Location:               info.Location,
 					PlatformImage:          pi,
+
+					SkipCleanup: b.config.OSDiskSkipCleanup,
 				})
 		} else {
 			panic("Unknown image source: " + b.config.Source)
diff --git a/builder/azure/chroot/step_create_new_disk.go b/builder/azure/chroot/step_create_new_disk.go
index 8d334a76a..d8df8b6b2 100644
--- a/builder/azure/chroot/step_create_new_disk.go
+++ b/builder/azure/chroot/step_create_new_disk.go
@@ -21,6 +21,8 @@ type StepCreateNewDisk struct {
 	HyperVGeneration                        string
 	Location                                string
 	PlatformImage                           *client.PlatformImage
+
+	SkipCleanup bool
 }
 
 func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
@@ -81,21 +83,23 @@ func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) mu
 }
 
 func (s StepCreateNewDisk) Cleanup(state multistep.StateBag) {
-	azcli := state.Get("azureclient").(client.AzureClientSet)
-	ui := state.Get("ui").(packer.Ui)
-	diskResourceID := state.Get("os_disk_resource_id").(string)
+	if !s.SkipCleanup {
+		azcli := state.Get("azureclient").(client.AzureClientSet)
+		ui := state.Get("ui").(packer.Ui)
+		diskResourceID := state.Get("os_disk_resource_id").(string)
 
-	ui.Say(fmt.Sprintf("Waiting for disk %q detach to complete", diskResourceID))
-	err := NewDiskAttacher(azcli).WaitForDetach(context.Background(), diskResourceID)
+		ui.Say(fmt.Sprintf("Waiting for disk %q detach to complete", diskResourceID))
+		err := NewDiskAttacher(azcli).WaitForDetach(context.Background(), diskResourceID)
 
-	ui.Say(fmt.Sprintf("Deleting disk %q", diskResourceID))
+		ui.Say(fmt.Sprintf("Deleting disk %q", diskResourceID))
 
-	f, err := azcli.DisksClient().Delete(context.TODO(), s.ResourceGroup, s.DiskName)
-	if err == nil {
-		err = f.WaitForCompletionRef(context.TODO(), azcli.PollClient())
-	}
-	if err != nil {
-		log.Printf("StepCreateNewDisk.Cleanup: error: %+v", err)
-		ui.Error(fmt.Sprintf("error deleting new disk '%s': %v.", diskResourceID, err))
+		f, err := azcli.DisksClient().Delete(context.TODO(), s.ResourceGroup, s.DiskName)
+		if err == nil {
+			err = f.WaitForCompletionRef(context.TODO(), azcli.PollClient())
+		}
+		if err != nil {
+			log.Printf("StepCreateNewDisk.Cleanup: error: %+v", err)
+			ui.Error(fmt.Sprintf("error deleting new disk '%s': %v.", diskResourceID, err))
+		}
 	}
 }

From eff3f2bdcfe694ea64a80f71c7b64e22abb97858 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Thu, 15 Aug 2019 20:05:36 +0000
Subject: [PATCH 111/155] Add test for disk input validation

---
 builder/azure/chroot/builder_test.go | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 builder/azure/chroot/builder_test.go

diff --git a/builder/azure/chroot/builder_test.go b/builder/azure/chroot/builder_test.go
new file mode 100644
index 000000000..707cdf196
--- /dev/null
+++ b/builder/azure/chroot/builder_test.go
@@ -0,0 +1,28 @@
+package chroot
+
+import (
+	"regexp"
+	"testing"
+
+	"github.com/hashicorp/packer/packer"
+)
+
+func TestBuilder_Prepare_DiskAsInput(t *testing.T) {
+	b := Builder{}
+	_, err := b.Prepare(map[string]interface{}{
+		"source": "/subscriptions/28279221-ccbe-40f0-b70b-4d78ab822e09/resourceGroups/testrg/providers/Microsoft.Compute/disks/diskname",
+	})
+
+	if err != nil {
+		// make sure there is no error about the source field
+		errs, ok := err.(*packer.MultiError)
+		if !ok {
+			t.Error("Expected the returned error to be of type packer.MultiError")
+		}
+		for _, err := range errs.Errors {
+			if matched, _:=regexp.MatchString(`(^|\W)source\W`,err.Error()); matched {
+				t.Errorf("Did not expect an error about the 'source' field, but found %q", err)
+			}
+		}
+	}
+}

From 27a5bfe11c7ff4c7a78e1f2cbe60c45eed8643a9 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Tue, 10 Sep 2019 12:48:55 +0000
Subject: [PATCH 112/155] Add implementation for disk as source

---
 builder/azure/chroot/builder.go               | 61 ++++++++++++----
 builder/azure/chroot/step_create_new_disk.go  | 12 +++-
 .../azure/chroot/step_create_new_disk_test.go | 69 +++++++++++++++++++
 .../common/client/azure_client_set_mock.go    | 46 +++++++++++++
 4 files changed, 171 insertions(+), 17 deletions(-)
 create mode 100644 builder/azure/chroot/step_create_new_disk_test.go
 create mode 100644 builder/azure/common/client/azure_client_set_mock.go

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index 398b2230e..4b07916a6 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -4,8 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/Azure/go-autorest/autorest/azure"
-	"github.com/Azure/go-autorest/autorest/to"
 	"log"
 	"runtime"
 	"strings"
@@ -20,6 +18,8 @@ import (
 	"github.com/hashicorp/packer/template/interpolate"
 
 	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/to"
 )
 
 type Config struct {
@@ -29,6 +29,7 @@ type Config struct {
 
 	FromScratch bool   `mapstructure:"from_scratch"`
 	Source      string `mapstructure:"source"`
+	sourceType  sourceType
 
 	CommandWrapper    string     `mapstructure:"command_wrapper"`
 	PreMountCommands  []string   `mapstructure:"pre_mount_commands"`
@@ -52,6 +53,13 @@ type Config struct {
 	ctx interpolate.Context
 }
 
+type sourceType string
+
+const (
+	sourcePlatformImage sourceType = "PlatformImage"
+	sourceDisk          sourceType = "Disk"
+)
+
 func (c *Config) GetContext() interpolate.Context {
 	return c.ctx
 }
@@ -163,9 +171,14 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	} else {
 		if _, err := client.ParsePlatformImageURN(b.config.Source); err == nil {
 			log.Println("Source is platform image:", b.config.Source)
+			b.config.sourceType = sourcePlatformImage
+		} else if id, err := azure.ParseResourceID(b.config.Source); err == nil &&
+			strings.EqualFold(id.Provider, "Microsoft.Compute") && strings.EqualFold(id.ResourceType, "disks") {
+			log.Println("Source is a disk resource ID:", b.config.Source)
+			b.config.sourceType = sourceDisk
 		} else {
 			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("source: %q is not a valid platform image specifier", b.config.Source))
+				errs, fmt.Errorf("source: %q is not a valid platform image specifier, nor is it a disk resource ID", b.config.Source))
 		}
 	}
 
@@ -301,16 +314,36 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 				Location:               info.Location,
 			})
 	} else {
-		if pi, err := client.ParsePlatformImageURN(b.config.Source); err == nil {
-			if strings.EqualFold(pi.Version, "latest") {
+		switch b.config.sourceType {
+		case sourcePlatformImage:
 
-				vmi, err := azcli.VirtualMachineImagesClient().GetLatest(ctx, pi.Publisher, pi.Offer, pi.Sku, info.Location)
-				if err != nil {
-					return nil, fmt.Errorf("error retieving latest version of %q: %v", b.config.Source, err)
+			if pi, err := client.ParsePlatformImageURN(b.config.Source); err == nil {
+				if strings.EqualFold(pi.Version, "latest") {
+
+					vmi, err := azcli.VirtualMachineImagesClient().GetLatest(ctx, pi.Publisher, pi.Offer, pi.Sku, info.Location)
+					if err != nil {
+						return nil, fmt.Errorf("error retieving latest version of %q: %v", b.config.Source, err)
+					}
+					pi.Version = to.String(vmi.Name)
+					log.Println("Resolved latest version of source image:", pi.Version)
 				}
-				pi.Version = to.String(vmi.Name)
-				log.Println("Resolved latest version of source image:", pi.Version)
+				steps = append(steps,
+					&StepCreateNewDisk{
+						SubscriptionID:         info.SubscriptionID,
+						ResourceGroup:          info.ResourceGroupName,
+						DiskName:               b.config.TemporaryOSDiskName,
+						DiskSizeGB:             b.config.OSDiskSizeGB,
+						DiskStorageAccountType: b.config.OSDiskStorageAccountType,
+						HyperVGeneration:       b.config.ImageHyperVGeneration,
+						Location:               info.Location,
+						PlatformImage:          pi,
+
+						SkipCleanup: b.config.OSDiskSkipCleanup,
+					})
+			} else {
+				panic("Unknown image source: " + b.config.Source)
 			}
+		case sourceDisk:
 			steps = append(steps,
 				&StepCreateNewDisk{
 					SubscriptionID:         info.SubscriptionID,
@@ -319,13 +352,13 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 					DiskSizeGB:             b.config.OSDiskSizeGB,
 					DiskStorageAccountType: b.config.OSDiskStorageAccountType,
 					HyperVGeneration:       b.config.ImageHyperVGeneration,
-					Location:               info.Location,
-					PlatformImage:          pi,
+					SourceDiskResourceID:   b.config.Source,
+					//todo(paulmey) validate that source disk is in same location as VM
 
 					SkipCleanup: b.config.OSDiskSkipCleanup,
 				})
-		} else {
-			panic("Unknown image source: " + b.config.Source)
+		default:
+			panic(fmt.Errorf("Unknown source type: %+q", b.config.sourceType))
 		}
 	}
 
diff --git a/builder/azure/chroot/step_create_new_disk.go b/builder/azure/chroot/step_create_new_disk.go
index d8df8b6b2..ed5844c4e 100644
--- a/builder/azure/chroot/step_create_new_disk.go
+++ b/builder/azure/chroot/step_create_new_disk.go
@@ -19,8 +19,11 @@ type StepCreateNewDisk struct {
 	DiskSizeGB                              int32  // optional, ignored if 0
 	DiskStorageAccountType                  string // from compute.DiskStorageAccountTypes
 	HyperVGeneration                        string
-	Location                                string
-	PlatformImage                           *client.PlatformImage
+
+	Location      string
+	PlatformImage *client.PlatformImage
+
+	SourceDiskResourceID string
 
 	SkipCleanup bool
 }
@@ -55,7 +58,10 @@ func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) mu
 		disk.DiskProperties.DiskSizeGB = to.Int32Ptr(s.DiskSizeGB)
 	}
 
-	if s.PlatformImage == nil {
+	if s.SourceDiskResourceID != "" {
+		disk.CreationData.CreateOption = compute.Copy
+		disk.CreationData.SourceResourceID = to.StringPtr(s.SourceDiskResourceID)
+	} else if s.PlatformImage == nil {
 		disk.CreationData.CreateOption = compute.Empty
 	} else {
 		disk.CreationData.CreateOption = compute.FromImage
diff --git a/builder/azure/chroot/step_create_new_disk_test.go b/builder/azure/chroot/step_create_new_disk_test.go
new file mode 100644
index 000000000..f0488ade7
--- /dev/null
+++ b/builder/azure/chroot/step_create_new_disk_test.go
@@ -0,0 +1,69 @@
+package chroot
+
+import (
+	"context"
+	"io/ioutil"
+	"net/http"
+	"regexp"
+	"testing"
+
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
+		"github.com/Azure/go-autorest/autorest"
+	"github.com/hashicorp/packer/builder/azure/common/client"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+)
+
+func Test_StepCreateNewDisk_FromDisk(t *testing.T) {
+	sut := StepCreateNewDisk{
+		SubscriptionID:         "SubscriptionID",
+		ResourceGroup:          "ResourceGroupName",
+		DiskName:               "TemporaryOSDiskName",
+		DiskSizeGB:             42,
+		DiskStorageAccountType: string(compute.PremiumLRS),
+		HyperVGeneration:       string(compute.V1),
+		Location:               "westus",
+		SourceDiskResourceID:   "SourceDisk",
+	}
+
+	expected := regexp.MustCompile(`[\s\n]`).ReplaceAllString(`
+{
+	"location": "westus",
+	"properties": {
+		"osType": "Linux",
+		"hyperVGeneration": "V1",
+		"creationData": {
+			"createOption": "Copy",
+			"sourceResourceId": "SourceDisk"
+		},
+		"diskSizeGB": 42
+	},
+	"sku": {
+		"name": "Premium_LRS"
+	}
+}`, "")
+
+	m := compute.NewDisksClient("subscriptionId")
+	m.Sender = autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
+		b, _ := ioutil.ReadAll(r.Body)
+		if string(b) != expected {
+			t.Fatalf("expected body to be %q, but got %q", expected, string(b))
+		}
+		return &http.Response{
+			Request:    r,
+			StatusCode: 200,
+		}, nil
+	})
+
+	state := new(multistep.BasicStateBag)
+	state.Put("azureclient", &client.AzureClientSetMock{
+		DisksClientMock: m,
+	})
+	state.Put("ui", packer.TestUi(t))
+
+	r := sut.Run(context.TODO(), state)
+
+	if r != multistep.ActionContinue {
+		t.Fatal("Run failed")
+	}
+}
diff --git a/builder/azure/common/client/azure_client_set_mock.go b/builder/azure/common/client/azure_client_set_mock.go
new file mode 100644
index 000000000..9f4a34b1c
--- /dev/null
+++ b/builder/azure/common/client/azure_client_set_mock.go
@@ -0,0 +1,46 @@
+package client
+
+import (
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/computeapi"
+	"github.com/Azure/go-autorest/autorest"
+)
+
+// AzureClientSetMock provides a generic mock for AzureClientSet
+type AzureClientSetMock struct {
+	DisksClientMock                computeapi.DisksClientAPI
+	ImagesClientMock               computeapi.ImagesClientAPI
+	VirtualMachineImagesClientMock VirtualMachineImagesClientAPI
+	VirtualMachinesClientMock      computeapi.VirtualMachinesClientAPI
+	PollClientMock                 autorest.Client
+	MetadataClientMock             MetadataClientAPI
+}
+
+// DisksClient returns a DisksClientAPI
+func (m *AzureClientSetMock) DisksClient() computeapi.DisksClientAPI {
+	return m.DisksClientMock
+}
+
+// ImagesClient returns a ImagesClientAPI
+func (m *AzureClientSetMock) ImagesClient() computeapi.ImagesClientAPI {
+	return m.ImagesClientMock
+}
+
+// VirtualMachineImagesClient returns a VirtualMachineImagesClientAPI
+func (m *AzureClientSetMock) VirtualMachineImagesClient() VirtualMachineImagesClientAPI {
+	return m.VirtualMachineImagesClientMock
+}
+
+// VirtualMachinesClient returns a VirtualMachinesClientAPI
+func (m *AzureClientSetMock) VirtualMachinesClient() computeapi.VirtualMachinesClientAPI {
+	return m.VirtualMachinesClientMock
+}
+
+// PollClient returns an autorest Client that can be used for polling async requests
+func (m *AzureClientSetMock) PollClient() autorest.Client {
+	return m.PollClientMock
+}
+
+// MetadataClient returns a MetadataClientAPI
+func (m *AzureClientSetMock) MetadataClient() MetadataClientAPI {
+	return m.MetadataClientMock
+}

From cb729e5a3872cdc86a42bad82a9f6597f6b2d42a Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Thu, 26 Sep 2019 18:44:35 +0000
Subject: [PATCH 113/155] Add documentation to config struct

---
 builder/azure/chroot/builder.go               | 72 +++++++++++++------
 .../azure/chroot/step_create_new_disk_test.go |  2 +-
 .../azure/chroot/_Config-not-required.html.md | 50 +++++++++++++
 .../azure/chroot/_Config-required.html.md     |  6 ++
 .../builder/azure/chroot/_Config.html.md      |  3 +
 5 files changed, 109 insertions(+), 24 deletions(-)
 create mode 100644 website/source/partials/builder/azure/chroot/_Config-not-required.html.md
 create mode 100644 website/source/partials/builder/azure/chroot/_Config-required.html.md
 create mode 100644 website/source/partials/builder/azure/chroot/_Config.html.md

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index 4b07916a6..f2f14f407 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -1,3 +1,9 @@
+//go:generate struct-markdown
+
+// Package chroot is able to create an Azure manage image without requiring the
+// launch of a new instance for every build. It does this by attaching and
+// mounting the root disk and chrooting into that directory.
+// It then creates a managed image from that attached disk.
 package chroot
 
 import (
@@ -22,32 +28,68 @@ import (
 	"github.com/Azure/go-autorest/autorest/to"
 )
 
+// Config is the configuration that is chained through the steps and settable
+// from the template.
 type Config struct {
 	common.PackerConfig `mapstructure:",squash"`
 
 	ClientConfig client.Config `mapstructure:",squash"`
 
+	// When set to `true`, starts with an empty, unpartitioned disk. Defaults to `false`.
 	FromScratch bool   `mapstructure:"from_scratch"`
-	Source      string `mapstructure:"source"`
+	// Either a managed disk resourced ID or a publisher:offer:sku:version specifier for plaform image sources.
+	Source      string `mapstructure:"source" required:"true"`
 	sourceType  sourceType
 
+	// How to run shell commands. This may be useful to set environment variables or perhaps run
+	// a command with sudo or so on. This is a configuration template where the `.Command` variable
+	// is replaced with the command to be run. Defaults to `{{.Command}}`.
 	CommandWrapper    string     `mapstructure:"command_wrapper"`
+	// A series of commands to execute after attaching the root volume and before mounting the chroot. 
+	// This is not required unless using `from_scratch`. If so, this should include any partitioning 
+	// and filesystem creation commands. The path to the device is provided by `{{.Device}}`.
 	PreMountCommands  []string   `mapstructure:"pre_mount_commands"`
+	// Options to supply the `mount` command when mounting devices. Each option will be prefixed with 
+	// `-o` and supplied to the `mount` command ran by Packer. Because this command is ran in a shell,
+	// user discretion is advised. See this manual page for the `mount` command for valid file system specific options.
 	MountOptions      []string   `mapstructure:"mount_options"`
+	// The partition number containing the / partition. By default this is the first partition of the volume.
 	MountPartition    string     `mapstructure:"mount_partition"`
+	// The path where the volume will be mounted. This is where the chroot environment will be. This defaults
+	// to `/mnt/packer-amazon-chroot-volumes/{{.Device}}`. This is a configuration template where the `.Device` 
+	// variable is replaced with the name of the device where the volume is attached.
 	MountPath         string     `mapstructure:"mount_path"`
+	// As `pre_mount_commands`, but the commands are executed after mounting the root device and before the
+	// extra mount and copy steps. The device and mount path are provided by `{{.Device}}` and `{{.MountPath}}`.
 	PostMountCommands []string   `mapstructure:"post_mount_commands"`
+	// This is a list of devices to mount into the chroot environment. This configuration parameter requires 
+	// some additional documentation which is in the "Chroot Mounts" section below. Please read that section
+	// for more information on how to use this.
 	ChrootMounts      [][]string `mapstructure:"chroot_mounts"`
+	// Paths to files on the running Azure instance that will be copied into the chroot environment prior to 
+	// provisioning. Defaults to `/etc/resolv.conf` so that DNS lookups work. Pass an empty list to skip copying
+	// `/etc/resolv.conf`. You may need to do this if you're building an image that uses systemd.
 	CopyFiles         []string   `mapstructure:"copy_files"`
 
+	// The name of the temporary disk that will be created in the resource group of the VM that Packer is
+	// running on. Will be generated if not set.
 	TemporaryOSDiskName      string `mapstructure:"temporary_os_disk_name"`
+	// Try to resize the OS disk to this size on the first copy. Disks can only be englarged. If not specified,
+	// the disk will keep its original size. Required when using `from_scratch`
 	OSDiskSizeGB             int32  `mapstructure:"os_disk_size_gb"`
+	// The [storage SKU](https://docs.microsoft.com/en-us/rest/api/compute/disks/createorupdate#diskstorageaccounttypes)
+	// to use for the OS Disk. Defaults to `Standard_LRS`.
 	OSDiskStorageAccountType string `mapstructure:"os_disk_storage_account_type"`
+	// The [cache type](https://docs.microsoft.com/en-us/rest/api/compute/images/createorupdate#cachingtypes)
+	// specified in the resulting image and for attaching it to the Packer VM. Defaults to `ReadOnly`
 	OSDiskCacheType          string `mapstructure:"os_disk_cache_type"`
+	// If set to `true`, leaves the temporary disk behind in the Packer VM resource group. Defaults to `false`
 	OSDiskSkipCleanup        bool   `mapstructure:"os_disk_skip_cleanup"`
 
-	ImageResourceID       string `mapstructure:"image_resource_id"`
-	ImageOSState          string `mapstructure:"image_os_state"`
+	// The image to create using this build.
+	ImageResourceID       string `mapstructure:"image_resource_id" required:"true"`
+	// The [Hyper-V generation type](https://docs.microsoft.com/en-us/rest/api/compute/images/createorupdate#hypervgenerationtypes).
+	// Defaults to `V2`.
 	ImageHyperVGeneration string `mapstructure:"image_hyperv_generation"`
 
 	ctx interpolate.Context
@@ -60,6 +102,8 @@ const (
 	sourceDisk          sourceType = "Disk"
 )
 
+// GetContext implements ContextProvider to allow steps to use the config context 
+// for template interpolation
 func (c *Config) GetContext() interpolate.Context {
 	return c.ctx
 }
@@ -145,12 +189,8 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.OSDiskCacheType = string(compute.CachingTypesReadOnly)
 	}
 
-	if b.config.ImageOSState == "" {
-		b.config.ImageOSState = string(compute.Generalized)
-	}
-
 	if b.config.ImageHyperVGeneration == "" {
-		b.config.ImageHyperVGeneration = string(compute.V1)
+		b.config.ImageHyperVGeneration = string(compute.V2)
 	}
 
 	// checks, accumulate any errors or warnings
@@ -202,10 +242,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		}
 	}
 
-	if err := checkOSState(b.config.ImageOSState); err != nil {
-		errs = packer.MultiErrorAppend(errs, fmt.Errorf("image_os_state: %v", err))
-	}
-
 	if err := checkHyperVGeneration(b.config.ImageHyperVGeneration); err != nil {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("image_hyperv_generation: %v", err))
 	}
@@ -218,16 +254,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	return warns, nil
 }
 
-func checkOSState(s string) interface{} {
-	for _, v := range compute.PossibleOperatingSystemStateTypesValues() {
-		if compute.OperatingSystemStateTypes(s) == v {
-			return nil
-		}
-	}
-	return fmt.Errorf("%q is not a valid value %v",
-		s, compute.PossibleOperatingSystemStateTypesValues())
-}
-
 func checkDiskCacheType(s string) interface{} {
 	for _, v := range compute.PossibleCachingTypesValues() {
 		if compute.CachingTypes(s) == v {
@@ -385,7 +411,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&chroot.StepEarlyCleanup{},
 		&StepCreateImage{
 			ImageResourceID:          b.config.ImageResourceID,
-			ImageOSState:             b.config.ImageOSState,
+			ImageOSState:             string(compute.Generalized),
 			OSDiskCacheType:          b.config.OSDiskCacheType,
 			OSDiskStorageAccountType: b.config.OSDiskStorageAccountType,
 			Location:                 info.Location,
diff --git a/builder/azure/chroot/step_create_new_disk_test.go b/builder/azure/chroot/step_create_new_disk_test.go
index f0488ade7..dc95a8b8e 100644
--- a/builder/azure/chroot/step_create_new_disk_test.go
+++ b/builder/azure/chroot/step_create_new_disk_test.go
@@ -8,7 +8,7 @@ import (
 	"testing"
 
 	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
-		"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest"
 	"github.com/hashicorp/packer/builder/azure/common/client"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
diff --git a/website/source/partials/builder/azure/chroot/_Config-not-required.html.md b/website/source/partials/builder/azure/chroot/_Config-not-required.html.md
new file mode 100644
index 000000000..8f8556919
--- /dev/null
+++ b/website/source/partials/builder/azure/chroot/_Config-not-required.html.md
@@ -0,0 +1,50 @@
+<!-- Code generated from the comments of the Config struct in builder/azure/chroot/builder.go; DO NOT EDIT MANUALLY -->
+
+-   `from_scratch` (bool) - When set to `true`, starts with an empty, unpartitioned disk. Defaults to `false`.
+    
+-   `command_wrapper` (string) - How to run shell commands. This may be useful to set environment variables or perhaps run
+    a command with sudo or so on. This is a configuration template where the `.Command` variable
+    is replaced with the command to be run. Defaults to `{{.Command}}`.
+    
+-   `pre_mount_commands` ([]string) - A series of commands to execute after attaching the root volume and before mounting the chroot.
+    This is not required unless using `from_scratch`. If so, this should include any partitioning
+    and filesystem creation commands. The path to the device is provided by `{{.Device}}`.
+    
+-   `mount_options` ([]string) - Options to supply the `mount` command when mounting devices. Each option will be prefixed with
+    `-o` and supplied to the `mount` command ran by Packer. Because this command is ran in a shell,
+    user discretion is advised. See this manual page for the `mount` command for valid file system specific options.
+    
+-   `mount_partition` (string) - The partition number containing the / partition. By default this is the first partition of the volume.
+    
+-   `mount_path` (string) - The path where the volume will be mounted. This is where the chroot environment will be. This defaults
+    to `/mnt/packer-amazon-chroot-volumes/{{.Device}}`. This is a configuration template where the `.Device`
+    variable is replaced with the name of the device where the volume is attached.
+    
+-   `post_mount_commands` ([]string) - As `pre_mount_commands`, but the commands are executed after mounting the root device and before the
+    extra mount and copy steps. The device and mount path are provided by `{{.Device}}` and `{{.MountPath}}`.
+    
+-   `chroot_mounts` ([][]string) - This is a list of devices to mount into the chroot environment. This configuration parameter requires
+    some additional documentation which is in the "Chroot Mounts" section below. Please read that section
+    for more information on how to use this.
+    
+-   `copy_files` ([]string) - Paths to files on the running Azure instance that will be copied into the chroot environment prior to
+    provisioning. Defaults to `/etc/resolv.conf` so that DNS lookups work. Pass an empty list to skip copying
+    `/etc/resolv.conf`. You may need to do this if you're building an image that uses systemd.
+    
+-   `temporary_os_disk_name` (string) - The name of the temporary disk that will be created in the resource group of the VM that Packer is
+    running on. Will be generated if not set.
+    
+-   `os_disk_size_gb` (int32) - Try to resize the OS disk to this size on the first copy. Disks can only be englarged. If not specified,
+    the disk will keep its original size. Required when using `from_scratch`
+    
+-   `os_disk_storage_account_type` (string) - The [storage SKU](https://docs.microsoft.com/en-us/rest/api/compute/disks/createorupdate#diskstorageaccounttypes)
+    to use for the OS Disk. Defaults to `Standard_LRS`.
+    
+-   `os_disk_cache_type` (string) - The [cache type](https://docs.microsoft.com/en-us/rest/api/compute/images/createorupdate#cachingtypes)
+    specified in the resulting image and for attaching it to the Packer VM. Defaults to `ReadOnly`
+    
+-   `os_disk_skip_cleanup` (bool) - If set to `true`, leaves the temporary disk behind in the Packer VM resource group. Defaults to `false`
+    
+-   `image_hyperv_generation` (string) - The [Hyper-V generation type](https://docs.microsoft.com/en-us/rest/api/compute/images/createorupdate#hypervgenerationtypes).
+    Defaults to `V2`.
+    
\ No newline at end of file
diff --git a/website/source/partials/builder/azure/chroot/_Config-required.html.md b/website/source/partials/builder/azure/chroot/_Config-required.html.md
new file mode 100644
index 000000000..e24734560
--- /dev/null
+++ b/website/source/partials/builder/azure/chroot/_Config-required.html.md
@@ -0,0 +1,6 @@
+<!-- Code generated from the comments of the Config struct in builder/azure/chroot/builder.go; DO NOT EDIT MANUALLY -->
+
+-   `source` (string) - Either a managed disk resourced ID or a publisher:offer:sku:version specifier for plaform image sources.
+    
+-   `image_resource_id` (string) - The image to create using this build.
+    
\ No newline at end of file
diff --git a/website/source/partials/builder/azure/chroot/_Config.html.md b/website/source/partials/builder/azure/chroot/_Config.html.md
new file mode 100644
index 000000000..147c5b9c7
--- /dev/null
+++ b/website/source/partials/builder/azure/chroot/_Config.html.md
@@ -0,0 +1,3 @@
+<!-- Code generated from the comments of the Config struct in builder/azure/chroot/builder.go; DO NOT EDIT MANUALLY -->
+Config is the configuration that is chained through the steps and settable
+from the template.

From 11ef06b94d853bcefeb0e48e79178741c6dc3ab2 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Thu, 26 Sep 2019 22:17:07 +0000
Subject: [PATCH 114/155] Add StepVerifySourceDisk

---
 builder/azure/chroot/builder.go               |  54 ++++---
 .../azure/chroot/step_verify_source_disk.go   |  65 ++++++++
 .../chroot/step_verify_source_disk_test.go    | 146 ++++++++++++++++++
 3 files changed, 241 insertions(+), 24 deletions(-)
 create mode 100644 builder/azure/chroot/step_verify_source_disk.go
 create mode 100644 builder/azure/chroot/step_verify_source_disk_test.go

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index f2f14f407..c476b2fd1 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -36,58 +36,58 @@ type Config struct {
 	ClientConfig client.Config `mapstructure:",squash"`
 
 	// When set to `true`, starts with an empty, unpartitioned disk. Defaults to `false`.
-	FromScratch bool   `mapstructure:"from_scratch"`
+	FromScratch bool `mapstructure:"from_scratch"`
 	// Either a managed disk resourced ID or a publisher:offer:sku:version specifier for plaform image sources.
-	Source      string `mapstructure:"source" required:"true"`
-	sourceType  sourceType
+	Source     string `mapstructure:"source" required:"true"`
+	sourceType sourceType
 
 	// How to run shell commands. This may be useful to set environment variables or perhaps run
 	// a command with sudo or so on. This is a configuration template where the `.Command` variable
 	// is replaced with the command to be run. Defaults to `{{.Command}}`.
-	CommandWrapper    string     `mapstructure:"command_wrapper"`
-	// A series of commands to execute after attaching the root volume and before mounting the chroot. 
-	// This is not required unless using `from_scratch`. If so, this should include any partitioning 
+	CommandWrapper string `mapstructure:"command_wrapper"`
+	// A series of commands to execute after attaching the root volume and before mounting the chroot.
+	// This is not required unless using `from_scratch`. If so, this should include any partitioning
 	// and filesystem creation commands. The path to the device is provided by `{{.Device}}`.
-	PreMountCommands  []string   `mapstructure:"pre_mount_commands"`
-	// Options to supply the `mount` command when mounting devices. Each option will be prefixed with 
+	PreMountCommands []string `mapstructure:"pre_mount_commands"`
+	// Options to supply the `mount` command when mounting devices. Each option will be prefixed with
 	// `-o` and supplied to the `mount` command ran by Packer. Because this command is ran in a shell,
 	// user discretion is advised. See this manual page for the `mount` command for valid file system specific options.
-	MountOptions      []string   `mapstructure:"mount_options"`
+	MountOptions []string `mapstructure:"mount_options"`
 	// The partition number containing the / partition. By default this is the first partition of the volume.
-	MountPartition    string     `mapstructure:"mount_partition"`
+	MountPartition string `mapstructure:"mount_partition"`
 	// The path where the volume will be mounted. This is where the chroot environment will be. This defaults
-	// to `/mnt/packer-amazon-chroot-volumes/{{.Device}}`. This is a configuration template where the `.Device` 
+	// to `/mnt/packer-amazon-chroot-volumes/{{.Device}}`. This is a configuration template where the `.Device`
 	// variable is replaced with the name of the device where the volume is attached.
-	MountPath         string     `mapstructure:"mount_path"`
+	MountPath string `mapstructure:"mount_path"`
 	// As `pre_mount_commands`, but the commands are executed after mounting the root device and before the
 	// extra mount and copy steps. The device and mount path are provided by `{{.Device}}` and `{{.MountPath}}`.
-	PostMountCommands []string   `mapstructure:"post_mount_commands"`
-	// This is a list of devices to mount into the chroot environment. This configuration parameter requires 
+	PostMountCommands []string `mapstructure:"post_mount_commands"`
+	// This is a list of devices to mount into the chroot environment. This configuration parameter requires
 	// some additional documentation which is in the "Chroot Mounts" section below. Please read that section
 	// for more information on how to use this.
-	ChrootMounts      [][]string `mapstructure:"chroot_mounts"`
-	// Paths to files on the running Azure instance that will be copied into the chroot environment prior to 
+	ChrootMounts [][]string `mapstructure:"chroot_mounts"`
+	// Paths to files on the running Azure instance that will be copied into the chroot environment prior to
 	// provisioning. Defaults to `/etc/resolv.conf` so that DNS lookups work. Pass an empty list to skip copying
 	// `/etc/resolv.conf`. You may need to do this if you're building an image that uses systemd.
-	CopyFiles         []string   `mapstructure:"copy_files"`
+	CopyFiles []string `mapstructure:"copy_files"`
 
 	// The name of the temporary disk that will be created in the resource group of the VM that Packer is
 	// running on. Will be generated if not set.
-	TemporaryOSDiskName      string `mapstructure:"temporary_os_disk_name"`
+	TemporaryOSDiskName string `mapstructure:"temporary_os_disk_name"`
 	// Try to resize the OS disk to this size on the first copy. Disks can only be englarged. If not specified,
 	// the disk will keep its original size. Required when using `from_scratch`
-	OSDiskSizeGB             int32  `mapstructure:"os_disk_size_gb"`
+	OSDiskSizeGB int32 `mapstructure:"os_disk_size_gb"`
 	// The [storage SKU](https://docs.microsoft.com/en-us/rest/api/compute/disks/createorupdate#diskstorageaccounttypes)
 	// to use for the OS Disk. Defaults to `Standard_LRS`.
 	OSDiskStorageAccountType string `mapstructure:"os_disk_storage_account_type"`
 	// The [cache type](https://docs.microsoft.com/en-us/rest/api/compute/images/createorupdate#cachingtypes)
 	// specified in the resulting image and for attaching it to the Packer VM. Defaults to `ReadOnly`
-	OSDiskCacheType          string `mapstructure:"os_disk_cache_type"`
+	OSDiskCacheType string `mapstructure:"os_disk_cache_type"`
 	// If set to `true`, leaves the temporary disk behind in the Packer VM resource group. Defaults to `false`
-	OSDiskSkipCleanup        bool   `mapstructure:"os_disk_skip_cleanup"`
+	OSDiskSkipCleanup bool `mapstructure:"os_disk_skip_cleanup"`
 
 	// The image to create using this build.
-	ImageResourceID       string `mapstructure:"image_resource_id" required:"true"`
+	ImageResourceID string `mapstructure:"image_resource_id" required:"true"`
 	// The [Hyper-V generation type](https://docs.microsoft.com/en-us/rest/api/compute/images/createorupdate#hypervgenerationtypes).
 	// Defaults to `V2`.
 	ImageHyperVGeneration string `mapstructure:"image_hyperv_generation"`
@@ -102,7 +102,7 @@ const (
 	sourceDisk          sourceType = "Disk"
 )
 
-// GetContext implements ContextProvider to allow steps to use the config context 
+// GetContext implements ContextProvider to allow steps to use the config context
 // for template interpolation
 func (c *Config) GetContext() interpolate.Context {
 	return c.ctx
@@ -354,6 +354,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 					log.Println("Resolved latest version of source image:", pi.Version)
 				}
 				steps = append(steps,
+
 					&StepCreateNewDisk{
 						SubscriptionID:         info.SubscriptionID,
 						ResourceGroup:          info.ResourceGroupName,
@@ -371,6 +372,11 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			}
 		case sourceDisk:
 			steps = append(steps,
+				&StepVerifySourceDisk{
+					SourceDiskResourceID: b.config.Source,
+					SubscriptionID:       info.SubscriptionID,
+					Location:             info.Location,
+				},
 				&StepCreateNewDisk{
 					SubscriptionID:         info.SubscriptionID,
 					ResourceGroup:          info.ResourceGroupName,
@@ -379,7 +385,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 					DiskStorageAccountType: b.config.OSDiskStorageAccountType,
 					HyperVGeneration:       b.config.ImageHyperVGeneration,
 					SourceDiskResourceID:   b.config.Source,
-					//todo(paulmey) validate that source disk is in same location as VM
+					Location:               info.Location,
 
 					SkipCleanup: b.config.OSDiskSkipCleanup,
 				})
diff --git a/builder/azure/chroot/step_verify_source_disk.go b/builder/azure/chroot/step_verify_source_disk.go
new file mode 100644
index 000000000..b949447cb
--- /dev/null
+++ b/builder/azure/chroot/step_verify_source_disk.go
@@ -0,0 +1,65 @@
+package chroot
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/to"
+
+	"github.com/hashicorp/packer/builder/azure/common/client"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+)
+
+type StepVerifySourceDisk struct {
+	SubscriptionID       string
+	SourceDiskResourceID string
+	Location             string
+}
+
+func (s StepVerifySourceDisk) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	azcli := state.Get("azureclient").(client.AzureClientSet)
+	ui := state.Get("ui").(packer.Ui)
+
+	ui.Say("Checking source disk location")
+	resource, err := azure.ParseResourceID(s.SourceDiskResourceID)
+	if err != nil {
+		ui.Error(fmt.Sprintf("Could not parse resource id %q: %s", s.SourceDiskResourceID, err))
+		return multistep.ActionHalt
+	}
+
+	if !strings.EqualFold(resource.SubscriptionID, s.SubscriptionID) {
+		ui.Error(fmt.Sprintf("Source disk resource %q is in a different subscription than this VM (%q). "+
+			"Packer does not know how to handle that.",
+			s.SourceDiskResourceID, s.SubscriptionID))
+		return multistep.ActionHalt
+	}
+
+	if !(strings.EqualFold(resource.Provider, "Microsoft.Compute") && strings.EqualFold(resource.ResourceType, "disks")) {
+		ui.Error(fmt.Sprintf("Resource ID %q is not a managed disk resource", s.SourceDiskResourceID))
+		return multistep.ActionHalt
+	}
+
+	disk, err := azcli.DisksClient().Get(ctx,
+		resource.ResourceGroup, resource.ResourceName)
+	if err != nil {
+		ui.Error(fmt.Sprintf("Unable to retrieve disk (%q): %s", s.SourceDiskResourceID, err))
+		return multistep.ActionHalt
+	}
+
+	location := to.String(disk.Location)
+	if !strings.EqualFold(location, s.Location) {
+		ui.Error(fmt.Sprintf("Source disk resource %q is in a different location (%q) than this VM (%q). "+
+			"Packer does not know how to handle that.",
+			s.SourceDiskResourceID,
+			location,
+			s.Location))
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s StepVerifySourceDisk) Cleanup(state multistep.StateBag) {}
diff --git a/builder/azure/chroot/step_verify_source_disk_test.go b/builder/azure/chroot/step_verify_source_disk_test.go
new file mode 100644
index 000000000..113fd3f73
--- /dev/null
+++ b/builder/azure/chroot/step_verify_source_disk_test.go
@@ -0,0 +1,146 @@
+package chroot
+
+import (
+	"context"
+	"io/ioutil"
+	"net/http"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/hashicorp/packer/builder/azure/common/client"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+)
+
+func Test_StepVerifySourceDisk_Run(t *testing.T) {
+	type fields struct {
+		SubscriptionID       string
+		SourceDiskResourceID string
+		Location             string
+
+		GetDiskResponseCode int
+		GetDiskResponseBody string
+	}
+	type args struct {
+		state multistep.StateBag
+	}
+	tests := []struct {
+		name       string
+		fields     fields
+		args       args
+		want       multistep.StepAction
+		errormatch string
+	}{
+		{
+			name: "HappyPath",
+			fields: fields{
+				SubscriptionID:       "subid1",
+				SourceDiskResourceID: "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/disks/disk1",
+				Location:             "westus2",
+
+				GetDiskResponseCode: 200,
+				GetDiskResponseBody: `{"location":"westus2"}`,
+			},
+			want: multistep.ActionContinue,
+		},
+		{
+			name: "DiskNotFound",
+			fields: fields{
+				SubscriptionID:       "subid1",
+				SourceDiskResourceID: "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/disks/disk1",
+				Location:             "westus2",
+
+				GetDiskResponseCode: 404,
+				GetDiskResponseBody: `{}`,
+			},
+			want:       multistep.ActionHalt,
+			errormatch: "Unable to retrieve",
+		},
+		{
+			name: "NotADisk",
+			fields: fields{
+				SubscriptionID:       "subid1",
+				SourceDiskResourceID: "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/images/image1",
+				Location:             "westus2",
+
+				GetDiskResponseCode: 404,
+			},
+			want:       multistep.ActionHalt,
+			errormatch: "not a managed disk",
+		},
+		{
+			name: "OtherSubscription",
+			fields: fields{
+				SubscriptionID:       "subid1",
+				SourceDiskResourceID: "/subscriptions/subid2/resourcegroups/rg1/providers/Microsoft.Compute/disks/disk1",
+				Location:             "westus2",
+
+				GetDiskResponseCode: 200,
+				GetDiskResponseBody: `{"location":"westus2"}`,
+			},
+			want:       multistep.ActionHalt,
+			errormatch: "different subscription",
+		},
+		{
+			name: "OtherLocation",
+			fields: fields{
+				SubscriptionID:       "subid1",
+				SourceDiskResourceID: "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.Compute/disks/disk1",
+				Location:             "eastus",
+
+				GetDiskResponseCode: 200,
+				GetDiskResponseBody: `{"location":"westus2"}`,
+			},
+			want:       multistep.ActionHalt,
+			errormatch: "different location",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := StepVerifySourceDisk{
+				SubscriptionID:       tt.fields.SubscriptionID,
+				SourceDiskResourceID: tt.fields.SourceDiskResourceID,
+				Location:             tt.fields.Location,
+			}
+
+			m := compute.NewDisksClient("subscriptionId")
+			m.Sender = autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
+				return &http.Response{
+					Request:    r,
+					Body:       ioutil.NopCloser(strings.NewReader(tt.fields.GetDiskResponseBody)),
+					StatusCode: tt.fields.GetDiskResponseCode,
+				}, nil
+			})
+			errorBuffer := &strings.Builder{}
+			ui := &packer.BasicUi{
+				Reader:      strings.NewReader(""),
+				Writer:      ioutil.Discard,
+				ErrorWriter: errorBuffer,
+			}
+
+			state := new(multistep.BasicStateBag)
+			state.Put("azureclient", &client.AzureClientSetMock{
+				DisksClientMock: m,
+			})
+			state.Put("ui", ui)
+
+			if got := s.Run(context.TODO(), state); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("StepVerifySourceDisk.Run() = %v, want %v", got, tt.want)
+			}
+			if tt.errormatch != "" {
+				if !regexp.MustCompile(tt.errormatch).MatchString(errorBuffer.String()) {
+					t.Errorf("Expected the error output (%q) to match %q", errorBuffer.String(), tt.errormatch)
+				}
+			}
+		})
+	}
+}
+
+type uiThatRemebersErrors struct {
+	packer.Ui
+	LastError string
+}

From 066ae0aa0744129a761b4e208ea1e652d62f1b2f Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 2 Oct 2019 22:13:04 +0000
Subject: [PATCH 115/155] Documentation update

---
 ...zure.html.md.erb => azure-arm.html.md.erb} |  10 +-
 .../docs/builders/azure-chroot.html.md.erb    | 101 ++++++++
 .../source/docs/builders/azure-setup.html.md  | 236 ------------------
 website/source/docs/builders/azure.html.md    | 101 ++++++++
 website/source/layouts/docs.erb               |   7 +-
 5 files changed, 212 insertions(+), 243 deletions(-)
 rename website/source/docs/builders/{azure.html.md.erb => azure-arm.html.md.erb} (98%)
 create mode 100644 website/source/docs/builders/azure-chroot.html.md.erb
 delete mode 100644 website/source/docs/builders/azure-setup.html.md
 create mode 100644 website/source/docs/builders/azure.html.md

diff --git a/website/source/docs/builders/azure.html.md.erb b/website/source/docs/builders/azure-arm.html.md.erb
similarity index 98%
rename from website/source/docs/builders/azure.html.md.erb
rename to website/source/docs/builders/azure-arm.html.md.erb
index e2c83f80b..b08e8506e 100644
--- a/website/source/docs/builders/azure.html.md.erb
+++ b/website/source/docs/builders/azure-arm.html.md.erb
@@ -1,8 +1,8 @@
 ---
 description: 'Packer supports building VHDs in Azure Resource manager.'
 layout: docs
-page_title: 'Azure - Builders'
-sidebar_current: 'docs-builders-azure'
+page_title: 'Azure arm - Builders'
+sidebar_current: 'docs-builders-azure-arm'
 ---
 
 # Azure Resource Manager Builder
@@ -23,7 +23,7 @@ VM from your build artifact.
 
 Azure uses a combination of OAuth and Active Directory to authorize requests to
 the ARM API. Learn how to [authorize access to
-ARM](/docs/builders/azure-setup.html).
+ARM](/docs/builders/azure.html#authentication-for-azure).
 
 The documentation below references command output from the [Azure
 CLI](https://azure.microsoft.com/en-us/documentation/articles/xplat-cli-install/).
@@ -36,12 +36,12 @@ addition to the options listed here, a
 builder.
 
 ### Required options for authentication:
-If you're running packer on an Azure VM with a [managed identity](/docs/builders/azure-setup.html#managed-identities-for-azure-resources)
+If you're running packer on an Azure VM with a [managed identity](/docs/builders/azure.html#azure-managed-identity)
 you don't need to specify any additional configuration options.
 If you would like to use interactive user authentication, you should specify
 `subscription_id` only. Packer will use cached credentials or redirect you
 to a website to log in.
-If you want to use a [service principal](/docs/builders/azure-setup.html#create-a-service-principal)
+If you want to use a [service principal](/docs/builders/azure.html#azure-active-directory-service-principal)
 you should specify `subscription_id`, `client_id` and one of `client_secret`,
 `client_cert_path` or `client_jwt`.
 
diff --git a/website/source/docs/builders/azure-chroot.html.md.erb b/website/source/docs/builders/azure-chroot.html.md.erb
new file mode 100644
index 000000000..6a67888d9
--- /dev/null
+++ b/website/source/docs/builders/azure-chroot.html.md.erb
@@ -0,0 +1,101 @@
+---
+description: |
+    The azure-chroot Packer builder is able to create Azure Managed Images leveraging
+    a VM in Azure.
+layout: docs
+page_title: 'Azure chroot - Builders'
+sidebar_current: 'docs-builders-azure-chroot'
+---
+
+# Azure Builder (chroot)
+
+Type: `azure-chroot`
+
+The `azure-chroot` builder is able to build Azure managed disk (MD) images. For
+more information on managed disks, see [Azure Managed Disks Overview](https://docs.microsoft.com/en-us/azure/virtual-machines/windows/managed-disks-overview).
+
+The difference between this builder and the `azure-arm` builder is that this
+builder is able to build a managed disk image without launching an Azure VM 
+instance. This can dramatically speed up image builds. It also allows for more
+deterministic image content and enables some capabilities that are not possible
+with the `azure-arm` builder.
+
+> **This is an advanced builder** If you're just getting started with Packer,
+it is recommend to start with the [azure-arm builder](/docs/builders/azure-arm.html),
+which is much easier to use.
+
+## How Does it Work?
+
+This builder works by creating a new MD from either an existing source or from
+scratch and attaching it to the (already existing) Azure  VM where Packer is
+running. Once attached, a [chroot](https://en.wikipedia.org/wiki/Chroot) is set
+up and made available to the provisioners. After provisioning, the MD is
+detached, snapshotted and a MD image is created.
+
+Using this process, minutes can be shaved off the image creation process
+because Packer does not need to launch a VM instance.
+
+There are some restrictions however:
+* The host system must be a similar system (generally the same OS version,
+  kernel versions, etc.) as the image being built.
+* If the source is a user image or managed disk, it must be made available in
+  the same region as the host system. ([name=Paul Meyer]: we could work around
+  this restriction by doing a cross-region copy, but that takes away the main
+  speed advantage.)
+* The host system SKU has to allow for all of the specified disks to be
+  attached.
+
+## Configuration Reference
+
+There are many configuration options available for the builder. We'll start
+withauthentication parameters, then go over the builder specific options.
+
+### Authentication options
+The Azure builders [share this configuration](/docs/builders/azure.html).
+
+<%= partial "partials/builder/azure/common/client/_Config-not-required.html" %>
+
+### Builder specific options 
+
+#### Required:
+<%= partial "partials/builder/azure/chroot/_Config-required.html" %>
+
+#### Optional:
+<%= partial "partials/builder/azure/chroot/_Config-not-required.html" %>
+
+## Chroot Mounts
+
+The `chroot_mounts` configuration can be used to mount specific devices within
+the chroot. By default, the following additional mounts are added into the
+chroot by Packer:
+
+-   `/proc` (proc)
+-   `/sys` (sysfs)
+-   `/dev` (bind to real `/dev`)
+-   `/dev/pts` (devpts)
+-   `/proc/sys/fs/binfmt_misc` (binfmt\_misc)
+
+These default mounts are usually good enough for anyone and are sane defaults.
+However, if you want to change or add the mount points, you may using the
+`chroot_mounts` configuration. Here is an example configuration which only
+mounts `/prod` and `/dev`:
+
+``` json
+{
+  "chroot_mounts": [
+    ["proc", "proc", "/proc"],
+    ["bind", "/dev", "/dev"]
+  ]
+}
+```
+
+`chroot_mounts` is a list of a 3-tuples of strings. The three components of the
+3-tuple, in order, are:
+
+-   The filesystem type. If this is "bind", then Packer will properly bind the
+    filesystem to another mount point.
+
+-   The source device.
+
+-   The mount directory.
+
diff --git a/website/source/docs/builders/azure-setup.html.md b/website/source/docs/builders/azure-setup.html.md
deleted file mode 100644
index ee73b1715..000000000
--- a/website/source/docs/builders/azure-setup.html.md
+++ /dev/null
@@ -1,236 +0,0 @@
----
-description: |
-    In order to build VMs in Azure, Packer needs various configuration options.
-    These options and how to obtain them are documented on this page.
-layout: docs
-page_title: 'Setup - Azure - Builders'
-sidebar_current: 'docs-builders-azure-setup'
----
-
-# Authorizing Packer Builds in Azure
-
-In order to build VMs in Azure, Packer needs 6 configuration options to be
-specified:
-
--   `subscription_id` - UUID identifying your Azure subscription (where billing
-    is handled)
-
--   `client_id` - UUID identifying the Active Directory service principal that
-    will run your Packer builds
-
--   `client_secret` - service principal secret / password
-
--   `resource_group_name` - name of the resource group where your VHD(s) will
-    be stored
-
--   `storage_account` - name of the storage account where your VHD(s) will be
-    stored
-
--&gt; Behind the scenes, Packer uses the OAuth protocol to authenticate against
-Azure Active Directory and authorize requests to the Azure Service Management
-API. These topics are unnecessarily complicated, so we will try to ignore them
-for the rest of this document.<br /><br />You do not need to understand how
-OAuth works in order to use Packer with Azure, though the Active Directory
-terms "service principal" and "role" will be useful for understanding Azure's
-access policies.
-
-In order to get all of the items above, you will need a username and password
-for your Azure account.
-
-## Device Login
-
-Device login is an alternative way to authorize in Azure Packer. Device login
-only requires you to know your Subscription ID. (Device login is only supported
-for Linux based VMs.) Device login is intended for those who are first time
-users, and just want to ''kick the tires.'' We recommend the SPN approach if
-you intend to automate Packer.
-
-> Device login is for **interactive** builds, and SPN is for **automated** builds.
-
-There are three pieces of information you must provide to enable device login
-mode:
-
-1.  SubscriptionID
-2.  Resource Group - parent resource group that Packer uses to build an image.
-3.  Storage Account - storage account where the image will be placed.
-
-> Device login mode is enabled by not setting client\_id and client\_secret.
-
-> Device login mode is for the Public and US Gov clouds only.
-
-The device login flow asks that you open a web browser, navigate to
-<a href="http://aka.ms/devicelogin" class="uri">http://aka.ms/devicelogin</a>,
-and input the supplied code. This authorizes the Packer for Azure application
-to act on your behalf. An OAuth token will be created, and stored in the user's
-home directory (\~/.azure/packer/oauth-TenantID.json). This token is used if
-the token file exists, and it is refreshed as necessary. The token file
-prevents the need to continually execute the device login flow. Packer will ask
-for two device login auth, one for service management endpoint and another for
-accessing temp keyvault secrets that it creates.
-
-## Managed identities for Azure resources
-
--&gt; Managed identities for Azure resources is the new name for the service
-formerly known as Managed Service Identity (MSI).
-
-Managed identities is an alternative way to authorize in Azure Packer. Managed
-identities for Azure resources are automatically managed by Azure and enable
-you to authenticate to services that support Azure AD authentication without
-needing to insert credentials into your buildfile. Navigate to
-<a href="https://docs.microsoft.com/en-gb/azure/active-directory/managed-identities-azure-resources/overview" 
-class="uri">managed identities azure resources overview</a> to learn more about
-this feature.
-
-This feature will be used when no `subscription_id`, `client_id` or
-`client_secret` is set in your buildfile.
-
-## Install the Azure CLI
-
-To get the credentials above, we will need to install the Azure CLI. Please
-refer to Microsoft's official [installation
-guide](https://azure.microsoft.com/en-us/documentation/articles/xplat-cli-install/).
-
-The guides below use [JMESPath](http://jmespath.org/) queries to select and reformat output from the AZ CLI commands. JMESPath is [part of the Azure CLI](https://docs.microsoft.com/en-us/cli/azure/query-azure-cli?view=azure-cli-latest) and can be used in the same way as the `jq` tool.
-
-## Guided Setup
-
-The Packer project includes a [setup
-script](https://github.com/hashicorp/packer/blob/master/contrib/azure-setup.sh)
-that can help you setup your account. It uses an interactive bash script to log
-you into Azure, name your resources, and export your Packer configuration.
-
-## Manual Setup
-
-If you want more control, or the script does not work for you, you can also use
-the manual instructions below to setup your Azure account. You will need to
-manually keep track of the various account identifiers, resource names, and
-your service principal password.
-
-### Identify Your Tenant and Subscription IDs
-
-Login using the Azure CLI
-
-``` shell
-$ az login
-# Note, we have launched a browser for you to login. For old experience with device code, use "az login --use-device-code"
-```
-
-Once you've completed logging in, you should get a JSON array like the one
-below:
-
-``` shell
-[
-  {
-    "cloudName": "AzureCloud",
-    "id": "$uuid",
-    "isDefault": false,
-    "name": "Pay-As-You-Go",
-    "state": "Enabled",
-    "tenantId": "$tenant_uuid",
-    "user": {
-      "name": "my_email@anywhere.com",
-      "type": "user"
-    }
-  }
-]
-```
-
-Get your account information
-
-``` shell
-$ az account list --output table --query '[].{Name:name,subscription_id:id}'
-$ az account set --subscription ACCOUNTNAME
-$ az account show --output json --query 'id'
-```
-
-This will print out one line that look like this:
-
-    4f562e88-8caf-421a-b4da-e3f6786c52ec
-
-This is your `subscription_id`. Note it for later.
-
-### Create a Resource Group
-
-A [resource
-group](https://azure.microsoft.com/en-us/documentation/articles/resource-group-overview/#resource-groups)
-is used to organize related resources. Resource groups and storage accounts are
-tied to a location. To see available locations, run:
-
-``` shell
-$ az account list-locations
-$ LOCATION=xxx
-$ GROUPNAME=xxx
-# ...
-
-$ az group create --name $GROUPNAME --location $LOCATION
-```
-
-Your storage account (below) will need to use the same `GROUPNAME` and
-`LOCATION`.
-
-### Create a Storage Account
-
-We will need to create a storage account where your Packer artifacts will be
-stored. We will create a `LRS` storage account which is the least expensive
-price/GB at the time of writing.
-
-``` shell
-$ az storage account create \
-  --name STORAGENAME
-  --resource-group $GROUPNAME \
-  --location $LOCATION \
-  --sku Standard_LRS \
-  --kind Storage
-```
-
--&gt; `LRS` and `Standard_LRS` are meant as literal "LRS" or "Standard\_LRS"
-and not as variables.
-
-Make sure that `GROUPNAME` and `LOCATION` are the same as above. Also, ensure
-that `GROUPNAME` is less than 24 characters long and contains only lowercase
-letters and numbers.
-
-### Create a Service Principal
-
-A service principal acts on behalf of an application (Packer) on your Azure
-subscription. To create an application and service principal for use with
-Packer, run the below command specifying the subscription. This will grant
-Packer the contributor role to the subscription.
-The output of this command is your service principal credentials, save these in
-a safe place as you will need these to configure Packer.
-
-``` shell
-az ad sp create-for-rbac -n "Packer" --role contributor \
-                            --scopes /subscriptions/{SubID}
-```
-
-The service principal credentials.
-
-``` shell
-{
-  "appId": "AppId",
-  "displayName": "Packer",
-  "name": "http://Packer",
-  "password": "Password",
-  "tenant": "TenantId"
-}
-```
-
-There are a lot of pre-defined roles and you can define your own with more
-granular permissions, though this is out of scope. You can see a list of
-pre-configured roles via:
-
-``` shell
-$ az role definition list --output table --query '[].{name:roleName, description:description}'
-```
-
-If you would rather use a certificate to autenticate your service principal,
-please follow the [Azure Active Directory documentation](https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-certificate-credentials#register-your-certificate-with-azure-ad).
-
-### Configuring Packer
-
-Now (finally) everything has been setup in Azure and our service principal has
-been created. You can use the output from creating your service principal in
-your template. Use the value from the `appId` field above as a value for
-`client_id` in your configuration and set `client_secret` to the `password`
-value from above.
diff --git a/website/source/docs/builders/azure.html.md b/website/source/docs/builders/azure.html.md
new file mode 100644
index 000000000..62bfdb25b
--- /dev/null
+++ b/website/source/docs/builders/azure.html.md
@@ -0,0 +1,101 @@
+---
+description: |
+    Packer is able to create Azure VM images. To achieve this, Packer comes with
+    multiple builders depending on the strategy you want to use to build the images.
+layout: docs
+page_title: 'Azure images - Builders'
+sidebar_current: 'docs-builders-azure'
+---
+
+# Azure Virtual Machine Image Builders
+
+Packer can create Azure virtual machine images through variety of ways 
+depending on the strategy that you want to use for building the images. 
+Packer supports the following builders for Azure images at the moment:
+
+-   [azure-arm](/docs/builders/azure-arm.html) - Uses Azure Resource
+    Manager (ARM) to launch a virtual machine (VM) from which a new image is
+    captured after provisioning. If in doubt, use this builder; it is the
+    easiest builder to get started with.
+
+-   [azure-chroot](/docs/builders/azure-chroot.html) - Uses ARM to create
+    a managed disk that is attached to an existing Azure VM that Packer is
+    running on. Provisioning leverages [Chroot](https://en.wikipedia.org/wiki/Chroot)
+    environment. After provisioning, the disk is detached an image is created
+    from this disk. This is an **advanced builder and should not be used by
+    newcomers**. However, it is also the fastest way to build a VM image in
+    Azure.
+
+-&gt; **Don't know which builder to use?** If in doubt, use the [azure-arm
+builder](/docs/builders/azure-arm.html). It is much easier to use.
+
+# Authentication for Azure
+
+The Packer Azure builders provide a couple of ways to authenticate to Azure. The
+following methods are available and are explained below:
+
+-   Azure Active Directory interactive login. Interactive login is available
+    for the Public and US Gov clouds only.
+-   Azure Managed Identity
+-   Azure Active Directory Service Principal
+
+-&gt; **Don't know which authentication method to use?** Go with interactive
+login to try out the builders. If you need packer to run automatically,
+switch to using a Service Principal or Managed Identity.
+
+No matter which method you choose, the identity you use will need the
+appropriate permissions on Azure resources for Packer to operate. The minimal
+set of permissions is highly dependent on the builder and its configuration.
+An easy way to get started is to assign the identity the `Contributor` role at
+the subscription level.
+
+## Azure Active Directory interactive login
+
+If your organization allows it, you can use a command line interactive login
+method based on oAuth 'device code flow'. Packer will select this method when
+you only specify a `subscription_id` in your builder configuration. When you
+run Packer, it will ask you to visit a web site and input a code. This web site
+will then authenticate you, satisfying any two-factor authentication policies
+that your organization might have. The tokens are cached under the `.azure/packer`
+directory in your home directory and will be reused if they are still valid
+on subsequent runs.
+
+## Azure Managed Identity
+
+Azure provides the option to assign an identity to a virtual machine ([Azure
+documentation](https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/qs-configure-portal-windows-vm)). Packer can
+use a system assigned identity for a VM where Packer is running to orchestrate
+Azure API's. This is the default behavior and requires no configuration
+properties to be set. It does, however, require that you run Packer on an
+Azure VM.
+
+To enable this method, [let Azure assign a system-assigned identity to your VM](https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/qs-configure-portal-windows-vm).
+Then, [grant your VM access to the appropriate resources](https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/howto-assign-access-portal).
+To get started, try assigning the `Contributor` role at the subscription level to
+your VM. Then, when you discover your exact scenario, scope the permissions
+appropriately or isolate Packer builds in a separate subscription.
+
+##  Azure Active Directory Service Principal
+
+Azure Active Directory models service accounts as 'Service Principal' (SP)
+objects. An SP represents an application accessing your Azure resources. It
+is identified by a client ID (aka application ID) and can use a password or a
+certificate to authenticate. To use a Service Principal, specify the 
+`subscription_id` and `client_id`, as well as either `client_secret`,
+`client_cert_path` or `client_jwt`. Each of these last three represent a different
+way to authenticate the SP to AAD:
+
+-   `client_secret` - allows the user to provide a password/secret registered 
+    for the AAD SP.
+-   `client_cert_path` - allows usage of a certificate to be used to
+    authenticate as the specified AAD SP.
+-   `client_jwt` - For advanced scenario's where the used cannot provide Packer
+    the full certificate, they can provide a JWT bearer token for client auth
+    (RFC 7523, Sec. 2.2). These bearer tokens are created and signed using a
+    certificate registered in AAD and have a user-chosen expiry time, limiting
+    the validity of the token. This is also the underlying mechanism used to
+    authenticate when using `client_cert_path`.
+
+To create a service principal, you can follow [the Azure documentation on this
+subject](https://docs.microsoft.com/en-us/cli/azure/create-an-azure-service-principal-azure-cli?view=azure-cli-latest).
+
diff --git a/website/source/layouts/docs.erb b/website/source/layouts/docs.erb
index 6593ae9f9..878c6653a 100644
--- a/website/source/layouts/docs.erb
+++ b/website/source/layouts/docs.erb
@@ -94,8 +94,11 @@
           <li<%= sidebar_current("docs-builders-azure") %>>
             <a href="/docs/builders/azure.html">Azure</a>
             <ul class="nav">
-              <li<%= sidebar_current("docs-builders-azure-setup") %>>
-                <a href="/docs/builders/azure-setup.html">Setup</a>
+              <li<%= sidebar_current("docs-builders-azure-arm") %>>
+                <a href="/docs/builders/azure-arm.html">ARM</a>
+              </li>
+              <li<%= sidebar_current("docs-builders-azure-chroot") %>>
+                <a href="/docs/builders/azure-chroot.html">chroot</a>
               </li>
             </ul>
           </li>

From e05d6a223e68ffc8f13e785f2c9834bca0114204 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 2 Oct 2019 22:35:16 +0000
Subject: [PATCH 116/155] fixup! Documentation update

---
 website/source/netlify-redirects | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/source/netlify-redirects b/website/source/netlify-redirects
index 04652a4e2..ef0074a7d 100644
--- a/website/source/netlify-redirects
+++ b/website/source/netlify-redirects
@@ -7,7 +7,7 @@
 /docs/command-line/machine-readable.html        /docs/commands/index.html
 /docs/command-line/introduction.html            /docs/commands/index.html
 /docs/templates/introduction.html               /docs/templates/index.html
-/docs/builders/azure-arm.html                   /docs/builders/azure.html
+/docs/builders/azure-setup.html                 /docs/builders/azure.html
 /docs/templates/veewee-to-packer.html           /guides/veewee-to-packer.html
 /docs/extend/developing-plugins.html            /docs/extending/plugins.html
 /docs/extending/developing-plugins.html         /docs/extending/plugins.html

From 8c73450f3dc35df561a4d400a6305849c92210ca Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 2 Oct 2019 22:44:15 +0000
Subject: [PATCH 117/155] fixup! Add documentation to config struct

---
 builder/azure/chroot/builder.go                                 | 2 +-
 .../partials/builder/azure/chroot/_Config-required.html.md      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index c476b2fd1..e72507441 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -37,7 +37,7 @@ type Config struct {
 
 	// When set to `true`, starts with an empty, unpartitioned disk. Defaults to `false`.
 	FromScratch bool `mapstructure:"from_scratch"`
-	// Either a managed disk resourced ID or a publisher:offer:sku:version specifier for plaform image sources.
+	// Either a managed disk resource ID or a publisher:offer:sku:version specifier for plaform image sources.
 	Source     string `mapstructure:"source" required:"true"`
 	sourceType sourceType
 
diff --git a/website/source/partials/builder/azure/chroot/_Config-required.html.md b/website/source/partials/builder/azure/chroot/_Config-required.html.md
index e24734560..8402b8c73 100644
--- a/website/source/partials/builder/azure/chroot/_Config-required.html.md
+++ b/website/source/partials/builder/azure/chroot/_Config-required.html.md
@@ -1,6 +1,6 @@
 <!-- Code generated from the comments of the Config struct in builder/azure/chroot/builder.go; DO NOT EDIT MANUALLY -->
 
--   `source` (string) - Either a managed disk resourced ID or a publisher:offer:sku:version specifier for plaform image sources.
+-   `source` (string) - Either a managed disk resource ID or a publisher:offer:sku:version specifier for plaform image sources.
     
 -   `image_resource_id` (string) - The image to create using this build.
     
\ No newline at end of file

From b9c726417f8540d456ebe69c66d09ff848f5d99d Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 2 Oct 2019 23:34:02 +0000
Subject: [PATCH 118/155] update modules

---
 go.mod | 1 +
 go.sum | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/go.mod b/go.mod
index 327a88162..e75f6325c 100644
--- a/go.mod
+++ b/go.mod
@@ -34,6 +34,7 @@ require (
 	github.com/digitalocean/go-libvirt v0.0.0-20190626172931-4d226dd6c437 // indirect
 	github.com/digitalocean/go-qemu v0.0.0-20181112162955-dd7bb9c771b8
 	github.com/digitalocean/godo v1.11.1
+	github.com/dimchansky/utfbom v1.1.0 // indirect
 	github.com/dnaeon/go-vcr v1.0.0 // indirect
 	github.com/docker/docker v0.0.0-20180422163414-57142e89befe // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
diff --git a/go.sum b/go.sum
index 6735fbbb6..e3e08c8ce 100644
--- a/go.sum
+++ b/go.sum
@@ -93,6 +93,8 @@ github.com/digitalocean/go-qemu v0.0.0-20181112162955-dd7bb9c771b8 h1:N7nH2py78L
 github.com/digitalocean/go-qemu v0.0.0-20181112162955-dd7bb9c771b8/go.mod h1:/YnlngP1PARC0SKAZx6kaAEMOp8bNTQGqS+Ka3MctNI=
 github.com/digitalocean/godo v1.11.1 h1:OsTh37YFKk+g6DnAOrkXJ9oDArTkRx5UTkBJ2EWAO38=
 github.com/digitalocean/godo v1.11.1/go.mod h1:h6faOIcZ8lWIwNQ+DN7b3CgX4Kwby5T+nbpNqkUIozU=
+github.com/dimchansky/utfbom v1.1.0 h1:FcM3g+nofKgUteL8dm/UpdRXNC9KmADgTpLKsu0TRo4=
+github.com/dimchansky/utfbom v1.1.0/go.mod h1:rO41eb7gLfo8SF1jd9F8HplJm1Fewwi4mQvIirEdv+8=
 github.com/dnaeon/go-vcr v1.0.0 h1:1QZ+ahihvRvppcJnFvuoHAdnZTf1PqKjO4Ftr1cfQTo=
 github.com/dnaeon/go-vcr v1.0.0/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
 github.com/docker/docker v0.0.0-20180422163414-57142e89befe h1:VW8TnWi0CZgg7oCv0wH6evNwkzcJg/emnw4HrVIWws4=

From cf8688ec40b405489b19cb20a07f37117e5235db Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 2 Oct 2019 23:41:22 +0000
Subject: [PATCH 119/155] doc updates after Dan's review

---
 .../docs/builders/azure-chroot.html.md.erb    | 20 ++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/website/source/docs/builders/azure-chroot.html.md.erb b/website/source/docs/builders/azure-chroot.html.md.erb
index 6a67888d9..ab5af6cb8 100644
--- a/website/source/docs/builders/azure-chroot.html.md.erb
+++ b/website/source/docs/builders/azure-chroot.html.md.erb
@@ -29,8 +29,8 @@ which is much easier to use.
 This builder works by creating a new MD from either an existing source or from
 scratch and attaching it to the (already existing) Azure  VM where Packer is
 running. Once attached, a [chroot](https://en.wikipedia.org/wiki/Chroot) is set
-up and made available to the provisioners. After provisioning, the MD is
-detached, snapshotted and a MD image is created.
+up and made available to the [provisioners](/docs/provisioners/index.html).
+After provisioning, the MD is detached, snapshotted and a MD image is created.
 
 Using this process, minutes can be shaved off the image creation process
 because Packer does not need to launch a VM instance.
@@ -38,24 +38,26 @@ because Packer does not need to launch a VM instance.
 There are some restrictions however:
 * The host system must be a similar system (generally the same OS version,
   kernel versions, etc.) as the image being built.
-* If the source is a user image or managed disk, it must be made available in
-  the same region as the host system. ([name=Paul Meyer]: we could work around
-  this restriction by doing a cross-region copy, but that takes away the main
-  speed advantage.)
+* If the source is a  managed disk, it must be made available in the same
+  region as the host system.
 * The host system SKU has to allow for all of the specified disks to be
   attached.
 
 ## Configuration Reference
 
 There are many configuration options available for the builder. We'll start
-withauthentication parameters, then go over the builder specific options.
+with authentication parameters, then go over the Azure chroot builder specific
+options.
 
 ### Authentication options
-The Azure builders [share this configuration](/docs/builders/azure.html).
+None of the authentication options are required, but depending on which
+ones are specified a different authentication method may be used. See the
+[shared Azure builders documentation](/docs/builders/azure.html) for more
+information.
 
 <%= partial "partials/builder/azure/common/client/_Config-not-required.html" %>
 
-### Builder specific options 
+### Azure chroot builder specific options 
 
 #### Required:
 <%= partial "partials/builder/azure/chroot/_Config-required.html" %>

From 37931c551f866c1dc0f7349379870965a5727358 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Wed, 2 Oct 2019 23:52:55 +0000
Subject: [PATCH 120/155] add example

---
 examples/azure/debian-chroot.json             | 26 +++++++++++++
 .../docs/builders/azure-chroot.html.md.erb    | 37 +++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 examples/azure/debian-chroot.json

diff --git a/examples/azure/debian-chroot.json b/examples/azure/debian-chroot.json
new file mode 100644
index 000000000..4b29632b1
--- /dev/null
+++ b/examples/azure/debian-chroot.json
@@ -0,0 +1,26 @@
+{
+  "variables": {
+    "client_id": "{{env `ARM_CLIENT_ID`}}",
+    "client_secret": "{{env `ARM_CLIENT_SECRET`}}",
+    "subscription_id": "{{env `ARM_SUBSCRIPTION_ID`}}"
+  },
+  "builders": [{
+    "type": "azure-chroot",
+
+    "client_id": "{{user `client_id`}}",
+    "client_secret": "{{user `client_secret`}}",
+    "subscription_id": "{{user `subscription_id`}}",
+    
+    "image_resource_id": "/subscriptions/{{user `subscription_id`}}/resourceGroups/{{user `resource_group`}}/providers/Microsoft.Compute/images/MyDebianOSImage-{{timestamp}}",
+
+    "source": "credativ:Debian:9:latest"
+  }],
+  "provisioners": [{
+    "inline": [
+      "apt-get update",
+      "apt-get upgrade -y"
+    ],
+    "inline_shebang": "/bin/sh -x",
+    "type": "shell"
+  }]
+}
diff --git a/website/source/docs/builders/azure-chroot.html.md.erb b/website/source/docs/builders/azure-chroot.html.md.erb
index ab5af6cb8..71b488deb 100644
--- a/website/source/docs/builders/azure-chroot.html.md.erb
+++ b/website/source/docs/builders/azure-chroot.html.md.erb
@@ -101,3 +101,40 @@ mounts `/prod` and `/dev`:
 
 -   The mount directory.
 
+## Example
+Here is an example that creates a Debian image with updated packages. Specify
+all environment variables (`ARM_CLIENT_ID`, `ARM_CLIENT_SECRET`, 
+`ARM_SUBSCRIPTION_ID`) to use a service principal, specify only `ARM_SUBSCRIPTION_ID`
+to use interactive login or leave them empty to use the system-assigned identity
+of the VM you run Packer on.
+The identity you choose should have permission to create disks and images and also
+to update your VM.
+
+``` json
+{
+  "variables": {
+    "client_id": "{{env `ARM_CLIENT_ID`}}",
+    "client_secret": "{{env `ARM_CLIENT_SECRET`}}",
+    "subscription_id": "{{env `ARM_SUBSCRIPTION_ID`}}"
+  },
+  "builders": [{
+    "type": "azure-chroot",
+
+    "client_id": "{{user `client_id`}}",
+    "client_secret": "{{user `client_secret`}}",
+    "subscription_id": "{{user `subscription_id`}}",
+    
+    "image_resource_id": "/subscriptions/{{user `subscription_id`}}/resourceGroups/{{user `resource_group`}}/providers/Microsoft.Compute/images/MyDebianOSImage-{{timestamp}}",
+
+    "source": "credativ:Debian:9:latest"
+  }],
+  "provisioners": [{
+    "inline": [
+      "apt-get update",
+      "apt-get upgrade -y"
+    ],
+    "inline_shebang": "/bin/sh -x",
+    "type": "shell"
+  }]
+}
+```
\ No newline at end of file

From 0694f2635b4daba8d708daf9485036f514f22f82 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Thu, 3 Oct 2019 04:17:54 +0000
Subject: [PATCH 121/155] update vendor directory

---
 .../compute/mgmt/compute/computeapi/models.go |   46 +
 .../latest/compute/mgmt/compute/models.go     | 1397 +++++++++++++++++
 .../compute/computeapi/interfaces.go          |  299 ++++
 .../go-autorest/autorest/azure/auth/auth.go   |  712 +++++++++
 .../go-autorest/autorest/azure/cli/profile.go |   79 +
 .../go-autorest/autorest/azure/cli/token.go   |  170 ++
 .../github.com/dimchansky/utfbom/.gitignore   |   37 +
 .../github.com/dimchansky/utfbom/.travis.yml  |   18 +
 vendor/github.com/dimchansky/utfbom/LICENSE   |  201 +++
 vendor/github.com/dimchansky/utfbom/README.md |   66 +
 vendor/github.com/dimchansky/utfbom/go.mod    |    1 +
 vendor/github.com/dimchansky/utfbom/utfbom.go |  192 +++
 .../golang.org/x/crypto/pkcs12/bmp-string.go  |   50 +
 vendor/golang.org/x/crypto/pkcs12/crypto.go   |  131 ++
 vendor/golang.org/x/crypto/pkcs12/errors.go   |   23 +
 .../x/crypto/pkcs12/internal/rc2/rc2.go       |  271 ++++
 vendor/golang.org/x/crypto/pkcs12/mac.go      |   45 +
 vendor/golang.org/x/crypto/pkcs12/pbkdf.go    |  170 ++
 vendor/golang.org/x/crypto/pkcs12/pkcs12.go   |  349 ++++
 vendor/golang.org/x/crypto/pkcs12/safebags.go |   57 +
 vendor/modules.txt                            |    9 +
 21 files changed, 4323 insertions(+)
 create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/computeapi/models.go
 create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/models.go
 create mode 100644 vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute/computeapi/interfaces.go
 create mode 100644 vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go
 create mode 100644 vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go
 create mode 100644 vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go
 create mode 100644 vendor/github.com/dimchansky/utfbom/.gitignore
 create mode 100644 vendor/github.com/dimchansky/utfbom/.travis.yml
 create mode 100644 vendor/github.com/dimchansky/utfbom/LICENSE
 create mode 100644 vendor/github.com/dimchansky/utfbom/README.md
 create mode 100644 vendor/github.com/dimchansky/utfbom/go.mod
 create mode 100644 vendor/github.com/dimchansky/utfbom/utfbom.go
 create mode 100644 vendor/golang.org/x/crypto/pkcs12/bmp-string.go
 create mode 100644 vendor/golang.org/x/crypto/pkcs12/crypto.go
 create mode 100644 vendor/golang.org/x/crypto/pkcs12/errors.go
 create mode 100644 vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2.go
 create mode 100644 vendor/golang.org/x/crypto/pkcs12/mac.go
 create mode 100644 vendor/golang.org/x/crypto/pkcs12/pbkdf.go
 create mode 100644 vendor/golang.org/x/crypto/pkcs12/pkcs12.go
 create mode 100644 vendor/golang.org/x/crypto/pkcs12/safebags.go

diff --git a/vendor/github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/computeapi/models.go b/vendor/github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/computeapi/models.go
new file mode 100644
index 000000000..2a5892f86
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/computeapi/models.go
@@ -0,0 +1,46 @@
+// +build go1.9
+
+// Copyright 2019 Microsoft Corporation
+//
+// 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.
+
+// This code was auto-generated by:
+// github.com/Azure/azure-sdk-for-go/tools/profileBuilder
+
+package computeapi
+
+import original "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute/computeapi"
+
+type AvailabilitySetsClientAPI = original.AvailabilitySetsClientAPI
+type ContainerServicesClientAPI = original.ContainerServicesClientAPI
+type DisksClientAPI = original.DisksClientAPI
+type GalleriesClientAPI = original.GalleriesClientAPI
+type GalleryImageVersionsClientAPI = original.GalleryImageVersionsClientAPI
+type GalleryImagesClientAPI = original.GalleryImagesClientAPI
+type ImagesClientAPI = original.ImagesClientAPI
+type LogAnalyticsClientAPI = original.LogAnalyticsClientAPI
+type OperationsClientAPI = original.OperationsClientAPI
+type ProximityPlacementGroupsClientAPI = original.ProximityPlacementGroupsClientAPI
+type ResourceSkusClientAPI = original.ResourceSkusClientAPI
+type SnapshotsClientAPI = original.SnapshotsClientAPI
+type UsageClientAPI = original.UsageClientAPI
+type VirtualMachineExtensionImagesClientAPI = original.VirtualMachineExtensionImagesClientAPI
+type VirtualMachineExtensionsClientAPI = original.VirtualMachineExtensionsClientAPI
+type VirtualMachineImagesClientAPI = original.VirtualMachineImagesClientAPI
+type VirtualMachineRunCommandsClientAPI = original.VirtualMachineRunCommandsClientAPI
+type VirtualMachineScaleSetExtensionsClientAPI = original.VirtualMachineScaleSetExtensionsClientAPI
+type VirtualMachineScaleSetRollingUpgradesClientAPI = original.VirtualMachineScaleSetRollingUpgradesClientAPI
+type VirtualMachineScaleSetVMsClientAPI = original.VirtualMachineScaleSetVMsClientAPI
+type VirtualMachineScaleSetsClientAPI = original.VirtualMachineScaleSetsClientAPI
+type VirtualMachineSizesClientAPI = original.VirtualMachineSizesClientAPI
+type VirtualMachinesClientAPI = original.VirtualMachinesClientAPI
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/models.go b/vendor/github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/models.go
new file mode 100644
index 000000000..cc724490f
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/models.go
@@ -0,0 +1,1397 @@
+// +build go1.9
+
+// Copyright 2019 Microsoft Corporation
+//
+// 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.
+
+// This code was auto-generated by:
+// github.com/Azure/azure-sdk-for-go/tools/profileBuilder
+
+package compute
+
+import (
+	"context"
+
+	original "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute"
+)
+
+const (
+	DefaultBaseURI = original.DefaultBaseURI
+)
+
+type AccessLevel = original.AccessLevel
+
+const (
+	None  AccessLevel = original.None
+	Read  AccessLevel = original.Read
+	Write AccessLevel = original.Write
+)
+
+type AggregatedReplicationState = original.AggregatedReplicationState
+
+const (
+	Completed  AggregatedReplicationState = original.Completed
+	Failed     AggregatedReplicationState = original.Failed
+	InProgress AggregatedReplicationState = original.InProgress
+	Unknown    AggregatedReplicationState = original.Unknown
+)
+
+type AvailabilitySetSkuTypes = original.AvailabilitySetSkuTypes
+
+const (
+	Aligned AvailabilitySetSkuTypes = original.Aligned
+	Classic AvailabilitySetSkuTypes = original.Classic
+)
+
+type CachingTypes = original.CachingTypes
+
+const (
+	CachingTypesNone      CachingTypes = original.CachingTypesNone
+	CachingTypesReadOnly  CachingTypes = original.CachingTypesReadOnly
+	CachingTypesReadWrite CachingTypes = original.CachingTypesReadWrite
+)
+
+type ComponentNames = original.ComponentNames
+
+const (
+	MicrosoftWindowsShellSetup ComponentNames = original.MicrosoftWindowsShellSetup
+)
+
+type ContainerServiceOrchestratorTypes = original.ContainerServiceOrchestratorTypes
+
+const (
+	Custom     ContainerServiceOrchestratorTypes = original.Custom
+	DCOS       ContainerServiceOrchestratorTypes = original.DCOS
+	Kubernetes ContainerServiceOrchestratorTypes = original.Kubernetes
+	Swarm      ContainerServiceOrchestratorTypes = original.Swarm
+)
+
+type ContainerServiceVMSizeTypes = original.ContainerServiceVMSizeTypes
+
+const (
+	StandardA0    ContainerServiceVMSizeTypes = original.StandardA0
+	StandardA1    ContainerServiceVMSizeTypes = original.StandardA1
+	StandardA10   ContainerServiceVMSizeTypes = original.StandardA10
+	StandardA11   ContainerServiceVMSizeTypes = original.StandardA11
+	StandardA2    ContainerServiceVMSizeTypes = original.StandardA2
+	StandardA3    ContainerServiceVMSizeTypes = original.StandardA3
+	StandardA4    ContainerServiceVMSizeTypes = original.StandardA4
+	StandardA5    ContainerServiceVMSizeTypes = original.StandardA5
+	StandardA6    ContainerServiceVMSizeTypes = original.StandardA6
+	StandardA7    ContainerServiceVMSizeTypes = original.StandardA7
+	StandardA8    ContainerServiceVMSizeTypes = original.StandardA8
+	StandardA9    ContainerServiceVMSizeTypes = original.StandardA9
+	StandardD1    ContainerServiceVMSizeTypes = original.StandardD1
+	StandardD11   ContainerServiceVMSizeTypes = original.StandardD11
+	StandardD11V2 ContainerServiceVMSizeTypes = original.StandardD11V2
+	StandardD12   ContainerServiceVMSizeTypes = original.StandardD12
+	StandardD12V2 ContainerServiceVMSizeTypes = original.StandardD12V2
+	StandardD13   ContainerServiceVMSizeTypes = original.StandardD13
+	StandardD13V2 ContainerServiceVMSizeTypes = original.StandardD13V2
+	StandardD14   ContainerServiceVMSizeTypes = original.StandardD14
+	StandardD14V2 ContainerServiceVMSizeTypes = original.StandardD14V2
+	StandardD1V2  ContainerServiceVMSizeTypes = original.StandardD1V2
+	StandardD2    ContainerServiceVMSizeTypes = original.StandardD2
+	StandardD2V2  ContainerServiceVMSizeTypes = original.StandardD2V2
+	StandardD3    ContainerServiceVMSizeTypes = original.StandardD3
+	StandardD3V2  ContainerServiceVMSizeTypes = original.StandardD3V2
+	StandardD4    ContainerServiceVMSizeTypes = original.StandardD4
+	StandardD4V2  ContainerServiceVMSizeTypes = original.StandardD4V2
+	StandardD5V2  ContainerServiceVMSizeTypes = original.StandardD5V2
+	StandardDS1   ContainerServiceVMSizeTypes = original.StandardDS1
+	StandardDS11  ContainerServiceVMSizeTypes = original.StandardDS11
+	StandardDS12  ContainerServiceVMSizeTypes = original.StandardDS12
+	StandardDS13  ContainerServiceVMSizeTypes = original.StandardDS13
+	StandardDS14  ContainerServiceVMSizeTypes = original.StandardDS14
+	StandardDS2   ContainerServiceVMSizeTypes = original.StandardDS2
+	StandardDS3   ContainerServiceVMSizeTypes = original.StandardDS3
+	StandardDS4   ContainerServiceVMSizeTypes = original.StandardDS4
+	StandardG1    ContainerServiceVMSizeTypes = original.StandardG1
+	StandardG2    ContainerServiceVMSizeTypes = original.StandardG2
+	StandardG3    ContainerServiceVMSizeTypes = original.StandardG3
+	StandardG4    ContainerServiceVMSizeTypes = original.StandardG4
+	StandardG5    ContainerServiceVMSizeTypes = original.StandardG5
+	StandardGS1   ContainerServiceVMSizeTypes = original.StandardGS1
+	StandardGS2   ContainerServiceVMSizeTypes = original.StandardGS2
+	StandardGS3   ContainerServiceVMSizeTypes = original.StandardGS3
+	StandardGS4   ContainerServiceVMSizeTypes = original.StandardGS4
+	StandardGS5   ContainerServiceVMSizeTypes = original.StandardGS5
+)
+
+type DiffDiskOptions = original.DiffDiskOptions
+
+const (
+	Local DiffDiskOptions = original.Local
+)
+
+type DiskCreateOption = original.DiskCreateOption
+
+const (
+	Attach    DiskCreateOption = original.Attach
+	Copy      DiskCreateOption = original.Copy
+	Empty     DiskCreateOption = original.Empty
+	FromImage DiskCreateOption = original.FromImage
+	Import    DiskCreateOption = original.Import
+	Restore   DiskCreateOption = original.Restore
+	Upload    DiskCreateOption = original.Upload
+)
+
+type DiskCreateOptionTypes = original.DiskCreateOptionTypes
+
+const (
+	DiskCreateOptionTypesAttach    DiskCreateOptionTypes = original.DiskCreateOptionTypesAttach
+	DiskCreateOptionTypesEmpty     DiskCreateOptionTypes = original.DiskCreateOptionTypesEmpty
+	DiskCreateOptionTypesFromImage DiskCreateOptionTypes = original.DiskCreateOptionTypesFromImage
+)
+
+type DiskState = original.DiskState
+
+const (
+	ActiveSAS     DiskState = original.ActiveSAS
+	ActiveUpload  DiskState = original.ActiveUpload
+	Attached      DiskState = original.Attached
+	ReadyToUpload DiskState = original.ReadyToUpload
+	Reserved      DiskState = original.Reserved
+	Unattached    DiskState = original.Unattached
+)
+
+type DiskStorageAccountTypes = original.DiskStorageAccountTypes
+
+const (
+	PremiumLRS     DiskStorageAccountTypes = original.PremiumLRS
+	StandardLRS    DiskStorageAccountTypes = original.StandardLRS
+	StandardSSDLRS DiskStorageAccountTypes = original.StandardSSDLRS
+	UltraSSDLRS    DiskStorageAccountTypes = original.UltraSSDLRS
+)
+
+type HostCaching = original.HostCaching
+
+const (
+	HostCachingNone      HostCaching = original.HostCachingNone
+	HostCachingReadOnly  HostCaching = original.HostCachingReadOnly
+	HostCachingReadWrite HostCaching = original.HostCachingReadWrite
+)
+
+type HyperVGeneration = original.HyperVGeneration
+
+const (
+	V1 HyperVGeneration = original.V1
+	V2 HyperVGeneration = original.V2
+)
+
+type HyperVGenerationTypes = original.HyperVGenerationTypes
+
+const (
+	HyperVGenerationTypesV1 HyperVGenerationTypes = original.HyperVGenerationTypesV1
+	HyperVGenerationTypesV2 HyperVGenerationTypes = original.HyperVGenerationTypesV2
+)
+
+type IPVersion = original.IPVersion
+
+const (
+	IPv4 IPVersion = original.IPv4
+	IPv6 IPVersion = original.IPv6
+)
+
+type InstanceViewTypes = original.InstanceViewTypes
+
+const (
+	InstanceView InstanceViewTypes = original.InstanceView
+)
+
+type IntervalInMins = original.IntervalInMins
+
+const (
+	FiveMins   IntervalInMins = original.FiveMins
+	SixtyMins  IntervalInMins = original.SixtyMins
+	ThirtyMins IntervalInMins = original.ThirtyMins
+	ThreeMins  IntervalInMins = original.ThreeMins
+)
+
+type MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypes
+
+const (
+	MaintenanceOperationResultCodeTypesMaintenanceAborted   MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesMaintenanceAborted
+	MaintenanceOperationResultCodeTypesMaintenanceCompleted MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesMaintenanceCompleted
+	MaintenanceOperationResultCodeTypesNone                 MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesNone
+	MaintenanceOperationResultCodeTypesRetryLater           MaintenanceOperationResultCodeTypes = original.MaintenanceOperationResultCodeTypesRetryLater
+)
+
+type OperatingSystemStateTypes = original.OperatingSystemStateTypes
+
+const (
+	Generalized OperatingSystemStateTypes = original.Generalized
+	Specialized OperatingSystemStateTypes = original.Specialized
+)
+
+type OperatingSystemTypes = original.OperatingSystemTypes
+
+const (
+	Linux   OperatingSystemTypes = original.Linux
+	Windows OperatingSystemTypes = original.Windows
+)
+
+type PassNames = original.PassNames
+
+const (
+	OobeSystem PassNames = original.OobeSystem
+)
+
+type ProtocolTypes = original.ProtocolTypes
+
+const (
+	HTTP  ProtocolTypes = original.HTTP
+	HTTPS ProtocolTypes = original.HTTPS
+)
+
+type ProvisioningState = original.ProvisioningState
+
+const (
+	ProvisioningStateCreating  ProvisioningState = original.ProvisioningStateCreating
+	ProvisioningStateDeleting  ProvisioningState = original.ProvisioningStateDeleting
+	ProvisioningStateFailed    ProvisioningState = original.ProvisioningStateFailed
+	ProvisioningStateMigrating ProvisioningState = original.ProvisioningStateMigrating
+	ProvisioningStateSucceeded ProvisioningState = original.ProvisioningStateSucceeded
+	ProvisioningStateUpdating  ProvisioningState = original.ProvisioningStateUpdating
+)
+
+type ProvisioningState1 = original.ProvisioningState1
+
+const (
+	ProvisioningState1Creating  ProvisioningState1 = original.ProvisioningState1Creating
+	ProvisioningState1Deleting  ProvisioningState1 = original.ProvisioningState1Deleting
+	ProvisioningState1Failed    ProvisioningState1 = original.ProvisioningState1Failed
+	ProvisioningState1Migrating ProvisioningState1 = original.ProvisioningState1Migrating
+	ProvisioningState1Succeeded ProvisioningState1 = original.ProvisioningState1Succeeded
+	ProvisioningState1Updating  ProvisioningState1 = original.ProvisioningState1Updating
+)
+
+type ProvisioningState2 = original.ProvisioningState2
+
+const (
+	ProvisioningState2Creating  ProvisioningState2 = original.ProvisioningState2Creating
+	ProvisioningState2Deleting  ProvisioningState2 = original.ProvisioningState2Deleting
+	ProvisioningState2Failed    ProvisioningState2 = original.ProvisioningState2Failed
+	ProvisioningState2Migrating ProvisioningState2 = original.ProvisioningState2Migrating
+	ProvisioningState2Succeeded ProvisioningState2 = original.ProvisioningState2Succeeded
+	ProvisioningState2Updating  ProvisioningState2 = original.ProvisioningState2Updating
+)
+
+type ProximityPlacementGroupType = original.ProximityPlacementGroupType
+
+const (
+	Standard ProximityPlacementGroupType = original.Standard
+	Ultra    ProximityPlacementGroupType = original.Ultra
+)
+
+type ReplicationState = original.ReplicationState
+
+const (
+	ReplicationStateCompleted   ReplicationState = original.ReplicationStateCompleted
+	ReplicationStateFailed      ReplicationState = original.ReplicationStateFailed
+	ReplicationStateReplicating ReplicationState = original.ReplicationStateReplicating
+	ReplicationStateUnknown     ReplicationState = original.ReplicationStateUnknown
+)
+
+type ReplicationStatusTypes = original.ReplicationStatusTypes
+
+const (
+	ReplicationStatusTypesReplicationStatus ReplicationStatusTypes = original.ReplicationStatusTypesReplicationStatus
+)
+
+type ResourceIdentityType = original.ResourceIdentityType
+
+const (
+	ResourceIdentityTypeNone                       ResourceIdentityType = original.ResourceIdentityTypeNone
+	ResourceIdentityTypeSystemAssigned             ResourceIdentityType = original.ResourceIdentityTypeSystemAssigned
+	ResourceIdentityTypeSystemAssignedUserAssigned ResourceIdentityType = original.ResourceIdentityTypeSystemAssignedUserAssigned
+	ResourceIdentityTypeUserAssigned               ResourceIdentityType = original.ResourceIdentityTypeUserAssigned
+)
+
+type ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleType
+
+const (
+	ResourceSkuCapacityScaleTypeAutomatic ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleTypeAutomatic
+	ResourceSkuCapacityScaleTypeManual    ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleTypeManual
+	ResourceSkuCapacityScaleTypeNone      ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleTypeNone
+)
+
+type ResourceSkuRestrictionsReasonCode = original.ResourceSkuRestrictionsReasonCode
+
+const (
+	NotAvailableForSubscription ResourceSkuRestrictionsReasonCode = original.NotAvailableForSubscription
+	QuotaID                     ResourceSkuRestrictionsReasonCode = original.QuotaID
+)
+
+type ResourceSkuRestrictionsType = original.ResourceSkuRestrictionsType
+
+const (
+	Location ResourceSkuRestrictionsType = original.Location
+	Zone     ResourceSkuRestrictionsType = original.Zone
+)
+
+type RollingUpgradeActionType = original.RollingUpgradeActionType
+
+const (
+	Cancel RollingUpgradeActionType = original.Cancel
+	Start  RollingUpgradeActionType = original.Start
+)
+
+type RollingUpgradeStatusCode = original.RollingUpgradeStatusCode
+
+const (
+	RollingUpgradeStatusCodeCancelled      RollingUpgradeStatusCode = original.RollingUpgradeStatusCodeCancelled
+	RollingUpgradeStatusCodeCompleted      RollingUpgradeStatusCode = original.RollingUpgradeStatusCodeCompleted
+	RollingUpgradeStatusCodeFaulted        RollingUpgradeStatusCode = original.RollingUpgradeStatusCodeFaulted
+	RollingUpgradeStatusCodeRollingForward RollingUpgradeStatusCode = original.RollingUpgradeStatusCodeRollingForward
+)
+
+type SettingNames = original.SettingNames
+
+const (
+	AutoLogon          SettingNames = original.AutoLogon
+	FirstLogonCommands SettingNames = original.FirstLogonCommands
+)
+
+type SnapshotStorageAccountTypes = original.SnapshotStorageAccountTypes
+
+const (
+	SnapshotStorageAccountTypesPremiumLRS  SnapshotStorageAccountTypes = original.SnapshotStorageAccountTypesPremiumLRS
+	SnapshotStorageAccountTypesStandardLRS SnapshotStorageAccountTypes = original.SnapshotStorageAccountTypesStandardLRS
+	SnapshotStorageAccountTypesStandardZRS SnapshotStorageAccountTypes = original.SnapshotStorageAccountTypesStandardZRS
+)
+
+type StatusLevelTypes = original.StatusLevelTypes
+
+const (
+	Error   StatusLevelTypes = original.Error
+	Info    StatusLevelTypes = original.Info
+	Warning StatusLevelTypes = original.Warning
+)
+
+type StorageAccountType = original.StorageAccountType
+
+const (
+	StorageAccountTypeStandardLRS StorageAccountType = original.StorageAccountTypeStandardLRS
+	StorageAccountTypeStandardZRS StorageAccountType = original.StorageAccountTypeStandardZRS
+)
+
+type StorageAccountTypes = original.StorageAccountTypes
+
+const (
+	StorageAccountTypesPremiumLRS     StorageAccountTypes = original.StorageAccountTypesPremiumLRS
+	StorageAccountTypesStandardLRS    StorageAccountTypes = original.StorageAccountTypesStandardLRS
+	StorageAccountTypesStandardSSDLRS StorageAccountTypes = original.StorageAccountTypesStandardSSDLRS
+	StorageAccountTypesUltraSSDLRS    StorageAccountTypes = original.StorageAccountTypesUltraSSDLRS
+)
+
+type UpgradeMode = original.UpgradeMode
+
+const (
+	Automatic UpgradeMode = original.Automatic
+	Manual    UpgradeMode = original.Manual
+	Rolling   UpgradeMode = original.Rolling
+)
+
+type UpgradeOperationInvoker = original.UpgradeOperationInvoker
+
+const (
+	UpgradeOperationInvokerPlatform UpgradeOperationInvoker = original.UpgradeOperationInvokerPlatform
+	UpgradeOperationInvokerUnknown  UpgradeOperationInvoker = original.UpgradeOperationInvokerUnknown
+	UpgradeOperationInvokerUser     UpgradeOperationInvoker = original.UpgradeOperationInvokerUser
+)
+
+type UpgradeState = original.UpgradeState
+
+const (
+	UpgradeStateCancelled      UpgradeState = original.UpgradeStateCancelled
+	UpgradeStateCompleted      UpgradeState = original.UpgradeStateCompleted
+	UpgradeStateFaulted        UpgradeState = original.UpgradeStateFaulted
+	UpgradeStateRollingForward UpgradeState = original.UpgradeStateRollingForward
+)
+
+type VirtualMachineEvictionPolicyTypes = original.VirtualMachineEvictionPolicyTypes
+
+const (
+	Deallocate VirtualMachineEvictionPolicyTypes = original.Deallocate
+	Delete     VirtualMachineEvictionPolicyTypes = original.Delete
+)
+
+type VirtualMachinePriorityTypes = original.VirtualMachinePriorityTypes
+
+const (
+	Low     VirtualMachinePriorityTypes = original.Low
+	Regular VirtualMachinePriorityTypes = original.Regular
+)
+
+type VirtualMachineScaleSetSkuScaleType = original.VirtualMachineScaleSetSkuScaleType
+
+const (
+	VirtualMachineScaleSetSkuScaleTypeAutomatic VirtualMachineScaleSetSkuScaleType = original.VirtualMachineScaleSetSkuScaleTypeAutomatic
+	VirtualMachineScaleSetSkuScaleTypeNone      VirtualMachineScaleSetSkuScaleType = original.VirtualMachineScaleSetSkuScaleTypeNone
+)
+
+type VirtualMachineSizeTypes = original.VirtualMachineSizeTypes
+
+const (
+	VirtualMachineSizeTypesBasicA0          VirtualMachineSizeTypes = original.VirtualMachineSizeTypesBasicA0
+	VirtualMachineSizeTypesBasicA1          VirtualMachineSizeTypes = original.VirtualMachineSizeTypesBasicA1
+	VirtualMachineSizeTypesBasicA2          VirtualMachineSizeTypes = original.VirtualMachineSizeTypesBasicA2
+	VirtualMachineSizeTypesBasicA3          VirtualMachineSizeTypes = original.VirtualMachineSizeTypesBasicA3
+	VirtualMachineSizeTypesBasicA4          VirtualMachineSizeTypes = original.VirtualMachineSizeTypesBasicA4
+	VirtualMachineSizeTypesStandardA0       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA0
+	VirtualMachineSizeTypesStandardA1       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA1
+	VirtualMachineSizeTypesStandardA10      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA10
+	VirtualMachineSizeTypesStandardA11      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA11
+	VirtualMachineSizeTypesStandardA1V2     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA1V2
+	VirtualMachineSizeTypesStandardA2       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA2
+	VirtualMachineSizeTypesStandardA2mV2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA2mV2
+	VirtualMachineSizeTypesStandardA2V2     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA2V2
+	VirtualMachineSizeTypesStandardA3       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA3
+	VirtualMachineSizeTypesStandardA4       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA4
+	VirtualMachineSizeTypesStandardA4mV2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA4mV2
+	VirtualMachineSizeTypesStandardA4V2     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA4V2
+	VirtualMachineSizeTypesStandardA5       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA5
+	VirtualMachineSizeTypesStandardA6       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA6
+	VirtualMachineSizeTypesStandardA7       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA7
+	VirtualMachineSizeTypesStandardA8       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA8
+	VirtualMachineSizeTypesStandardA8mV2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA8mV2
+	VirtualMachineSizeTypesStandardA8V2     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA8V2
+	VirtualMachineSizeTypesStandardA9       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardA9
+	VirtualMachineSizeTypesStandardB1ms     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardB1ms
+	VirtualMachineSizeTypesStandardB1s      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardB1s
+	VirtualMachineSizeTypesStandardB2ms     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardB2ms
+	VirtualMachineSizeTypesStandardB2s      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardB2s
+	VirtualMachineSizeTypesStandardB4ms     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardB4ms
+	VirtualMachineSizeTypesStandardB8ms     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardB8ms
+	VirtualMachineSizeTypesStandardD1       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD1
+	VirtualMachineSizeTypesStandardD11      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD11
+	VirtualMachineSizeTypesStandardD11V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD11V2
+	VirtualMachineSizeTypesStandardD12      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD12
+	VirtualMachineSizeTypesStandardD12V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD12V2
+	VirtualMachineSizeTypesStandardD13      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD13
+	VirtualMachineSizeTypesStandardD13V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD13V2
+	VirtualMachineSizeTypesStandardD14      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD14
+	VirtualMachineSizeTypesStandardD14V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD14V2
+	VirtualMachineSizeTypesStandardD15V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD15V2
+	VirtualMachineSizeTypesStandardD16sV3   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD16sV3
+	VirtualMachineSizeTypesStandardD16V3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD16V3
+	VirtualMachineSizeTypesStandardD1V2     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD1V2
+	VirtualMachineSizeTypesStandardD2       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD2
+	VirtualMachineSizeTypesStandardD2sV3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD2sV3
+	VirtualMachineSizeTypesStandardD2V2     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD2V2
+	VirtualMachineSizeTypesStandardD2V3     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD2V3
+	VirtualMachineSizeTypesStandardD3       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD3
+	VirtualMachineSizeTypesStandardD32sV3   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD32sV3
+	VirtualMachineSizeTypesStandardD32V3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD32V3
+	VirtualMachineSizeTypesStandardD3V2     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD3V2
+	VirtualMachineSizeTypesStandardD4       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD4
+	VirtualMachineSizeTypesStandardD4sV3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD4sV3
+	VirtualMachineSizeTypesStandardD4V2     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD4V2
+	VirtualMachineSizeTypesStandardD4V3     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD4V3
+	VirtualMachineSizeTypesStandardD5V2     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD5V2
+	VirtualMachineSizeTypesStandardD64sV3   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD64sV3
+	VirtualMachineSizeTypesStandardD64V3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD64V3
+	VirtualMachineSizeTypesStandardD8sV3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD8sV3
+	VirtualMachineSizeTypesStandardD8V3     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardD8V3
+	VirtualMachineSizeTypesStandardDS1      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS1
+	VirtualMachineSizeTypesStandardDS11     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS11
+	VirtualMachineSizeTypesStandardDS11V2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS11V2
+	VirtualMachineSizeTypesStandardDS12     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS12
+	VirtualMachineSizeTypesStandardDS12V2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS12V2
+	VirtualMachineSizeTypesStandardDS13     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS13
+	VirtualMachineSizeTypesStandardDS132V2  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS132V2
+	VirtualMachineSizeTypesStandardDS134V2  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS134V2
+	VirtualMachineSizeTypesStandardDS13V2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS13V2
+	VirtualMachineSizeTypesStandardDS14     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS14
+	VirtualMachineSizeTypesStandardDS144V2  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS144V2
+	VirtualMachineSizeTypesStandardDS148V2  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS148V2
+	VirtualMachineSizeTypesStandardDS14V2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS14V2
+	VirtualMachineSizeTypesStandardDS15V2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS15V2
+	VirtualMachineSizeTypesStandardDS1V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS1V2
+	VirtualMachineSizeTypesStandardDS2      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS2
+	VirtualMachineSizeTypesStandardDS2V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS2V2
+	VirtualMachineSizeTypesStandardDS3      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS3
+	VirtualMachineSizeTypesStandardDS3V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS3V2
+	VirtualMachineSizeTypesStandardDS4      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS4
+	VirtualMachineSizeTypesStandardDS4V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS4V2
+	VirtualMachineSizeTypesStandardDS5V2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardDS5V2
+	VirtualMachineSizeTypesStandardE16sV3   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE16sV3
+	VirtualMachineSizeTypesStandardE16V3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE16V3
+	VirtualMachineSizeTypesStandardE2sV3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE2sV3
+	VirtualMachineSizeTypesStandardE2V3     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE2V3
+	VirtualMachineSizeTypesStandardE3216V3  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE3216V3
+	VirtualMachineSizeTypesStandardE328sV3  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE328sV3
+	VirtualMachineSizeTypesStandardE32sV3   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE32sV3
+	VirtualMachineSizeTypesStandardE32V3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE32V3
+	VirtualMachineSizeTypesStandardE4sV3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE4sV3
+	VirtualMachineSizeTypesStandardE4V3     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE4V3
+	VirtualMachineSizeTypesStandardE6416sV3 VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE6416sV3
+	VirtualMachineSizeTypesStandardE6432sV3 VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE6432sV3
+	VirtualMachineSizeTypesStandardE64sV3   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE64sV3
+	VirtualMachineSizeTypesStandardE64V3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE64V3
+	VirtualMachineSizeTypesStandardE8sV3    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE8sV3
+	VirtualMachineSizeTypesStandardE8V3     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardE8V3
+	VirtualMachineSizeTypesStandardF1       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF1
+	VirtualMachineSizeTypesStandardF16      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF16
+	VirtualMachineSizeTypesStandardF16s     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF16s
+	VirtualMachineSizeTypesStandardF16sV2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF16sV2
+	VirtualMachineSizeTypesStandardF1s      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF1s
+	VirtualMachineSizeTypesStandardF2       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF2
+	VirtualMachineSizeTypesStandardF2s      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF2s
+	VirtualMachineSizeTypesStandardF2sV2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF2sV2
+	VirtualMachineSizeTypesStandardF32sV2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF32sV2
+	VirtualMachineSizeTypesStandardF4       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF4
+	VirtualMachineSizeTypesStandardF4s      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF4s
+	VirtualMachineSizeTypesStandardF4sV2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF4sV2
+	VirtualMachineSizeTypesStandardF64sV2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF64sV2
+	VirtualMachineSizeTypesStandardF72sV2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF72sV2
+	VirtualMachineSizeTypesStandardF8       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF8
+	VirtualMachineSizeTypesStandardF8s      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF8s
+	VirtualMachineSizeTypesStandardF8sV2    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardF8sV2
+	VirtualMachineSizeTypesStandardG1       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardG1
+	VirtualMachineSizeTypesStandardG2       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardG2
+	VirtualMachineSizeTypesStandardG3       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardG3
+	VirtualMachineSizeTypesStandardG4       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardG4
+	VirtualMachineSizeTypesStandardG5       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardG5
+	VirtualMachineSizeTypesStandardGS1      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardGS1
+	VirtualMachineSizeTypesStandardGS2      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardGS2
+	VirtualMachineSizeTypesStandardGS3      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardGS3
+	VirtualMachineSizeTypesStandardGS4      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardGS4
+	VirtualMachineSizeTypesStandardGS44     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardGS44
+	VirtualMachineSizeTypesStandardGS48     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardGS48
+	VirtualMachineSizeTypesStandardGS5      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardGS5
+	VirtualMachineSizeTypesStandardGS516    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardGS516
+	VirtualMachineSizeTypesStandardGS58     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardGS58
+	VirtualMachineSizeTypesStandardH16      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardH16
+	VirtualMachineSizeTypesStandardH16m     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardH16m
+	VirtualMachineSizeTypesStandardH16mr    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardH16mr
+	VirtualMachineSizeTypesStandardH16r     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardH16r
+	VirtualMachineSizeTypesStandardH8       VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardH8
+	VirtualMachineSizeTypesStandardH8m      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardH8m
+	VirtualMachineSizeTypesStandardL16s     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardL16s
+	VirtualMachineSizeTypesStandardL32s     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardL32s
+	VirtualMachineSizeTypesStandardL4s      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardL4s
+	VirtualMachineSizeTypesStandardL8s      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardL8s
+	VirtualMachineSizeTypesStandardM12832ms VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardM12832ms
+	VirtualMachineSizeTypesStandardM12864ms VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardM12864ms
+	VirtualMachineSizeTypesStandardM128ms   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardM128ms
+	VirtualMachineSizeTypesStandardM128s    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardM128s
+	VirtualMachineSizeTypesStandardM6416ms  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardM6416ms
+	VirtualMachineSizeTypesStandardM6432ms  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardM6432ms
+	VirtualMachineSizeTypesStandardM64ms    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardM64ms
+	VirtualMachineSizeTypesStandardM64s     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardM64s
+	VirtualMachineSizeTypesStandardNC12     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC12
+	VirtualMachineSizeTypesStandardNC12sV2  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC12sV2
+	VirtualMachineSizeTypesStandardNC12sV3  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC12sV3
+	VirtualMachineSizeTypesStandardNC24     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC24
+	VirtualMachineSizeTypesStandardNC24r    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC24r
+	VirtualMachineSizeTypesStandardNC24rsV2 VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC24rsV2
+	VirtualMachineSizeTypesStandardNC24rsV3 VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC24rsV3
+	VirtualMachineSizeTypesStandardNC24sV2  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC24sV2
+	VirtualMachineSizeTypesStandardNC24sV3  VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC24sV3
+	VirtualMachineSizeTypesStandardNC6      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC6
+	VirtualMachineSizeTypesStandardNC6sV2   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC6sV2
+	VirtualMachineSizeTypesStandardNC6sV3   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNC6sV3
+	VirtualMachineSizeTypesStandardND12s    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardND12s
+	VirtualMachineSizeTypesStandardND24rs   VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardND24rs
+	VirtualMachineSizeTypesStandardND24s    VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardND24s
+	VirtualMachineSizeTypesStandardND6s     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardND6s
+	VirtualMachineSizeTypesStandardNV12     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNV12
+	VirtualMachineSizeTypesStandardNV24     VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNV24
+	VirtualMachineSizeTypesStandardNV6      VirtualMachineSizeTypes = original.VirtualMachineSizeTypesStandardNV6
+)
+
+type APIEntityReference = original.APIEntityReference
+type APIError = original.APIError
+type APIErrorBase = original.APIErrorBase
+type AccessURI = original.AccessURI
+type AdditionalCapabilities = original.AdditionalCapabilities
+type AdditionalUnattendContent = original.AdditionalUnattendContent
+type AutomaticOSUpgradePolicy = original.AutomaticOSUpgradePolicy
+type AutomaticOSUpgradeProperties = original.AutomaticOSUpgradeProperties
+type AvailabilitySet = original.AvailabilitySet
+type AvailabilitySetListResult = original.AvailabilitySetListResult
+type AvailabilitySetListResultIterator = original.AvailabilitySetListResultIterator
+type AvailabilitySetListResultPage = original.AvailabilitySetListResultPage
+type AvailabilitySetProperties = original.AvailabilitySetProperties
+type AvailabilitySetUpdate = original.AvailabilitySetUpdate
+type AvailabilitySetsClient = original.AvailabilitySetsClient
+type BaseClient = original.BaseClient
+type BootDiagnostics = original.BootDiagnostics
+type BootDiagnosticsInstanceView = original.BootDiagnosticsInstanceView
+type CloudError = original.CloudError
+type ContainerService = original.ContainerService
+type ContainerServiceAgentPoolProfile = original.ContainerServiceAgentPoolProfile
+type ContainerServiceCustomProfile = original.ContainerServiceCustomProfile
+type ContainerServiceDiagnosticsProfile = original.ContainerServiceDiagnosticsProfile
+type ContainerServiceLinuxProfile = original.ContainerServiceLinuxProfile
+type ContainerServiceListResult = original.ContainerServiceListResult
+type ContainerServiceListResultIterator = original.ContainerServiceListResultIterator
+type ContainerServiceListResultPage = original.ContainerServiceListResultPage
+type ContainerServiceMasterProfile = original.ContainerServiceMasterProfile
+type ContainerServiceOrchestratorProfile = original.ContainerServiceOrchestratorProfile
+type ContainerServiceProperties = original.ContainerServiceProperties
+type ContainerServiceSSHConfiguration = original.ContainerServiceSSHConfiguration
+type ContainerServiceSSHPublicKey = original.ContainerServiceSSHPublicKey
+type ContainerServiceServicePrincipalProfile = original.ContainerServiceServicePrincipalProfile
+type ContainerServiceVMDiagnostics = original.ContainerServiceVMDiagnostics
+type ContainerServiceWindowsProfile = original.ContainerServiceWindowsProfile
+type ContainerServicesClient = original.ContainerServicesClient
+type ContainerServicesCreateOrUpdateFuture = original.ContainerServicesCreateOrUpdateFuture
+type ContainerServicesDeleteFuture = original.ContainerServicesDeleteFuture
+type CreationData = original.CreationData
+type DataDisk = original.DataDisk
+type DataDiskImage = original.DataDiskImage
+type DiagnosticsProfile = original.DiagnosticsProfile
+type DiffDiskSettings = original.DiffDiskSettings
+type Disallowed = original.Disallowed
+type Disk = original.Disk
+type DiskEncryptionSettings = original.DiskEncryptionSettings
+type DiskInstanceView = original.DiskInstanceView
+type DiskList = original.DiskList
+type DiskListIterator = original.DiskListIterator
+type DiskListPage = original.DiskListPage
+type DiskProperties = original.DiskProperties
+type DiskSku = original.DiskSku
+type DiskUpdate = original.DiskUpdate
+type DiskUpdateProperties = original.DiskUpdateProperties
+type DisksClient = original.DisksClient
+type DisksCreateOrUpdateFuture = original.DisksCreateOrUpdateFuture
+type DisksDeleteFuture = original.DisksDeleteFuture
+type DisksGrantAccessFuture = original.DisksGrantAccessFuture
+type DisksRevokeAccessFuture = original.DisksRevokeAccessFuture
+type DisksUpdateFuture = original.DisksUpdateFuture
+type EncryptionSettingsCollection = original.EncryptionSettingsCollection
+type EncryptionSettingsElement = original.EncryptionSettingsElement
+type GalleriesClient = original.GalleriesClient
+type GalleriesCreateOrUpdateFuture = original.GalleriesCreateOrUpdateFuture
+type GalleriesDeleteFuture = original.GalleriesDeleteFuture
+type Gallery = original.Gallery
+type GalleryArtifactPublishingProfileBase = original.GalleryArtifactPublishingProfileBase
+type GalleryArtifactSource = original.GalleryArtifactSource
+type GalleryDataDiskImage = original.GalleryDataDiskImage
+type GalleryDiskImage = original.GalleryDiskImage
+type GalleryIdentifier = original.GalleryIdentifier
+type GalleryImage = original.GalleryImage
+type GalleryImageIdentifier = original.GalleryImageIdentifier
+type GalleryImageList = original.GalleryImageList
+type GalleryImageListIterator = original.GalleryImageListIterator
+type GalleryImageListPage = original.GalleryImageListPage
+type GalleryImageProperties = original.GalleryImageProperties
+type GalleryImageVersion = original.GalleryImageVersion
+type GalleryImageVersionList = original.GalleryImageVersionList
+type GalleryImageVersionListIterator = original.GalleryImageVersionListIterator
+type GalleryImageVersionListPage = original.GalleryImageVersionListPage
+type GalleryImageVersionProperties = original.GalleryImageVersionProperties
+type GalleryImageVersionPublishingProfile = original.GalleryImageVersionPublishingProfile
+type GalleryImageVersionStorageProfile = original.GalleryImageVersionStorageProfile
+type GalleryImageVersionsClient = original.GalleryImageVersionsClient
+type GalleryImageVersionsCreateOrUpdateFuture = original.GalleryImageVersionsCreateOrUpdateFuture
+type GalleryImageVersionsDeleteFuture = original.GalleryImageVersionsDeleteFuture
+type GalleryImagesClient = original.GalleryImagesClient
+type GalleryImagesCreateOrUpdateFuture = original.GalleryImagesCreateOrUpdateFuture
+type GalleryImagesDeleteFuture = original.GalleryImagesDeleteFuture
+type GalleryList = original.GalleryList
+type GalleryListIterator = original.GalleryListIterator
+type GalleryListPage = original.GalleryListPage
+type GalleryOSDiskImage = original.GalleryOSDiskImage
+type GalleryProperties = original.GalleryProperties
+type GrantAccessData = original.GrantAccessData
+type HardwareProfile = original.HardwareProfile
+type Image = original.Image
+type ImageDataDisk = original.ImageDataDisk
+type ImageDiskReference = original.ImageDiskReference
+type ImageListResult = original.ImageListResult
+type ImageListResultIterator = original.ImageListResultIterator
+type ImageListResultPage = original.ImageListResultPage
+type ImageOSDisk = original.ImageOSDisk
+type ImageProperties = original.ImageProperties
+type ImagePurchasePlan = original.ImagePurchasePlan
+type ImageReference = original.ImageReference
+type ImageStorageProfile = original.ImageStorageProfile
+type ImageUpdate = original.ImageUpdate
+type ImagesClient = original.ImagesClient
+type ImagesCreateOrUpdateFuture = original.ImagesCreateOrUpdateFuture
+type ImagesDeleteFuture = original.ImagesDeleteFuture
+type ImagesUpdateFuture = original.ImagesUpdateFuture
+type InnerError = original.InnerError
+type InstanceViewStatus = original.InstanceViewStatus
+type KeyVaultAndKeyReference = original.KeyVaultAndKeyReference
+type KeyVaultAndSecretReference = original.KeyVaultAndSecretReference
+type KeyVaultKeyReference = original.KeyVaultKeyReference
+type KeyVaultSecretReference = original.KeyVaultSecretReference
+type LinuxConfiguration = original.LinuxConfiguration
+type ListUsagesResult = original.ListUsagesResult
+type ListUsagesResultIterator = original.ListUsagesResultIterator
+type ListUsagesResultPage = original.ListUsagesResultPage
+type ListVirtualMachineExtensionImage = original.ListVirtualMachineExtensionImage
+type ListVirtualMachineImageResource = original.ListVirtualMachineImageResource
+type LogAnalyticsClient = original.LogAnalyticsClient
+type LogAnalyticsExportRequestRateByIntervalFuture = original.LogAnalyticsExportRequestRateByIntervalFuture
+type LogAnalyticsExportThrottledRequestsFuture = original.LogAnalyticsExportThrottledRequestsFuture
+type LogAnalyticsInputBase = original.LogAnalyticsInputBase
+type LogAnalyticsOperationResult = original.LogAnalyticsOperationResult
+type LogAnalyticsOutput = original.LogAnalyticsOutput
+type MaintenanceRedeployStatus = original.MaintenanceRedeployStatus
+type ManagedArtifact = original.ManagedArtifact
+type ManagedDiskParameters = original.ManagedDiskParameters
+type NetworkInterfaceReference = original.NetworkInterfaceReference
+type NetworkInterfaceReferenceProperties = original.NetworkInterfaceReferenceProperties
+type NetworkProfile = original.NetworkProfile
+type OSDisk = original.OSDisk
+type OSDiskImage = original.OSDiskImage
+type OSProfile = original.OSProfile
+type OperationListResult = original.OperationListResult
+type OperationValue = original.OperationValue
+type OperationValueDisplay = original.OperationValueDisplay
+type OperationsClient = original.OperationsClient
+type Plan = original.Plan
+type ProximityPlacementGroup = original.ProximityPlacementGroup
+type ProximityPlacementGroupListResult = original.ProximityPlacementGroupListResult
+type ProximityPlacementGroupListResultIterator = original.ProximityPlacementGroupListResultIterator
+type ProximityPlacementGroupListResultPage = original.ProximityPlacementGroupListResultPage
+type ProximityPlacementGroupProperties = original.ProximityPlacementGroupProperties
+type ProximityPlacementGroupUpdate = original.ProximityPlacementGroupUpdate
+type ProximityPlacementGroupsClient = original.ProximityPlacementGroupsClient
+type PurchasePlan = original.PurchasePlan
+type RecommendedMachineConfiguration = original.RecommendedMachineConfiguration
+type RecoveryWalkResponse = original.RecoveryWalkResponse
+type RegionalReplicationStatus = original.RegionalReplicationStatus
+type ReplicationStatus = original.ReplicationStatus
+type RequestRateByIntervalInput = original.RequestRateByIntervalInput
+type Resource = original.Resource
+type ResourceRange = original.ResourceRange
+type ResourceSku = original.ResourceSku
+type ResourceSkuCapabilities = original.ResourceSkuCapabilities
+type ResourceSkuCapacity = original.ResourceSkuCapacity
+type ResourceSkuCosts = original.ResourceSkuCosts
+type ResourceSkuLocationInfo = original.ResourceSkuLocationInfo
+type ResourceSkuRestrictionInfo = original.ResourceSkuRestrictionInfo
+type ResourceSkuRestrictions = original.ResourceSkuRestrictions
+type ResourceSkuZoneDetails = original.ResourceSkuZoneDetails
+type ResourceSkusClient = original.ResourceSkusClient
+type ResourceSkusResult = original.ResourceSkusResult
+type ResourceSkusResultIterator = original.ResourceSkusResultIterator
+type ResourceSkusResultPage = original.ResourceSkusResultPage
+type RollbackStatusInfo = original.RollbackStatusInfo
+type RollingUpgradePolicy = original.RollingUpgradePolicy
+type RollingUpgradeProgressInfo = original.RollingUpgradeProgressInfo
+type RollingUpgradeRunningStatus = original.RollingUpgradeRunningStatus
+type RollingUpgradeStatusInfo = original.RollingUpgradeStatusInfo
+type RollingUpgradeStatusInfoProperties = original.RollingUpgradeStatusInfoProperties
+type RunCommandDocument = original.RunCommandDocument
+type RunCommandDocumentBase = original.RunCommandDocumentBase
+type RunCommandInput = original.RunCommandInput
+type RunCommandInputParameter = original.RunCommandInputParameter
+type RunCommandListResult = original.RunCommandListResult
+type RunCommandListResultIterator = original.RunCommandListResultIterator
+type RunCommandListResultPage = original.RunCommandListResultPage
+type RunCommandParameterDefinition = original.RunCommandParameterDefinition
+type RunCommandResult = original.RunCommandResult
+type SSHConfiguration = original.SSHConfiguration
+type SSHPublicKey = original.SSHPublicKey
+type Sku = original.Sku
+type Snapshot = original.Snapshot
+type SnapshotList = original.SnapshotList
+type SnapshotListIterator = original.SnapshotListIterator
+type SnapshotListPage = original.SnapshotListPage
+type SnapshotProperties = original.SnapshotProperties
+type SnapshotSku = original.SnapshotSku
+type SnapshotUpdate = original.SnapshotUpdate
+type SnapshotUpdateProperties = original.SnapshotUpdateProperties
+type SnapshotsClient = original.SnapshotsClient
+type SnapshotsCreateOrUpdateFuture = original.SnapshotsCreateOrUpdateFuture
+type SnapshotsDeleteFuture = original.SnapshotsDeleteFuture
+type SnapshotsGrantAccessFuture = original.SnapshotsGrantAccessFuture
+type SnapshotsRevokeAccessFuture = original.SnapshotsRevokeAccessFuture
+type SnapshotsUpdateFuture = original.SnapshotsUpdateFuture
+type SourceVault = original.SourceVault
+type StorageProfile = original.StorageProfile
+type SubResource = original.SubResource
+type SubResourceReadOnly = original.SubResourceReadOnly
+type TargetRegion = original.TargetRegion
+type ThrottledRequestsInput = original.ThrottledRequestsInput
+type UpdateResource = original.UpdateResource
+type UpgradeOperationHistoricalStatusInfo = original.UpgradeOperationHistoricalStatusInfo
+type UpgradeOperationHistoricalStatusInfoProperties = original.UpgradeOperationHistoricalStatusInfoProperties
+type UpgradeOperationHistoryStatus = original.UpgradeOperationHistoryStatus
+type UpgradePolicy = original.UpgradePolicy
+type Usage = original.Usage
+type UsageClient = original.UsageClient
+type UsageName = original.UsageName
+type VMScaleSetConvertToSinglePlacementGroupInput = original.VMScaleSetConvertToSinglePlacementGroupInput
+type VaultCertificate = original.VaultCertificate
+type VaultSecretGroup = original.VaultSecretGroup
+type VirtualHardDisk = original.VirtualHardDisk
+type VirtualMachine = original.VirtualMachine
+type VirtualMachineAgentInstanceView = original.VirtualMachineAgentInstanceView
+type VirtualMachineCaptureParameters = original.VirtualMachineCaptureParameters
+type VirtualMachineCaptureResult = original.VirtualMachineCaptureResult
+type VirtualMachineExtension = original.VirtualMachineExtension
+type VirtualMachineExtensionHandlerInstanceView = original.VirtualMachineExtensionHandlerInstanceView
+type VirtualMachineExtensionImage = original.VirtualMachineExtensionImage
+type VirtualMachineExtensionImageProperties = original.VirtualMachineExtensionImageProperties
+type VirtualMachineExtensionImagesClient = original.VirtualMachineExtensionImagesClient
+type VirtualMachineExtensionInstanceView = original.VirtualMachineExtensionInstanceView
+type VirtualMachineExtensionProperties = original.VirtualMachineExtensionProperties
+type VirtualMachineExtensionUpdate = original.VirtualMachineExtensionUpdate
+type VirtualMachineExtensionUpdateProperties = original.VirtualMachineExtensionUpdateProperties
+type VirtualMachineExtensionsClient = original.VirtualMachineExtensionsClient
+type VirtualMachineExtensionsCreateOrUpdateFuture = original.VirtualMachineExtensionsCreateOrUpdateFuture
+type VirtualMachineExtensionsDeleteFuture = original.VirtualMachineExtensionsDeleteFuture
+type VirtualMachineExtensionsListResult = original.VirtualMachineExtensionsListResult
+type VirtualMachineExtensionsUpdateFuture = original.VirtualMachineExtensionsUpdateFuture
+type VirtualMachineHealthStatus = original.VirtualMachineHealthStatus
+type VirtualMachineIdentity = original.VirtualMachineIdentity
+type VirtualMachineIdentityUserAssignedIdentitiesValue = original.VirtualMachineIdentityUserAssignedIdentitiesValue
+type VirtualMachineImage = original.VirtualMachineImage
+type VirtualMachineImageProperties = original.VirtualMachineImageProperties
+type VirtualMachineImageResource = original.VirtualMachineImageResource
+type VirtualMachineImagesClient = original.VirtualMachineImagesClient
+type VirtualMachineInstanceView = original.VirtualMachineInstanceView
+type VirtualMachineListResult = original.VirtualMachineListResult
+type VirtualMachineListResultIterator = original.VirtualMachineListResultIterator
+type VirtualMachineListResultPage = original.VirtualMachineListResultPage
+type VirtualMachineProperties = original.VirtualMachineProperties
+type VirtualMachineReimageParameters = original.VirtualMachineReimageParameters
+type VirtualMachineRunCommandsClient = original.VirtualMachineRunCommandsClient
+type VirtualMachineScaleSet = original.VirtualMachineScaleSet
+type VirtualMachineScaleSetDataDisk = original.VirtualMachineScaleSetDataDisk
+type VirtualMachineScaleSetExtension = original.VirtualMachineScaleSetExtension
+type VirtualMachineScaleSetExtensionListResult = original.VirtualMachineScaleSetExtensionListResult
+type VirtualMachineScaleSetExtensionListResultIterator = original.VirtualMachineScaleSetExtensionListResultIterator
+type VirtualMachineScaleSetExtensionListResultPage = original.VirtualMachineScaleSetExtensionListResultPage
+type VirtualMachineScaleSetExtensionProfile = original.VirtualMachineScaleSetExtensionProfile
+type VirtualMachineScaleSetExtensionProperties = original.VirtualMachineScaleSetExtensionProperties
+type VirtualMachineScaleSetExtensionsClient = original.VirtualMachineScaleSetExtensionsClient
+type VirtualMachineScaleSetExtensionsCreateOrUpdateFuture = original.VirtualMachineScaleSetExtensionsCreateOrUpdateFuture
+type VirtualMachineScaleSetExtensionsDeleteFuture = original.VirtualMachineScaleSetExtensionsDeleteFuture
+type VirtualMachineScaleSetIPConfiguration = original.VirtualMachineScaleSetIPConfiguration
+type VirtualMachineScaleSetIPConfigurationProperties = original.VirtualMachineScaleSetIPConfigurationProperties
+type VirtualMachineScaleSetIPTag = original.VirtualMachineScaleSetIPTag
+type VirtualMachineScaleSetIdentity = original.VirtualMachineScaleSetIdentity
+type VirtualMachineScaleSetIdentityUserAssignedIdentitiesValue = original.VirtualMachineScaleSetIdentityUserAssignedIdentitiesValue
+type VirtualMachineScaleSetInstanceView = original.VirtualMachineScaleSetInstanceView
+type VirtualMachineScaleSetInstanceViewStatusesSummary = original.VirtualMachineScaleSetInstanceViewStatusesSummary
+type VirtualMachineScaleSetListOSUpgradeHistory = original.VirtualMachineScaleSetListOSUpgradeHistory
+type VirtualMachineScaleSetListOSUpgradeHistoryIterator = original.VirtualMachineScaleSetListOSUpgradeHistoryIterator
+type VirtualMachineScaleSetListOSUpgradeHistoryPage = original.VirtualMachineScaleSetListOSUpgradeHistoryPage
+type VirtualMachineScaleSetListResult = original.VirtualMachineScaleSetListResult
+type VirtualMachineScaleSetListResultIterator = original.VirtualMachineScaleSetListResultIterator
+type VirtualMachineScaleSetListResultPage = original.VirtualMachineScaleSetListResultPage
+type VirtualMachineScaleSetListSkusResult = original.VirtualMachineScaleSetListSkusResult
+type VirtualMachineScaleSetListSkusResultIterator = original.VirtualMachineScaleSetListSkusResultIterator
+type VirtualMachineScaleSetListSkusResultPage = original.VirtualMachineScaleSetListSkusResultPage
+type VirtualMachineScaleSetListWithLinkResult = original.VirtualMachineScaleSetListWithLinkResult
+type VirtualMachineScaleSetListWithLinkResultIterator = original.VirtualMachineScaleSetListWithLinkResultIterator
+type VirtualMachineScaleSetListWithLinkResultPage = original.VirtualMachineScaleSetListWithLinkResultPage
+type VirtualMachineScaleSetManagedDiskParameters = original.VirtualMachineScaleSetManagedDiskParameters
+type VirtualMachineScaleSetNetworkConfiguration = original.VirtualMachineScaleSetNetworkConfiguration
+type VirtualMachineScaleSetNetworkConfigurationDNSSettings = original.VirtualMachineScaleSetNetworkConfigurationDNSSettings
+type VirtualMachineScaleSetNetworkConfigurationProperties = original.VirtualMachineScaleSetNetworkConfigurationProperties
+type VirtualMachineScaleSetNetworkProfile = original.VirtualMachineScaleSetNetworkProfile
+type VirtualMachineScaleSetOSDisk = original.VirtualMachineScaleSetOSDisk
+type VirtualMachineScaleSetOSProfile = original.VirtualMachineScaleSetOSProfile
+type VirtualMachineScaleSetProperties = original.VirtualMachineScaleSetProperties
+type VirtualMachineScaleSetPublicIPAddressConfiguration = original.VirtualMachineScaleSetPublicIPAddressConfiguration
+type VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings = original.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings
+type VirtualMachineScaleSetPublicIPAddressConfigurationProperties = original.VirtualMachineScaleSetPublicIPAddressConfigurationProperties
+type VirtualMachineScaleSetReimageParameters = original.VirtualMachineScaleSetReimageParameters
+type VirtualMachineScaleSetRollingUpgradesCancelFuture = original.VirtualMachineScaleSetRollingUpgradesCancelFuture
+type VirtualMachineScaleSetRollingUpgradesClient = original.VirtualMachineScaleSetRollingUpgradesClient
+type VirtualMachineScaleSetRollingUpgradesStartExtensionUpgradeFuture = original.VirtualMachineScaleSetRollingUpgradesStartExtensionUpgradeFuture
+type VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture = original.VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture
+type VirtualMachineScaleSetSku = original.VirtualMachineScaleSetSku
+type VirtualMachineScaleSetSkuCapacity = original.VirtualMachineScaleSetSkuCapacity
+type VirtualMachineScaleSetStorageProfile = original.VirtualMachineScaleSetStorageProfile
+type VirtualMachineScaleSetUpdate = original.VirtualMachineScaleSetUpdate
+type VirtualMachineScaleSetUpdateIPConfiguration = original.VirtualMachineScaleSetUpdateIPConfiguration
+type VirtualMachineScaleSetUpdateIPConfigurationProperties = original.VirtualMachineScaleSetUpdateIPConfigurationProperties
+type VirtualMachineScaleSetUpdateNetworkConfiguration = original.VirtualMachineScaleSetUpdateNetworkConfiguration
+type VirtualMachineScaleSetUpdateNetworkConfigurationProperties = original.VirtualMachineScaleSetUpdateNetworkConfigurationProperties
+type VirtualMachineScaleSetUpdateNetworkProfile = original.VirtualMachineScaleSetUpdateNetworkProfile
+type VirtualMachineScaleSetUpdateOSDisk = original.VirtualMachineScaleSetUpdateOSDisk
+type VirtualMachineScaleSetUpdateOSProfile = original.VirtualMachineScaleSetUpdateOSProfile
+type VirtualMachineScaleSetUpdateProperties = original.VirtualMachineScaleSetUpdateProperties
+type VirtualMachineScaleSetUpdatePublicIPAddressConfiguration = original.VirtualMachineScaleSetUpdatePublicIPAddressConfiguration
+type VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties = original.VirtualMachineScaleSetUpdatePublicIPAddressConfigurationProperties
+type VirtualMachineScaleSetUpdateStorageProfile = original.VirtualMachineScaleSetUpdateStorageProfile
+type VirtualMachineScaleSetUpdateVMProfile = original.VirtualMachineScaleSetUpdateVMProfile
+type VirtualMachineScaleSetVM = original.VirtualMachineScaleSetVM
+type VirtualMachineScaleSetVMExtensionsSummary = original.VirtualMachineScaleSetVMExtensionsSummary
+type VirtualMachineScaleSetVMInstanceIDs = original.VirtualMachineScaleSetVMInstanceIDs
+type VirtualMachineScaleSetVMInstanceRequiredIDs = original.VirtualMachineScaleSetVMInstanceRequiredIDs
+type VirtualMachineScaleSetVMInstanceView = original.VirtualMachineScaleSetVMInstanceView
+type VirtualMachineScaleSetVMListResult = original.VirtualMachineScaleSetVMListResult
+type VirtualMachineScaleSetVMListResultIterator = original.VirtualMachineScaleSetVMListResultIterator
+type VirtualMachineScaleSetVMListResultPage = original.VirtualMachineScaleSetVMListResultPage
+type VirtualMachineScaleSetVMNetworkProfileConfiguration = original.VirtualMachineScaleSetVMNetworkProfileConfiguration
+type VirtualMachineScaleSetVMProfile = original.VirtualMachineScaleSetVMProfile
+type VirtualMachineScaleSetVMProperties = original.VirtualMachineScaleSetVMProperties
+type VirtualMachineScaleSetVMProtectionPolicy = original.VirtualMachineScaleSetVMProtectionPolicy
+type VirtualMachineScaleSetVMReimageParameters = original.VirtualMachineScaleSetVMReimageParameters
+type VirtualMachineScaleSetVMsClient = original.VirtualMachineScaleSetVMsClient
+type VirtualMachineScaleSetVMsDeallocateFuture = original.VirtualMachineScaleSetVMsDeallocateFuture
+type VirtualMachineScaleSetVMsDeleteFuture = original.VirtualMachineScaleSetVMsDeleteFuture
+type VirtualMachineScaleSetVMsPerformMaintenanceFuture = original.VirtualMachineScaleSetVMsPerformMaintenanceFuture
+type VirtualMachineScaleSetVMsPowerOffFuture = original.VirtualMachineScaleSetVMsPowerOffFuture
+type VirtualMachineScaleSetVMsRedeployFuture = original.VirtualMachineScaleSetVMsRedeployFuture
+type VirtualMachineScaleSetVMsReimageAllFuture = original.VirtualMachineScaleSetVMsReimageAllFuture
+type VirtualMachineScaleSetVMsReimageFuture = original.VirtualMachineScaleSetVMsReimageFuture
+type VirtualMachineScaleSetVMsRestartFuture = original.VirtualMachineScaleSetVMsRestartFuture
+type VirtualMachineScaleSetVMsRunCommandFuture = original.VirtualMachineScaleSetVMsRunCommandFuture
+type VirtualMachineScaleSetVMsStartFuture = original.VirtualMachineScaleSetVMsStartFuture
+type VirtualMachineScaleSetVMsUpdateFuture = original.VirtualMachineScaleSetVMsUpdateFuture
+type VirtualMachineScaleSetsClient = original.VirtualMachineScaleSetsClient
+type VirtualMachineScaleSetsCreateOrUpdateFuture = original.VirtualMachineScaleSetsCreateOrUpdateFuture
+type VirtualMachineScaleSetsDeallocateFuture = original.VirtualMachineScaleSetsDeallocateFuture
+type VirtualMachineScaleSetsDeleteFuture = original.VirtualMachineScaleSetsDeleteFuture
+type VirtualMachineScaleSetsDeleteInstancesFuture = original.VirtualMachineScaleSetsDeleteInstancesFuture
+type VirtualMachineScaleSetsPerformMaintenanceFuture = original.VirtualMachineScaleSetsPerformMaintenanceFuture
+type VirtualMachineScaleSetsPowerOffFuture = original.VirtualMachineScaleSetsPowerOffFuture
+type VirtualMachineScaleSetsRedeployFuture = original.VirtualMachineScaleSetsRedeployFuture
+type VirtualMachineScaleSetsReimageAllFuture = original.VirtualMachineScaleSetsReimageAllFuture
+type VirtualMachineScaleSetsReimageFuture = original.VirtualMachineScaleSetsReimageFuture
+type VirtualMachineScaleSetsRestartFuture = original.VirtualMachineScaleSetsRestartFuture
+type VirtualMachineScaleSetsStartFuture = original.VirtualMachineScaleSetsStartFuture
+type VirtualMachineScaleSetsUpdateFuture = original.VirtualMachineScaleSetsUpdateFuture
+type VirtualMachineScaleSetsUpdateInstancesFuture = original.VirtualMachineScaleSetsUpdateInstancesFuture
+type VirtualMachineSize = original.VirtualMachineSize
+type VirtualMachineSizeListResult = original.VirtualMachineSizeListResult
+type VirtualMachineSizesClient = original.VirtualMachineSizesClient
+type VirtualMachineStatusCodeCount = original.VirtualMachineStatusCodeCount
+type VirtualMachineUpdate = original.VirtualMachineUpdate
+type VirtualMachinesCaptureFuture = original.VirtualMachinesCaptureFuture
+type VirtualMachinesClient = original.VirtualMachinesClient
+type VirtualMachinesConvertToManagedDisksFuture = original.VirtualMachinesConvertToManagedDisksFuture
+type VirtualMachinesCreateOrUpdateFuture = original.VirtualMachinesCreateOrUpdateFuture
+type VirtualMachinesDeallocateFuture = original.VirtualMachinesDeallocateFuture
+type VirtualMachinesDeleteFuture = original.VirtualMachinesDeleteFuture
+type VirtualMachinesPerformMaintenanceFuture = original.VirtualMachinesPerformMaintenanceFuture
+type VirtualMachinesPowerOffFuture = original.VirtualMachinesPowerOffFuture
+type VirtualMachinesRedeployFuture = original.VirtualMachinesRedeployFuture
+type VirtualMachinesReimageFuture = original.VirtualMachinesReimageFuture
+type VirtualMachinesRestartFuture = original.VirtualMachinesRestartFuture
+type VirtualMachinesRunCommandFuture = original.VirtualMachinesRunCommandFuture
+type VirtualMachinesStartFuture = original.VirtualMachinesStartFuture
+type VirtualMachinesUpdateFuture = original.VirtualMachinesUpdateFuture
+type WinRMConfiguration = original.WinRMConfiguration
+type WinRMListener = original.WinRMListener
+type WindowsConfiguration = original.WindowsConfiguration
+
+func New(subscriptionID string) BaseClient {
+	return original.New(subscriptionID)
+}
+func NewAvailabilitySetListResultIterator(page AvailabilitySetListResultPage) AvailabilitySetListResultIterator {
+	return original.NewAvailabilitySetListResultIterator(page)
+}
+func NewAvailabilitySetListResultPage(getNextPage func(context.Context, AvailabilitySetListResult) (AvailabilitySetListResult, error)) AvailabilitySetListResultPage {
+	return original.NewAvailabilitySetListResultPage(getNextPage)
+}
+func NewAvailabilitySetsClient(subscriptionID string) AvailabilitySetsClient {
+	return original.NewAvailabilitySetsClient(subscriptionID)
+}
+func NewAvailabilitySetsClientWithBaseURI(baseURI string, subscriptionID string) AvailabilitySetsClient {
+	return original.NewAvailabilitySetsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewContainerServiceListResultIterator(page ContainerServiceListResultPage) ContainerServiceListResultIterator {
+	return original.NewContainerServiceListResultIterator(page)
+}
+func NewContainerServiceListResultPage(getNextPage func(context.Context, ContainerServiceListResult) (ContainerServiceListResult, error)) ContainerServiceListResultPage {
+	return original.NewContainerServiceListResultPage(getNextPage)
+}
+func NewContainerServicesClient(subscriptionID string) ContainerServicesClient {
+	return original.NewContainerServicesClient(subscriptionID)
+}
+func NewContainerServicesClientWithBaseURI(baseURI string, subscriptionID string) ContainerServicesClient {
+	return original.NewContainerServicesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewDiskListIterator(page DiskListPage) DiskListIterator {
+	return original.NewDiskListIterator(page)
+}
+func NewDiskListPage(getNextPage func(context.Context, DiskList) (DiskList, error)) DiskListPage {
+	return original.NewDiskListPage(getNextPage)
+}
+func NewDisksClient(subscriptionID string) DisksClient {
+	return original.NewDisksClient(subscriptionID)
+}
+func NewDisksClientWithBaseURI(baseURI string, subscriptionID string) DisksClient {
+	return original.NewDisksClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewGalleriesClient(subscriptionID string) GalleriesClient {
+	return original.NewGalleriesClient(subscriptionID)
+}
+func NewGalleriesClientWithBaseURI(baseURI string, subscriptionID string) GalleriesClient {
+	return original.NewGalleriesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewGalleryImageListIterator(page GalleryImageListPage) GalleryImageListIterator {
+	return original.NewGalleryImageListIterator(page)
+}
+func NewGalleryImageListPage(getNextPage func(context.Context, GalleryImageList) (GalleryImageList, error)) GalleryImageListPage {
+	return original.NewGalleryImageListPage(getNextPage)
+}
+func NewGalleryImageVersionListIterator(page GalleryImageVersionListPage) GalleryImageVersionListIterator {
+	return original.NewGalleryImageVersionListIterator(page)
+}
+func NewGalleryImageVersionListPage(getNextPage func(context.Context, GalleryImageVersionList) (GalleryImageVersionList, error)) GalleryImageVersionListPage {
+	return original.NewGalleryImageVersionListPage(getNextPage)
+}
+func NewGalleryImageVersionsClient(subscriptionID string) GalleryImageVersionsClient {
+	return original.NewGalleryImageVersionsClient(subscriptionID)
+}
+func NewGalleryImageVersionsClientWithBaseURI(baseURI string, subscriptionID string) GalleryImageVersionsClient {
+	return original.NewGalleryImageVersionsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewGalleryImagesClient(subscriptionID string) GalleryImagesClient {
+	return original.NewGalleryImagesClient(subscriptionID)
+}
+func NewGalleryImagesClientWithBaseURI(baseURI string, subscriptionID string) GalleryImagesClient {
+	return original.NewGalleryImagesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewGalleryListIterator(page GalleryListPage) GalleryListIterator {
+	return original.NewGalleryListIterator(page)
+}
+func NewGalleryListPage(getNextPage func(context.Context, GalleryList) (GalleryList, error)) GalleryListPage {
+	return original.NewGalleryListPage(getNextPage)
+}
+func NewImageListResultIterator(page ImageListResultPage) ImageListResultIterator {
+	return original.NewImageListResultIterator(page)
+}
+func NewImageListResultPage(getNextPage func(context.Context, ImageListResult) (ImageListResult, error)) ImageListResultPage {
+	return original.NewImageListResultPage(getNextPage)
+}
+func NewImagesClient(subscriptionID string) ImagesClient {
+	return original.NewImagesClient(subscriptionID)
+}
+func NewImagesClientWithBaseURI(baseURI string, subscriptionID string) ImagesClient {
+	return original.NewImagesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewListUsagesResultIterator(page ListUsagesResultPage) ListUsagesResultIterator {
+	return original.NewListUsagesResultIterator(page)
+}
+func NewListUsagesResultPage(getNextPage func(context.Context, ListUsagesResult) (ListUsagesResult, error)) ListUsagesResultPage {
+	return original.NewListUsagesResultPage(getNextPage)
+}
+func NewLogAnalyticsClient(subscriptionID string) LogAnalyticsClient {
+	return original.NewLogAnalyticsClient(subscriptionID)
+}
+func NewLogAnalyticsClientWithBaseURI(baseURI string, subscriptionID string) LogAnalyticsClient {
+	return original.NewLogAnalyticsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewOperationsClient(subscriptionID string) OperationsClient {
+	return original.NewOperationsClient(subscriptionID)
+}
+func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient {
+	return original.NewOperationsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewProximityPlacementGroupListResultIterator(page ProximityPlacementGroupListResultPage) ProximityPlacementGroupListResultIterator {
+	return original.NewProximityPlacementGroupListResultIterator(page)
+}
+func NewProximityPlacementGroupListResultPage(getNextPage func(context.Context, ProximityPlacementGroupListResult) (ProximityPlacementGroupListResult, error)) ProximityPlacementGroupListResultPage {
+	return original.NewProximityPlacementGroupListResultPage(getNextPage)
+}
+func NewProximityPlacementGroupsClient(subscriptionID string) ProximityPlacementGroupsClient {
+	return original.NewProximityPlacementGroupsClient(subscriptionID)
+}
+func NewProximityPlacementGroupsClientWithBaseURI(baseURI string, subscriptionID string) ProximityPlacementGroupsClient {
+	return original.NewProximityPlacementGroupsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewResourceSkusClient(subscriptionID string) ResourceSkusClient {
+	return original.NewResourceSkusClient(subscriptionID)
+}
+func NewResourceSkusClientWithBaseURI(baseURI string, subscriptionID string) ResourceSkusClient {
+	return original.NewResourceSkusClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewResourceSkusResultIterator(page ResourceSkusResultPage) ResourceSkusResultIterator {
+	return original.NewResourceSkusResultIterator(page)
+}
+func NewResourceSkusResultPage(getNextPage func(context.Context, ResourceSkusResult) (ResourceSkusResult, error)) ResourceSkusResultPage {
+	return original.NewResourceSkusResultPage(getNextPage)
+}
+func NewRunCommandListResultIterator(page RunCommandListResultPage) RunCommandListResultIterator {
+	return original.NewRunCommandListResultIterator(page)
+}
+func NewRunCommandListResultPage(getNextPage func(context.Context, RunCommandListResult) (RunCommandListResult, error)) RunCommandListResultPage {
+	return original.NewRunCommandListResultPage(getNextPage)
+}
+func NewSnapshotListIterator(page SnapshotListPage) SnapshotListIterator {
+	return original.NewSnapshotListIterator(page)
+}
+func NewSnapshotListPage(getNextPage func(context.Context, SnapshotList) (SnapshotList, error)) SnapshotListPage {
+	return original.NewSnapshotListPage(getNextPage)
+}
+func NewSnapshotsClient(subscriptionID string) SnapshotsClient {
+	return original.NewSnapshotsClient(subscriptionID)
+}
+func NewSnapshotsClientWithBaseURI(baseURI string, subscriptionID string) SnapshotsClient {
+	return original.NewSnapshotsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewUsageClient(subscriptionID string) UsageClient {
+	return original.NewUsageClient(subscriptionID)
+}
+func NewUsageClientWithBaseURI(baseURI string, subscriptionID string) UsageClient {
+	return original.NewUsageClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineExtensionImagesClient(subscriptionID string) VirtualMachineExtensionImagesClient {
+	return original.NewVirtualMachineExtensionImagesClient(subscriptionID)
+}
+func NewVirtualMachineExtensionImagesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineExtensionImagesClient {
+	return original.NewVirtualMachineExtensionImagesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineExtensionsClient(subscriptionID string) VirtualMachineExtensionsClient {
+	return original.NewVirtualMachineExtensionsClient(subscriptionID)
+}
+func NewVirtualMachineExtensionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineExtensionsClient {
+	return original.NewVirtualMachineExtensionsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineImagesClient(subscriptionID string) VirtualMachineImagesClient {
+	return original.NewVirtualMachineImagesClient(subscriptionID)
+}
+func NewVirtualMachineImagesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineImagesClient {
+	return original.NewVirtualMachineImagesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineListResultIterator(page VirtualMachineListResultPage) VirtualMachineListResultIterator {
+	return original.NewVirtualMachineListResultIterator(page)
+}
+func NewVirtualMachineListResultPage(getNextPage func(context.Context, VirtualMachineListResult) (VirtualMachineListResult, error)) VirtualMachineListResultPage {
+	return original.NewVirtualMachineListResultPage(getNextPage)
+}
+func NewVirtualMachineRunCommandsClient(subscriptionID string) VirtualMachineRunCommandsClient {
+	return original.NewVirtualMachineRunCommandsClient(subscriptionID)
+}
+func NewVirtualMachineRunCommandsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineRunCommandsClient {
+	return original.NewVirtualMachineRunCommandsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineScaleSetExtensionListResultIterator(page VirtualMachineScaleSetExtensionListResultPage) VirtualMachineScaleSetExtensionListResultIterator {
+	return original.NewVirtualMachineScaleSetExtensionListResultIterator(page)
+}
+func NewVirtualMachineScaleSetExtensionListResultPage(getNextPage func(context.Context, VirtualMachineScaleSetExtensionListResult) (VirtualMachineScaleSetExtensionListResult, error)) VirtualMachineScaleSetExtensionListResultPage {
+	return original.NewVirtualMachineScaleSetExtensionListResultPage(getNextPage)
+}
+func NewVirtualMachineScaleSetExtensionsClient(subscriptionID string) VirtualMachineScaleSetExtensionsClient {
+	return original.NewVirtualMachineScaleSetExtensionsClient(subscriptionID)
+}
+func NewVirtualMachineScaleSetExtensionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetExtensionsClient {
+	return original.NewVirtualMachineScaleSetExtensionsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineScaleSetListOSUpgradeHistoryIterator(page VirtualMachineScaleSetListOSUpgradeHistoryPage) VirtualMachineScaleSetListOSUpgradeHistoryIterator {
+	return original.NewVirtualMachineScaleSetListOSUpgradeHistoryIterator(page)
+}
+func NewVirtualMachineScaleSetListOSUpgradeHistoryPage(getNextPage func(context.Context, VirtualMachineScaleSetListOSUpgradeHistory) (VirtualMachineScaleSetListOSUpgradeHistory, error)) VirtualMachineScaleSetListOSUpgradeHistoryPage {
+	return original.NewVirtualMachineScaleSetListOSUpgradeHistoryPage(getNextPage)
+}
+func NewVirtualMachineScaleSetListResultIterator(page VirtualMachineScaleSetListResultPage) VirtualMachineScaleSetListResultIterator {
+	return original.NewVirtualMachineScaleSetListResultIterator(page)
+}
+func NewVirtualMachineScaleSetListResultPage(getNextPage func(context.Context, VirtualMachineScaleSetListResult) (VirtualMachineScaleSetListResult, error)) VirtualMachineScaleSetListResultPage {
+	return original.NewVirtualMachineScaleSetListResultPage(getNextPage)
+}
+func NewVirtualMachineScaleSetListSkusResultIterator(page VirtualMachineScaleSetListSkusResultPage) VirtualMachineScaleSetListSkusResultIterator {
+	return original.NewVirtualMachineScaleSetListSkusResultIterator(page)
+}
+func NewVirtualMachineScaleSetListSkusResultPage(getNextPage func(context.Context, VirtualMachineScaleSetListSkusResult) (VirtualMachineScaleSetListSkusResult, error)) VirtualMachineScaleSetListSkusResultPage {
+	return original.NewVirtualMachineScaleSetListSkusResultPage(getNextPage)
+}
+func NewVirtualMachineScaleSetListWithLinkResultIterator(page VirtualMachineScaleSetListWithLinkResultPage) VirtualMachineScaleSetListWithLinkResultIterator {
+	return original.NewVirtualMachineScaleSetListWithLinkResultIterator(page)
+}
+func NewVirtualMachineScaleSetListWithLinkResultPage(getNextPage func(context.Context, VirtualMachineScaleSetListWithLinkResult) (VirtualMachineScaleSetListWithLinkResult, error)) VirtualMachineScaleSetListWithLinkResultPage {
+	return original.NewVirtualMachineScaleSetListWithLinkResultPage(getNextPage)
+}
+func NewVirtualMachineScaleSetRollingUpgradesClient(subscriptionID string) VirtualMachineScaleSetRollingUpgradesClient {
+	return original.NewVirtualMachineScaleSetRollingUpgradesClient(subscriptionID)
+}
+func NewVirtualMachineScaleSetRollingUpgradesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetRollingUpgradesClient {
+	return original.NewVirtualMachineScaleSetRollingUpgradesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineScaleSetVMListResultIterator(page VirtualMachineScaleSetVMListResultPage) VirtualMachineScaleSetVMListResultIterator {
+	return original.NewVirtualMachineScaleSetVMListResultIterator(page)
+}
+func NewVirtualMachineScaleSetVMListResultPage(getNextPage func(context.Context, VirtualMachineScaleSetVMListResult) (VirtualMachineScaleSetVMListResult, error)) VirtualMachineScaleSetVMListResultPage {
+	return original.NewVirtualMachineScaleSetVMListResultPage(getNextPage)
+}
+func NewVirtualMachineScaleSetVMsClient(subscriptionID string) VirtualMachineScaleSetVMsClient {
+	return original.NewVirtualMachineScaleSetVMsClient(subscriptionID)
+}
+func NewVirtualMachineScaleSetVMsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetVMsClient {
+	return original.NewVirtualMachineScaleSetVMsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineScaleSetsClient(subscriptionID string) VirtualMachineScaleSetsClient {
+	return original.NewVirtualMachineScaleSetsClient(subscriptionID)
+}
+func NewVirtualMachineScaleSetsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetsClient {
+	return original.NewVirtualMachineScaleSetsClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachineSizesClient(subscriptionID string) VirtualMachineSizesClient {
+	return original.NewVirtualMachineSizesClient(subscriptionID)
+}
+func NewVirtualMachineSizesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineSizesClient {
+	return original.NewVirtualMachineSizesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewVirtualMachinesClient(subscriptionID string) VirtualMachinesClient {
+	return original.NewVirtualMachinesClient(subscriptionID)
+}
+func NewVirtualMachinesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachinesClient {
+	return original.NewVirtualMachinesClientWithBaseURI(baseURI, subscriptionID)
+}
+func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient {
+	return original.NewWithBaseURI(baseURI, subscriptionID)
+}
+func PossibleAccessLevelValues() []AccessLevel {
+	return original.PossibleAccessLevelValues()
+}
+func PossibleAggregatedReplicationStateValues() []AggregatedReplicationState {
+	return original.PossibleAggregatedReplicationStateValues()
+}
+func PossibleAvailabilitySetSkuTypesValues() []AvailabilitySetSkuTypes {
+	return original.PossibleAvailabilitySetSkuTypesValues()
+}
+func PossibleCachingTypesValues() []CachingTypes {
+	return original.PossibleCachingTypesValues()
+}
+func PossibleComponentNamesValues() []ComponentNames {
+	return original.PossibleComponentNamesValues()
+}
+func PossibleContainerServiceOrchestratorTypesValues() []ContainerServiceOrchestratorTypes {
+	return original.PossibleContainerServiceOrchestratorTypesValues()
+}
+func PossibleContainerServiceVMSizeTypesValues() []ContainerServiceVMSizeTypes {
+	return original.PossibleContainerServiceVMSizeTypesValues()
+}
+func PossibleDiffDiskOptionsValues() []DiffDiskOptions {
+	return original.PossibleDiffDiskOptionsValues()
+}
+func PossibleDiskCreateOptionTypesValues() []DiskCreateOptionTypes {
+	return original.PossibleDiskCreateOptionTypesValues()
+}
+func PossibleDiskCreateOptionValues() []DiskCreateOption {
+	return original.PossibleDiskCreateOptionValues()
+}
+func PossibleDiskStateValues() []DiskState {
+	return original.PossibleDiskStateValues()
+}
+func PossibleDiskStorageAccountTypesValues() []DiskStorageAccountTypes {
+	return original.PossibleDiskStorageAccountTypesValues()
+}
+func PossibleHostCachingValues() []HostCaching {
+	return original.PossibleHostCachingValues()
+}
+func PossibleHyperVGenerationTypesValues() []HyperVGenerationTypes {
+	return original.PossibleHyperVGenerationTypesValues()
+}
+func PossibleHyperVGenerationValues() []HyperVGeneration {
+	return original.PossibleHyperVGenerationValues()
+}
+func PossibleIPVersionValues() []IPVersion {
+	return original.PossibleIPVersionValues()
+}
+func PossibleInstanceViewTypesValues() []InstanceViewTypes {
+	return original.PossibleInstanceViewTypesValues()
+}
+func PossibleIntervalInMinsValues() []IntervalInMins {
+	return original.PossibleIntervalInMinsValues()
+}
+func PossibleMaintenanceOperationResultCodeTypesValues() []MaintenanceOperationResultCodeTypes {
+	return original.PossibleMaintenanceOperationResultCodeTypesValues()
+}
+func PossibleOperatingSystemStateTypesValues() []OperatingSystemStateTypes {
+	return original.PossibleOperatingSystemStateTypesValues()
+}
+func PossibleOperatingSystemTypesValues() []OperatingSystemTypes {
+	return original.PossibleOperatingSystemTypesValues()
+}
+func PossiblePassNamesValues() []PassNames {
+	return original.PossiblePassNamesValues()
+}
+func PossibleProtocolTypesValues() []ProtocolTypes {
+	return original.PossibleProtocolTypesValues()
+}
+func PossibleProvisioningState1Values() []ProvisioningState1 {
+	return original.PossibleProvisioningState1Values()
+}
+func PossibleProvisioningState2Values() []ProvisioningState2 {
+	return original.PossibleProvisioningState2Values()
+}
+func PossibleProvisioningStateValues() []ProvisioningState {
+	return original.PossibleProvisioningStateValues()
+}
+func PossibleProximityPlacementGroupTypeValues() []ProximityPlacementGroupType {
+	return original.PossibleProximityPlacementGroupTypeValues()
+}
+func PossibleReplicationStateValues() []ReplicationState {
+	return original.PossibleReplicationStateValues()
+}
+func PossibleReplicationStatusTypesValues() []ReplicationStatusTypes {
+	return original.PossibleReplicationStatusTypesValues()
+}
+func PossibleResourceIdentityTypeValues() []ResourceIdentityType {
+	return original.PossibleResourceIdentityTypeValues()
+}
+func PossibleResourceSkuCapacityScaleTypeValues() []ResourceSkuCapacityScaleType {
+	return original.PossibleResourceSkuCapacityScaleTypeValues()
+}
+func PossibleResourceSkuRestrictionsReasonCodeValues() []ResourceSkuRestrictionsReasonCode {
+	return original.PossibleResourceSkuRestrictionsReasonCodeValues()
+}
+func PossibleResourceSkuRestrictionsTypeValues() []ResourceSkuRestrictionsType {
+	return original.PossibleResourceSkuRestrictionsTypeValues()
+}
+func PossibleRollingUpgradeActionTypeValues() []RollingUpgradeActionType {
+	return original.PossibleRollingUpgradeActionTypeValues()
+}
+func PossibleRollingUpgradeStatusCodeValues() []RollingUpgradeStatusCode {
+	return original.PossibleRollingUpgradeStatusCodeValues()
+}
+func PossibleSettingNamesValues() []SettingNames {
+	return original.PossibleSettingNamesValues()
+}
+func PossibleSnapshotStorageAccountTypesValues() []SnapshotStorageAccountTypes {
+	return original.PossibleSnapshotStorageAccountTypesValues()
+}
+func PossibleStatusLevelTypesValues() []StatusLevelTypes {
+	return original.PossibleStatusLevelTypesValues()
+}
+func PossibleStorageAccountTypeValues() []StorageAccountType {
+	return original.PossibleStorageAccountTypeValues()
+}
+func PossibleStorageAccountTypesValues() []StorageAccountTypes {
+	return original.PossibleStorageAccountTypesValues()
+}
+func PossibleUpgradeModeValues() []UpgradeMode {
+	return original.PossibleUpgradeModeValues()
+}
+func PossibleUpgradeOperationInvokerValues() []UpgradeOperationInvoker {
+	return original.PossibleUpgradeOperationInvokerValues()
+}
+func PossibleUpgradeStateValues() []UpgradeState {
+	return original.PossibleUpgradeStateValues()
+}
+func PossibleVirtualMachineEvictionPolicyTypesValues() []VirtualMachineEvictionPolicyTypes {
+	return original.PossibleVirtualMachineEvictionPolicyTypesValues()
+}
+func PossibleVirtualMachinePriorityTypesValues() []VirtualMachinePriorityTypes {
+	return original.PossibleVirtualMachinePriorityTypesValues()
+}
+func PossibleVirtualMachineScaleSetSkuScaleTypeValues() []VirtualMachineScaleSetSkuScaleType {
+	return original.PossibleVirtualMachineScaleSetSkuScaleTypeValues()
+}
+func PossibleVirtualMachineSizeTypesValues() []VirtualMachineSizeTypes {
+	return original.PossibleVirtualMachineSizeTypesValues()
+}
+func UserAgent() string {
+	return original.UserAgent() + " profiles/latest"
+}
+func Version() string {
+	return original.Version()
+}
diff --git a/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute/computeapi/interfaces.go b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute/computeapi/interfaces.go
new file mode 100644
index 000000000..668736597
--- /dev/null
+++ b/vendor/github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute/computeapi/interfaces.go
@@ -0,0 +1,299 @@
+package computeapi
+
+// Copyright (c) Microsoft and contributors.  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.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"context"
+	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute"
+	"github.com/Azure/go-autorest/autorest"
+)
+
+// OperationsClientAPI contains the set of methods on the OperationsClient type.
+type OperationsClientAPI interface {
+	List(ctx context.Context) (result compute.OperationListResult, err error)
+}
+
+var _ OperationsClientAPI = (*compute.OperationsClient)(nil)
+
+// AvailabilitySetsClientAPI contains the set of methods on the AvailabilitySetsClient type.
+type AvailabilitySetsClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, availabilitySetName string, parameters compute.AvailabilitySet) (result compute.AvailabilitySet, err error)
+	Delete(ctx context.Context, resourceGroupName string, availabilitySetName string) (result autorest.Response, err error)
+	Get(ctx context.Context, resourceGroupName string, availabilitySetName string) (result compute.AvailabilitySet, err error)
+	List(ctx context.Context, resourceGroupName string) (result compute.AvailabilitySetListResultPage, err error)
+	ListAvailableSizes(ctx context.Context, resourceGroupName string, availabilitySetName string) (result compute.VirtualMachineSizeListResult, err error)
+	ListBySubscription(ctx context.Context) (result compute.AvailabilitySetListResultPage, err error)
+	Update(ctx context.Context, resourceGroupName string, availabilitySetName string, parameters compute.AvailabilitySetUpdate) (result compute.AvailabilitySet, err error)
+}
+
+var _ AvailabilitySetsClientAPI = (*compute.AvailabilitySetsClient)(nil)
+
+// ProximityPlacementGroupsClientAPI contains the set of methods on the ProximityPlacementGroupsClient type.
+type ProximityPlacementGroupsClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string, parameters compute.ProximityPlacementGroup) (result compute.ProximityPlacementGroup, err error)
+	Delete(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string) (result autorest.Response, err error)
+	Get(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string) (result compute.ProximityPlacementGroup, err error)
+	ListByResourceGroup(ctx context.Context, resourceGroupName string) (result compute.ProximityPlacementGroupListResultPage, err error)
+	ListBySubscription(ctx context.Context) (result compute.ProximityPlacementGroupListResultPage, err error)
+	Update(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string, parameters compute.ProximityPlacementGroupUpdate) (result compute.ProximityPlacementGroup, err error)
+}
+
+var _ ProximityPlacementGroupsClientAPI = (*compute.ProximityPlacementGroupsClient)(nil)
+
+// VirtualMachineExtensionImagesClientAPI contains the set of methods on the VirtualMachineExtensionImagesClient type.
+type VirtualMachineExtensionImagesClientAPI interface {
+	Get(ctx context.Context, location string, publisherName string, typeParameter string, version string) (result compute.VirtualMachineExtensionImage, err error)
+	ListTypes(ctx context.Context, location string, publisherName string) (result compute.ListVirtualMachineExtensionImage, err error)
+	ListVersions(ctx context.Context, location string, publisherName string, typeParameter string, filter string, top *int32, orderby string) (result compute.ListVirtualMachineExtensionImage, err error)
+}
+
+var _ VirtualMachineExtensionImagesClientAPI = (*compute.VirtualMachineExtensionImagesClient)(nil)
+
+// VirtualMachineExtensionsClientAPI contains the set of methods on the VirtualMachineExtensionsClient type.
+type VirtualMachineExtensionsClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters compute.VirtualMachineExtension) (result compute.VirtualMachineExtensionsCreateOrUpdateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string) (result compute.VirtualMachineExtensionsDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, expand string) (result compute.VirtualMachineExtension, err error)
+	List(ctx context.Context, resourceGroupName string, VMName string, expand string) (result compute.VirtualMachineExtensionsListResult, err error)
+	Update(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters compute.VirtualMachineExtensionUpdate) (result compute.VirtualMachineExtensionsUpdateFuture, err error)
+}
+
+var _ VirtualMachineExtensionsClientAPI = (*compute.VirtualMachineExtensionsClient)(nil)
+
+// VirtualMachineImagesClientAPI contains the set of methods on the VirtualMachineImagesClient type.
+type VirtualMachineImagesClientAPI interface {
+	Get(ctx context.Context, location string, publisherName string, offer string, skus string, version string) (result compute.VirtualMachineImage, err error)
+	List(ctx context.Context, location string, publisherName string, offer string, skus string, filter string, top *int32, orderby string) (result compute.ListVirtualMachineImageResource, err error)
+	ListOffers(ctx context.Context, location string, publisherName string) (result compute.ListVirtualMachineImageResource, err error)
+	ListPublishers(ctx context.Context, location string) (result compute.ListVirtualMachineImageResource, err error)
+	ListSkus(ctx context.Context, location string, publisherName string, offer string) (result compute.ListVirtualMachineImageResource, err error)
+}
+
+var _ VirtualMachineImagesClientAPI = (*compute.VirtualMachineImagesClient)(nil)
+
+// UsageClientAPI contains the set of methods on the UsageClient type.
+type UsageClientAPI interface {
+	List(ctx context.Context, location string) (result compute.ListUsagesResultPage, err error)
+}
+
+var _ UsageClientAPI = (*compute.UsageClient)(nil)
+
+// VirtualMachinesClientAPI contains the set of methods on the VirtualMachinesClient type.
+type VirtualMachinesClientAPI interface {
+	Capture(ctx context.Context, resourceGroupName string, VMName string, parameters compute.VirtualMachineCaptureParameters) (result compute.VirtualMachinesCaptureFuture, err error)
+	ConvertToManagedDisks(ctx context.Context, resourceGroupName string, VMName string) (result compute.VirtualMachinesConvertToManagedDisksFuture, err error)
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, VMName string, parameters compute.VirtualMachine) (result compute.VirtualMachinesCreateOrUpdateFuture, err error)
+	Deallocate(ctx context.Context, resourceGroupName string, VMName string) (result compute.VirtualMachinesDeallocateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, VMName string) (result compute.VirtualMachinesDeleteFuture, err error)
+	Generalize(ctx context.Context, resourceGroupName string, VMName string) (result autorest.Response, err error)
+	Get(ctx context.Context, resourceGroupName string, VMName string, expand compute.InstanceViewTypes) (result compute.VirtualMachine, err error)
+	InstanceView(ctx context.Context, resourceGroupName string, VMName string) (result compute.VirtualMachineInstanceView, err error)
+	List(ctx context.Context, resourceGroupName string) (result compute.VirtualMachineListResultPage, err error)
+	ListAll(ctx context.Context) (result compute.VirtualMachineListResultPage, err error)
+	ListAvailableSizes(ctx context.Context, resourceGroupName string, VMName string) (result compute.VirtualMachineSizeListResult, err error)
+	ListByLocation(ctx context.Context, location string) (result compute.VirtualMachineListResultPage, err error)
+	PerformMaintenance(ctx context.Context, resourceGroupName string, VMName string) (result compute.VirtualMachinesPerformMaintenanceFuture, err error)
+	PowerOff(ctx context.Context, resourceGroupName string, VMName string, skipShutdown *bool) (result compute.VirtualMachinesPowerOffFuture, err error)
+	Redeploy(ctx context.Context, resourceGroupName string, VMName string) (result compute.VirtualMachinesRedeployFuture, err error)
+	Reimage(ctx context.Context, resourceGroupName string, VMName string, parameters *compute.VirtualMachineReimageParameters) (result compute.VirtualMachinesReimageFuture, err error)
+	Restart(ctx context.Context, resourceGroupName string, VMName string) (result compute.VirtualMachinesRestartFuture, err error)
+	RunCommand(ctx context.Context, resourceGroupName string, VMName string, parameters compute.RunCommandInput) (result compute.VirtualMachinesRunCommandFuture, err error)
+	Start(ctx context.Context, resourceGroupName string, VMName string) (result compute.VirtualMachinesStartFuture, err error)
+	Update(ctx context.Context, resourceGroupName string, VMName string, parameters compute.VirtualMachineUpdate) (result compute.VirtualMachinesUpdateFuture, err error)
+}
+
+var _ VirtualMachinesClientAPI = (*compute.VirtualMachinesClient)(nil)
+
+// VirtualMachineSizesClientAPI contains the set of methods on the VirtualMachineSizesClient type.
+type VirtualMachineSizesClientAPI interface {
+	List(ctx context.Context, location string) (result compute.VirtualMachineSizeListResult, err error)
+}
+
+var _ VirtualMachineSizesClientAPI = (*compute.VirtualMachineSizesClient)(nil)
+
+// ImagesClientAPI contains the set of methods on the ImagesClient type.
+type ImagesClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, imageName string, parameters compute.Image) (result compute.ImagesCreateOrUpdateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, imageName string) (result compute.ImagesDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, imageName string, expand string) (result compute.Image, err error)
+	List(ctx context.Context) (result compute.ImageListResultPage, err error)
+	ListByResourceGroup(ctx context.Context, resourceGroupName string) (result compute.ImageListResultPage, err error)
+	Update(ctx context.Context, resourceGroupName string, imageName string, parameters compute.ImageUpdate) (result compute.ImagesUpdateFuture, err error)
+}
+
+var _ ImagesClientAPI = (*compute.ImagesClient)(nil)
+
+// VirtualMachineScaleSetsClientAPI contains the set of methods on the VirtualMachineScaleSetsClient type.
+type VirtualMachineScaleSetsClientAPI interface {
+	ConvertToSinglePlacementGroup(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters compute.VMScaleSetConvertToSinglePlacementGroupInput) (result autorest.Response, err error)
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters compute.VirtualMachineScaleSet) (result compute.VirtualMachineScaleSetsCreateOrUpdateFuture, err error)
+	Deallocate(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *compute.VirtualMachineScaleSetVMInstanceIDs) (result compute.VirtualMachineScaleSetsDeallocateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSetsDeleteFuture, err error)
+	DeleteInstances(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs) (result compute.VirtualMachineScaleSetsDeleteInstancesFuture, err error)
+	ForceRecoveryServiceFabricPlatformUpdateDomainWalk(ctx context.Context, resourceGroupName string, VMScaleSetName string, platformUpdateDomain int32) (result compute.RecoveryWalkResponse, err error)
+	Get(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSet, err error)
+	GetInstanceView(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSetInstanceView, err error)
+	GetOSUpgradeHistory(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSetListOSUpgradeHistoryPage, err error)
+	List(ctx context.Context, resourceGroupName string) (result compute.VirtualMachineScaleSetListResultPage, err error)
+	ListAll(ctx context.Context) (result compute.VirtualMachineScaleSetListWithLinkResultPage, err error)
+	ListSkus(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSetListSkusResultPage, err error)
+	PerformMaintenance(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *compute.VirtualMachineScaleSetVMInstanceIDs) (result compute.VirtualMachineScaleSetsPerformMaintenanceFuture, err error)
+	PowerOff(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *compute.VirtualMachineScaleSetVMInstanceIDs, skipShutdown *bool) (result compute.VirtualMachineScaleSetsPowerOffFuture, err error)
+	Redeploy(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *compute.VirtualMachineScaleSetVMInstanceIDs) (result compute.VirtualMachineScaleSetsRedeployFuture, err error)
+	Reimage(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMScaleSetReimageInput *compute.VirtualMachineScaleSetReimageParameters) (result compute.VirtualMachineScaleSetsReimageFuture, err error)
+	ReimageAll(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *compute.VirtualMachineScaleSetVMInstanceIDs) (result compute.VirtualMachineScaleSetsReimageAllFuture, err error)
+	Restart(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *compute.VirtualMachineScaleSetVMInstanceIDs) (result compute.VirtualMachineScaleSetsRestartFuture, err error)
+	Start(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *compute.VirtualMachineScaleSetVMInstanceIDs) (result compute.VirtualMachineScaleSetsStartFuture, err error)
+	Update(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters compute.VirtualMachineScaleSetUpdate) (result compute.VirtualMachineScaleSetsUpdateFuture, err error)
+	UpdateInstances(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs) (result compute.VirtualMachineScaleSetsUpdateInstancesFuture, err error)
+}
+
+var _ VirtualMachineScaleSetsClientAPI = (*compute.VirtualMachineScaleSetsClient)(nil)
+
+// VirtualMachineScaleSetExtensionsClientAPI contains the set of methods on the VirtualMachineScaleSetExtensionsClient type.
+type VirtualMachineScaleSetExtensionsClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, VMScaleSetName string, vmssExtensionName string, extensionParameters compute.VirtualMachineScaleSetExtension) (result compute.VirtualMachineScaleSetExtensionsCreateOrUpdateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, VMScaleSetName string, vmssExtensionName string) (result compute.VirtualMachineScaleSetExtensionsDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, VMScaleSetName string, vmssExtensionName string, expand string) (result compute.VirtualMachineScaleSetExtension, err error)
+	List(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSetExtensionListResultPage, err error)
+}
+
+var _ VirtualMachineScaleSetExtensionsClientAPI = (*compute.VirtualMachineScaleSetExtensionsClient)(nil)
+
+// VirtualMachineScaleSetRollingUpgradesClientAPI contains the set of methods on the VirtualMachineScaleSetRollingUpgradesClient type.
+type VirtualMachineScaleSetRollingUpgradesClientAPI interface {
+	Cancel(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSetRollingUpgradesCancelFuture, err error)
+	GetLatest(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.RollingUpgradeStatusInfo, err error)
+	StartExtensionUpgrade(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSetRollingUpgradesStartExtensionUpgradeFuture, err error)
+	StartOSUpgrade(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSetRollingUpgradesStartOSUpgradeFuture, err error)
+}
+
+var _ VirtualMachineScaleSetRollingUpgradesClientAPI = (*compute.VirtualMachineScaleSetRollingUpgradesClient)(nil)
+
+// VirtualMachineScaleSetVMsClientAPI contains the set of methods on the VirtualMachineScaleSetVMsClient type.
+type VirtualMachineScaleSetVMsClientAPI interface {
+	Deallocate(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMsDeallocateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMsDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVM, err error)
+	GetInstanceView(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMInstanceView, err error)
+	List(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, filter string, selectParameter string, expand string) (result compute.VirtualMachineScaleSetVMListResultPage, err error)
+	PerformMaintenance(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMsPerformMaintenanceFuture, err error)
+	PowerOff(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string, skipShutdown *bool) (result compute.VirtualMachineScaleSetVMsPowerOffFuture, err error)
+	Redeploy(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMsRedeployFuture, err error)
+	Reimage(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string, VMScaleSetVMReimageInput *compute.VirtualMachineScaleSetVMReimageParameters) (result compute.VirtualMachineScaleSetVMsReimageFuture, err error)
+	ReimageAll(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMsReimageAllFuture, err error)
+	Restart(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMsRestartFuture, err error)
+	RunCommand(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string, parameters compute.RunCommandInput) (result compute.VirtualMachineScaleSetVMsRunCommandFuture, err error)
+	Start(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMsStartFuture, err error)
+	Update(ctx context.Context, resourceGroupName string, VMScaleSetName string, instanceID string, parameters compute.VirtualMachineScaleSetVM) (result compute.VirtualMachineScaleSetVMsUpdateFuture, err error)
+}
+
+var _ VirtualMachineScaleSetVMsClientAPI = (*compute.VirtualMachineScaleSetVMsClient)(nil)
+
+// LogAnalyticsClientAPI contains the set of methods on the LogAnalyticsClient type.
+type LogAnalyticsClientAPI interface {
+	ExportRequestRateByInterval(ctx context.Context, parameters compute.RequestRateByIntervalInput, location string) (result compute.LogAnalyticsExportRequestRateByIntervalFuture, err error)
+	ExportThrottledRequests(ctx context.Context, parameters compute.ThrottledRequestsInput, location string) (result compute.LogAnalyticsExportThrottledRequestsFuture, err error)
+}
+
+var _ LogAnalyticsClientAPI = (*compute.LogAnalyticsClient)(nil)
+
+// VirtualMachineRunCommandsClientAPI contains the set of methods on the VirtualMachineRunCommandsClient type.
+type VirtualMachineRunCommandsClientAPI interface {
+	Get(ctx context.Context, location string, commandID string) (result compute.RunCommandDocument, err error)
+	List(ctx context.Context, location string) (result compute.RunCommandListResultPage, err error)
+}
+
+var _ VirtualMachineRunCommandsClientAPI = (*compute.VirtualMachineRunCommandsClient)(nil)
+
+// ResourceSkusClientAPI contains the set of methods on the ResourceSkusClient type.
+type ResourceSkusClientAPI interface {
+	List(ctx context.Context) (result compute.ResourceSkusResultPage, err error)
+}
+
+var _ ResourceSkusClientAPI = (*compute.ResourceSkusClient)(nil)
+
+// DisksClientAPI contains the set of methods on the DisksClient type.
+type DisksClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, diskName string, disk compute.Disk) (result compute.DisksCreateOrUpdateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, diskName string) (result compute.DisksDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, diskName string) (result compute.Disk, err error)
+	GrantAccess(ctx context.Context, resourceGroupName string, diskName string, grantAccessData compute.GrantAccessData) (result compute.DisksGrantAccessFuture, err error)
+	List(ctx context.Context) (result compute.DiskListPage, err error)
+	ListByResourceGroup(ctx context.Context, resourceGroupName string) (result compute.DiskListPage, err error)
+	RevokeAccess(ctx context.Context, resourceGroupName string, diskName string) (result compute.DisksRevokeAccessFuture, err error)
+	Update(ctx context.Context, resourceGroupName string, diskName string, disk compute.DiskUpdate) (result compute.DisksUpdateFuture, err error)
+}
+
+var _ DisksClientAPI = (*compute.DisksClient)(nil)
+
+// SnapshotsClientAPI contains the set of methods on the SnapshotsClient type.
+type SnapshotsClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, snapshotName string, snapshot compute.Snapshot) (result compute.SnapshotsCreateOrUpdateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, snapshotName string) (result compute.SnapshotsDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, snapshotName string) (result compute.Snapshot, err error)
+	GrantAccess(ctx context.Context, resourceGroupName string, snapshotName string, grantAccessData compute.GrantAccessData) (result compute.SnapshotsGrantAccessFuture, err error)
+	List(ctx context.Context) (result compute.SnapshotListPage, err error)
+	ListByResourceGroup(ctx context.Context, resourceGroupName string) (result compute.SnapshotListPage, err error)
+	RevokeAccess(ctx context.Context, resourceGroupName string, snapshotName string) (result compute.SnapshotsRevokeAccessFuture, err error)
+	Update(ctx context.Context, resourceGroupName string, snapshotName string, snapshot compute.SnapshotUpdate) (result compute.SnapshotsUpdateFuture, err error)
+}
+
+var _ SnapshotsClientAPI = (*compute.SnapshotsClient)(nil)
+
+// GalleriesClientAPI contains the set of methods on the GalleriesClient type.
+type GalleriesClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, galleryName string, gallery compute.Gallery) (result compute.GalleriesCreateOrUpdateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, galleryName string) (result compute.GalleriesDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, galleryName string) (result compute.Gallery, err error)
+	List(ctx context.Context) (result compute.GalleryListPage, err error)
+	ListByResourceGroup(ctx context.Context, resourceGroupName string) (result compute.GalleryListPage, err error)
+}
+
+var _ GalleriesClientAPI = (*compute.GalleriesClient)(nil)
+
+// GalleryImagesClientAPI contains the set of methods on the GalleryImagesClient type.
+type GalleryImagesClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, galleryName string, galleryImageName string, galleryImage compute.GalleryImage) (result compute.GalleryImagesCreateOrUpdateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, galleryName string, galleryImageName string) (result compute.GalleryImagesDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, galleryName string, galleryImageName string) (result compute.GalleryImage, err error)
+	ListByGallery(ctx context.Context, resourceGroupName string, galleryName string) (result compute.GalleryImageListPage, err error)
+}
+
+var _ GalleryImagesClientAPI = (*compute.GalleryImagesClient)(nil)
+
+// GalleryImageVersionsClientAPI contains the set of methods on the GalleryImageVersionsClient type.
+type GalleryImageVersionsClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, galleryName string, galleryImageName string, galleryImageVersionName string, galleryImageVersion compute.GalleryImageVersion) (result compute.GalleryImageVersionsCreateOrUpdateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, galleryName string, galleryImageName string, galleryImageVersionName string) (result compute.GalleryImageVersionsDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, galleryName string, galleryImageName string, galleryImageVersionName string, expand compute.ReplicationStatusTypes) (result compute.GalleryImageVersion, err error)
+	ListByGalleryImage(ctx context.Context, resourceGroupName string, galleryName string, galleryImageName string) (result compute.GalleryImageVersionListPage, err error)
+}
+
+var _ GalleryImageVersionsClientAPI = (*compute.GalleryImageVersionsClient)(nil)
+
+// ContainerServicesClientAPI contains the set of methods on the ContainerServicesClient type.
+type ContainerServicesClientAPI interface {
+	CreateOrUpdate(ctx context.Context, resourceGroupName string, containerServiceName string, parameters compute.ContainerService) (result compute.ContainerServicesCreateOrUpdateFuture, err error)
+	Delete(ctx context.Context, resourceGroupName string, containerServiceName string) (result compute.ContainerServicesDeleteFuture, err error)
+	Get(ctx context.Context, resourceGroupName string, containerServiceName string) (result compute.ContainerService, err error)
+	List(ctx context.Context) (result compute.ContainerServiceListResultPage, err error)
+	ListByResourceGroup(ctx context.Context, resourceGroupName string) (result compute.ContainerServiceListResultPage, err error)
+}
+
+var _ ContainerServicesClientAPI = (*compute.ContainerServicesClient)(nil)
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go b/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go
new file mode 100644
index 000000000..20855d4ab
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/auth/auth.go
@@ -0,0 +1,712 @@
+package auth
+
+// Copyright 2017 Microsoft Corporation
+//
+//  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.
+
+import (
+	"bytes"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+	"unicode/utf16"
+
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/adal"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/Azure/go-autorest/autorest/azure/cli"
+	"github.com/dimchansky/utfbom"
+	"golang.org/x/crypto/pkcs12"
+)
+
+// The possible keys in the Values map.
+const (
+	SubscriptionID          = "AZURE_SUBSCRIPTION_ID"
+	TenantID                = "AZURE_TENANT_ID"
+	ClientID                = "AZURE_CLIENT_ID"
+	ClientSecret            = "AZURE_CLIENT_SECRET"
+	CertificatePath         = "AZURE_CERTIFICATE_PATH"
+	CertificatePassword     = "AZURE_CERTIFICATE_PASSWORD"
+	Username                = "AZURE_USERNAME"
+	Password                = "AZURE_PASSWORD"
+	EnvironmentName         = "AZURE_ENVIRONMENT"
+	Resource                = "AZURE_AD_RESOURCE"
+	ActiveDirectoryEndpoint = "ActiveDirectoryEndpoint"
+	ResourceManagerEndpoint = "ResourceManagerEndpoint"
+	GraphResourceID         = "GraphResourceID"
+	SQLManagementEndpoint   = "SQLManagementEndpoint"
+	GalleryEndpoint         = "GalleryEndpoint"
+	ManagementEndpoint      = "ManagementEndpoint"
+)
+
+// NewAuthorizerFromEnvironment creates an Authorizer configured from environment variables in the order:
+// 1. Client credentials
+// 2. Client certificate
+// 3. Username password
+// 4. MSI
+func NewAuthorizerFromEnvironment() (autorest.Authorizer, error) {
+	settings, err := GetSettingsFromEnvironment()
+	if err != nil {
+		return nil, err
+	}
+	return settings.GetAuthorizer()
+}
+
+// NewAuthorizerFromEnvironmentWithResource creates an Authorizer configured from environment variables in the order:
+// 1. Client credentials
+// 2. Client certificate
+// 3. Username password
+// 4. MSI
+func NewAuthorizerFromEnvironmentWithResource(resource string) (autorest.Authorizer, error) {
+	settings, err := GetSettingsFromEnvironment()
+	if err != nil {
+		return nil, err
+	}
+	settings.Values[Resource] = resource
+	return settings.GetAuthorizer()
+}
+
+// EnvironmentSettings contains the available authentication settings.
+type EnvironmentSettings struct {
+	Values      map[string]string
+	Environment azure.Environment
+}
+
+// GetSettingsFromEnvironment returns the available authentication settings from the environment.
+func GetSettingsFromEnvironment() (s EnvironmentSettings, err error) {
+	s = EnvironmentSettings{
+		Values: map[string]string{},
+	}
+	s.setValue(SubscriptionID)
+	s.setValue(TenantID)
+	s.setValue(ClientID)
+	s.setValue(ClientSecret)
+	s.setValue(CertificatePath)
+	s.setValue(CertificatePassword)
+	s.setValue(Username)
+	s.setValue(Password)
+	s.setValue(EnvironmentName)
+	s.setValue(Resource)
+	if v := s.Values[EnvironmentName]; v == "" {
+		s.Environment = azure.PublicCloud
+	} else {
+		s.Environment, err = azure.EnvironmentFromName(v)
+	}
+	if s.Values[Resource] == "" {
+		s.Values[Resource] = s.Environment.ResourceManagerEndpoint
+	}
+	return
+}
+
+// GetSubscriptionID returns the available subscription ID or an empty string.
+func (settings EnvironmentSettings) GetSubscriptionID() string {
+	return settings.Values[SubscriptionID]
+}
+
+// adds the specified environment variable value to the Values map if it exists
+func (settings EnvironmentSettings) setValue(key string) {
+	if v := os.Getenv(key); v != "" {
+		settings.Values[key] = v
+	}
+}
+
+// helper to return client and tenant IDs
+func (settings EnvironmentSettings) getClientAndTenant() (string, string) {
+	clientID := settings.Values[ClientID]
+	tenantID := settings.Values[TenantID]
+	return clientID, tenantID
+}
+
+// GetClientCredentials creates a config object from the available client credentials.
+// An error is returned if no client credentials are available.
+func (settings EnvironmentSettings) GetClientCredentials() (ClientCredentialsConfig, error) {
+	secret := settings.Values[ClientSecret]
+	if secret == "" {
+		return ClientCredentialsConfig{}, errors.New("missing client secret")
+	}
+	clientID, tenantID := settings.getClientAndTenant()
+	config := NewClientCredentialsConfig(clientID, secret, tenantID)
+	config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
+	config.Resource = settings.Values[Resource]
+	return config, nil
+}
+
+// GetClientCertificate creates a config object from the available certificate credentials.
+// An error is returned if no certificate credentials are available.
+func (settings EnvironmentSettings) GetClientCertificate() (ClientCertificateConfig, error) {
+	certPath := settings.Values[CertificatePath]
+	if certPath == "" {
+		return ClientCertificateConfig{}, errors.New("missing certificate path")
+	}
+	certPwd := settings.Values[CertificatePassword]
+	clientID, tenantID := settings.getClientAndTenant()
+	config := NewClientCertificateConfig(certPath, certPwd, clientID, tenantID)
+	config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
+	config.Resource = settings.Values[Resource]
+	return config, nil
+}
+
+// GetUsernamePassword creates a config object from the available username/password credentials.
+// An error is returned if no username/password credentials are available.
+func (settings EnvironmentSettings) GetUsernamePassword() (UsernamePasswordConfig, error) {
+	username := settings.Values[Username]
+	password := settings.Values[Password]
+	if username == "" || password == "" {
+		return UsernamePasswordConfig{}, errors.New("missing username/password")
+	}
+	clientID, tenantID := settings.getClientAndTenant()
+	config := NewUsernamePasswordConfig(username, password, clientID, tenantID)
+	config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
+	config.Resource = settings.Values[Resource]
+	return config, nil
+}
+
+// GetMSI creates a MSI config object from the available client ID.
+func (settings EnvironmentSettings) GetMSI() MSIConfig {
+	config := NewMSIConfig()
+	config.Resource = settings.Values[Resource]
+	config.ClientID = settings.Values[ClientID]
+	return config
+}
+
+// GetDeviceFlow creates a device-flow config object from the available client and tenant IDs.
+func (settings EnvironmentSettings) GetDeviceFlow() DeviceFlowConfig {
+	clientID, tenantID := settings.getClientAndTenant()
+	config := NewDeviceFlowConfig(clientID, tenantID)
+	config.AADEndpoint = settings.Environment.ActiveDirectoryEndpoint
+	config.Resource = settings.Values[Resource]
+	return config
+}
+
+// GetAuthorizer creates an Authorizer configured from environment variables in the order:
+// 1. Client credentials
+// 2. Client certificate
+// 3. Username password
+// 4. MSI
+func (settings EnvironmentSettings) GetAuthorizer() (autorest.Authorizer, error) {
+	//1.Client Credentials
+	if c, e := settings.GetClientCredentials(); e == nil {
+		return c.Authorizer()
+	}
+
+	//2. Client Certificate
+	if c, e := settings.GetClientCertificate(); e == nil {
+		return c.Authorizer()
+	}
+
+	//3. Username Password
+	if c, e := settings.GetUsernamePassword(); e == nil {
+		return c.Authorizer()
+	}
+
+	// 4. MSI
+	return settings.GetMSI().Authorizer()
+}
+
+// NewAuthorizerFromFile creates an Authorizer configured from a configuration file in the following order.
+// 1. Client credentials
+// 2. Client certificate
+func NewAuthorizerFromFile(baseURI string) (autorest.Authorizer, error) {
+	settings, err := GetSettingsFromFile()
+	if err != nil {
+		return nil, err
+	}
+	if a, err := settings.ClientCredentialsAuthorizer(baseURI); err == nil {
+		return a, err
+	}
+	if a, err := settings.ClientCertificateAuthorizer(baseURI); err == nil {
+		return a, err
+	}
+	return nil, errors.New("auth file missing client and certificate credentials")
+}
+
+// NewAuthorizerFromFileWithResource creates an Authorizer configured from a configuration file in the following order.
+// 1. Client credentials
+// 2. Client certificate
+func NewAuthorizerFromFileWithResource(resource string) (autorest.Authorizer, error) {
+	s, err := GetSettingsFromFile()
+	if err != nil {
+		return nil, err
+	}
+	if a, err := s.ClientCredentialsAuthorizerWithResource(resource); err == nil {
+		return a, err
+	}
+	if a, err := s.ClientCertificateAuthorizerWithResource(resource); err == nil {
+		return a, err
+	}
+	return nil, errors.New("auth file missing client and certificate credentials")
+}
+
+// NewAuthorizerFromCLI creates an Authorizer configured from Azure CLI 2.0 for local development scenarios.
+func NewAuthorizerFromCLI() (autorest.Authorizer, error) {
+	settings, err := GetSettingsFromEnvironment()
+	if err != nil {
+		return nil, err
+	}
+
+	if settings.Values[Resource] == "" {
+		settings.Values[Resource] = settings.Environment.ResourceManagerEndpoint
+	}
+
+	return NewAuthorizerFromCLIWithResource(settings.Values[Resource])
+}
+
+// NewAuthorizerFromCLIWithResource creates an Authorizer configured from Azure CLI 2.0 for local development scenarios.
+func NewAuthorizerFromCLIWithResource(resource string) (autorest.Authorizer, error) {
+	token, err := cli.GetTokenFromCLI(resource)
+	if err != nil {
+		return nil, err
+	}
+
+	adalToken, err := token.ToADALToken()
+	if err != nil {
+		return nil, err
+	}
+
+	return autorest.NewBearerAuthorizer(&adalToken), nil
+}
+
+// GetSettingsFromFile returns the available authentication settings from an Azure CLI authentication file.
+func GetSettingsFromFile() (FileSettings, error) {
+	s := FileSettings{}
+	fileLocation := os.Getenv("AZURE_AUTH_LOCATION")
+	if fileLocation == "" {
+		return s, errors.New("environment variable AZURE_AUTH_LOCATION is not set")
+	}
+
+	contents, err := ioutil.ReadFile(fileLocation)
+	if err != nil {
+		return s, err
+	}
+
+	// Auth file might be encoded
+	decoded, err := decode(contents)
+	if err != nil {
+		return s, err
+	}
+
+	authFile := map[string]interface{}{}
+	err = json.Unmarshal(decoded, &authFile)
+	if err != nil {
+		return s, err
+	}
+
+	s.Values = map[string]string{}
+	s.setKeyValue(ClientID, authFile["clientId"])
+	s.setKeyValue(ClientSecret, authFile["clientSecret"])
+	s.setKeyValue(CertificatePath, authFile["clientCertificate"])
+	s.setKeyValue(CertificatePassword, authFile["clientCertificatePassword"])
+	s.setKeyValue(SubscriptionID, authFile["subscriptionId"])
+	s.setKeyValue(TenantID, authFile["tenantId"])
+	s.setKeyValue(ActiveDirectoryEndpoint, authFile["activeDirectoryEndpointUrl"])
+	s.setKeyValue(ResourceManagerEndpoint, authFile["resourceManagerEndpointUrl"])
+	s.setKeyValue(GraphResourceID, authFile["activeDirectoryGraphResourceId"])
+	s.setKeyValue(SQLManagementEndpoint, authFile["sqlManagementEndpointUrl"])
+	s.setKeyValue(GalleryEndpoint, authFile["galleryEndpointUrl"])
+	s.setKeyValue(ManagementEndpoint, authFile["managementEndpointUrl"])
+	return s, nil
+}
+
+// FileSettings contains the available authentication settings.
+type FileSettings struct {
+	Values map[string]string
+}
+
+// GetSubscriptionID returns the available subscription ID or an empty string.
+func (settings FileSettings) GetSubscriptionID() string {
+	return settings.Values[SubscriptionID]
+}
+
+// adds the specified value to the Values map if it isn't nil
+func (settings FileSettings) setKeyValue(key string, val interface{}) {
+	if val != nil {
+		settings.Values[key] = val.(string)
+	}
+}
+
+// returns the specified AAD endpoint or the public cloud endpoint if unspecified
+func (settings FileSettings) getAADEndpoint() string {
+	if v, ok := settings.Values[ActiveDirectoryEndpoint]; ok {
+		return v
+	}
+	return azure.PublicCloud.ActiveDirectoryEndpoint
+}
+
+// ServicePrincipalTokenFromClientCredentials creates a ServicePrincipalToken from the available client credentials.
+func (settings FileSettings) ServicePrincipalTokenFromClientCredentials(baseURI string) (*adal.ServicePrincipalToken, error) {
+	resource, err := settings.getResourceForToken(baseURI)
+	if err != nil {
+		return nil, err
+	}
+	return settings.ServicePrincipalTokenFromClientCredentialsWithResource(resource)
+}
+
+// ClientCredentialsAuthorizer creates an authorizer from the available client credentials.
+func (settings FileSettings) ClientCredentialsAuthorizer(baseURI string) (autorest.Authorizer, error) {
+	resource, err := settings.getResourceForToken(baseURI)
+	if err != nil {
+		return nil, err
+	}
+	return settings.ClientCredentialsAuthorizerWithResource(resource)
+}
+
+// ServicePrincipalTokenFromClientCredentialsWithResource creates a ServicePrincipalToken
+// from the available client credentials and the specified resource.
+func (settings FileSettings) ServicePrincipalTokenFromClientCredentialsWithResource(resource string) (*adal.ServicePrincipalToken, error) {
+	if _, ok := settings.Values[ClientSecret]; !ok {
+		return nil, errors.New("missing client secret")
+	}
+	config, err := adal.NewOAuthConfig(settings.getAADEndpoint(), settings.Values[TenantID])
+	if err != nil {
+		return nil, err
+	}
+	return adal.NewServicePrincipalToken(*config, settings.Values[ClientID], settings.Values[ClientSecret], resource)
+}
+
+func (settings FileSettings) clientCertificateConfigWithResource(resource string) (ClientCertificateConfig, error) {
+	if _, ok := settings.Values[CertificatePath]; !ok {
+		return ClientCertificateConfig{}, errors.New("missing certificate path")
+	}
+	cfg := NewClientCertificateConfig(settings.Values[CertificatePath], settings.Values[CertificatePassword], settings.Values[ClientID], settings.Values[TenantID])
+	cfg.AADEndpoint = settings.getAADEndpoint()
+	cfg.Resource = resource
+	return cfg, nil
+}
+
+// ClientCredentialsAuthorizerWithResource creates an authorizer from the available client credentials and the specified resource.
+func (settings FileSettings) ClientCredentialsAuthorizerWithResource(resource string) (autorest.Authorizer, error) {
+	spToken, err := settings.ServicePrincipalTokenFromClientCredentialsWithResource(resource)
+	if err != nil {
+		return nil, err
+	}
+	return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// ServicePrincipalTokenFromClientCertificate creates a ServicePrincipalToken from the available certificate credentials.
+func (settings FileSettings) ServicePrincipalTokenFromClientCertificate(baseURI string) (*adal.ServicePrincipalToken, error) {
+	resource, err := settings.getResourceForToken(baseURI)
+	if err != nil {
+		return nil, err
+	}
+	return settings.ServicePrincipalTokenFromClientCertificateWithResource(resource)
+}
+
+// ClientCertificateAuthorizer creates an authorizer from the available certificate credentials.
+func (settings FileSettings) ClientCertificateAuthorizer(baseURI string) (autorest.Authorizer, error) {
+	resource, err := settings.getResourceForToken(baseURI)
+	if err != nil {
+		return nil, err
+	}
+	return settings.ClientCertificateAuthorizerWithResource(resource)
+}
+
+// ServicePrincipalTokenFromClientCertificateWithResource creates a ServicePrincipalToken from the available certificate credentials.
+func (settings FileSettings) ServicePrincipalTokenFromClientCertificateWithResource(resource string) (*adal.ServicePrincipalToken, error) {
+	cfg, err := settings.clientCertificateConfigWithResource(resource)
+	if err != nil {
+		return nil, err
+	}
+	return cfg.ServicePrincipalToken()
+}
+
+// ClientCertificateAuthorizerWithResource creates an authorizer from the available certificate credentials and the specified resource.
+func (settings FileSettings) ClientCertificateAuthorizerWithResource(resource string) (autorest.Authorizer, error) {
+	cfg, err := settings.clientCertificateConfigWithResource(resource)
+	if err != nil {
+		return nil, err
+	}
+	return cfg.Authorizer()
+}
+
+func decode(b []byte) ([]byte, error) {
+	reader, enc := utfbom.Skip(bytes.NewReader(b))
+
+	switch enc {
+	case utfbom.UTF16LittleEndian:
+		u16 := make([]uint16, (len(b)/2)-1)
+		err := binary.Read(reader, binary.LittleEndian, &u16)
+		if err != nil {
+			return nil, err
+		}
+		return []byte(string(utf16.Decode(u16))), nil
+	case utfbom.UTF16BigEndian:
+		u16 := make([]uint16, (len(b)/2)-1)
+		err := binary.Read(reader, binary.BigEndian, &u16)
+		if err != nil {
+			return nil, err
+		}
+		return []byte(string(utf16.Decode(u16))), nil
+	}
+	return ioutil.ReadAll(reader)
+}
+
+func (settings FileSettings) getResourceForToken(baseURI string) (string, error) {
+	// Compare dafault base URI from the SDK to the endpoints from the public cloud
+	// Base URI and token resource are the same string. This func finds the authentication
+	// file field that matches the SDK base URI. The SDK defines the public cloud
+	// endpoint as its default base URI
+	if !strings.HasSuffix(baseURI, "/") {
+		baseURI += "/"
+	}
+	switch baseURI {
+	case azure.PublicCloud.ServiceManagementEndpoint:
+		return settings.Values[ManagementEndpoint], nil
+	case azure.PublicCloud.ResourceManagerEndpoint:
+		return settings.Values[ResourceManagerEndpoint], nil
+	case azure.PublicCloud.ActiveDirectoryEndpoint:
+		return settings.Values[ActiveDirectoryEndpoint], nil
+	case azure.PublicCloud.GalleryEndpoint:
+		return settings.Values[GalleryEndpoint], nil
+	case azure.PublicCloud.GraphEndpoint:
+		return settings.Values[GraphResourceID], nil
+	}
+	return "", fmt.Errorf("auth: base URI not found in endpoints")
+}
+
+// NewClientCredentialsConfig creates an AuthorizerConfig object configured to obtain an Authorizer through Client Credentials.
+// Defaults to Public Cloud and Resource Manager Endpoint.
+func NewClientCredentialsConfig(clientID string, clientSecret string, tenantID string) ClientCredentialsConfig {
+	return ClientCredentialsConfig{
+		ClientID:     clientID,
+		ClientSecret: clientSecret,
+		TenantID:     tenantID,
+		Resource:     azure.PublicCloud.ResourceManagerEndpoint,
+		AADEndpoint:  azure.PublicCloud.ActiveDirectoryEndpoint,
+	}
+}
+
+// NewClientCertificateConfig creates a ClientCertificateConfig object configured to obtain an Authorizer through client certificate.
+// Defaults to Public Cloud and Resource Manager Endpoint.
+func NewClientCertificateConfig(certificatePath string, certificatePassword string, clientID string, tenantID string) ClientCertificateConfig {
+	return ClientCertificateConfig{
+		CertificatePath:     certificatePath,
+		CertificatePassword: certificatePassword,
+		ClientID:            clientID,
+		TenantID:            tenantID,
+		Resource:            azure.PublicCloud.ResourceManagerEndpoint,
+		AADEndpoint:         azure.PublicCloud.ActiveDirectoryEndpoint,
+	}
+}
+
+// NewUsernamePasswordConfig creates an UsernamePasswordConfig object configured to obtain an Authorizer through username and password.
+// Defaults to Public Cloud and Resource Manager Endpoint.
+func NewUsernamePasswordConfig(username string, password string, clientID string, tenantID string) UsernamePasswordConfig {
+	return UsernamePasswordConfig{
+		Username:    username,
+		Password:    password,
+		ClientID:    clientID,
+		TenantID:    tenantID,
+		Resource:    azure.PublicCloud.ResourceManagerEndpoint,
+		AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
+	}
+}
+
+// NewMSIConfig creates an MSIConfig object configured to obtain an Authorizer through MSI.
+func NewMSIConfig() MSIConfig {
+	return MSIConfig{
+		Resource: azure.PublicCloud.ResourceManagerEndpoint,
+	}
+}
+
+// NewDeviceFlowConfig creates a DeviceFlowConfig object configured to obtain an Authorizer through device flow.
+// Defaults to Public Cloud and Resource Manager Endpoint.
+func NewDeviceFlowConfig(clientID string, tenantID string) DeviceFlowConfig {
+	return DeviceFlowConfig{
+		ClientID:    clientID,
+		TenantID:    tenantID,
+		Resource:    azure.PublicCloud.ResourceManagerEndpoint,
+		AADEndpoint: azure.PublicCloud.ActiveDirectoryEndpoint,
+	}
+}
+
+//AuthorizerConfig provides an authorizer from the configuration provided.
+type AuthorizerConfig interface {
+	Authorizer() (autorest.Authorizer, error)
+}
+
+// ClientCredentialsConfig provides the options to get a bearer authorizer from client credentials.
+type ClientCredentialsConfig struct {
+	ClientID     string
+	ClientSecret string
+	TenantID     string
+	AADEndpoint  string
+	Resource     string
+}
+
+// ServicePrincipalToken creates a ServicePrincipalToken from client credentials.
+func (ccc ClientCredentialsConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
+	oauthConfig, err := adal.NewOAuthConfig(ccc.AADEndpoint, ccc.TenantID)
+	if err != nil {
+		return nil, err
+	}
+	return adal.NewServicePrincipalToken(*oauthConfig, ccc.ClientID, ccc.ClientSecret, ccc.Resource)
+}
+
+// Authorizer gets the authorizer from client credentials.
+func (ccc ClientCredentialsConfig) Authorizer() (autorest.Authorizer, error) {
+	spToken, err := ccc.ServicePrincipalToken()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get oauth token from client credentials: %v", err)
+	}
+	return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// ClientCertificateConfig provides the options to get a bearer authorizer from a client certificate.
+type ClientCertificateConfig struct {
+	ClientID            string
+	CertificatePath     string
+	CertificatePassword string
+	TenantID            string
+	AADEndpoint         string
+	Resource            string
+}
+
+// ServicePrincipalToken creates a ServicePrincipalToken from client certificate.
+func (ccc ClientCertificateConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
+	oauthConfig, err := adal.NewOAuthConfig(ccc.AADEndpoint, ccc.TenantID)
+	if err != nil {
+		return nil, err
+	}
+	certData, err := ioutil.ReadFile(ccc.CertificatePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read the certificate file (%s): %v", ccc.CertificatePath, err)
+	}
+	certificate, rsaPrivateKey, err := decodePkcs12(certData, ccc.CertificatePassword)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode pkcs12 certificate while creating spt: %v", err)
+	}
+	return adal.NewServicePrincipalTokenFromCertificate(*oauthConfig, ccc.ClientID, certificate, rsaPrivateKey, ccc.Resource)
+}
+
+// Authorizer gets an authorizer object from client certificate.
+func (ccc ClientCertificateConfig) Authorizer() (autorest.Authorizer, error) {
+	spToken, err := ccc.ServicePrincipalToken()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get oauth token from certificate auth: %v", err)
+	}
+	return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// DeviceFlowConfig provides the options to get a bearer authorizer using device flow authentication.
+type DeviceFlowConfig struct {
+	ClientID    string
+	TenantID    string
+	AADEndpoint string
+	Resource    string
+}
+
+// Authorizer gets the authorizer from device flow.
+func (dfc DeviceFlowConfig) Authorizer() (autorest.Authorizer, error) {
+	spToken, err := dfc.ServicePrincipalToken()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get oauth token from device flow: %v", err)
+	}
+	return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// ServicePrincipalToken gets the service principal token from device flow.
+func (dfc DeviceFlowConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
+	oauthConfig, err := adal.NewOAuthConfig(dfc.AADEndpoint, dfc.TenantID)
+	if err != nil {
+		return nil, err
+	}
+	oauthClient := &autorest.Client{}
+	deviceCode, err := adal.InitiateDeviceAuth(oauthClient, *oauthConfig, dfc.ClientID, dfc.Resource)
+	if err != nil {
+		return nil, fmt.Errorf("failed to start device auth flow: %s", err)
+	}
+	log.Println(*deviceCode.Message)
+	token, err := adal.WaitForUserCompletion(oauthClient, deviceCode)
+	if err != nil {
+		return nil, fmt.Errorf("failed to finish device auth flow: %s", err)
+	}
+	return adal.NewServicePrincipalTokenFromManualToken(*oauthConfig, dfc.ClientID, dfc.Resource, *token)
+}
+
+func decodePkcs12(pkcs []byte, password string) (*x509.Certificate, *rsa.PrivateKey, error) {
+	privateKey, certificate, err := pkcs12.Decode(pkcs, password)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	rsaPrivateKey, isRsaKey := privateKey.(*rsa.PrivateKey)
+	if !isRsaKey {
+		return nil, nil, fmt.Errorf("PKCS#12 certificate must contain an RSA private key")
+	}
+
+	return certificate, rsaPrivateKey, nil
+}
+
+// UsernamePasswordConfig provides the options to get a bearer authorizer from a username and a password.
+type UsernamePasswordConfig struct {
+	ClientID    string
+	Username    string
+	Password    string
+	TenantID    string
+	AADEndpoint string
+	Resource    string
+}
+
+// ServicePrincipalToken creates a ServicePrincipalToken from username and password.
+func (ups UsernamePasswordConfig) ServicePrincipalToken() (*adal.ServicePrincipalToken, error) {
+	oauthConfig, err := adal.NewOAuthConfig(ups.AADEndpoint, ups.TenantID)
+	if err != nil {
+		return nil, err
+	}
+	return adal.NewServicePrincipalTokenFromUsernamePassword(*oauthConfig, ups.ClientID, ups.Username, ups.Password, ups.Resource)
+}
+
+// Authorizer gets the authorizer from a username and a password.
+func (ups UsernamePasswordConfig) Authorizer() (autorest.Authorizer, error) {
+	spToken, err := ups.ServicePrincipalToken()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get oauth token from username and password auth: %v", err)
+	}
+	return autorest.NewBearerAuthorizer(spToken), nil
+}
+
+// MSIConfig provides the options to get a bearer authorizer through MSI.
+type MSIConfig struct {
+	Resource string
+	ClientID string
+}
+
+// Authorizer gets the authorizer from MSI.
+func (mc MSIConfig) Authorizer() (autorest.Authorizer, error) {
+	msiEndpoint, err := adal.GetMSIVMEndpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	var spToken *adal.ServicePrincipalToken
+	if mc.ClientID == "" {
+		spToken, err = adal.NewServicePrincipalTokenFromMSI(msiEndpoint, mc.Resource)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get oauth token from MSI: %v", err)
+		}
+	} else {
+		spToken, err = adal.NewServicePrincipalTokenFromMSIWithUserAssignedID(msiEndpoint, mc.Resource, mc.ClientID)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get oauth token from MSI for user assigned identity: %v", err)
+		}
+	}
+
+	return autorest.NewBearerAuthorizer(spToken), nil
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go
new file mode 100644
index 000000000..a336b958d
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/profile.go
@@ -0,0 +1,79 @@
+package cli
+
+// Copyright 2017 Microsoft Corporation
+//
+//  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.
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/dimchansky/utfbom"
+	"github.com/mitchellh/go-homedir"
+)
+
+// Profile represents a Profile from the Azure CLI
+type Profile struct {
+	InstallationID string         `json:"installationId"`
+	Subscriptions  []Subscription `json:"subscriptions"`
+}
+
+// Subscription represents a Subscription from the Azure CLI
+type Subscription struct {
+	EnvironmentName string `json:"environmentName"`
+	ID              string `json:"id"`
+	IsDefault       bool   `json:"isDefault"`
+	Name            string `json:"name"`
+	State           string `json:"state"`
+	TenantID        string `json:"tenantId"`
+	User            *User  `json:"user"`
+}
+
+// User represents a User from the Azure CLI
+type User struct {
+	Name string `json:"name"`
+	Type string `json:"type"`
+}
+
+const azureProfileJSON = "azureProfile.json"
+
+// ProfilePath returns the path where the Azure Profile is stored from the Azure CLI
+func ProfilePath() (string, error) {
+	if cfgDir := os.Getenv("AZURE_CONFIG_DIR"); cfgDir != "" {
+		return filepath.Join(cfgDir, azureProfileJSON), nil
+	}
+	return homedir.Expand("~/.azure/" + azureProfileJSON)
+}
+
+// LoadProfile restores a Profile object from a file located at 'path'.
+func LoadProfile(path string) (result Profile, err error) {
+	var contents []byte
+	contents, err = ioutil.ReadFile(path)
+	if err != nil {
+		err = fmt.Errorf("failed to open file (%s) while loading token: %v", path, err)
+		return
+	}
+	reader := utfbom.SkipOnly(bytes.NewReader(contents))
+
+	dec := json.NewDecoder(reader)
+	if err = dec.Decode(&result); err != nil {
+		err = fmt.Errorf("failed to decode contents of file (%s) into a Profile representation: %v", path, err)
+		return
+	}
+
+	return
+}
diff --git a/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go
new file mode 100644
index 000000000..810075ba6
--- /dev/null
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/cli/token.go
@@ -0,0 +1,170 @@
+package cli
+
+// Copyright 2017 Microsoft Corporation
+//
+//  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.
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"regexp"
+	"runtime"
+	"strconv"
+	"time"
+
+	"github.com/Azure/go-autorest/autorest/adal"
+	"github.com/Azure/go-autorest/autorest/date"
+	"github.com/mitchellh/go-homedir"
+)
+
+// Token represents an AccessToken from the Azure CLI
+type Token struct {
+	AccessToken      string `json:"accessToken"`
+	Authority        string `json:"_authority"`
+	ClientID         string `json:"_clientId"`
+	ExpiresOn        string `json:"expiresOn"`
+	IdentityProvider string `json:"identityProvider"`
+	IsMRRT           bool   `json:"isMRRT"`
+	RefreshToken     string `json:"refreshToken"`
+	Resource         string `json:"resource"`
+	TokenType        string `json:"tokenType"`
+	UserID           string `json:"userId"`
+}
+
+// ToADALToken converts an Azure CLI `Token`` to an `adal.Token``
+func (t Token) ToADALToken() (converted adal.Token, err error) {
+	tokenExpirationDate, err := ParseExpirationDate(t.ExpiresOn)
+	if err != nil {
+		err = fmt.Errorf("Error parsing Token Expiration Date %q: %+v", t.ExpiresOn, err)
+		return
+	}
+
+	difference := tokenExpirationDate.Sub(date.UnixEpoch())
+
+	converted = adal.Token{
+		AccessToken:  t.AccessToken,
+		Type:         t.TokenType,
+		ExpiresIn:    "3600",
+		ExpiresOn:    json.Number(strconv.Itoa(int(difference.Seconds()))),
+		RefreshToken: t.RefreshToken,
+		Resource:     t.Resource,
+	}
+	return
+}
+
+// AccessTokensPath returns the path where access tokens are stored from the Azure CLI
+// TODO(#199): add unit test.
+func AccessTokensPath() (string, error) {
+	// Azure-CLI allows user to customize the path of access tokens thorugh environment variable.
+	var accessTokenPath = os.Getenv("AZURE_ACCESS_TOKEN_FILE")
+	var err error
+
+	// Fallback logic to default path on non-cloud-shell environment.
+	// TODO(#200): remove the dependency on hard-coding path.
+	if accessTokenPath == "" {
+		accessTokenPath, err = homedir.Expand("~/.azure/accessTokens.json")
+	}
+
+	return accessTokenPath, err
+}
+
+// ParseExpirationDate parses either a Azure CLI or CloudShell date into a time object
+func ParseExpirationDate(input string) (*time.Time, error) {
+	// CloudShell (and potentially the Azure CLI in future)
+	expirationDate, cloudShellErr := time.Parse(time.RFC3339, input)
+	if cloudShellErr != nil {
+		// Azure CLI (Python) e.g. 2017-08-31 19:48:57.998857 (plus the local timezone)
+		const cliFormat = "2006-01-02 15:04:05.999999"
+		expirationDate, cliErr := time.ParseInLocation(cliFormat, input, time.Local)
+		if cliErr == nil {
+			return &expirationDate, nil
+		}
+
+		return nil, fmt.Errorf("Error parsing expiration date %q.\n\nCloudShell Error: \n%+v\n\nCLI Error:\n%+v", input, cloudShellErr, cliErr)
+	}
+
+	return &expirationDate, nil
+}
+
+// LoadTokens restores a set of Token objects from a file located at 'path'.
+func LoadTokens(path string) ([]Token, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file (%s) while loading token: %v", path, err)
+	}
+	defer file.Close()
+
+	var tokens []Token
+
+	dec := json.NewDecoder(file)
+	if err = dec.Decode(&tokens); err != nil {
+		return nil, fmt.Errorf("failed to decode contents of file (%s) into a `cli.Token` representation: %v", path, err)
+	}
+
+	return tokens, nil
+}
+
+// GetTokenFromCLI gets a token using Azure CLI 2.0 for local development scenarios.
+func GetTokenFromCLI(resource string) (*Token, error) {
+	// This is the path that a developer can set to tell this class what the install path for Azure CLI is.
+	const azureCLIPath = "AzureCLIPath"
+
+	// The default install paths are used to find Azure CLI. This is for security, so that any path in the calling program's Path environment is not used to execute Azure CLI.
+	azureCLIDefaultPathWindows := fmt.Sprintf("%s\\Microsoft SDKs\\Azure\\CLI2\\wbin; %s\\Microsoft SDKs\\Azure\\CLI2\\wbin", os.Getenv("ProgramFiles(x86)"), os.Getenv("ProgramFiles"))
+
+	// Default path for non-Windows.
+	const azureCLIDefaultPath = "/bin:/sbin:/usr/bin:/usr/local/bin"
+
+	// Validate resource, since it gets sent as a command line argument to Azure CLI
+	const invalidResourceErrorTemplate = "Resource %s is not in expected format. Only alphanumeric characters, [dot], [colon], [hyphen], and [forward slash] are allowed."
+	match, err := regexp.MatchString("^[0-9a-zA-Z-.:/]+$", resource)
+	if err != nil {
+		return nil, err
+	}
+	if !match {
+		return nil, fmt.Errorf(invalidResourceErrorTemplate, resource)
+	}
+
+	// Execute Azure CLI to get token
+	var cliCmd *exec.Cmd
+	if runtime.GOOS == "windows" {
+		cliCmd = exec.Command(fmt.Sprintf("%s\\system32\\cmd.exe", os.Getenv("windir")))
+		cliCmd.Env = os.Environ()
+		cliCmd.Env = append(cliCmd.Env, fmt.Sprintf("PATH=%s;%s", os.Getenv(azureCLIPath), azureCLIDefaultPathWindows))
+		cliCmd.Args = append(cliCmd.Args, "/c", "az")
+	} else {
+		cliCmd = exec.Command("az")
+		cliCmd.Env = os.Environ()
+		cliCmd.Env = append(cliCmd.Env, fmt.Sprintf("PATH=%s:%s", os.Getenv(azureCLIPath), azureCLIDefaultPath))
+	}
+	cliCmd.Args = append(cliCmd.Args, "account", "get-access-token", "-o", "json", "--resource", resource)
+
+	var stderr bytes.Buffer
+	cliCmd.Stderr = &stderr
+
+	output, err := cliCmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("Invoking Azure CLI failed with the following error: %s", stderr.String())
+	}
+
+	tokenResponse := Token{}
+	err = json.Unmarshal(output, &tokenResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	return &tokenResponse, err
+}
diff --git a/vendor/github.com/dimchansky/utfbom/.gitignore b/vendor/github.com/dimchansky/utfbom/.gitignore
new file mode 100644
index 000000000..d7ec5cebb
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/.gitignore
@@ -0,0 +1,37 @@
+# Binaries for programs and plugins
+*.exe
+*.dll
+*.so
+*.dylib
+*.o
+*.a
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.prof
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
+.glide/
+
+# Gogland
+.idea/
\ No newline at end of file
diff --git a/vendor/github.com/dimchansky/utfbom/.travis.yml b/vendor/github.com/dimchansky/utfbom/.travis.yml
new file mode 100644
index 000000000..b2e420c0d
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/.travis.yml
@@ -0,0 +1,18 @@
+language: go
+
+go:
+  - '1.10'
+  - '1.11'
+
+# sudo=false makes the build run using a container
+sudo: false
+
+before_install:
+  - go get github.com/mattn/goveralls
+  - go get golang.org/x/tools/cmd/cover
+  - go get golang.org/x/tools/cmd/goimports
+  - go get github.com/golang/lint/golint
+script:
+  - gofiles=$(find ./ -name '*.go') && [ -z "$gofiles" ] || unformatted=$(goimports -l $gofiles) && [ -z "$unformatted" ] || (echo >&2 "Go files must be formatted with gofmt. Following files has problem:\n $unformatted" && false)
+  - golint ./... # This won't break the build, just show warnings
+  - $HOME/gopath/bin/goveralls -service=travis-ci
diff --git a/vendor/github.com/dimchansky/utfbom/LICENSE b/vendor/github.com/dimchansky/utfbom/LICENSE
new file mode 100644
index 000000000..8dada3eda
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/LICENSE
@@ -0,0 +1,201 @@
+                                 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.
diff --git a/vendor/github.com/dimchansky/utfbom/README.md b/vendor/github.com/dimchansky/utfbom/README.md
new file mode 100644
index 000000000..8ece28008
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/README.md
@@ -0,0 +1,66 @@
+# utfbom [![Godoc](https://godoc.org/github.com/dimchansky/utfbom?status.png)](https://godoc.org/github.com/dimchansky/utfbom) [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Build Status](https://travis-ci.org/dimchansky/utfbom.svg?branch=master)](https://travis-ci.org/dimchansky/utfbom) [![Go Report Card](https://goreportcard.com/badge/github.com/dimchansky/utfbom)](https://goreportcard.com/report/github.com/dimchansky/utfbom) [![Coverage Status](https://coveralls.io/repos/github/dimchansky/utfbom/badge.svg?branch=master)](https://coveralls.io/github/dimchansky/utfbom?branch=master)
+
+The package utfbom implements the detection of the BOM (Unicode Byte Order Mark) and removing as necessary. It can also return the encoding detected by the BOM.
+
+## Installation
+
+    go get -u github.com/dimchansky/utfbom
+    
+## Example
+
+```go
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+
+	"github.com/dimchansky/utfbom"
+)
+
+func main() {
+	trySkip([]byte("\xEF\xBB\xBFhello"))
+	trySkip([]byte("hello"))
+}
+
+func trySkip(byteData []byte) {
+	fmt.Println("Input:", byteData)
+
+	// just skip BOM
+	output, err := ioutil.ReadAll(utfbom.SkipOnly(bytes.NewReader(byteData)))
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println("ReadAll with BOM skipping", output)
+
+	// skip BOM and detect encoding
+	sr, enc := utfbom.Skip(bytes.NewReader(byteData))
+	fmt.Printf("Detected encoding: %s\n", enc)
+	output, err = ioutil.ReadAll(sr)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println("ReadAll with BOM detection and skipping", output)
+	fmt.Println()
+}
+```
+
+Output:
+
+```
+$ go run main.go
+Input: [239 187 191 104 101 108 108 111]
+ReadAll with BOM skipping [104 101 108 108 111]
+Detected encoding: UTF8
+ReadAll with BOM detection and skipping [104 101 108 108 111]
+
+Input: [104 101 108 108 111]
+ReadAll with BOM skipping [104 101 108 108 111]
+Detected encoding: Unknown
+ReadAll with BOM detection and skipping [104 101 108 108 111]
+```
+
+
diff --git a/vendor/github.com/dimchansky/utfbom/go.mod b/vendor/github.com/dimchansky/utfbom/go.mod
new file mode 100644
index 000000000..4b9ecc6f5
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/go.mod
@@ -0,0 +1 @@
+module github.com/dimchansky/utfbom
\ No newline at end of file
diff --git a/vendor/github.com/dimchansky/utfbom/utfbom.go b/vendor/github.com/dimchansky/utfbom/utfbom.go
new file mode 100644
index 000000000..77a303e56
--- /dev/null
+++ b/vendor/github.com/dimchansky/utfbom/utfbom.go
@@ -0,0 +1,192 @@
+// Package utfbom implements the detection of the BOM (Unicode Byte Order Mark) and removing as necessary.
+// It wraps an io.Reader object, creating another object (Reader) that also implements the io.Reader
+// interface but provides automatic BOM checking and removing as necessary.
+package utfbom
+
+import (
+	"errors"
+	"io"
+)
+
+// Encoding is type alias for detected UTF encoding.
+type Encoding int
+
+// Constants to identify detected UTF encodings.
+const (
+	// Unknown encoding, returned when no BOM was detected
+	Unknown Encoding = iota
+
+	// UTF8, BOM bytes: EF BB BF
+	UTF8
+
+	// UTF-16, big-endian, BOM bytes: FE FF
+	UTF16BigEndian
+
+	// UTF-16, little-endian, BOM bytes: FF FE
+	UTF16LittleEndian
+
+	// UTF-32, big-endian, BOM bytes: 00 00 FE FF
+	UTF32BigEndian
+
+	// UTF-32, little-endian, BOM bytes: FF FE 00 00
+	UTF32LittleEndian
+)
+
+// String returns a user-friendly string representation of the encoding. Satisfies fmt.Stringer interface.
+func (e Encoding) String() string {
+	switch e {
+	case UTF8:
+		return "UTF8"
+	case UTF16BigEndian:
+		return "UTF16BigEndian"
+	case UTF16LittleEndian:
+		return "UTF16LittleEndian"
+	case UTF32BigEndian:
+		return "UTF32BigEndian"
+	case UTF32LittleEndian:
+		return "UTF32LittleEndian"
+	default:
+		return "Unknown"
+	}
+}
+
+const maxConsecutiveEmptyReads = 100
+
+// Skip creates Reader which automatically detects BOM (Unicode Byte Order Mark) and removes it as necessary.
+// It also returns the encoding detected by the BOM.
+// If the detected encoding is not needed, you can call the SkipOnly function.
+func Skip(rd io.Reader) (*Reader, Encoding) {
+	// Is it already a Reader?
+	b, ok := rd.(*Reader)
+	if ok {
+		return b, Unknown
+	}
+
+	enc, left, err := detectUtf(rd)
+	return &Reader{
+		rd:  rd,
+		buf: left,
+		err: err,
+	}, enc
+}
+
+// SkipOnly creates Reader which automatically detects BOM (Unicode Byte Order Mark) and removes it as necessary.
+func SkipOnly(rd io.Reader) *Reader {
+	r, _ := Skip(rd)
+	return r
+}
+
+// Reader implements automatic BOM (Unicode Byte Order Mark) checking and
+// removing as necessary for an io.Reader object.
+type Reader struct {
+	rd  io.Reader // reader provided by the client
+	buf []byte    // buffered data
+	err error     // last error
+}
+
+// Read is an implementation of io.Reader interface.
+// The bytes are taken from the underlying Reader, but it checks for BOMs, removing them as necessary.
+func (r *Reader) Read(p []byte) (n int, err error) {
+	if len(p) == 0 {
+		return 0, nil
+	}
+
+	if r.buf == nil {
+		if r.err != nil {
+			return 0, r.readErr()
+		}
+
+		return r.rd.Read(p)
+	}
+
+	// copy as much as we can
+	n = copy(p, r.buf)
+	r.buf = nilIfEmpty(r.buf[n:])
+	return n, nil
+}
+
+func (r *Reader) readErr() error {
+	err := r.err
+	r.err = nil
+	return err
+}
+
+var errNegativeRead = errors.New("utfbom: reader returned negative count from Read")
+
+func detectUtf(rd io.Reader) (enc Encoding, buf []byte, err error) {
+	buf, err = readBOM(rd)
+
+	if len(buf) >= 4 {
+		if isUTF32BigEndianBOM4(buf) {
+			return UTF32BigEndian, nilIfEmpty(buf[4:]), err
+		}
+		if isUTF32LittleEndianBOM4(buf) {
+			return UTF32LittleEndian, nilIfEmpty(buf[4:]), err
+		}
+	}
+
+	if len(buf) > 2 && isUTF8BOM3(buf) {
+		return UTF8, nilIfEmpty(buf[3:]), err
+	}
+
+	if (err != nil && err != io.EOF) || (len(buf) < 2) {
+		return Unknown, nilIfEmpty(buf), err
+	}
+
+	if isUTF16BigEndianBOM2(buf) {
+		return UTF16BigEndian, nilIfEmpty(buf[2:]), err
+	}
+	if isUTF16LittleEndianBOM2(buf) {
+		return UTF16LittleEndian, nilIfEmpty(buf[2:]), err
+	}
+
+	return Unknown, nilIfEmpty(buf), err
+}
+
+func readBOM(rd io.Reader) (buf []byte, err error) {
+	const maxBOMSize = 4
+	var bom [maxBOMSize]byte // used to read BOM
+
+	// read as many bytes as possible
+	for nEmpty, n := 0, 0; err == nil && len(buf) < maxBOMSize; buf = bom[:len(buf)+n] {
+		if n, err = rd.Read(bom[len(buf):]); n < 0 {
+			panic(errNegativeRead)
+		}
+		if n > 0 {
+			nEmpty = 0
+		} else {
+			nEmpty++
+			if nEmpty >= maxConsecutiveEmptyReads {
+				err = io.ErrNoProgress
+			}
+		}
+	}
+	return
+}
+
+func isUTF32BigEndianBOM4(buf []byte) bool {
+	return buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0xFE && buf[3] == 0xFF
+}
+
+func isUTF32LittleEndianBOM4(buf []byte) bool {
+	return buf[0] == 0xFF && buf[1] == 0xFE && buf[2] == 0x00 && buf[3] == 0x00
+}
+
+func isUTF8BOM3(buf []byte) bool {
+	return buf[0] == 0xEF && buf[1] == 0xBB && buf[2] == 0xBF
+}
+
+func isUTF16BigEndianBOM2(buf []byte) bool {
+	return buf[0] == 0xFE && buf[1] == 0xFF
+}
+
+func isUTF16LittleEndianBOM2(buf []byte) bool {
+	return buf[0] == 0xFF && buf[1] == 0xFE
+}
+
+func nilIfEmpty(buf []byte) (res []byte) {
+	if len(buf) > 0 {
+		res = buf
+	}
+	return
+}
diff --git a/vendor/golang.org/x/crypto/pkcs12/bmp-string.go b/vendor/golang.org/x/crypto/pkcs12/bmp-string.go
new file mode 100644
index 000000000..233b8b62c
--- /dev/null
+++ b/vendor/golang.org/x/crypto/pkcs12/bmp-string.go
@@ -0,0 +1,50 @@
+// Copyright 2015 The Go 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 pkcs12
+
+import (
+	"errors"
+	"unicode/utf16"
+)
+
+// bmpString returns s encoded in UCS-2 with a zero terminator.
+func bmpString(s string) ([]byte, error) {
+	// References:
+	// https://tools.ietf.org/html/rfc7292#appendix-B.1
+	// https://en.wikipedia.org/wiki/Plane_(Unicode)#Basic_Multilingual_Plane
+	//  - non-BMP characters are encoded in UTF 16 by using a surrogate pair of 16-bit codes
+	//	  EncodeRune returns 0xfffd if the rune does not need special encoding
+	//  - the above RFC provides the info that BMPStrings are NULL terminated.
+
+	ret := make([]byte, 0, 2*len(s)+2)
+
+	for _, r := range s {
+		if t, _ := utf16.EncodeRune(r); t != 0xfffd {
+			return nil, errors.New("pkcs12: string contains characters that cannot be encoded in UCS-2")
+		}
+		ret = append(ret, byte(r/256), byte(r%256))
+	}
+
+	return append(ret, 0, 0), nil
+}
+
+func decodeBMPString(bmpString []byte) (string, error) {
+	if len(bmpString)%2 != 0 {
+		return "", errors.New("pkcs12: odd-length BMP string")
+	}
+
+	// strip terminator if present
+	if l := len(bmpString); l >= 2 && bmpString[l-1] == 0 && bmpString[l-2] == 0 {
+		bmpString = bmpString[:l-2]
+	}
+
+	s := make([]uint16, 0, len(bmpString)/2)
+	for len(bmpString) > 0 {
+		s = append(s, uint16(bmpString[0])<<8+uint16(bmpString[1]))
+		bmpString = bmpString[2:]
+	}
+
+	return string(utf16.Decode(s)), nil
+}
diff --git a/vendor/golang.org/x/crypto/pkcs12/crypto.go b/vendor/golang.org/x/crypto/pkcs12/crypto.go
new file mode 100644
index 000000000..484ca51b7
--- /dev/null
+++ b/vendor/golang.org/x/crypto/pkcs12/crypto.go
@@ -0,0 +1,131 @@
+// Copyright 2015 The Go 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 pkcs12
+
+import (
+	"bytes"
+	"crypto/cipher"
+	"crypto/des"
+	"crypto/x509/pkix"
+	"encoding/asn1"
+	"errors"
+
+	"golang.org/x/crypto/pkcs12/internal/rc2"
+)
+
+var (
+	oidPBEWithSHAAnd3KeyTripleDESCBC = asn1.ObjectIdentifier([]int{1, 2, 840, 113549, 1, 12, 1, 3})
+	oidPBEWithSHAAnd40BitRC2CBC      = asn1.ObjectIdentifier([]int{1, 2, 840, 113549, 1, 12, 1, 6})
+)
+
+// pbeCipher is an abstraction of a PKCS#12 cipher.
+type pbeCipher interface {
+	// create returns a cipher.Block given a key.
+	create(key []byte) (cipher.Block, error)
+	// deriveKey returns a key derived from the given password and salt.
+	deriveKey(salt, password []byte, iterations int) []byte
+	// deriveKey returns an IV derived from the given password and salt.
+	deriveIV(salt, password []byte, iterations int) []byte
+}
+
+type shaWithTripleDESCBC struct{}
+
+func (shaWithTripleDESCBC) create(key []byte) (cipher.Block, error) {
+	return des.NewTripleDESCipher(key)
+}
+
+func (shaWithTripleDESCBC) deriveKey(salt, password []byte, iterations int) []byte {
+	return pbkdf(sha1Sum, 20, 64, salt, password, iterations, 1, 24)
+}
+
+func (shaWithTripleDESCBC) deriveIV(salt, password []byte, iterations int) []byte {
+	return pbkdf(sha1Sum, 20, 64, salt, password, iterations, 2, 8)
+}
+
+type shaWith40BitRC2CBC struct{}
+
+func (shaWith40BitRC2CBC) create(key []byte) (cipher.Block, error) {
+	return rc2.New(key, len(key)*8)
+}
+
+func (shaWith40BitRC2CBC) deriveKey(salt, password []byte, iterations int) []byte {
+	return pbkdf(sha1Sum, 20, 64, salt, password, iterations, 1, 5)
+}
+
+func (shaWith40BitRC2CBC) deriveIV(salt, password []byte, iterations int) []byte {
+	return pbkdf(sha1Sum, 20, 64, salt, password, iterations, 2, 8)
+}
+
+type pbeParams struct {
+	Salt       []byte
+	Iterations int
+}
+
+func pbDecrypterFor(algorithm pkix.AlgorithmIdentifier, password []byte) (cipher.BlockMode, int, error) {
+	var cipherType pbeCipher
+
+	switch {
+	case algorithm.Algorithm.Equal(oidPBEWithSHAAnd3KeyTripleDESCBC):
+		cipherType = shaWithTripleDESCBC{}
+	case algorithm.Algorithm.Equal(oidPBEWithSHAAnd40BitRC2CBC):
+		cipherType = shaWith40BitRC2CBC{}
+	default:
+		return nil, 0, NotImplementedError("algorithm " + algorithm.Algorithm.String() + " is not supported")
+	}
+
+	var params pbeParams
+	if err := unmarshal(algorithm.Parameters.FullBytes, &params); err != nil {
+		return nil, 0, err
+	}
+
+	key := cipherType.deriveKey(params.Salt, password, params.Iterations)
+	iv := cipherType.deriveIV(params.Salt, password, params.Iterations)
+
+	block, err := cipherType.create(key)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return cipher.NewCBCDecrypter(block, iv), block.BlockSize(), nil
+}
+
+func pbDecrypt(info decryptable, password []byte) (decrypted []byte, err error) {
+	cbc, blockSize, err := pbDecrypterFor(info.Algorithm(), password)
+	if err != nil {
+		return nil, err
+	}
+
+	encrypted := info.Data()
+	if len(encrypted) == 0 {
+		return nil, errors.New("pkcs12: empty encrypted data")
+	}
+	if len(encrypted)%blockSize != 0 {
+		return nil, errors.New("pkcs12: input is not a multiple of the block size")
+	}
+	decrypted = make([]byte, len(encrypted))
+	cbc.CryptBlocks(decrypted, encrypted)
+
+	psLen := int(decrypted[len(decrypted)-1])
+	if psLen == 0 || psLen > blockSize {
+		return nil, ErrDecryption
+	}
+
+	if len(decrypted) < psLen {
+		return nil, ErrDecryption
+	}
+	ps := decrypted[len(decrypted)-psLen:]
+	decrypted = decrypted[:len(decrypted)-psLen]
+	if bytes.Compare(ps, bytes.Repeat([]byte{byte(psLen)}, psLen)) != 0 {
+		return nil, ErrDecryption
+	}
+
+	return
+}
+
+// decryptable abstracts an object that contains ciphertext.
+type decryptable interface {
+	Algorithm() pkix.AlgorithmIdentifier
+	Data() []byte
+}
diff --git a/vendor/golang.org/x/crypto/pkcs12/errors.go b/vendor/golang.org/x/crypto/pkcs12/errors.go
new file mode 100644
index 000000000..7377ce6fb
--- /dev/null
+++ b/vendor/golang.org/x/crypto/pkcs12/errors.go
@@ -0,0 +1,23 @@
+// Copyright 2015 The Go 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 pkcs12
+
+import "errors"
+
+var (
+	// ErrDecryption represents a failure to decrypt the input.
+	ErrDecryption = errors.New("pkcs12: decryption error, incorrect padding")
+
+	// ErrIncorrectPassword is returned when an incorrect password is detected.
+	// Usually, P12/PFX data is signed to be able to verify the password.
+	ErrIncorrectPassword = errors.New("pkcs12: decryption password incorrect")
+)
+
+// NotImplementedError indicates that the input is not currently supported.
+type NotImplementedError string
+
+func (e NotImplementedError) Error() string {
+	return "pkcs12: " + string(e)
+}
diff --git a/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2.go b/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2.go
new file mode 100644
index 000000000..7499e3fb6
--- /dev/null
+++ b/vendor/golang.org/x/crypto/pkcs12/internal/rc2/rc2.go
@@ -0,0 +1,271 @@
+// Copyright 2015 The Go 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 rc2 implements the RC2 cipher
+/*
+https://www.ietf.org/rfc/rfc2268.txt
+http://people.csail.mit.edu/rivest/pubs/KRRR98.pdf
+
+This code is licensed under the MIT license.
+*/
+package rc2
+
+import (
+	"crypto/cipher"
+	"encoding/binary"
+)
+
+// The rc2 block size in bytes
+const BlockSize = 8
+
+type rc2Cipher struct {
+	k [64]uint16
+}
+
+// New returns a new rc2 cipher with the given key and effective key length t1
+func New(key []byte, t1 int) (cipher.Block, error) {
+	// TODO(dgryski): error checking for key length
+	return &rc2Cipher{
+		k: expandKey(key, t1),
+	}, nil
+}
+
+func (*rc2Cipher) BlockSize() int { return BlockSize }
+
+var piTable = [256]byte{
+	0xd9, 0x78, 0xf9, 0xc4, 0x19, 0xdd, 0xb5, 0xed, 0x28, 0xe9, 0xfd, 0x79, 0x4a, 0xa0, 0xd8, 0x9d,
+	0xc6, 0x7e, 0x37, 0x83, 0x2b, 0x76, 0x53, 0x8e, 0x62, 0x4c, 0x64, 0x88, 0x44, 0x8b, 0xfb, 0xa2,
+	0x17, 0x9a, 0x59, 0xf5, 0x87, 0xb3, 0x4f, 0x13, 0x61, 0x45, 0x6d, 0x8d, 0x09, 0x81, 0x7d, 0x32,
+	0xbd, 0x8f, 0x40, 0xeb, 0x86, 0xb7, 0x7b, 0x0b, 0xf0, 0x95, 0x21, 0x22, 0x5c, 0x6b, 0x4e, 0x82,
+	0x54, 0xd6, 0x65, 0x93, 0xce, 0x60, 0xb2, 0x1c, 0x73, 0x56, 0xc0, 0x14, 0xa7, 0x8c, 0xf1, 0xdc,
+	0x12, 0x75, 0xca, 0x1f, 0x3b, 0xbe, 0xe4, 0xd1, 0x42, 0x3d, 0xd4, 0x30, 0xa3, 0x3c, 0xb6, 0x26,
+	0x6f, 0xbf, 0x0e, 0xda, 0x46, 0x69, 0x07, 0x57, 0x27, 0xf2, 0x1d, 0x9b, 0xbc, 0x94, 0x43, 0x03,
+	0xf8, 0x11, 0xc7, 0xf6, 0x90, 0xef, 0x3e, 0xe7, 0x06, 0xc3, 0xd5, 0x2f, 0xc8, 0x66, 0x1e, 0xd7,
+	0x08, 0xe8, 0xea, 0xde, 0x80, 0x52, 0xee, 0xf7, 0x84, 0xaa, 0x72, 0xac, 0x35, 0x4d, 0x6a, 0x2a,
+	0x96, 0x1a, 0xd2, 0x71, 0x5a, 0x15, 0x49, 0x74, 0x4b, 0x9f, 0xd0, 0x5e, 0x04, 0x18, 0xa4, 0xec,
+	0xc2, 0xe0, 0x41, 0x6e, 0x0f, 0x51, 0xcb, 0xcc, 0x24, 0x91, 0xaf, 0x50, 0xa1, 0xf4, 0x70, 0x39,
+	0x99, 0x7c, 0x3a, 0x85, 0x23, 0xb8, 0xb4, 0x7a, 0xfc, 0x02, 0x36, 0x5b, 0x25, 0x55, 0x97, 0x31,
+	0x2d, 0x5d, 0xfa, 0x98, 0xe3, 0x8a, 0x92, 0xae, 0x05, 0xdf, 0x29, 0x10, 0x67, 0x6c, 0xba, 0xc9,
+	0xd3, 0x00, 0xe6, 0xcf, 0xe1, 0x9e, 0xa8, 0x2c, 0x63, 0x16, 0x01, 0x3f, 0x58, 0xe2, 0x89, 0xa9,
+	0x0d, 0x38, 0x34, 0x1b, 0xab, 0x33, 0xff, 0xb0, 0xbb, 0x48, 0x0c, 0x5f, 0xb9, 0xb1, 0xcd, 0x2e,
+	0xc5, 0xf3, 0xdb, 0x47, 0xe5, 0xa5, 0x9c, 0x77, 0x0a, 0xa6, 0x20, 0x68, 0xfe, 0x7f, 0xc1, 0xad,
+}
+
+func expandKey(key []byte, t1 int) [64]uint16 {
+
+	l := make([]byte, 128)
+	copy(l, key)
+
+	var t = len(key)
+	var t8 = (t1 + 7) / 8
+	var tm = byte(255 % uint(1<<(8+uint(t1)-8*uint(t8))))
+
+	for i := len(key); i < 128; i++ {
+		l[i] = piTable[l[i-1]+l[uint8(i-t)]]
+	}
+
+	l[128-t8] = piTable[l[128-t8]&tm]
+
+	for i := 127 - t8; i >= 0; i-- {
+		l[i] = piTable[l[i+1]^l[i+t8]]
+	}
+
+	var k [64]uint16
+
+	for i := range k {
+		k[i] = uint16(l[2*i]) + uint16(l[2*i+1])*256
+	}
+
+	return k
+}
+
+func rotl16(x uint16, b uint) uint16 {
+	return (x >> (16 - b)) | (x << b)
+}
+
+func (c *rc2Cipher) Encrypt(dst, src []byte) {
+
+	r0 := binary.LittleEndian.Uint16(src[0:])
+	r1 := binary.LittleEndian.Uint16(src[2:])
+	r2 := binary.LittleEndian.Uint16(src[4:])
+	r3 := binary.LittleEndian.Uint16(src[6:])
+
+	var j int
+
+	for j <= 16 {
+		// mix r0
+		r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)
+		r0 = rotl16(r0, 1)
+		j++
+
+		// mix r1
+		r1 = r1 + c.k[j] + (r0 & r3) + ((^r0) & r2)
+		r1 = rotl16(r1, 2)
+		j++
+
+		// mix r2
+		r2 = r2 + c.k[j] + (r1 & r0) + ((^r1) & r3)
+		r2 = rotl16(r2, 3)
+		j++
+
+		// mix r3
+		r3 = r3 + c.k[j] + (r2 & r1) + ((^r2) & r0)
+		r3 = rotl16(r3, 5)
+		j++
+
+	}
+
+	r0 = r0 + c.k[r3&63]
+	r1 = r1 + c.k[r0&63]
+	r2 = r2 + c.k[r1&63]
+	r3 = r3 + c.k[r2&63]
+
+	for j <= 40 {
+		// mix r0
+		r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)
+		r0 = rotl16(r0, 1)
+		j++
+
+		// mix r1
+		r1 = r1 + c.k[j] + (r0 & r3) + ((^r0) & r2)
+		r1 = rotl16(r1, 2)
+		j++
+
+		// mix r2
+		r2 = r2 + c.k[j] + (r1 & r0) + ((^r1) & r3)
+		r2 = rotl16(r2, 3)
+		j++
+
+		// mix r3
+		r3 = r3 + c.k[j] + (r2 & r1) + ((^r2) & r0)
+		r3 = rotl16(r3, 5)
+		j++
+
+	}
+
+	r0 = r0 + c.k[r3&63]
+	r1 = r1 + c.k[r0&63]
+	r2 = r2 + c.k[r1&63]
+	r3 = r3 + c.k[r2&63]
+
+	for j <= 60 {
+		// mix r0
+		r0 = r0 + c.k[j] + (r3 & r2) + ((^r3) & r1)
+		r0 = rotl16(r0, 1)
+		j++
+
+		// mix r1
+		r1 = r1 + c.k[j] + (r0 & r3) + ((^r0) & r2)
+		r1 = rotl16(r1, 2)
+		j++
+
+		// mix r2
+		r2 = r2 + c.k[j] + (r1 & r0) + ((^r1) & r3)
+		r2 = rotl16(r2, 3)
+		j++
+
+		// mix r3
+		r3 = r3 + c.k[j] + (r2 & r1) + ((^r2) & r0)
+		r3 = rotl16(r3, 5)
+		j++
+	}
+
+	binary.LittleEndian.PutUint16(dst[0:], r0)
+	binary.LittleEndian.PutUint16(dst[2:], r1)
+	binary.LittleEndian.PutUint16(dst[4:], r2)
+	binary.LittleEndian.PutUint16(dst[6:], r3)
+}
+
+func (c *rc2Cipher) Decrypt(dst, src []byte) {
+
+	r0 := binary.LittleEndian.Uint16(src[0:])
+	r1 := binary.LittleEndian.Uint16(src[2:])
+	r2 := binary.LittleEndian.Uint16(src[4:])
+	r3 := binary.LittleEndian.Uint16(src[6:])
+
+	j := 63
+
+	for j >= 44 {
+		// unmix r3
+		r3 = rotl16(r3, 16-5)
+		r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)
+		j--
+
+		// unmix r2
+		r2 = rotl16(r2, 16-3)
+		r2 = r2 - c.k[j] - (r1 & r0) - ((^r1) & r3)
+		j--
+
+		// unmix r1
+		r1 = rotl16(r1, 16-2)
+		r1 = r1 - c.k[j] - (r0 & r3) - ((^r0) & r2)
+		j--
+
+		// unmix r0
+		r0 = rotl16(r0, 16-1)
+		r0 = r0 - c.k[j] - (r3 & r2) - ((^r3) & r1)
+		j--
+	}
+
+	r3 = r3 - c.k[r2&63]
+	r2 = r2 - c.k[r1&63]
+	r1 = r1 - c.k[r0&63]
+	r0 = r0 - c.k[r3&63]
+
+	for j >= 20 {
+		// unmix r3
+		r3 = rotl16(r3, 16-5)
+		r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)
+		j--
+
+		// unmix r2
+		r2 = rotl16(r2, 16-3)
+		r2 = r2 - c.k[j] - (r1 & r0) - ((^r1) & r3)
+		j--
+
+		// unmix r1
+		r1 = rotl16(r1, 16-2)
+		r1 = r1 - c.k[j] - (r0 & r3) - ((^r0) & r2)
+		j--
+
+		// unmix r0
+		r0 = rotl16(r0, 16-1)
+		r0 = r0 - c.k[j] - (r3 & r2) - ((^r3) & r1)
+		j--
+
+	}
+
+	r3 = r3 - c.k[r2&63]
+	r2 = r2 - c.k[r1&63]
+	r1 = r1 - c.k[r0&63]
+	r0 = r0 - c.k[r3&63]
+
+	for j >= 0 {
+		// unmix r3
+		r3 = rotl16(r3, 16-5)
+		r3 = r3 - c.k[j] - (r2 & r1) - ((^r2) & r0)
+		j--
+
+		// unmix r2
+		r2 = rotl16(r2, 16-3)
+		r2 = r2 - c.k[j] - (r1 & r0) - ((^r1) & r3)
+		j--
+
+		// unmix r1
+		r1 = rotl16(r1, 16-2)
+		r1 = r1 - c.k[j] - (r0 & r3) - ((^r0) & r2)
+		j--
+
+		// unmix r0
+		r0 = rotl16(r0, 16-1)
+		r0 = r0 - c.k[j] - (r3 & r2) - ((^r3) & r1)
+		j--
+
+	}
+
+	binary.LittleEndian.PutUint16(dst[0:], r0)
+	binary.LittleEndian.PutUint16(dst[2:], r1)
+	binary.LittleEndian.PutUint16(dst[4:], r2)
+	binary.LittleEndian.PutUint16(dst[6:], r3)
+}
diff --git a/vendor/golang.org/x/crypto/pkcs12/mac.go b/vendor/golang.org/x/crypto/pkcs12/mac.go
new file mode 100644
index 000000000..5f38aa7de
--- /dev/null
+++ b/vendor/golang.org/x/crypto/pkcs12/mac.go
@@ -0,0 +1,45 @@
+// Copyright 2015 The Go 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 pkcs12
+
+import (
+	"crypto/hmac"
+	"crypto/sha1"
+	"crypto/x509/pkix"
+	"encoding/asn1"
+)
+
+type macData struct {
+	Mac        digestInfo
+	MacSalt    []byte
+	Iterations int `asn1:"optional,default:1"`
+}
+
+// from PKCS#7:
+type digestInfo struct {
+	Algorithm pkix.AlgorithmIdentifier
+	Digest    []byte
+}
+
+var (
+	oidSHA1 = asn1.ObjectIdentifier([]int{1, 3, 14, 3, 2, 26})
+)
+
+func verifyMac(macData *macData, message, password []byte) error {
+	if !macData.Mac.Algorithm.Algorithm.Equal(oidSHA1) {
+		return NotImplementedError("unknown digest algorithm: " + macData.Mac.Algorithm.Algorithm.String())
+	}
+
+	key := pbkdf(sha1Sum, 20, 64, macData.MacSalt, password, macData.Iterations, 3, 20)
+
+	mac := hmac.New(sha1.New, key)
+	mac.Write(message)
+	expectedMAC := mac.Sum(nil)
+
+	if !hmac.Equal(macData.Mac.Digest, expectedMAC) {
+		return ErrIncorrectPassword
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/crypto/pkcs12/pbkdf.go b/vendor/golang.org/x/crypto/pkcs12/pbkdf.go
new file mode 100644
index 000000000..5c419d41e
--- /dev/null
+++ b/vendor/golang.org/x/crypto/pkcs12/pbkdf.go
@@ -0,0 +1,170 @@
+// Copyright 2015 The Go 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 pkcs12
+
+import (
+	"bytes"
+	"crypto/sha1"
+	"math/big"
+)
+
+var (
+	one = big.NewInt(1)
+)
+
+// sha1Sum returns the SHA-1 hash of in.
+func sha1Sum(in []byte) []byte {
+	sum := sha1.Sum(in)
+	return sum[:]
+}
+
+// fillWithRepeats returns v*ceiling(len(pattern) / v) bytes consisting of
+// repeats of pattern.
+func fillWithRepeats(pattern []byte, v int) []byte {
+	if len(pattern) == 0 {
+		return nil
+	}
+	outputLen := v * ((len(pattern) + v - 1) / v)
+	return bytes.Repeat(pattern, (outputLen+len(pattern)-1)/len(pattern))[:outputLen]
+}
+
+func pbkdf(hash func([]byte) []byte, u, v int, salt, password []byte, r int, ID byte, size int) (key []byte) {
+	// implementation of https://tools.ietf.org/html/rfc7292#appendix-B.2 , RFC text verbatim in comments
+
+	//    Let H be a hash function built around a compression function f:
+
+	//       Z_2^u x Z_2^v -> Z_2^u
+
+	//    (that is, H has a chaining variable and output of length u bits, and
+	//    the message input to the compression function of H is v bits).  The
+	//    values for u and v are as follows:
+
+	//            HASH FUNCTION     VALUE u        VALUE v
+	//              MD2, MD5          128            512
+	//                SHA-1           160            512
+	//               SHA-224          224            512
+	//               SHA-256          256            512
+	//               SHA-384          384            1024
+	//               SHA-512          512            1024
+	//             SHA-512/224        224            1024
+	//             SHA-512/256        256            1024
+
+	//    Furthermore, let r be the iteration count.
+
+	//    We assume here that u and v are both multiples of 8, as are the
+	//    lengths of the password and salt strings (which we denote by p and s,
+	//    respectively) and the number n of pseudorandom bits required.  In
+	//    addition, u and v are of course non-zero.
+
+	//    For information on security considerations for MD5 [19], see [25] and
+	//    [1], and on those for MD2, see [18].
+
+	//    The following procedure can be used to produce pseudorandom bits for
+	//    a particular "purpose" that is identified by a byte called "ID".
+	//    This standard specifies 3 different values for the ID byte:
+
+	//    1.  If ID=1, then the pseudorandom bits being produced are to be used
+	//        as key material for performing encryption or decryption.
+
+	//    2.  If ID=2, then the pseudorandom bits being produced are to be used
+	//        as an IV (Initial Value) for encryption or decryption.
+
+	//    3.  If ID=3, then the pseudorandom bits being produced are to be used
+	//        as an integrity key for MACing.
+
+	//    1.  Construct a string, D (the "diversifier"), by concatenating v/8
+	//        copies of ID.
+	var D []byte
+	for i := 0; i < v; i++ {
+		D = append(D, ID)
+	}
+
+	//    2.  Concatenate copies of the salt together to create a string S of
+	//        length v(ceiling(s/v)) bits (the final copy of the salt may be
+	//        truncated to create S).  Note that if the salt is the empty
+	//        string, then so is S.
+
+	S := fillWithRepeats(salt, v)
+
+	//    3.  Concatenate copies of the password together to create a string P
+	//        of length v(ceiling(p/v)) bits (the final copy of the password
+	//        may be truncated to create P).  Note that if the password is the
+	//        empty string, then so is P.
+
+	P := fillWithRepeats(password, v)
+
+	//    4.  Set I=S||P to be the concatenation of S and P.
+	I := append(S, P...)
+
+	//    5.  Set c=ceiling(n/u).
+	c := (size + u - 1) / u
+
+	//    6.  For i=1, 2, ..., c, do the following:
+	A := make([]byte, c*20)
+	var IjBuf []byte
+	for i := 0; i < c; i++ {
+		//        A.  Set A2=H^r(D||I). (i.e., the r-th hash of D||1,
+		//            H(H(H(... H(D||I))))
+		Ai := hash(append(D, I...))
+		for j := 1; j < r; j++ {
+			Ai = hash(Ai)
+		}
+		copy(A[i*20:], Ai[:])
+
+		if i < c-1 { // skip on last iteration
+			// B.  Concatenate copies of Ai to create a string B of length v
+			//     bits (the final copy of Ai may be truncated to create B).
+			var B []byte
+			for len(B) < v {
+				B = append(B, Ai[:]...)
+			}
+			B = B[:v]
+
+			// C.  Treating I as a concatenation I_0, I_1, ..., I_(k-1) of v-bit
+			//     blocks, where k=ceiling(s/v)+ceiling(p/v), modify I by
+			//     setting I_j=(I_j+B+1) mod 2^v for each j.
+			{
+				Bbi := new(big.Int).SetBytes(B)
+				Ij := new(big.Int)
+
+				for j := 0; j < len(I)/v; j++ {
+					Ij.SetBytes(I[j*v : (j+1)*v])
+					Ij.Add(Ij, Bbi)
+					Ij.Add(Ij, one)
+					Ijb := Ij.Bytes()
+					// We expect Ijb to be exactly v bytes,
+					// if it is longer or shorter we must
+					// adjust it accordingly.
+					if len(Ijb) > v {
+						Ijb = Ijb[len(Ijb)-v:]
+					}
+					if len(Ijb) < v {
+						if IjBuf == nil {
+							IjBuf = make([]byte, v)
+						}
+						bytesShort := v - len(Ijb)
+						for i := 0; i < bytesShort; i++ {
+							IjBuf[i] = 0
+						}
+						copy(IjBuf[bytesShort:], Ijb)
+						Ijb = IjBuf
+					}
+					copy(I[j*v:(j+1)*v], Ijb)
+				}
+			}
+		}
+	}
+	//    7.  Concatenate A_1, A_2, ..., A_c together to form a pseudorandom
+	//        bit string, A.
+
+	//    8.  Use the first n bits of A as the output of this entire process.
+	return A[:size]
+
+	//    If the above process is being used to generate a DES key, the process
+	//    should be used to create 64 random bits, and the key's parity bits
+	//    should be set after the 64 bits have been produced.  Similar concerns
+	//    hold for 2-key and 3-key triple-DES keys, for CDMF keys, and for any
+	//    similar keys with parity bits "built into them".
+}
diff --git a/vendor/golang.org/x/crypto/pkcs12/pkcs12.go b/vendor/golang.org/x/crypto/pkcs12/pkcs12.go
new file mode 100644
index 000000000..55f7691d4
--- /dev/null
+++ b/vendor/golang.org/x/crypto/pkcs12/pkcs12.go
@@ -0,0 +1,349 @@
+// Copyright 2015 The Go 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 pkcs12 implements some of PKCS#12.
+//
+// This implementation is distilled from https://tools.ietf.org/html/rfc7292
+// and referenced documents. It is intended for decoding P12/PFX-stored
+// certificates and keys for use with the crypto/tls package.
+//
+// This package is frozen. If it's missing functionality you need, consider
+// an alternative like software.sslmate.com/src/go-pkcs12.
+package pkcs12
+
+import (
+	"crypto/ecdsa"
+	"crypto/rsa"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/asn1"
+	"encoding/hex"
+	"encoding/pem"
+	"errors"
+)
+
+var (
+	oidDataContentType          = asn1.ObjectIdentifier([]int{1, 2, 840, 113549, 1, 7, 1})
+	oidEncryptedDataContentType = asn1.ObjectIdentifier([]int{1, 2, 840, 113549, 1, 7, 6})
+
+	oidFriendlyName     = asn1.ObjectIdentifier([]int{1, 2, 840, 113549, 1, 9, 20})
+	oidLocalKeyID       = asn1.ObjectIdentifier([]int{1, 2, 840, 113549, 1, 9, 21})
+	oidMicrosoftCSPName = asn1.ObjectIdentifier([]int{1, 3, 6, 1, 4, 1, 311, 17, 1})
+)
+
+type pfxPdu struct {
+	Version  int
+	AuthSafe contentInfo
+	MacData  macData `asn1:"optional"`
+}
+
+type contentInfo struct {
+	ContentType asn1.ObjectIdentifier
+	Content     asn1.RawValue `asn1:"tag:0,explicit,optional"`
+}
+
+type encryptedData struct {
+	Version              int
+	EncryptedContentInfo encryptedContentInfo
+}
+
+type encryptedContentInfo struct {
+	ContentType                asn1.ObjectIdentifier
+	ContentEncryptionAlgorithm pkix.AlgorithmIdentifier
+	EncryptedContent           []byte `asn1:"tag:0,optional"`
+}
+
+func (i encryptedContentInfo) Algorithm() pkix.AlgorithmIdentifier {
+	return i.ContentEncryptionAlgorithm
+}
+
+func (i encryptedContentInfo) Data() []byte { return i.EncryptedContent }
+
+type safeBag struct {
+	Id         asn1.ObjectIdentifier
+	Value      asn1.RawValue     `asn1:"tag:0,explicit"`
+	Attributes []pkcs12Attribute `asn1:"set,optional"`
+}
+
+type pkcs12Attribute struct {
+	Id    asn1.ObjectIdentifier
+	Value asn1.RawValue `asn1:"set"`
+}
+
+type encryptedPrivateKeyInfo struct {
+	AlgorithmIdentifier pkix.AlgorithmIdentifier
+	EncryptedData       []byte
+}
+
+func (i encryptedPrivateKeyInfo) Algorithm() pkix.AlgorithmIdentifier {
+	return i.AlgorithmIdentifier
+}
+
+func (i encryptedPrivateKeyInfo) Data() []byte {
+	return i.EncryptedData
+}
+
+// PEM block types
+const (
+	certificateType = "CERTIFICATE"
+	privateKeyType  = "PRIVATE KEY"
+)
+
+// unmarshal calls asn1.Unmarshal, but also returns an error if there is any
+// trailing data after unmarshaling.
+func unmarshal(in []byte, out interface{}) error {
+	trailing, err := asn1.Unmarshal(in, out)
+	if err != nil {
+		return err
+	}
+	if len(trailing) != 0 {
+		return errors.New("pkcs12: trailing data found")
+	}
+	return nil
+}
+
+// ToPEM converts all "safe bags" contained in pfxData to PEM blocks.
+func ToPEM(pfxData []byte, password string) ([]*pem.Block, error) {
+	encodedPassword, err := bmpString(password)
+	if err != nil {
+		return nil, ErrIncorrectPassword
+	}
+
+	bags, encodedPassword, err := getSafeContents(pfxData, encodedPassword)
+
+	if err != nil {
+		return nil, err
+	}
+
+	blocks := make([]*pem.Block, 0, len(bags))
+	for _, bag := range bags {
+		block, err := convertBag(&bag, encodedPassword)
+		if err != nil {
+			return nil, err
+		}
+		blocks = append(blocks, block)
+	}
+
+	return blocks, nil
+}
+
+func convertBag(bag *safeBag, password []byte) (*pem.Block, error) {
+	block := &pem.Block{
+		Headers: make(map[string]string),
+	}
+
+	for _, attribute := range bag.Attributes {
+		k, v, err := convertAttribute(&attribute)
+		if err != nil {
+			return nil, err
+		}
+		block.Headers[k] = v
+	}
+
+	switch {
+	case bag.Id.Equal(oidCertBag):
+		block.Type = certificateType
+		certsData, err := decodeCertBag(bag.Value.Bytes)
+		if err != nil {
+			return nil, err
+		}
+		block.Bytes = certsData
+	case bag.Id.Equal(oidPKCS8ShroundedKeyBag):
+		block.Type = privateKeyType
+
+		key, err := decodePkcs8ShroudedKeyBag(bag.Value.Bytes, password)
+		if err != nil {
+			return nil, err
+		}
+
+		switch key := key.(type) {
+		case *rsa.PrivateKey:
+			block.Bytes = x509.MarshalPKCS1PrivateKey(key)
+		case *ecdsa.PrivateKey:
+			block.Bytes, err = x509.MarshalECPrivateKey(key)
+			if err != nil {
+				return nil, err
+			}
+		default:
+			return nil, errors.New("found unknown private key type in PKCS#8 wrapping")
+		}
+	default:
+		return nil, errors.New("don't know how to convert a safe bag of type " + bag.Id.String())
+	}
+	return block, nil
+}
+
+func convertAttribute(attribute *pkcs12Attribute) (key, value string, err error) {
+	isString := false
+
+	switch {
+	case attribute.Id.Equal(oidFriendlyName):
+		key = "friendlyName"
+		isString = true
+	case attribute.Id.Equal(oidLocalKeyID):
+		key = "localKeyId"
+	case attribute.Id.Equal(oidMicrosoftCSPName):
+		// This key is chosen to match OpenSSL.
+		key = "Microsoft CSP Name"
+		isString = true
+	default:
+		return "", "", errors.New("pkcs12: unknown attribute with OID " + attribute.Id.String())
+	}
+
+	if isString {
+		if err := unmarshal(attribute.Value.Bytes, &attribute.Value); err != nil {
+			return "", "", err
+		}
+		if value, err = decodeBMPString(attribute.Value.Bytes); err != nil {
+			return "", "", err
+		}
+	} else {
+		var id []byte
+		if err := unmarshal(attribute.Value.Bytes, &id); err != nil {
+			return "", "", err
+		}
+		value = hex.EncodeToString(id)
+	}
+
+	return key, value, nil
+}
+
+// Decode extracts a certificate and private key from pfxData. This function
+// assumes that there is only one certificate and only one private key in the
+// pfxData; if there are more use ToPEM instead.
+func Decode(pfxData []byte, password string) (privateKey interface{}, certificate *x509.Certificate, err error) {
+	encodedPassword, err := bmpString(password)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	bags, encodedPassword, err := getSafeContents(pfxData, encodedPassword)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if len(bags) != 2 {
+		err = errors.New("pkcs12: expected exactly two safe bags in the PFX PDU")
+		return
+	}
+
+	for _, bag := range bags {
+		switch {
+		case bag.Id.Equal(oidCertBag):
+			if certificate != nil {
+				err = errors.New("pkcs12: expected exactly one certificate bag")
+			}
+
+			certsData, err := decodeCertBag(bag.Value.Bytes)
+			if err != nil {
+				return nil, nil, err
+			}
+			certs, err := x509.ParseCertificates(certsData)
+			if err != nil {
+				return nil, nil, err
+			}
+			if len(certs) != 1 {
+				err = errors.New("pkcs12: expected exactly one certificate in the certBag")
+				return nil, nil, err
+			}
+			certificate = certs[0]
+
+		case bag.Id.Equal(oidPKCS8ShroundedKeyBag):
+			if privateKey != nil {
+				err = errors.New("pkcs12: expected exactly one key bag")
+			}
+
+			if privateKey, err = decodePkcs8ShroudedKeyBag(bag.Value.Bytes, encodedPassword); err != nil {
+				return nil, nil, err
+			}
+		}
+	}
+
+	if certificate == nil {
+		return nil, nil, errors.New("pkcs12: certificate missing")
+	}
+	if privateKey == nil {
+		return nil, nil, errors.New("pkcs12: private key missing")
+	}
+
+	return
+}
+
+func getSafeContents(p12Data, password []byte) (bags []safeBag, updatedPassword []byte, err error) {
+	pfx := new(pfxPdu)
+	if err := unmarshal(p12Data, pfx); err != nil {
+		return nil, nil, errors.New("pkcs12: error reading P12 data: " + err.Error())
+	}
+
+	if pfx.Version != 3 {
+		return nil, nil, NotImplementedError("can only decode v3 PFX PDU's")
+	}
+
+	if !pfx.AuthSafe.ContentType.Equal(oidDataContentType) {
+		return nil, nil, NotImplementedError("only password-protected PFX is implemented")
+	}
+
+	// unmarshal the explicit bytes in the content for type 'data'
+	if err := unmarshal(pfx.AuthSafe.Content.Bytes, &pfx.AuthSafe.Content); err != nil {
+		return nil, nil, err
+	}
+
+	if len(pfx.MacData.Mac.Algorithm.Algorithm) == 0 {
+		return nil, nil, errors.New("pkcs12: no MAC in data")
+	}
+
+	if err := verifyMac(&pfx.MacData, pfx.AuthSafe.Content.Bytes, password); err != nil {
+		if err == ErrIncorrectPassword && len(password) == 2 && password[0] == 0 && password[1] == 0 {
+			// some implementations use an empty byte array
+			// for the empty string password try one more
+			// time with empty-empty password
+			password = nil
+			err = verifyMac(&pfx.MacData, pfx.AuthSafe.Content.Bytes, password)
+		}
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	var authenticatedSafe []contentInfo
+	if err := unmarshal(pfx.AuthSafe.Content.Bytes, &authenticatedSafe); err != nil {
+		return nil, nil, err
+	}
+
+	if len(authenticatedSafe) != 2 {
+		return nil, nil, NotImplementedError("expected exactly two items in the authenticated safe")
+	}
+
+	for _, ci := range authenticatedSafe {
+		var data []byte
+
+		switch {
+		case ci.ContentType.Equal(oidDataContentType):
+			if err := unmarshal(ci.Content.Bytes, &data); err != nil {
+				return nil, nil, err
+			}
+		case ci.ContentType.Equal(oidEncryptedDataContentType):
+			var encryptedData encryptedData
+			if err := unmarshal(ci.Content.Bytes, &encryptedData); err != nil {
+				return nil, nil, err
+			}
+			if encryptedData.Version != 0 {
+				return nil, nil, NotImplementedError("only version 0 of EncryptedData is supported")
+			}
+			if data, err = pbDecrypt(encryptedData.EncryptedContentInfo, password); err != nil {
+				return nil, nil, err
+			}
+		default:
+			return nil, nil, NotImplementedError("only data and encryptedData content types are supported in authenticated safe")
+		}
+
+		var safeContents []safeBag
+		if err := unmarshal(data, &safeContents); err != nil {
+			return nil, nil, err
+		}
+		bags = append(bags, safeContents...)
+	}
+
+	return bags, password, nil
+}
diff --git a/vendor/golang.org/x/crypto/pkcs12/safebags.go b/vendor/golang.org/x/crypto/pkcs12/safebags.go
new file mode 100644
index 000000000..def1f7b98
--- /dev/null
+++ b/vendor/golang.org/x/crypto/pkcs12/safebags.go
@@ -0,0 +1,57 @@
+// Copyright 2015 The Go 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 pkcs12
+
+import (
+	"crypto/x509"
+	"encoding/asn1"
+	"errors"
+)
+
+var (
+	// see https://tools.ietf.org/html/rfc7292#appendix-D
+	oidCertTypeX509Certificate = asn1.ObjectIdentifier([]int{1, 2, 840, 113549, 1, 9, 22, 1})
+	oidPKCS8ShroundedKeyBag    = asn1.ObjectIdentifier([]int{1, 2, 840, 113549, 1, 12, 10, 1, 2})
+	oidCertBag                 = asn1.ObjectIdentifier([]int{1, 2, 840, 113549, 1, 12, 10, 1, 3})
+)
+
+type certBag struct {
+	Id   asn1.ObjectIdentifier
+	Data []byte `asn1:"tag:0,explicit"`
+}
+
+func decodePkcs8ShroudedKeyBag(asn1Data, password []byte) (privateKey interface{}, err error) {
+	pkinfo := new(encryptedPrivateKeyInfo)
+	if err = unmarshal(asn1Data, pkinfo); err != nil {
+		return nil, errors.New("pkcs12: error decoding PKCS#8 shrouded key bag: " + err.Error())
+	}
+
+	pkData, err := pbDecrypt(pkinfo, password)
+	if err != nil {
+		return nil, errors.New("pkcs12: error decrypting PKCS#8 shrouded key bag: " + err.Error())
+	}
+
+	ret := new(asn1.RawValue)
+	if err = unmarshal(pkData, ret); err != nil {
+		return nil, errors.New("pkcs12: error unmarshaling decrypted private key: " + err.Error())
+	}
+
+	if privateKey, err = x509.ParsePKCS8PrivateKey(pkData); err != nil {
+		return nil, errors.New("pkcs12: error parsing PKCS#8 private key: " + err.Error())
+	}
+
+	return privateKey, nil
+}
+
+func decodeCertBag(asn1Data []byte) (x509Certificates []byte, err error) {
+	bag := new(certBag)
+	if err := unmarshal(asn1Data, bag); err != nil {
+		return nil, errors.New("pkcs12: error decoding cert bag: " + err.Error())
+	}
+	if !bag.Id.Equal(oidCertTypeX509Certificate) {
+		return nil, NotImplementedError("only X509 certificates are supported")
+	}
+	return bag.Data, nil
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 9446197b2..6f4714a00 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -11,8 +11,11 @@ contrib.go.opencensus.io/exporter/ocagent
 # github.com/1and1/oneandone-cloudserver-sdk-go v1.0.1
 github.com/1and1/oneandone-cloudserver-sdk-go
 # github.com/Azure/azure-sdk-for-go v30.0.0+incompatible
+github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute
+github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute/computeapi
 github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-04-01/compute
 github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute
+github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-03-01/compute/computeapi
 github.com/Azure/azure-sdk-for-go/services/network/mgmt/2018-01-01/network
 github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2016-06-01/subscriptions
 github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2018-02-01/resources
@@ -23,6 +26,8 @@ github.com/Azure/azure-sdk-for-go/version
 github.com/Azure/go-autorest/autorest
 github.com/Azure/go-autorest/autorest/adal
 github.com/Azure/go-autorest/autorest/azure
+github.com/Azure/go-autorest/autorest/azure/auth
+github.com/Azure/go-autorest/autorest/azure/cli
 github.com/Azure/go-autorest/autorest/date
 github.com/Azure/go-autorest/autorest/to
 github.com/Azure/go-autorest/autorest/validation
@@ -169,6 +174,8 @@ github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2
 github.com/digitalocean/go-qemu/qmp
 # github.com/digitalocean/godo v1.11.1
 github.com/digitalocean/godo
+# github.com/dimchansky/utfbom v1.1.0
+github.com/dimchansky/utfbom
 # github.com/docker/docker v0.0.0-20180422163414-57142e89befe
 github.com/docker/docker/pkg/namesgenerator
 # github.com/dustin/go-humanize v1.0.0
@@ -605,6 +612,8 @@ golang.org/x/crypto/ed25519/internal/edwards25519
 golang.org/x/crypto/internal/chacha20
 golang.org/x/crypto/internal/subtle
 golang.org/x/crypto/md4
+golang.org/x/crypto/pkcs12
+golang.org/x/crypto/pkcs12/internal/rc2
 golang.org/x/crypto/poly1305
 golang.org/x/crypto/ssh
 golang.org/x/crypto/ssh/agent

From 716f19a4576e4f4d33a1f13db77bea0b75e7c77f Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Thu, 3 Oct 2019 04:23:37 +0000
Subject: [PATCH 122/155] make fmt

---
 builder/azure/chroot/builder_test.go      |  2 +-
 builder/azure/common/client/metadata.go   |  6 +++---
 builder/azure/common/client/testclient.go | 13 ++++++-------
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/builder/azure/chroot/builder_test.go b/builder/azure/chroot/builder_test.go
index 707cdf196..a0b3e2ca8 100644
--- a/builder/azure/chroot/builder_test.go
+++ b/builder/azure/chroot/builder_test.go
@@ -20,7 +20,7 @@ func TestBuilder_Prepare_DiskAsInput(t *testing.T) {
 			t.Error("Expected the returned error to be of type packer.MultiError")
 		}
 		for _, err := range errs.Errors {
-			if matched, _:=regexp.MatchString(`(^|\W)source\W`,err.Error()); matched {
+			if matched, _ := regexp.MatchString(`(^|\W)source\W`, err.Error()); matched {
 				t.Errorf("Did not expect an error about the 'source' field, but found %q", err)
 			}
 		}
diff --git a/builder/azure/common/client/metadata.go b/builder/azure/common/client/metadata.go
index ad76cb007..c6dcf2783 100644
--- a/builder/azure/common/client/metadata.go
+++ b/builder/azure/common/client/metadata.go
@@ -17,11 +17,11 @@ type MetadataClientAPI interface {
 	GetComputeInfo() (*ComputeInfo, error)
 }
 
-type ComputeInfo struct{
+type ComputeInfo struct {
 	Name              string
 	ResourceGroupName string
 	SubscriptionID    string
-Location string
+	Location          string
 }
 
 // metadataClient implements MetadataClient
@@ -65,7 +65,7 @@ func (client metadataClient) GetComputeInfo() (*ComputeInfo, error) {
 	return &vminfo.ComputeInfo, nil
 }
 
-func(ci ComputeInfo) ResourceID() string{
+func (ci ComputeInfo) ResourceID() string {
 	return fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/virtualMachines/%s",
 		ci.SubscriptionID,
 		ci.ResourceGroupName,
diff --git a/builder/azure/common/client/testclient.go b/builder/azure/common/client/testclient.go
index 964e04795..afb2156dc 100644
--- a/builder/azure/common/client/testclient.go
+++ b/builder/azure/common/client/testclient.go
@@ -1,31 +1,30 @@
 package client
 
 import (
+	"errors"
+	"net/http"
 	"os"
 	"testing"
-	"net/http"
-	"errors"
 
 	"github.com/Azure/go-autorest/autorest/azure/auth"
 )
 
 func GetTestClientSet(t *testing.T) (AzureClientSet, error) {
-	if (os.Getenv("AZURE_INTEGRATION_TEST") == "") {
-		t.Skip("AZURE_INTEGRATION_TEST not set")		
+	if os.Getenv("AZURE_INTEGRATION_TEST") == "" {
+		t.Skip("AZURE_INTEGRATION_TEST not set")
 	} else {
 		a, err := auth.NewAuthorizerFromEnvironment()
 		if err == nil {
 			cli := azureClientSet{}
-		cli.authorizer = a
+			cli.authorizer = a
 			cli.subscriptionID = os.Getenv("AZURE_SUBSCRIPTION_ID")
 			cli.PollingDelay = 0
 			cli.sender = http.DefaultClient
 			return cli, nil
-					} else {
+		} else {
 			t.Skipf("Could not create Azure client: %v", err)
 		}
 	}
 
 	return nil, errors.New("Couldn't create client set")
 }
-

From 59438810512dbbbbe6230c467b98ecc859212141 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Thu, 3 Oct 2019 04:45:39 +0000
Subject: [PATCH 123/155] Default for Gen 1 VMs

---
 builder/azure/chroot/builder.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index e72507441..711146703 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -89,7 +89,7 @@ type Config struct {
 	// The image to create using this build.
 	ImageResourceID string `mapstructure:"image_resource_id" required:"true"`
 	// The [Hyper-V generation type](https://docs.microsoft.com/en-us/rest/api/compute/images/createorupdate#hypervgenerationtypes).
-	// Defaults to `V2`.
+	// Defaults to `V1`.
 	ImageHyperVGeneration string `mapstructure:"image_hyperv_generation"`
 
 	ctx interpolate.Context
@@ -190,7 +190,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	if b.config.ImageHyperVGeneration == "" {
-		b.config.ImageHyperVGeneration = string(compute.V2)
+		b.config.ImageHyperVGeneration = string(compute.V1)
 	}
 
 	// checks, accumulate any errors or warnings

From 97e48153bc41552044d9c456b077d87c8f2ec1bb Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Thu, 3 Oct 2019 21:01:17 +0000
Subject: [PATCH 124/155] fixup! Default for Gen 1 VMs

---
 .../partials/builder/azure/chroot/_Config-not-required.html.md  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/source/partials/builder/azure/chroot/_Config-not-required.html.md b/website/source/partials/builder/azure/chroot/_Config-not-required.html.md
index 8f8556919..91029b5f1 100644
--- a/website/source/partials/builder/azure/chroot/_Config-not-required.html.md
+++ b/website/source/partials/builder/azure/chroot/_Config-not-required.html.md
@@ -46,5 +46,5 @@
 -   `os_disk_skip_cleanup` (bool) - If set to `true`, leaves the temporary disk behind in the Packer VM resource group. Defaults to `false`
     
 -   `image_hyperv_generation` (string) - The [Hyper-V generation type](https://docs.microsoft.com/en-us/rest/api/compute/images/createorupdate#hypervgenerationtypes).
-    Defaults to `V2`.
+    Defaults to `V1`.
     
\ No newline at end of file

From eb5dc9326d5ed6e5d5ac3ec4cad794722b37e7d7 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 4 Oct 2019 16:59:41 +0000
Subject: [PATCH 125/155] Adding more tests

---
 builder/azure/chroot/diskattacher.go          |   2 +-
 builder/azure/chroot/step_attach_disk_test.go | 131 ++++++++++++++++++
 .../azure/chroot/step_verify_source_disk.go   |  30 +++-
 .../chroot/step_verify_source_disk_test.go    |  24 +++-
 4 files changed, 178 insertions(+), 9 deletions(-)
 create mode 100644 builder/azure/chroot/step_attach_disk_test.go

diff --git a/builder/azure/chroot/diskattacher.go b/builder/azure/chroot/diskattacher.go
index c52e294eb..abeba5af6 100644
--- a/builder/azure/chroot/diskattacher.go
+++ b/builder/azure/chroot/diskattacher.go
@@ -26,7 +26,7 @@ type DiskAttacher interface {
 	WaitForDetach(ctx context.Context, diskID string) error
 }
 
-func NewDiskAttacher(azureClient client.AzureClientSet) DiskAttacher {
+var NewDiskAttacher = func (azureClient client.AzureClientSet) DiskAttacher {
 	return &diskAttacher{
 		azcli: azureClient,
 	}
diff --git a/builder/azure/chroot/step_attach_disk_test.go b/builder/azure/chroot/step_attach_disk_test.go
new file mode 100644
index 000000000..e644b6a78
--- /dev/null
+++ b/builder/azure/chroot/step_attach_disk_test.go
@@ -0,0 +1,131 @@
+package chroot
+
+import (
+	"context"
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/hashicorp/packer/builder/azure/common/client"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+)
+
+func TestStepAttachDisk_Run(t *testing.T) {
+	type fields struct {
+		GetDiskResponseCode int
+		GetDiskResponseBody string
+
+		attachError        error
+		waitForDeviceError error
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   multistep.StepAction
+	}{
+		{
+			name: "HappyPath",
+			want: multistep.ActionContinue,
+		},
+		{
+			name: "AttachError",
+			fields: fields{
+				attachError: errors.New("unit test"),
+			},
+			want: multistep.ActionHalt,
+		},
+		{
+			name: "WaitForDeviceError",
+			fields: fields{
+				waitForDeviceError: errors.New("unit test"),
+			},
+			want: multistep.ActionHalt,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &StepAttachDisk{}
+
+			NewDiskAttacher = func(azcli client.AzureClientSet) DiskAttacher {
+				return &fakeDiskAttacher{
+					attachError:        tt.fields.attachError,
+					waitForDeviceError: tt.fields.waitForDeviceError,
+				}
+			}
+
+			dm := compute.NewDisksClient("subscriptionId")
+			dm.Sender = autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
+				return &http.Response{
+					Request:    r,
+					Body:       ioutil.NopCloser(strings.NewReader(tt.fields.GetDiskResponseBody)),
+					StatusCode: tt.fields.GetDiskResponseCode,
+				}, nil
+			})
+
+			errorBuffer := &strings.Builder{}
+			ui := &packer.BasicUi{
+				Reader:      strings.NewReader(""),
+				Writer:      ioutil.Discard,
+				ErrorWriter: errorBuffer,
+			}
+
+			state := new(multistep.BasicStateBag)
+			state.Put("azureclient", &client.AzureClientSetMock{})
+			state.Put("ui", ui)
+			state.Put("os_disk_resource_id", "/subscriptions/12345/resourceGroups/group1/providers/Microsoft.Compute/disks/disk1")
+
+			got := s.Run(context.TODO(), state)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("StepAttachDisk.Run() = %v, want %v", got, tt.want)
+			}
+
+			if got == multistep.ActionHalt {
+				if _, ok := state.GetOk("error"); !ok {
+					t.Fatal("Expected 'error' to be set in statebag after failure")
+				}
+			}
+		})
+	}
+}
+
+type fakeDiskAttacher struct {
+	attachError        error
+	waitForDeviceError error
+}
+
+var _ DiskAttacher = &fakeDiskAttacher{}
+
+func (da *fakeDiskAttacher) AttachDisk(ctx context.Context, disk string) (lun int32, err error) {
+	if da.attachError != nil {
+		return 0, da.attachError
+	}
+	return 3, nil
+}
+
+func (da *fakeDiskAttacher) DiskPathForLun(lun int32) string {
+	panic("not implemented")
+}
+
+func (da *fakeDiskAttacher) WaitForDevice(ctx context.Context, lun int32) (device string, err error) {
+	if da.waitForDeviceError != nil {
+		return "", da.waitForDeviceError
+	}
+	if lun == 3 {
+		return "/dev/sdq", nil
+	}
+	panic("expected lun==3")
+}
+
+func (da *fakeDiskAttacher) DetachDisk(ctx context.Context, disk string) (err error) {
+	panic("not implemented")
+}
+
+func (da *fakeDiskAttacher) WaitForDetach(ctx context.Context, diskID string) error {
+	panic("not implemented")
+}
diff --git a/builder/azure/chroot/step_verify_source_disk.go b/builder/azure/chroot/step_verify_source_disk.go
index b949447cb..04879abd9 100644
--- a/builder/azure/chroot/step_verify_source_disk.go
+++ b/builder/azure/chroot/step_verify_source_disk.go
@@ -3,6 +3,7 @@ package chroot
 import (
 	"context"
 	"fmt"
+	"log"
 	"strings"
 
 	"github.com/Azure/go-autorest/autorest/azure"
@@ -26,36 +27,51 @@ func (s StepVerifySourceDisk) Run(ctx context.Context, state multistep.StateBag)
 	ui.Say("Checking source disk location")
 	resource, err := azure.ParseResourceID(s.SourceDiskResourceID)
 	if err != nil {
-		ui.Error(fmt.Sprintf("Could not parse resource id %q: %s", s.SourceDiskResourceID, err))
+		log.Printf("StepVerifySourceDisk.Run: error: %+v", err)
+		err := fmt.Errorf("Could not parse resource id %q: %s", s.SourceDiskResourceID, err)
+		state.Put("error", err)
+		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	if !strings.EqualFold(resource.SubscriptionID, s.SubscriptionID) {
-		ui.Error(fmt.Sprintf("Source disk resource %q is in a different subscription than this VM (%q). "+
+		err := fmt.Errorf("Source disk resource %q is in a different subscription than this VM (%q). "+
 			"Packer does not know how to handle that.",
-			s.SourceDiskResourceID, s.SubscriptionID))
+			s.SourceDiskResourceID, s.SubscriptionID)
+		log.Printf("StepVerifySourceDisk.Run: error: %+v", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	if !(strings.EqualFold(resource.Provider, "Microsoft.Compute") && strings.EqualFold(resource.ResourceType, "disks")) {
-		ui.Error(fmt.Sprintf("Resource ID %q is not a managed disk resource", s.SourceDiskResourceID))
+		err := fmt.Errorf("Resource ID %q is not a managed disk resource", s.SourceDiskResourceID)
+		log.Printf("StepVerifySourceDisk.Run: error: %+v", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	disk, err := azcli.DisksClient().Get(ctx,
 		resource.ResourceGroup, resource.ResourceName)
 	if err != nil {
-		ui.Error(fmt.Sprintf("Unable to retrieve disk (%q): %s", s.SourceDiskResourceID, err))
+		err := fmt.Errorf("Unable to retrieve disk (%q): %s", s.SourceDiskResourceID, err)
+		log.Printf("StepVerifySourceDisk.Run: error: %+v", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
 	location := to.String(disk.Location)
 	if !strings.EqualFold(location, s.Location) {
-		ui.Error(fmt.Sprintf("Source disk resource %q is in a different location (%q) than this VM (%q). "+
+		err := fmt.Errorf("Source disk resource %q is in a different location (%q) than this VM (%q). "+
 			"Packer does not know how to handle that.",
 			s.SourceDiskResourceID,
 			location,
-			s.Location))
+			s.Location)
+		log.Printf("StepVerifySourceDisk.Run: error: %+v", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
 
diff --git a/builder/azure/chroot/step_verify_source_disk_test.go b/builder/azure/chroot/step_verify_source_disk_test.go
index 113fd3f73..3f60e5c57 100644
--- a/builder/azure/chroot/step_verify_source_disk_test.go
+++ b/builder/azure/chroot/step_verify_source_disk_test.go
@@ -47,6 +47,19 @@ func Test_StepVerifySourceDisk_Run(t *testing.T) {
 			},
 			want: multistep.ActionContinue,
 		},
+		{
+			name: "NotAResourceID",
+			fields: fields{
+				SubscriptionID:       "subid1",
+				SourceDiskResourceID: "/other",
+				Location:             "westus2",
+
+				GetDiskResponseCode: 200,
+				GetDiskResponseBody: `{"location":"westus2"}`,
+			},
+			want: multistep.ActionHalt,
+			errormatch: "Could not parse resource id",
+		},
 		{
 			name: "DiskNotFound",
 			fields: fields{
@@ -115,6 +128,7 @@ func Test_StepVerifySourceDisk_Run(t *testing.T) {
 					StatusCode: tt.fields.GetDiskResponseCode,
 				}, nil
 			})
+
 			errorBuffer := &strings.Builder{}
 			ui := &packer.BasicUi{
 				Reader:      strings.NewReader(""),
@@ -128,14 +142,22 @@ func Test_StepVerifySourceDisk_Run(t *testing.T) {
 			})
 			state.Put("ui", ui)
 
-			if got := s.Run(context.TODO(), state); !reflect.DeepEqual(got, tt.want) {
+			got := s.Run(context.TODO(), state);
+			if !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("StepVerifySourceDisk.Run() = %v, want %v", got, tt.want)
 			}
+
 			if tt.errormatch != "" {
 				if !regexp.MustCompile(tt.errormatch).MatchString(errorBuffer.String()) {
 					t.Errorf("Expected the error output (%q) to match %q", errorBuffer.String(), tt.errormatch)
 				}
 			}
+			
+			if got == multistep.ActionHalt {
+				if _, ok := state.GetOk("error"); !ok {
+					t.Fatal("Expected 'error' to be set in statebag after failure")
+				}
+			}
 		})
 	}
 }

From 98175c06d5301da87dba2c15d5c2fdf1e1b6e35c Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 4 Oct 2019 17:14:10 +0000
Subject: [PATCH 126/155] Add test that verifies disksize bug (1/2)

---
 builder/azure/chroot/diskattacher_test.go     |   2 +-
 builder/azure/chroot/step_create_new_disk.go  |   1 -
 .../azure/chroot/step_create_new_disk_test.go | 166 +++++++++++++-----
 3 files changed, 123 insertions(+), 46 deletions(-)

diff --git a/builder/azure/chroot/diskattacher_test.go b/builder/azure/chroot/diskattacher_test.go
index 088dbd147..3b8c55e4d 100644
--- a/builder/azure/chroot/diskattacher_test.go
+++ b/builder/azure/chroot/diskattacher_test.go
@@ -19,7 +19,7 @@ const (
 // Tests assume current machine is capable of running chroot builder (i.e. an Azure VM)
 
 func Test_DiskAttacherAttachesDiskToVM(t *testing.T) {
-	azcli, err := client.GetTestClientSet(t)
+	azcli, err := client.GetTestClientSet(t) // integration test
 	require.Nil(t, err)
 	da := NewDiskAttacher(azcli)
 	testDiskName := t.Name()
diff --git a/builder/azure/chroot/step_create_new_disk.go b/builder/azure/chroot/step_create_new_disk.go
index ed5844c4e..cf033ccf0 100644
--- a/builder/azure/chroot/step_create_new_disk.go
+++ b/builder/azure/chroot/step_create_new_disk.go
@@ -49,7 +49,6 @@ func (s StepCreateNewDisk) Run(ctx context.Context, state multistep.StateBag) mu
 			OsType:           "Linux",
 			HyperVGeneration: compute.HyperVGeneration(s.HyperVGeneration),
 			CreationData:     &compute.CreationData{},
-			DiskSizeGB:       to.Int32Ptr(s.DiskSizeGB),
 		},
 		//Tags: map[string]*string{
 	}
diff --git a/builder/azure/chroot/step_create_new_disk_test.go b/builder/azure/chroot/step_create_new_disk_test.go
index dc95a8b8e..4e05adcd5 100644
--- a/builder/azure/chroot/step_create_new_disk_test.go
+++ b/builder/azure/chroot/step_create_new_disk_test.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"io/ioutil"
 	"net/http"
+	"reflect"
 	"regexp"
 	"testing"
 
@@ -14,56 +15,133 @@ import (
 	"github.com/hashicorp/packer/packer"
 )
 
-func Test_StepCreateNewDisk_FromDisk(t *testing.T) {
-	sut := StepCreateNewDisk{
-		SubscriptionID:         "SubscriptionID",
-		ResourceGroup:          "ResourceGroupName",
-		DiskName:               "TemporaryOSDiskName",
-		DiskSizeGB:             42,
-		DiskStorageAccountType: string(compute.PremiumLRS),
-		HyperVGeneration:       string(compute.V1),
-		Location:               "westus",
-		SourceDiskResourceID:   "SourceDisk",
-	}
+func TestStepCreateNewDisk_Run(t *testing.T) {
+	type fields struct {
+		SubscriptionID         string
+		ResourceGroup          string
+		DiskName               string
+		DiskSizeGB             int32
+		DiskStorageAccountType string
+		HyperVGeneration       string
+		Location               string
+		PlatformImage          *client.PlatformImage
+		SourceDiskResourceID   string
 
-	expected := regexp.MustCompile(`[\s\n]`).ReplaceAllString(`
-{
-	"location": "westus",
-	"properties": {
-		"osType": "Linux",
-		"hyperVGeneration": "V1",
-		"creationData": {
-			"createOption": "Copy",
-			"sourceResourceId": "SourceDisk"
+		expectedPutDiskBody string
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   multistep.StepAction
+	}{
+		{
+			name: "HappyPathDiskSource",
+			fields: fields{
+				SubscriptionID:         "SubscriptionID",
+				ResourceGroup:          "ResourceGroupName",
+				DiskName:               "TemporaryOSDiskName",
+				DiskSizeGB:             42,
+				DiskStorageAccountType: string(compute.PremiumLRS),
+				HyperVGeneration:       string(compute.V1),
+				Location:               "westus",
+				SourceDiskResourceID:   "SourceDisk",
+
+				expectedPutDiskBody: `
+				{
+					"location": "westus",
+					"properties": {
+						"osType": "Linux",
+						"hyperVGeneration": "V1",
+						"creationData": {
+							"createOption": "Copy",
+							"sourceResourceId": "SourceDisk"
+						},
+						"diskSizeGB": 42
+					},
+					"sku": {
+						"name": "Premium_LRS"
+					}
+				}`,
+			},
+			want: multistep.ActionContinue,
+		},
+		{
+			name: "HappyPathDiskSource",
+			fields: fields{
+				SubscriptionID:         "SubscriptionID",
+				ResourceGroup:          "ResourceGroupName",
+				DiskName:               "TemporaryOSDiskName",
+				DiskStorageAccountType: string(compute.StandardLRS),
+				HyperVGeneration:       string(compute.V1),
+				Location:               "westus",
+				PlatformImage: &client.PlatformImage{
+					Publisher: "Microsoft",
+					Offer:     "Windows",
+					Sku:       "2016-DataCenter",
+					Version:   "2016.1.4",
+				},
+
+				expectedPutDiskBody: `
+				{
+					"location": "westus",
+					"properties": {
+						"osType": "Linux",
+						"hyperVGeneration": "V1",
+						"creationData": {
+							"createOption":"FromImage",
+							"imageReference": {
+								"id":"/subscriptions/SubscriptionID/providers/Microsoft.Compute/locations/westus/publishers/Microsoft/artifacttypes/vmimage/offers/Windows/skus/2016-DataCenter/versions/2016.1.4"
+							}
+						}
+					},
+					"sku": {
+						"name": "Standard_LRS"
+					}
+				}`,
+			},
+			want: multistep.ActionContinue,
 		},
-		"diskSizeGB": 42
-	},
-	"sku": {
-		"name": "Premium_LRS"
 	}
-}`, "")
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := StepCreateNewDisk{
+				SubscriptionID:         tt.fields.SubscriptionID,
+				ResourceGroup:          tt.fields.ResourceGroup,
+				DiskName:               tt.fields.DiskName,
+				DiskSizeGB:             tt.fields.DiskSizeGB,
+				DiskStorageAccountType: tt.fields.DiskStorageAccountType,
+				HyperVGeneration:       tt.fields.HyperVGeneration,
+				Location:               tt.fields.Location,
+				PlatformImage:          tt.fields.PlatformImage,
+				SourceDiskResourceID:   tt.fields.SourceDiskResourceID,
+			}
 
-	m := compute.NewDisksClient("subscriptionId")
-	m.Sender = autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
-		b, _ := ioutil.ReadAll(r.Body)
-		if string(b) != expected {
-			t.Fatalf("expected body to be %q, but got %q", expected, string(b))
-		}
-		return &http.Response{
-			Request:    r,
-			StatusCode: 200,
-		}, nil
-	})
+			expectedPutDiskBody := regexp.MustCompile(`[\s\n]`).ReplaceAllString(tt.fields.expectedPutDiskBody, "")
 
-	state := new(multistep.BasicStateBag)
-	state.Put("azureclient", &client.AzureClientSetMock{
-		DisksClientMock: m,
-	})
-	state.Put("ui", packer.TestUi(t))
+			m := compute.NewDisksClient("subscriptionId")
+			m.Sender = autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
+				if r.Method != "PUT" {
+					t.Fatal("Expected only a PUT disk call")
+				}
+				b, _ := ioutil.ReadAll(r.Body)
+				if string(b) != expectedPutDiskBody {
+					t.Fatalf("expected body to be %q, but got %q", expectedPutDiskBody, string(b))
+				}
+				return &http.Response{
+					Request:    r,
+					StatusCode: 200,
+				}, nil
+			})
 
-	r := sut.Run(context.TODO(), state)
+			state := new(multistep.BasicStateBag)
+			state.Put("azureclient", &client.AzureClientSetMock{
+				DisksClientMock: m,
+			})
+			state.Put("ui", packer.TestUi(t))
 
-	if r != multistep.ActionContinue {
-		t.Fatal("Run failed")
+			if got := s.Run(context.TODO(), state); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("StepCreateNewDisk.Run() = %v, want %v", got, tt.want)
+			}
+		})
 	}
 }

From b5c0742951a8b3dc5912860188517011d5f43873 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 4 Oct 2019 17:30:34 +0000
Subject: [PATCH 127/155] Add test that verifies disksize bug (2/2)

---
 builder/azure/chroot/builder_test.go | 45 ++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/builder/azure/chroot/builder_test.go b/builder/azure/chroot/builder_test.go
index a0b3e2ca8..40156bf1f 100644
--- a/builder/azure/chroot/builder_test.go
+++ b/builder/azure/chroot/builder_test.go
@@ -1,6 +1,7 @@
 package chroot
 
 import (
+	"reflect"
 	"regexp"
 	"testing"
 
@@ -26,3 +27,47 @@ func TestBuilder_Prepare_DiskAsInput(t *testing.T) {
 		}
 	}
 }
+
+func TestBuilder_Prepare(t *testing.T) {
+	type config map[string]interface{}
+	
+	tests := []struct {
+		name     string
+		config   config
+		want     []string
+		validate func(Config)
+		wantErr  bool
+	}{
+		{
+			name: "HappyPath",
+			config: config{
+				"client_id":         "123",
+				"client_secret":     "456",
+				"subscription_id":   "789",
+				"resource_group":    "rgname",
+				"image_resource_id": "/subscriptions/789/resourceGroups/otherrgname/providers/Microsoft.Compute/images/MyDebianOSImage-{{timestamp}}",
+				"source":            "credativ:Debian:9:latest",
+			},
+			wantErr: false,
+			validate: func(c Config){
+				if(c.OSDiskSizeGB!=0){
+					t.Fatalf("Expected OSDiskSizeGB to be 0, was %+v", c.OSDiskSizeGB)
+				}
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b := &Builder{}
+
+			got, err := b.Prepare(tt.config)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Builder.Prepare() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("Builder.Prepare() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

From f72c4ec7a37fbb7ec24829b0eb5d02e02008e4c2 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 4 Oct 2019 18:01:02 +0000
Subject: [PATCH 128/155] Update example and docs

---
 builder/azure/chroot/builder_test.go          | 65 +++++++++----------
 examples/azure/debian-chroot.json             |  5 +-
 .../docs/builders/azure-chroot.html.md.erb    |  9 +--
 3 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/builder/azure/chroot/builder_test.go b/builder/azure/chroot/builder_test.go
index 40156bf1f..dd40f7737 100644
--- a/builder/azure/chroot/builder_test.go
+++ b/builder/azure/chroot/builder_test.go
@@ -1,58 +1,53 @@
 package chroot
 
 import (
-	"reflect"
-	"regexp"
 	"testing"
 
-	"github.com/hashicorp/packer/packer"
+	"github.com/Azure/azure-sdk-for-go/profiles/latest/compute/mgmt/compute"
 )
 
-func TestBuilder_Prepare_DiskAsInput(t *testing.T) {
-	b := Builder{}
-	_, err := b.Prepare(map[string]interface{}{
-		"source": "/subscriptions/28279221-ccbe-40f0-b70b-4d78ab822e09/resourceGroups/testrg/providers/Microsoft.Compute/disks/diskname",
-	})
-
-	if err != nil {
-		// make sure there is no error about the source field
-		errs, ok := err.(*packer.MultiError)
-		if !ok {
-			t.Error("Expected the returned error to be of type packer.MultiError")
-		}
-		for _, err := range errs.Errors {
-			if matched, _ := regexp.MatchString(`(^|\W)source\W`, err.Error()); matched {
-				t.Errorf("Did not expect an error about the 'source' field, but found %q", err)
-			}
-		}
-	}
-}
-
 func TestBuilder_Prepare(t *testing.T) {
 	type config map[string]interface{}
-	
+	type regexMatchers map[string]string // map of regex : error message
+
 	tests := []struct {
 		name     string
 		config   config
-		want     []string
 		validate func(Config)
 		wantErr  bool
 	}{
 		{
-			name: "HappyPath",
+			name: "HappyPathFromPlatformImage",
 			config: config{
 				"client_id":         "123",
 				"client_secret":     "456",
 				"subscription_id":   "789",
-				"resource_group":    "rgname",
 				"image_resource_id": "/subscriptions/789/resourceGroups/otherrgname/providers/Microsoft.Compute/images/MyDebianOSImage-{{timestamp}}",
 				"source":            "credativ:Debian:9:latest",
 			},
-			wantErr: false,
-			validate: func(c Config){
-				if(c.OSDiskSizeGB!=0){
-					t.Fatalf("Expected OSDiskSizeGB to be 0, was %+v", c.OSDiskSizeGB)
+			validate: func(c Config) {
+				if c.OSDiskSizeGB != 0 {
+					t.Errorf("Expected OSDiskSizeGB to be 0, was %+v", c.OSDiskSizeGB)
 				}
+				if c.MountPartition != "1" {
+					t.Errorf("Expected MountPartition to be %s, but found %s", "1", c.MountPartition)
+				}
+				if c.OSDiskStorageAccountType != string(compute.PremiumLRS) {
+					t.Errorf("Expected OSDiskStorageAccountType to be %s, but found %s", string(compute.PremiumLRS), c.OSDiskStorageAccountType)
+				}
+				if c.OSDiskCacheType != string(compute.CachingTypesReadOnly) {
+					t.Errorf("Expected OSDiskCacheType to be %s, but found %s", string(compute.CachingTypesReadOnly), c.OSDiskCacheType)
+				}
+				if c.ImageHyperVGeneration != string(compute.V1) {
+					t.Errorf("Expected ImageHyperVGeneration to be %s, but found %s", string(compute.V1), c.ImageHyperVGeneration)
+				}
+			},
+		},
+		{
+			name: "HappyPathFromPlatformImage",
+			config: config{
+				"image_resource_id": "/subscriptions/789/resourceGroups/otherrgname/providers/Microsoft.Compute/images/MyDebianOSImage-{{timestamp}}",
+				"source":            "/subscriptions/789/resourceGroups/testrg/providers/Microsoft.Compute/disks/diskname",
 			},
 		},
 	}
@@ -60,13 +55,15 @@ func TestBuilder_Prepare(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			b := &Builder{}
 
-			got, err := b.Prepare(tt.config)
+			_, err := b.Prepare(tt.config)
+
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Builder.Prepare() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("Builder.Prepare() = %v, want %v", got, tt.want)
+
+			if tt.validate != nil {
+				tt.validate(b.config)
 			}
 		})
 	}
diff --git a/examples/azure/debian-chroot.json b/examples/azure/debian-chroot.json
index 4b29632b1..00909a55f 100644
--- a/examples/azure/debian-chroot.json
+++ b/examples/azure/debian-chroot.json
@@ -2,7 +2,8 @@
   "variables": {
     "client_id": "{{env `ARM_CLIENT_ID`}}",
     "client_secret": "{{env `ARM_CLIENT_SECRET`}}",
-    "subscription_id": "{{env `ARM_SUBSCRIPTION_ID`}}"
+    "subscription_id": "{{env `ARM_SUBSCRIPTION_ID`}}",
+    "resource_group": "{{env `ARM_IMAGE_RESOURCEGROUP_ID`}}"
   },
   "builders": [{
     "type": "azure-chroot",
@@ -23,4 +24,4 @@
     "inline_shebang": "/bin/sh -x",
     "type": "shell"
   }]
-}
+}
\ No newline at end of file
diff --git a/website/source/docs/builders/azure-chroot.html.md.erb b/website/source/docs/builders/azure-chroot.html.md.erb
index 71b488deb..7244671a7 100644
--- a/website/source/docs/builders/azure-chroot.html.md.erb
+++ b/website/source/docs/builders/azure-chroot.html.md.erb
@@ -104,18 +104,19 @@ mounts `/prod` and `/dev`:
 ## Example
 Here is an example that creates a Debian image with updated packages. Specify
 all environment variables (`ARM_CLIENT_ID`, `ARM_CLIENT_SECRET`, 
-`ARM_SUBSCRIPTION_ID`) to use a service principal, specify only `ARM_SUBSCRIPTION_ID`
-to use interactive login or leave them empty to use the system-assigned identity
-of the VM you run Packer on.
+`ARM_SUBSCRIPTION_ID`) to use a service principal.
 The identity you choose should have permission to create disks and images and also
 to update your VM.
+Set the `ARM_IMAGE_RESOURCEGROUP_ID` variable to an existing resource group in the
+subscription where the resulting image will be created.
 
 ``` json
 {
   "variables": {
     "client_id": "{{env `ARM_CLIENT_ID`}}",
     "client_secret": "{{env `ARM_CLIENT_SECRET`}}",
-    "subscription_id": "{{env `ARM_SUBSCRIPTION_ID`}}"
+    "subscription_id": "{{env `ARM_SUBSCRIPTION_ID`}}",
+    "resource_group": "{{env `ARM_IMAGE_RESOURCEGROUP_ID`}}"
   },
   "builders": [{
     "type": "azure-chroot",

From 19a3502b3655e9c2400df720232f9ab4f3fea9dd Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 4 Oct 2019 18:59:11 +0000
Subject: [PATCH 129/155] Add 'vm' template function

---
 builder/azure/chroot/builder.go               |  4 ++
 builder/azure/chroot/template_funcs.go        | 37 +++++++++++++++
 .../docs/builders/azure-chroot.html.md.erb    | 47 ++++++++++++++++++-
 3 files changed, 87 insertions(+), 1 deletion(-)
 create mode 100644 builder/azure/chroot/template_funcs.go

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index 711146703..a5e26f9b3 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -115,6 +115,7 @@ type Builder struct {
 
 func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	b.config.ctx.Funcs = azcommon.TemplateFuncs
+	b.config.ctx.Funcs["vm"] = CreateVMMetadataTemplateFunc()
 	err := config.Decode(&b.config, &config.DecodeOpts{
 		Interpolate:        true,
 		InterpolateContext: &b.config.ctx,
@@ -129,6 +130,9 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			},
 		},
 	}, raws...)
+	if err != nil {
+		return nil, err
+	}
 
 	var errs *packer.MultiError
 	var warns []string
diff --git a/builder/azure/chroot/template_funcs.go b/builder/azure/chroot/template_funcs.go
new file mode 100644
index 000000000..7594cf949
--- /dev/null
+++ b/builder/azure/chroot/template_funcs.go
@@ -0,0 +1,37 @@
+package chroot
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/hashicorp/packer/builder/azure/common/client"
+)
+
+// CreateVMMetadataTemplateFunc returns a template function that retrieves VM metadata. VM metadata is retrieved only once and reused for all executions of the function.
+func CreateVMMetadataTemplateFunc() func(string) (string, error) {
+	var data *client.ComputeInfo
+	var dataErr error
+	once := sync.Once{}
+	return func(key string) (string, error) {
+		once.Do(func() {
+			data, dataErr = client.DefaultMetadataClient.GetComputeInfo()
+		})
+		if dataErr != nil {
+			return "", dataErr
+		}
+		switch key {
+		case "name":
+			return data.Name, nil
+		case "subscription_id":
+			return data.SubscriptionID, nil
+		case "resource_group":
+			return data.ResourceGroupName, nil
+		case "location":
+			return data.Location, nil
+		case "resource_id":
+			return data.ResourceID(), nil
+		default:
+			return "", fmt.Errorf("unknown metadata key: %s (supported: name, subscription_id, resource_group, location, resource_id)", key)
+		}
+	}
+}
diff --git a/website/source/docs/builders/azure-chroot.html.md.erb b/website/source/docs/builders/azure-chroot.html.md.erb
index 7244671a7..4a11152bd 100644
--- a/website/source/docs/builders/azure-chroot.html.md.erb
+++ b/website/source/docs/builders/azure-chroot.html.md.erb
@@ -101,7 +101,52 @@ mounts `/prod` and `/dev`:
 
 -   The mount directory.
 
-## Example
+## Additional template function
+
+Because this builder runs on an Azure VM, there is an additional template function
+available called `vm`, which returns the following VM metadata:
+
+-   name
+-   subscription_id
+-   resource_group
+-   location
+-   resource_id
+
+This function can be used in the configuration templates, for example, use
+```
+"{{ vm `subscription_id` }}"
+```
+to fill in the subscription ID of the VM in any of the configuration options.
+
+## Examples
+Here are some examples using this builder.
+
+### Using a VM with a Managed Identity
+On a VM with a system-assigned managed identity that has the contributor role
+on its own resource group, the following config can be used to create an
+updated Debian image:
+``` json
+{
+  "builders": [{
+    "type": "azure-chroot",
+
+    "command_wrapper": "sudo {{.Command}}",
+
+    "image_resource_id": "/subscriptions/{{vm `subscription_id`}}/resourceGroups/{{vm `resource_group`}}/providers/Microsoft.Compute/images/MyDebianOSImage-{{timestamp}}",
+    "source": "credativ:Debian:9:latest"
+  }],
+  "provisioners": [{
+    "inline": [
+      "apt-get update",
+      "apt-get upgrade -y"
+    ],
+    "inline_shebang": "/bin/sh -x",
+    "type": "shell"
+  }]
+}
+```
+
+### Using a Service Principal
 Here is an example that creates a Debian image with updated packages. Specify
 all environment variables (`ARM_CLIENT_ID`, `ARM_CLIENT_SECRET`, 
 `ARM_SUBSCRIPTION_ID`) to use a service principal.

From fe584f4448f884845753de503e607aa6c08f9726 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 4 Oct 2019 19:00:22 +0000
Subject: [PATCH 130/155] Format updates

---
 builder/azure/chroot/diskattacher.go                  | 2 +-
 builder/azure/chroot/step_verify_source_disk_test.go  | 6 +++---
 website/source/docs/builders/azure-chroot.html.md.erb | 1 +
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/builder/azure/chroot/diskattacher.go b/builder/azure/chroot/diskattacher.go
index abeba5af6..0aa833b6d 100644
--- a/builder/azure/chroot/diskattacher.go
+++ b/builder/azure/chroot/diskattacher.go
@@ -26,7 +26,7 @@ type DiskAttacher interface {
 	WaitForDetach(ctx context.Context, diskID string) error
 }
 
-var NewDiskAttacher = func (azureClient client.AzureClientSet) DiskAttacher {
+var NewDiskAttacher = func(azureClient client.AzureClientSet) DiskAttacher {
 	return &diskAttacher{
 		azcli: azureClient,
 	}
diff --git a/builder/azure/chroot/step_verify_source_disk_test.go b/builder/azure/chroot/step_verify_source_disk_test.go
index 3f60e5c57..8d2191ac0 100644
--- a/builder/azure/chroot/step_verify_source_disk_test.go
+++ b/builder/azure/chroot/step_verify_source_disk_test.go
@@ -57,7 +57,7 @@ func Test_StepVerifySourceDisk_Run(t *testing.T) {
 				GetDiskResponseCode: 200,
 				GetDiskResponseBody: `{"location":"westus2"}`,
 			},
-			want: multistep.ActionHalt,
+			want:       multistep.ActionHalt,
 			errormatch: "Could not parse resource id",
 		},
 		{
@@ -142,7 +142,7 @@ func Test_StepVerifySourceDisk_Run(t *testing.T) {
 			})
 			state.Put("ui", ui)
 
-			got := s.Run(context.TODO(), state);
+			got := s.Run(context.TODO(), state)
 			if !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("StepVerifySourceDisk.Run() = %v, want %v", got, tt.want)
 			}
@@ -152,7 +152,7 @@ func Test_StepVerifySourceDisk_Run(t *testing.T) {
 					t.Errorf("Expected the error output (%q) to match %q", errorBuffer.String(), tt.errormatch)
 				}
 			}
-			
+
 			if got == multistep.ActionHalt {
 				if _, ok := state.GetOk("error"); !ok {
 					t.Fatal("Expected 'error' to be set in statebag after failure")
diff --git a/website/source/docs/builders/azure-chroot.html.md.erb b/website/source/docs/builders/azure-chroot.html.md.erb
index 4a11152bd..a6a52bc46 100644
--- a/website/source/docs/builders/azure-chroot.html.md.erb
+++ b/website/source/docs/builders/azure-chroot.html.md.erb
@@ -125,6 +125,7 @@ Here are some examples using this builder.
 On a VM with a system-assigned managed identity that has the contributor role
 on its own resource group, the following config can be used to create an
 updated Debian image:
+
 ``` json
 {
   "builders": [{

From 0866cb3714df37df79cbf753ce354fcb9a65be50 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Mon, 7 Oct 2019 18:56:20 +0000
Subject: [PATCH 131/155] Reorganize client/common packages

---
 builder/azure/common/client/config.go                        | 3 +--
 builder/azure/common/{ => client}/detect_azure.go            | 2 +-
 builder/azure/common/{ => client}/detect_azure_linux.go      | 2 +-
 builder/azure/common/{ => client}/detect_azure_linux_test.go | 2 +-
 builder/azure/common/{ => client}/devicelogin.go             | 2 +-
 builder/azure/common/client/metadata_test.go                 | 3 +--
 builder/azure/common/client/tokenprovider_devicewflow.go     | 3 +--
 7 files changed, 7 insertions(+), 10 deletions(-)
 rename builder/azure/common/{ => client}/detect_azure.go (90%)
 rename builder/azure/common/{ => client}/detect_azure_linux.go (96%)
 rename builder/azure/common/{ => client}/detect_azure_linux_test.go (97%)
 rename builder/azure/common/{ => client}/devicelogin.go (99%)

diff --git a/builder/azure/common/client/config.go b/builder/azure/common/client/config.go
index 230188eb5..7591b4b33 100644
--- a/builder/azure/common/client/config.go
+++ b/builder/azure/common/client/config.go
@@ -4,7 +4,6 @@ package client
 
 import (
 	"fmt"
-	"github.com/hashicorp/packer/builder/azure/common"
 	"os"
 	"strings"
 	"time"
@@ -303,4 +302,4 @@ func (c *Config) FillParameters() error {
 }
 
 // allow override for unit tests
-var findTenantID = common.FindTenantID
+var findTenantID = FindTenantID
diff --git a/builder/azure/common/detect_azure.go b/builder/azure/common/client/detect_azure.go
similarity index 90%
rename from builder/azure/common/detect_azure.go
rename to builder/azure/common/client/detect_azure.go
index 001ca1b4f..fef7a2932 100644
--- a/builder/azure/common/detect_azure.go
+++ b/builder/azure/common/client/detect_azure.go
@@ -1,6 +1,6 @@
 // +build !linux
 
-package common
+package client
 
 // IsAzure returns true if Packer is running on Azure (currently only works on Linux)
 func IsAzure() bool {
diff --git a/builder/azure/common/detect_azure_linux.go b/builder/azure/common/client/detect_azure_linux.go
similarity index 96%
rename from builder/azure/common/detect_azure_linux.go
rename to builder/azure/common/client/detect_azure_linux.go
index f57eb42b9..c2b9a2800 100644
--- a/builder/azure/common/detect_azure_linux.go
+++ b/builder/azure/common/client/detect_azure_linux.go
@@ -1,4 +1,4 @@
-package common
+package client
 
 import (
 	"bytes"
diff --git a/builder/azure/common/detect_azure_linux_test.go b/builder/azure/common/client/detect_azure_linux_test.go
similarity index 97%
rename from builder/azure/common/detect_azure_linux_test.go
rename to builder/azure/common/client/detect_azure_linux_test.go
index 9d755cfd9..5975d7a6b 100644
--- a/builder/azure/common/detect_azure_linux_test.go
+++ b/builder/azure/common/client/detect_azure_linux_test.go
@@ -1,4 +1,4 @@
-package common
+package client
 
 import (
 	"io/ioutil"
diff --git a/builder/azure/common/devicelogin.go b/builder/azure/common/client/devicelogin.go
similarity index 99%
rename from builder/azure/common/devicelogin.go
rename to builder/azure/common/client/devicelogin.go
index ea177638a..888e851bf 100644
--- a/builder/azure/common/devicelogin.go
+++ b/builder/azure/common/client/devicelogin.go
@@ -1,4 +1,4 @@
-package common
+package client
 
 import (
 	"context"
diff --git a/builder/azure/common/client/metadata_test.go b/builder/azure/common/client/metadata_test.go
index dddc9a2a0..75353d141 100644
--- a/builder/azure/common/client/metadata_test.go
+++ b/builder/azure/common/client/metadata_test.go
@@ -6,12 +6,11 @@ import (
 
 	"github.com/Azure/go-autorest/autorest/azure"
 
-	"github.com/hashicorp/packer/builder/azure/common"
 	"github.com/stretchr/testify/assert"
 )
 
 func Test_MetadataReturnsComputeInfo(t *testing.T) {
-	if !common.IsAzure() {
+	if !IsAzure() {
 		t.Skipf("Not running on Azure, skipping live IMDS test")
 	}
 	mdc := NewMetadataClient()
diff --git a/builder/azure/common/client/tokenprovider_devicewflow.go b/builder/azure/common/client/tokenprovider_devicewflow.go
index 3c2b9fd17..00d83488a 100644
--- a/builder/azure/common/client/tokenprovider_devicewflow.go
+++ b/builder/azure/common/client/tokenprovider_devicewflow.go
@@ -6,7 +6,6 @@ import (
 
 	"github.com/Azure/go-autorest/autorest/adal"
 	"github.com/Azure/go-autorest/autorest/azure"
-	packerAzureCommon "github.com/hashicorp/packer/builder/azure/common"
 )
 
 func NewDeviceFlowOAuthTokenProvider(env azure.Environment, say func(string), tenantID string) oAuthTokenProvider {
@@ -36,5 +35,5 @@ func (tp *deviceflowOauthTokenProvider) getServicePrincipalTokenWithResource(res
 		tp.say(fmt.Sprintf("Getting token for %s", resource))
 	}
 
-	return packerAzureCommon.Authenticate(tp.env, tp.tenantID, tp.say, resource)
+	return Authenticate(tp.env, tp.tenantID, tp.say, resource)
 }

From 9b724d4ca05e7f151929375ef1a9d47777ef47f4 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Mon, 7 Oct 2019 19:20:08 +0000
Subject: [PATCH 132/155] Add artifact

---
 builder/azure/chroot/builder.go  |  11 +++-
 builder/azure/common/artifact.go | 103 +++++++++++++++++++++++++++++++
 2 files changed, 113 insertions(+), 1 deletion(-)
 create mode 100644 builder/azure/common/artifact.go

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index a5e26f9b3..27f763706 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -28,6 +28,9 @@ import (
 	"github.com/Azure/go-autorest/autorest/to"
 )
 
+// BuilderId is the unique ID for this builder
+const BuilderId = "azure.chroot"
+
 // Config is the configuration that is chained through the steps and settable
 // from the template.
 type Config struct {
@@ -437,7 +440,13 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		return nil, rawErr.(error)
 	}
 
-	return nil, nil
+	// Build the artifact and return it
+	artifact := &azcommon.Artifact{
+		Resources:      []string{b.config.ImageResourceID},
+		BuilderIdValue: BuilderId,
+	}
+
+	return artifact, nil
 }
 
 var _ packer.Builder = &Builder{}
diff --git a/builder/azure/common/artifact.go b/builder/azure/common/artifact.go
new file mode 100644
index 000000000..d74ff9b54
--- /dev/null
+++ b/builder/azure/common/artifact.go
@@ -0,0 +1,103 @@
+package common
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"sort"
+	"strings"
+
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/hashicorp/packer/builder/azure/common/client"
+	"github.com/hashicorp/packer/packer"
+)
+
+// Artifact is an artifact implementation that contains built Managed Images or Disks.
+type Artifact struct {
+	// Array of the Azure resource IDs that were created.
+	Resources []string
+
+	// BuilderId is the unique ID for the builder that created this AMI
+	BuilderIdValue string
+
+	// Azure client for performing API stuff.
+	AzureClientSet client.AzureClientSet
+}
+
+func (a *Artifact) BuilderId() string {
+	return a.BuilderIdValue
+}
+
+func (*Artifact) Files() []string {
+	// We have no files
+	return nil
+}
+
+func (a *Artifact) Id() string {
+	parts := make([]string, 0, len(a.Resources))
+	for _, resource := range a.Resources {
+		parts = append(parts, strings.ToLower(resource))
+	}
+
+	sort.Strings(parts)
+	return strings.Join(parts, ",")
+}
+
+func (a *Artifact) String() string {
+	parts := make([]string, 0, len(a.Resources))
+	for _, resource := range a.Resources {
+		parts = append(parts, strings.ToLower(resource))
+	}
+
+	sort.Strings(parts)
+	return fmt.Sprintf("Azure resources created:\n%s\n", strings.Join(parts, "\n"))
+}
+
+func (a *Artifact) State(name string) interface{} {
+	switch name {
+	default:
+		return nil
+	}
+}
+
+func (a *Artifact) Destroy() error {
+	errs := make([]error, 0)
+
+	for _, resource := range a.Resources {
+		log.Printf("Deleting resource %s", resource)
+
+		id, err := azure.ParseResourceID(resource)
+		if err != nil {
+			return fmt.Errorf("Unable to parse resource id (%s): %v", resource, err)
+		}
+
+		ctx := context.TODO()
+		restype := strings.ToLower(fmt.Sprintf("%s/%s", id.Provider, id.ResourceType))
+
+		switch restype {
+		case "microsoft.compute/images":
+			res, err := a.AzureClientSet.ImagesClient().Delete(ctx, id.ResourceGroup, id.ResourceName)
+			if err != nil {
+				errs = append(errs, fmt.Errorf("Unable to initiate deletion of resource (%s): %v", resource, err))
+			} else {
+				err := res.WaitForCompletionRef(ctx, a.AzureClientSet.PollClient())
+				if err != nil {
+					errs = append(errs, fmt.Errorf("Unable to complete deletion of resource (%s): %v", resource, err))
+				}
+			}
+		default:
+			errs = append(errs, fmt.Errorf("Don't know how to delete resources of type %s (%s)", resource, restype))
+		}
+
+	}
+
+	if len(errs) > 0 {
+		if len(errs) == 1 {
+			return errs[0]
+		} else {
+			return &packer.MultiError{Errors: errs}
+		}
+	}
+
+	return nil
+}

From ade95350d69dd086aea801cdd1d01fcade3b7692 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Mon, 7 Oct 2019 21:38:32 +0000
Subject: [PATCH 133/155] Use sudo in docs

---
 website/source/docs/builders/azure-chroot.html.md.erb | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/website/source/docs/builders/azure-chroot.html.md.erb b/website/source/docs/builders/azure-chroot.html.md.erb
index a6a52bc46..069fc1853 100644
--- a/website/source/docs/builders/azure-chroot.html.md.erb
+++ b/website/source/docs/builders/azure-chroot.html.md.erb
@@ -120,6 +120,13 @@ to fill in the subscription ID of the VM in any of the configuration options.
 
 ## Examples
 Here are some examples using this builder.
+This builder requires privileged actions, such as mounting disks, running
+`chroot` and other admin commands. Usually it needs to be run with root
+permissions, for example:
+
+```
+sudo -E packer build example.json
+```
 
 ### Using a VM with a Managed Identity
 On a VM with a system-assigned managed identity that has the contributor role
@@ -131,8 +138,6 @@ updated Debian image:
   "builders": [{
     "type": "azure-chroot",
 
-    "command_wrapper": "sudo {{.Command}}",
-
     "image_resource_id": "/subscriptions/{{vm `subscription_id`}}/resourceGroups/{{vm `resource_group`}}/providers/Microsoft.Compute/images/MyDebianOSImage-{{timestamp}}",
     "source": "credativ:Debian:9:latest"
   }],

From d3dc1be71c62414d82f8f980fb1694195984dbf1 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Fri, 11 Oct 2019 15:32:02 +0000
Subject: [PATCH 134/155] Doc updates

---
 builder/azure/chroot/builder.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/builder/azure/chroot/builder.go b/builder/azure/chroot/builder.go
index 27f763706..ee2dbe08f 100644
--- a/builder/azure/chroot/builder.go
+++ b/builder/azure/chroot/builder.go
@@ -1,7 +1,7 @@
 //go:generate struct-markdown
 
-// Package chroot is able to create an Azure manage image without requiring the
-// launch of a new instance for every build. It does this by attaching and
+// Package chroot is able to create an Azure managed image without requiring the
+// launch of a new virtual machine for every build. It does this by attaching and
 // mounting the root disk and chrooting into that directory.
 // It then creates a managed image from that attached disk.
 package chroot

From b716299d8ee578849e70a8d988a7b570e5672b3c Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Tue, 15 Oct 2019 21:13:07 +0000
Subject: [PATCH 135/155] PR comment

---
 builder/azure/chroot/diskattacher.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/builder/azure/chroot/diskattacher.go b/builder/azure/chroot/diskattacher.go
index 0aa833b6d..6dbdec73c 100644
--- a/builder/azure/chroot/diskattacher.go
+++ b/builder/azure/chroot/diskattacher.go
@@ -49,8 +49,7 @@ func (da diskAttacher) WaitForDevice(ctx context.Context, lun int32) (device str
 		link, err := os.Readlink(path)
 		if err == nil {
 			return filepath.Abs("/dev/disk/azure/scsi1/" + link)
-		}
-		if err != nil && err != os.ErrNotExist {
+		} else if err != os.ErrNotExist {
 			if pe, ok := err.(*os.PathError); ok && pe.Err != syscall.ENOENT {
 				return "", err
 			}

From 015c1949867f772f54e322b27215ce98180d6f0b Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Tue, 15 Oct 2019 22:29:09 +0000
Subject: [PATCH 136/155] clarify docs

---
 .../source/docs/builders/azure-chroot.html.md.erb | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/website/source/docs/builders/azure-chroot.html.md.erb b/website/source/docs/builders/azure-chroot.html.md.erb
index 069fc1853..fd59e4fad 100644
--- a/website/source/docs/builders/azure-chroot.html.md.erb
+++ b/website/source/docs/builders/azure-chroot.html.md.erb
@@ -15,10 +15,11 @@ The `azure-chroot` builder is able to build Azure managed disk (MD) images. For
 more information on managed disks, see [Azure Managed Disks Overview](https://docs.microsoft.com/en-us/azure/virtual-machines/windows/managed-disks-overview).
 
 The difference between this builder and the `azure-arm` builder is that this
-builder is able to build a managed disk image without launching an Azure VM 
-instance. This can dramatically speed up image builds. It also allows for more
-deterministic image content and enables some capabilities that are not possible
-with the `azure-arm` builder.
+builder is able to build a managed disk image without launching a new Azure VM
+for every build, but instead use an already-running Azure VM. This can
+dramatically speed up image builds. It also allows for more deterministic image
+content and enables some capabilities that are not possible with the
+`azure-arm` builder.
 
 > **This is an advanced builder** If you're just getting started with Packer,
 it is recommend to start with the [azure-arm builder](/docs/builders/azure-arm.html),
@@ -57,7 +58,7 @@ information.
 
 <%= partial "partials/builder/azure/common/client/_Config-not-required.html" %>
 
-### Azure chroot builder specific options 
+### Azure chroot builder specific options
 
 #### Required:
 <%= partial "partials/builder/azure/chroot/_Config-required.html" %>
@@ -154,7 +155,7 @@ updated Debian image:
 
 ### Using a Service Principal
 Here is an example that creates a Debian image with updated packages. Specify
-all environment variables (`ARM_CLIENT_ID`, `ARM_CLIENT_SECRET`, 
+all environment variables (`ARM_CLIENT_ID`, `ARM_CLIENT_SECRET`,
 `ARM_SUBSCRIPTION_ID`) to use a service principal.
 The identity you choose should have permission to create disks and images and also
 to update your VM.
@@ -175,7 +176,7 @@ subscription where the resulting image will be created.
     "client_id": "{{user `client_id`}}",
     "client_secret": "{{user `client_secret`}}",
     "subscription_id": "{{user `subscription_id`}}",
-    
+
     "image_resource_id": "/subscriptions/{{user `subscription_id`}}/resourceGroups/{{user `resource_group`}}/providers/Microsoft.Compute/images/MyDebianOSImage-{{timestamp}}",
 
     "source": "credativ:Debian:9:latest"

From 3b6c6f46e7b4d44be89a16e73305ff010594e8a1 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Tue, 15 Oct 2019 15:57:43 -0700
Subject: [PATCH 137/155] Update CHANGELOG.md

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 696a9e236..16fa1e637 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,7 @@
 ## 1.4.5 (Upcoming)
 
 ### IMPROVEMENTS:
+* builder/azure-chroot: Add Azure chroot builder [GH-8185]
 * builder/oracle-oci: Support defined tags for oci builder [GH-8172]
 * builder/proxmos: Add ability to select CPU type [GH-8201]
 * builder/proxmox: Add support for SCSI controller selection [GH-8199]

From 11a1221b538cc28ba4b08ec495dd0f83eed806a5 Mon Sep 17 00:00:00 2001
From: Paul Meyer <paulmey@microsoft.com>
Date: Tue, 15 Oct 2019 16:26:35 -0700
Subject: [PATCH 138/155] Update CHANGELOG.md

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 16fa1e637..9657e7047 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,7 @@
 ## 1.4.5 (Upcoming)
 
 ### IMPROVEMENTS:
+* builder/azure-arm: Allow specification of polling duration [GH-8226]
 * builder/azure-chroot: Add Azure chroot builder [GH-8185]
 * builder/oracle-oci: Support defined tags for oci builder [GH-8172]
 * builder/proxmos: Add ability to select CPU type [GH-8201]

From 75a639775e0146c91fb2dffdbb4521071f79814b Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Wed, 16 Oct 2019 10:24:34 +0200
Subject: [PATCH 139/155] Update Makefile

there's no find dir
---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 0a9d7cf85..888648c25 100644
--- a/Makefile
+++ b/Makefile
@@ -99,7 +99,7 @@ generate: install-gen-deps ## Generate dynamically generated code
 	@echo "==> removing autogenerated markdown..."
 	@find website/source/ -type f | xargs grep -l '^<!-- Code generated' | xargs rm
 	@echo "==> removing autogenerated code..."
-	@find find post-processor common helper template builder provisioner -type f | xargs grep -l '^// Code generated' | xargs rm
+	@find post-processor common helper template builder provisioner -type f | xargs grep -l '^// Code generated' | xargs rm
 	go generate ./...
 	go fmt common/bootcommand/boot_command.go
 	go fmt command/plugin.go

From 4479f73995541030a14cc4b05bab07fa0d184945 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Wed, 16 Oct 2019 10:37:26 +0200
Subject: [PATCH 140/155] uncomment duplicate check tests

---
 hcl2template/load_test.go | 269 ++++++++++++++++++++------------------
 1 file changed, 144 insertions(+), 125 deletions(-)

diff --git a/hcl2template/load_test.go b/hcl2template/load_test.go
index 1503f085c..c91893c8e 100644
--- a/hcl2template/load_test.go
+++ b/hcl2template/load_test.go
@@ -169,133 +169,152 @@ func TestParser_ParseFile(t *testing.T) {
 			false,
 		},
 
-		// {
-		// 	"duplicate " + sourceLabel, defaultParser,
-		// 	args{"testdata/sources/basic.pkr.hcl", &PackerConfig{
-		// 		Sources: map[SourceRef]*Source{
-		// 			SourceRef{
-		// 				Type: "amazon-ebs",
-		// 				Name: "ubuntu-1604",
-		// 			}: {
-		// 				Type: "amazon-ebs",
-		// 				Name: "ubuntu-1604",
-		// 				Cfg:  &amazonebs.FlatConfig{RawRegion: "eu-west-3", InstanceType: "t2.micro"},
-		// 			},
-		// 		},
-		// 	},
-		// 	},
-		// 	&PackerConfig{
-		// 		Sources: map[SourceRef]*Source{
-		// 			SourceRef{
-		// 				Type: "virtualbox-iso",
-		// 				Name: "ubuntu-1204",
-		// 			}: {
-		// 				Type: "virtualbox-iso",
-		// 				Name: "ubuntu-1204",
-		// 				Cfg: &iso.FlatConfig{
-		// 					HTTPDir:         "xxx",
-		// 					ISOChecksum:     "769474248a3897f4865817446f9a4a53",
-		// 					ISOChecksumType: "md5",
-		// 					RawSingleISOUrl: "http://releases.ubuntu.com/12.04/ubuntu-12.04.5-server-amd64.iso",
-		// 					BootCommand:     []string{"..."},
-		// 					ShutdownCommand: "echo 'vagrant' | sudo -S shutdown -P now",
-		// 					RawBootWait:     "10s",
-		// 				},
-		// 			},
-		// 			SourceRef{
-		// 				Type: "amazon-ebs",
-		// 				Name: "ubuntu-1604",
-		// 			}: {
-		// 				Type: "amazon-ebs",
-		// 				Name: "ubuntu-1604",
-		// 				Cfg:  &amazonebs.FlatConfig{RawRegion: "eu-west-3", InstanceType: "t2.micro"},
-		// 			},
-		// 			SourceRef{
-		// 				Type: "amazon-ebs",
-		// 				Name: "that-ubuntu-1.0",
-		// 			}: {
-		// 				Type: "amazon-ebs",
-		// 				Name: "that-ubuntu-1.0",
-		// 				Cfg:  &amazonebs.FlatConfig{RawRegion: "eu-west-3", InstanceType: "t2.micro"},
-		// 			},
-		// 		},
-		// 	},
-		// 	true,
-		// },
+		{
+			"duplicate " + sourceLabel, defaultParser,
+			args{"testdata/sources/basic.pkr.hcl", &PackerConfig{
+				Sources: map[SourceRef]*Source{
+					SourceRef{
+						Type: "virtualbox-iso",
+						Name: "ubuntu-1204",
+					}: {
+						Type: "virtualbox-iso",
+						Name: "ubuntu-1204",
+						Cfg: &iso.FlatConfig{
+							HTTPDir: strPtr("xxx"),
+						},
+					},
+				},
+			},
+			},
+			&PackerConfig{
+				Sources: map[SourceRef]*Source{
+					SourceRef{
+						Type: "virtualbox-iso",
+						Name: "ubuntu-1204",
+					}: {
+						Type: "virtualbox-iso",
+						Name: "ubuntu-1204",
+						Cfg: &iso.FlatConfig{
+							HTTPDir: strPtr("xxx"),
+						},
+					},
+					SourceRef{
+						Type: "amazon-ebs",
+						Name: "ubuntu-1604",
+					}: {
+						Type: "amazon-ebs",
+						Name: "ubuntu-1604",
+						Cfg: &amazonebs.FlatConfig{
+							RawRegion:            strPtr("eu-west-3"),
+							AMIEncryptBootVolume: boolPtr(true),
+							InstanceType:         strPtr("t2.micro"),
+							SourceAmiFilter: &awscommon.FlatAmiFilterOptions{
+								Filters: map[string]string{
+									"name":                "ubuntu/images/*ubuntu-xenial-{16.04}-amd64-server-*",
+									"root-device-type":    "ebs",
+									"virtualization-type": "hvm",
+								},
+								Owners: []string{"099720109477"},
+							},
+							AMIMappings:    []awscommon.FlatBlockDevice{},
+							LaunchMappings: []awscommon.FlatBlockDevice{},
+						},
+					},
+					SourceRef{
+						Type: "amazon-ebs",
+						Name: "that-ubuntu-1.0",
+					}: {
+						Type: "amazon-ebs",
+						Name: "that-ubuntu-1.0",
+						Cfg: &amazonebs.FlatConfig{
+							RawRegion:            strPtr("eu-west-3"),
+							AMIEncryptBootVolume: boolPtr(true),
+							InstanceType:         strPtr("t2.micro"),
+							SourceAmiFilter: &awscommon.FlatAmiFilterOptions{
+								MostRecent: boolPtr(true),
+							},
+							AMIMappings:    []awscommon.FlatBlockDevice{},
+							LaunchMappings: []awscommon.FlatBlockDevice{},
+						},
+					},
+				},
+			},
+			true,
+		},
 
-		// {"valid variables load", defaultParser,
-		// 	args{"testdata/variables/basic.pkr.hcl", new(PackerConfig)},
-		// 	&PackerConfig{
-		// 		Variables: PackerV1Variables{
-		// 			"image_name": "foo-image-{{user `my_secret`}}",
-		// 			"key":        "value",
-		// 			"my_secret":  "foo",
-		// 		},
-		// 	},
-		// 	false,
-		// },
+		{"valid variables load", defaultParser,
+			args{"testdata/variables/basic.pkr.hcl", new(PackerConfig)},
+			&PackerConfig{
+				Variables: PackerV1Variables{
+					"image_name": "foo-image-{{user `my_secret`}}",
+					"key":        "value",
+					"my_secret":  "foo",
+				},
+			},
+			false,
+		},
 
-		// {"valid " + buildLabel + " load", defaultParser,
-		// 	args{"testdata/build/basic.pkr.hcl", new(PackerConfig)},
-		// 	&PackerConfig{
-		// 		Builds: Builds{
-		// 			{
-		// 				Froms: BuildFromList{
-		// 					{
-		// 						Src: SourceRef{"amazon-ebs", "ubuntu-1604"},
-		// 					},
-		// 					{
-		// 						Src: SourceRef{"virtualbox-iso", "ubuntu-1204"},
-		// 					},
-		// 				},
-		// 				ProvisionerGroups: ProvisionerGroups{
-		// 					&ProvisionerGroup{
-		// 						CommunicatorRef: CommunicatorRef{"ssh", "vagrant"},
-		// 						Provisioners: []Provisioner{
-		// 							{Cfg: &shell.FlatConfig{
-		// 								Inline: []string{"echo '{{user `my_secret`}}' :D"},
-		// 							}},
-		// 							{Cfg: &shell.FlatConfig{
-		// 								Scripts:        []string{"script-1.sh", "script-2.sh"},
-		// 								ValidExitCodes: []int{0, 42},
-		// 							}},
-		// 							{Cfg: &file.FlatConfig{
-		// 								Source:      "app.tar.gz",
-		// 								Destination: "/tmp/app.tar.gz",
-		// 							}},
-		// 						},
-		// 					},
-		// 				},
-		// 				PostProvisionerGroups: ProvisionerGroups{
-		// 					&ProvisionerGroup{
-		// 						Provisioners: []Provisioner{
-		// 							{Cfg: &amazon_import.FlatConfig{
-		// 								Name: "that-ubuntu-1.0",
-		// 							}},
-		// 						},
-		// 					},
-		// 				},
-		// 			},
-		// 			&Build{
-		// 				Froms: BuildFromList{
-		// 					{
-		// 						Src: SourceRef{"amazon", "that-ubuntu-1"},
-		// 					},
-		// 				},
-		// 				ProvisionerGroups: ProvisionerGroups{
-		// 					&ProvisionerGroup{
-		// 						Provisioners: []Provisioner{
-		// 							{Cfg: &shell.FlatConfig{
-		// 								Inline: []string{"echo HOLY GUACAMOLE !"},
-		// 							}},
-		// 						},
-		// 					},
-		// 				},
-		// 			},
-		// 		},
-		// 	},
-		// 	false,
-		// },
+		{"valid " + buildLabel + " load", defaultParser,
+			args{"testdata/build/basic.pkr.hcl", new(PackerConfig)},
+			&PackerConfig{
+				Builds: Builds{
+					{
+						Froms: BuildFromList{
+							{
+								Src: SourceRef{"amazon-ebs", "ubuntu-1604"},
+							},
+							{
+								Src: SourceRef{"virtualbox-iso", "ubuntu-1204"},
+							},
+						},
+						ProvisionerGroups: ProvisionerGroups{
+							&ProvisionerGroup{
+								CommunicatorRef: CommunicatorRef{"ssh", "vagrant"},
+								Provisioners: []Provisioner{
+									{Cfg: &shell.FlatConfig{
+										Inline: []string{"echo '{{user `my_secret`}}' :D"},
+									}},
+									{Cfg: &shell.FlatConfig{
+										Scripts:        []string{"script-1.sh", "script-2.sh"},
+										ValidExitCodes: []int{0, 42},
+									}},
+									{Cfg: &file.FlatConfig{
+										Source:      strPtr("app.tar.gz"),
+										Destination: strPtr("/tmp/app.tar.gz"),
+									}},
+								},
+							},
+						},
+						PostProvisionerGroups: ProvisionerGroups{
+							&ProvisionerGroup{
+								Provisioners: []Provisioner{
+									{Cfg: &amazon_import.FlatConfig{
+										Name: strPtr("that-ubuntu-1.0"),
+									}},
+								},
+							},
+						},
+					},
+					&Build{
+						Froms: BuildFromList{
+							{
+								Src: SourceRef{"amazon", "that-ubuntu-1"},
+							},
+						},
+						ProvisionerGroups: ProvisionerGroups{
+							&ProvisionerGroup{
+								Provisioners: []Provisioner{
+									{Cfg: &shell.FlatConfig{
+										Inline: []string{"echo HOLY GUACAMOLE !"},
+									}},
+								},
+							},
+						},
+					},
+				},
+			},
+			false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

From 4542666e258ca8a5f5fe8875aa9ad21704939d5e Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Wed, 16 Oct 2019 10:40:25 +0200
Subject: [PATCH 141/155] fix func calls after master merge

---
 builder/azure/common/client/azure_client_set.go | 2 +-
 builder/azure/common/client/config.go           | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/builder/azure/common/client/azure_client_set.go b/builder/azure/common/client/azure_client_set.go
index c0dfb12e8..f57442b2f 100644
--- a/builder/azure/common/client/azure_client_set.go
+++ b/builder/azure/common/client/azure_client_set.go
@@ -33,7 +33,7 @@ type azureClientSet struct {
 }
 
 func New(c Config, say func(string)) (AzureClientSet, error) {
-	token, err := c.GetServicePrincipalToken(say, c.CloudEnvironment.ResourceManagerEndpoint)
+	token, err := c.GetServicePrincipalToken(say, c.CloudEnvironment().ResourceManagerEndpoint)
 	if err != nil {
 		return nil, err
 	}
diff --git a/builder/azure/common/client/config.go b/builder/azure/common/client/config.go
index 721435375..d3449cc6c 100644
--- a/builder/azure/common/client/config.go
+++ b/builder/azure/common/client/config.go
@@ -207,12 +207,12 @@ func (c Config) GetServicePrincipalTokens(say func(string)) (
 	err error) {
 
 	servicePrincipalToken, err = c.GetServicePrincipalToken(say,
-		c.CloudEnvironment.ResourceManagerEndpoint)
+		c.CloudEnvironment().ResourceManagerEndpoint)
 	if err != nil {
 		return nil, nil, err
 	}
 	servicePrincipalTokenVault, err = c.GetServicePrincipalToken(say,
-		strings.TrimRight(c.CloudEnvironment.KeyVaultEndpoint, "/"))
+		strings.TrimRight(c.CloudEnvironment().KeyVaultEndpoint, "/"))
 	if err != nil {
 		return nil, nil, err
 	}

From f6af5ecf07beb700d9534e1d597a9dd848942df8 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Wed, 16 Oct 2019 10:49:20 +0200
Subject: [PATCH 142/155] Update mapstructure-to-hcl2.go

make log/usage prompt prefix coherent
---
 cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go b/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go
index bc6cf41b2..5fce0daaf 100644
--- a/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go
+++ b/cmd/mapstructure-to-hcl2/mapstructure-to-hcl2.go
@@ -49,7 +49,7 @@ var (
 
 // Usage is a replacement usage function for the flags package.
 func Usage() {
-	fmt.Fprintf(os.Stderr, "Usage of flatten-mapstructure:\n")
+	fmt.Fprintf(os.Stderr, "Usage of mapstructure-to-hcl2:\n")
 	fmt.Fprintf(os.Stderr, "\tflatten-mapstructure [flags] -type T[,T...] pkg\n")
 	fmt.Fprintf(os.Stderr, "Flags:\n")
 	flag.PrintDefaults()
@@ -57,7 +57,7 @@ func Usage() {
 
 func main() {
 	log.SetFlags(0)
-	log.SetPrefix("flatten-mapstructure: ")
+	log.SetPrefix("mapstructure-to-hcl2: ")
 	flag.Usage = Usage
 	flag.Parse()
 	if len(*typeNames) == 0 {
@@ -76,7 +76,7 @@ func main() {
 	if goFile := os.Getenv("GOFILE"); goFile != "" {
 		outputPath = goFile[:len(goFile)-2] + "hcl2spec.go"
 	}
-	log.SetPrefix(fmt.Sprintf("flatten-mapstructure: %s.%v: ", os.Getenv("GOPACKAGE"), typeNames))
+	log.SetPrefix(fmt.Sprintf("mapstructure-to-hcl2: %s.%v: ", os.Getenv("GOPACKAGE"), typeNames))
 
 	cfg := &packages.Config{
 		Mode: packages.LoadSyntax,

From 8b76453e7f84919a51f9c6c66fde8487082a51e0 Mon Sep 17 00:00:00 2001
From: Adrien Delorme <adrien.delorme@icloud.com>
Date: Wed, 16 Oct 2019 10:50:45 +0200
Subject: [PATCH 143/155] make generate

---
 builder/azure/arm/config.hcl2spec.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/builder/azure/arm/config.hcl2spec.go b/builder/azure/arm/config.hcl2spec.go
index 3fe3eac09..4409a78af 100644
--- a/builder/azure/arm/config.hcl2spec.go
+++ b/builder/azure/arm/config.hcl2spec.go
@@ -56,6 +56,7 @@ type FlatConfig struct {
 	VirtualNetworkResourceGroupName     *string                            `mapstructure:"virtual_network_resource_group_name" required:"false" cty:"virtual_network_resource_group_name"`
 	CustomDataFile                      *string                            `mapstructure:"custom_data_file" required:"false" cty:"custom_data_file"`
 	PlanInfo                            *FlatPlanInformation               `mapstructure:"plan_info" required:"false" cty:"plan_info"`
+	PollingDurationTimeout              *string                            `mapstructure:"polling_duration_timeout" required:"false" cty:"polling_duration_timeout"`
 	OSType                              *string                            `mapstructure:"os_type" required:"false" cty:"os_type"`
 	OSDiskSizeGB                        *int32                             `mapstructure:"os_disk_size_gb" required:"false" cty:"os_disk_size_gb"`
 	AdditionalDiskSize                  []int32                            `mapstructure:"disk_additional_size" required:"false" cty:"disk_additional_size"`
@@ -161,6 +162,7 @@ func (*FlatConfig) HCL2Spec() map[string]hcldec.Spec {
 		"virtual_network_resource_group_name":      &hcldec.AttrSpec{Name: "virtual_network_resource_group_name", Type: cty.String, Required: false},
 		"custom_data_file":                         &hcldec.AttrSpec{Name: "custom_data_file", Type: cty.String, Required: false},
 		"plan_info":                                &hcldec.BlockSpec{TypeName: "plan_info", Nested: hcldec.ObjectSpec((*FlatPlanInformation)(nil).HCL2Spec())},
+		"polling_duration_timeout":                 &hcldec.AttrSpec{Name: "polling_duration_timeout", Type: cty.String, Required: false},
 		"os_type":                                  &hcldec.AttrSpec{Name: "os_type", Type: cty.String, Required: false},
 		"os_disk_size_gb":                          &hcldec.AttrSpec{Name: "os_disk_size_gb", Type: cty.Number, Required: false},
 		"disk_additional_size":                     &hcldec.AttrSpec{Name: "disk_additional_size", Type: cty.List(cty.Number), Required: false},

From 4b9ceb402a8acbb7c1dc7a9df40a40cfa18a3fc4 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Wed, 16 Oct 2019 09:54:18 -0700
Subject: [PATCH 144/155] update docs to link to master branch template instead
 of a static, old, link.

---
 website/source/docs/builders/vagrant.html.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/source/docs/builders/vagrant.html.md b/website/source/docs/builders/vagrant.html.md
index 01e4add2b..18d67a210 100644
--- a/website/source/docs/builders/vagrant.html.md
+++ b/website/source/docs/builders/vagrant.html.md
@@ -76,7 +76,7 @@ one, by using `global_id` instead of `source_box`.
 
 -   `template` (string) - a path to a golang template for a
     vagrantfile. Our default template can be found
-    [here](https://github.com/hashicorp/packer/blob/a6d1d852bb0643e3593cc5d3dfe5ed80c4409b65/builder/vagrant/step_create_vagrantfile.go#L23-L30). So far the only template variables available to you are {{ .BoxName }} and
+    [here](https://github.com/hashicorp/packer/blob/master/builder/vagrant/step_create_vagrantfile.go#L23-L37). So far the only template variables available to you are {{ .BoxName }} and
     {{ .SyncedFolder }}, which correspond to the Packer options `box_name` and
     `synced_folder`.
 

From a66de11c31fc732fc30c41f5e29c978095b4942d Mon Sep 17 00:00:00 2001
From: Andre Hofmeister <9199345+HofmeisterAn@users.noreply.github.com>
Date: Wed, 16 Oct 2019 19:09:11 +0200
Subject: [PATCH 145/155] #8225 Add Docker shell and exec format documentation
 for CMD and ENTRYPOINT

---
 website/source/docs/builders/docker.html.md.erb | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/website/source/docs/builders/docker.html.md.erb b/website/source/docs/builders/docker.html.md.erb
index 3834e0601..7d3f030b6 100644
--- a/website/source/docs/builders/docker.html.md.erb
+++ b/website/source/docs/builders/docker.html.md.erb
@@ -94,11 +94,12 @@ Allowed metadata fields that can be changed are:
 
 -   CMD
     -   String, supports both array (escaped) and string form
-    -   EX: `"CMD [\"nginx\", \"-g\", \"daemon off;\"]"`
-    -   EX: `"CMD nginx -g daemon off;"`
+    -   EX: `"CMD [\"nginx\", \"-g\", \"daemon off;\"]"` corresponds to Docker exec form
+    -   EX: `"CMD nginx -g daemon off;"` corresponds to Docker shell form, invokes a command shell first
 -   ENTRYPOINT
-    -   String
-    -   EX: `"ENTRYPOINT /var/www/start.sh"`
+    -   String, supports both array (escaped) and string form
+    -   EX: `"ENTRYPOINT [\"/bin/sh\", \"-c\", \"/var/www/start.sh\"]"` corresponds to Docker exec form
+    -   EX: `"ENTRYPOINT /var/www/start.sh"` corresponds to Docker shell form, invokes a command shell first
 -   ENV
     -   String, note there is no equal sign:
     -   EX: `"ENV HOSTNAME www.example.com"` not

From 8b83cca0649c530ae9aaaec6621c454bca6f1c99 Mon Sep 17 00:00:00 2001
From: Bernard Baltrusaitis <bernard@runawaylover.info>
Date: Sat, 19 Oct 2019 20:56:18 +1100
Subject: [PATCH 146/155] adding temporary instance profile document policy

---
 builder/amazon/common/run_config.go           |    30 +-
 .../common/step_iam_instance_profile.go       |   195 +
 .../amazon/common/step_run_source_instance.go |     5 +-
 .../amazon/common/step_run_spot_instance.go   |     5 +-
 .../common/step_run_spot_instance_test.go     |     2 +-
 builder/amazon/ebs/builder.go                 |    10 +-
 builder/amazon/ebssurrogate/builder.go        |     2 -
 builder/amazon/ebsvolume/builder.go           |     9 +-
 builder/amazon/instance/builder.go            |     9 +-
 .../aws/aws-sdk-go/service/iam/api.go         | 33117 ++++++++++++++++
 .../aws/aws-sdk-go/service/iam/doc.go         |    80 +
 .../aws/aws-sdk-go/service/iam/errors.go      |   200 +
 .../aws/aws-sdk-go/service/iam/service.go     |    95 +
 .../aws/aws-sdk-go/service/iam/waiters.go     |   214 +
 vendor/modules.txt                            |     1 +
 .../common/_RunConfig-not-required.html.md    |    18 +
 16 files changed, 33977 insertions(+), 15 deletions(-)
 create mode 100644 builder/amazon/common/step_iam_instance_profile.go
 create mode 100644 vendor/github.com/aws/aws-sdk-go/service/iam/api.go
 create mode 100644 vendor/github.com/aws/aws-sdk-go/service/iam/doc.go
 create mode 100644 vendor/github.com/aws/aws-sdk-go/service/iam/errors.go
 create mode 100644 vendor/github.com/aws/aws-sdk-go/service/iam/service.go
 create mode 100644 vendor/github.com/aws/aws-sdk-go/service/iam/waiters.go

diff --git a/builder/amazon/common/run_config.go b/builder/amazon/common/run_config.go
index d42825032..8021824bb 100644
--- a/builder/amazon/common/run_config.go
+++ b/builder/amazon/common/run_config.go
@@ -45,6 +45,15 @@ type VpcFilterOptions struct {
 	Filters map[*string]*string
 }
 
+type PolicyDocument struct {
+	Version   string
+	Statement []struct {
+		Effect   string
+		Action   []string
+		Resource string
+	}
+}
+
 func (d *VpcFilterOptions) Empty() bool {
 	return len(d.Filters) == 0
 }
@@ -123,7 +132,26 @@ type RunConfig struct {
 	// The name of an [IAM instance
 	// profile](https://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html)
 	// to launch the EC2 instance with.
-	IamInstanceProfile string `mapstructure:"iam_instance_profile" required:"false"`
+	IamInstanceProfile                        string          `mapstructure:"iam_instance_profile" required:"false"`
+	// Temporary IAM instance profile policy document
+	// If IamInstanceProfile is specified it will be used instead. Example:
+	//
+	// ```json
+	//{
+	//	"Version": "2012-10-17",
+	//	"Statement": [
+	//		{
+	//			"Action": [
+	//			"logs:*"
+	//			],
+	//			"Effect": "Allow",
+	//			"Resource": "*"
+	//		}
+	//	]
+	//}
+	// ```
+	//
+	TemporaryIamInstanceProfilePolicyDocument *PolicyDocument `mapstructure:"temporary_iam_instance_profile_policy_document" required:"false"`
 	// Automatically terminate instances on
 	// shutdown in case Packer exits ungracefully. Possible values are stop and
 	// terminate. Defaults to stop.
diff --git a/builder/amazon/common/step_iam_instance_profile.go b/builder/amazon/common/step_iam_instance_profile.go
new file mode 100644
index 000000000..75d84d3be
--- /dev/null
+++ b/builder/amazon/common/step_iam_instance_profile.go
@@ -0,0 +1,195 @@
+package common
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"github.com/aws/aws-sdk-go/aws"
+	"time"
+
+	"github.com/hashicorp/packer/common/uuid"
+	"github.com/hashicorp/packer/helper/multistep"
+	"github.com/hashicorp/packer/packer"
+	"github.com/aws/aws-sdk-go/service/iam"
+	"encoding/json"
+
+)
+
+type StepIamInstanceProfile struct {
+	IamInstanceProfile                        string
+	TemporaryIamInstanceProfilePolicyDocument *PolicyDocument
+	createdInstanceProfileName                string
+	createdRoleName                           string
+	createdPolicyName                         string
+	roleIsAttached                            bool
+}
+
+func (s *StepIamInstanceProfile) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	iamsvc := state.Get("iam").(*iam.IAM)
+	ui := state.Get("ui").(packer.Ui)
+
+	state.Put("iamInstanceProfile", "")
+
+	if len(s.IamInstanceProfile) > 0 {
+		_, err := iamsvc.GetInstanceProfile(
+			&iam.GetInstanceProfileInput{
+				InstanceProfileName: aws.String(s.IamInstanceProfile),
+			},
+		)
+		if err != nil {
+			err := fmt.Errorf("Couldn't find specified instance profile: %s", err)
+			log.Printf("[DEBUG] %s", err.Error())
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+		log.Printf("Using specified instance profile: %v", s.IamInstanceProfile)
+		state.Put("iamInstanceProfile", s.IamInstanceProfile)
+		return multistep.ActionContinue
+	}
+
+	if s.TemporaryIamInstanceProfilePolicyDocument != nil {
+		// Create the profile
+		profileName := fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID())
+
+		policy, err := json.Marshal(s.TemporaryIamInstanceProfilePolicyDocument)
+		if err != nil {
+			ui.Error(err.Error())
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+
+		ui.Say(fmt.Sprintf("Creating temporary instance profile for this instance: %s", profileName))
+
+		profileResp, err := iamsvc.CreateInstanceProfile(&iam.CreateInstanceProfileInput{
+			InstanceProfileName: aws.String(profileName),
+		})
+		if err != nil {
+			ui.Error(err.Error())
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+		s.createdInstanceProfileName = aws.StringValue(profileResp.InstanceProfile.InstanceProfileName)
+
+		log.Printf("[DEBUG] Waiting for temporary instance profile: %s", s.createdInstanceProfileName)
+		err = iamsvc.WaitUntilInstanceProfileExists(&iam.GetInstanceProfileInput{
+			InstanceProfileName: aws.String(s.createdInstanceProfileName),
+		})
+
+		if err == nil {
+			log.Printf("[DEBUG] Found instance profile %s", s.createdInstanceProfileName)
+		} else {
+			err := fmt.Errorf("Timed out waiting for instance profile %s: %s", s.createdInstanceProfileName, err)
+			log.Printf("[DEBUG] %s", err.Error())
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+
+		ui.Say(fmt.Sprintf("Creating temporary role for this instance: %s", profileName))
+
+		roleResp, err := iamsvc.CreateRole(&iam.CreateRoleInput{
+			RoleName:   aws.String(profileName),
+			Description: aws.String("Temporary role for Packer"),
+			AssumeRolePolicyDocument: aws.String("{\"Version\": \"2012-10-17\",\"Statement\": [{\"Effect\": \"Allow\",\"Principal\": {\"Service\": \"ec2.amazonaws.com\"},\"Action\": \"sts:AssumeRole\"}]}"),
+		})
+		if err != nil {
+			ui.Error(err.Error())
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+
+		s.createdRoleName = aws.StringValue(roleResp.Role.RoleName)
+
+		log.Printf("[DEBUG] Waiting for temporary role: %s", s.createdInstanceProfileName)
+		err = iamsvc.WaitUntilRoleExists(&iam.GetRoleInput{
+			RoleName: aws.String(s.createdRoleName),
+		})
+		if err == nil {
+			log.Printf("[DEBUG] Found temporary role %s", s.createdRoleName)
+		} else {
+			err := fmt.Errorf("Timed out waiting for temporary role %s: %s", s.createdRoleName, err)
+			log.Printf("[DEBUG] %s", err.Error())
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+
+		ui.Say(fmt.Sprintf("Attaching policy to the temporary role: %s", profileName))
+
+		_, err = iamsvc.PutRolePolicy(&iam.PutRolePolicyInput{
+			RoleName: roleResp.Role.RoleName,
+			PolicyName:aws.String(profileName),
+			PolicyDocument: aws.String(string(policy)),
+		})
+		if err != nil {
+			ui.Error(err.Error())
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+
+		s.createdPolicyName = aws.StringValue(roleResp.Role.RoleName)
+
+		_, err = iamsvc.AddRoleToInstanceProfile(&iam.AddRoleToInstanceProfileInput{
+			RoleName: roleResp.Role.RoleName,
+			InstanceProfileName: profileResp.InstanceProfile.InstanceProfileName,
+		})
+		if err != nil {
+			ui.Error(err.Error())
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+
+		s.roleIsAttached = true
+		state.Put("iamInstanceProfile", aws.StringValue(profileResp.InstanceProfile.InstanceProfileName))
+
+		time.Sleep(5*time.Second)
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *StepIamInstanceProfile) Cleanup(state multistep.StateBag) {
+	iamsvc := state.Get("iam").(*iam.IAM)
+	ui := state.Get("ui").(packer.Ui)
+	var err error
+
+	if s.roleIsAttached == true {
+		ui.Say("Detaching temporary role from instance profile...")
+
+		_, err := iamsvc.RemoveRoleFromInstanceProfile(&iam.RemoveRoleFromInstanceProfileInput{
+			InstanceProfileName: aws.String(s.createdInstanceProfileName),
+			RoleName: aws.String(s.createdRoleName),
+		})
+		if err != nil {
+			ui.Error(fmt.Sprintf(
+				"Error %s. Please delete the role manually: %s", err.Error(), s.createdRoleName))
+		}
+	}
+
+	if s.createdPolicyName != "" {
+		ui.Say("Removing policy from temporary role...")
+		iamsvc.DeleteRolePolicy(&iam.DeleteRolePolicyInput{
+			PolicyName: aws.String(s.createdPolicyName),
+			RoleName: aws.String(s.createdRoleName),
+		})
+	}
+	if s.createdRoleName != "" {
+		ui.Say("Deleting temporary role...")
+
+		_, err = iamsvc.DeleteRole(&iam.DeleteRoleInput{RoleName: &s.createdRoleName})
+		if err != nil {
+			ui.Error(fmt.Sprintf(
+				"Error %s. Please delete the role manually: %s", err.Error(), s.createdRoleName))
+		}
+	}
+
+	if s.createdInstanceProfileName != "" {
+		ui.Say("Deleting temporary instance profile...")
+
+		_, err = iamsvc.DeleteInstanceProfile(&iam.DeleteInstanceProfileInput{
+			InstanceProfileName: &s.createdInstanceProfileName})
+
+		if err != nil {
+			ui.Error(fmt.Sprintf(
+				"Error %s. Please delete the instance profile manually: %s", err.Error(), s.createdInstanceProfileName))
+		}
+	}
+}
\ No newline at end of file
diff --git a/builder/amazon/common/step_run_source_instance.go b/builder/amazon/common/step_run_source_instance.go
index abb0ab0f1..2f9fb0505 100644
--- a/builder/amazon/common/step_run_source_instance.go
+++ b/builder/amazon/common/step_run_source_instance.go
@@ -28,7 +28,6 @@ type StepRunSourceInstance struct {
 	EbsOptimized                      bool
 	EnableT2Unlimited                 bool
 	ExpectedRootDevice                string
-	IamInstanceProfile                string
 	InstanceInitiatedShutdownBehavior string
 	InstanceType                      string
 	IsRestricted                      bool
@@ -45,6 +44,8 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 
 	securityGroupIds := aws.StringSlice(state.Get("securityGroupIds").([]string))
+	iamInstanceProfile := aws.String(state.Get("iamInstanceProfile").(string))
+
 	ui := state.Get("ui").(packer.Ui)
 
 	userData := s.UserData
@@ -110,7 +111,7 @@ func (s *StepRunSourceInstance) Run(ctx context.Context, state multistep.StateBa
 		UserData:            &userData,
 		MaxCount:            aws.Int64(1),
 		MinCount:            aws.Int64(1),
-		IamInstanceProfile:  &ec2.IamInstanceProfileSpecification{Name: &s.IamInstanceProfile},
+		IamInstanceProfile:  &ec2.IamInstanceProfileSpecification{Name: iamInstanceProfile},
 		BlockDeviceMappings: s.LaunchMappings.BuildEC2BlockDeviceMappings(),
 		Placement:           &ec2.Placement{AvailabilityZone: &az},
 		EbsOptimized:        &s.EbsOptimized,
diff --git a/builder/amazon/common/step_run_spot_instance.go b/builder/amazon/common/step_run_spot_instance.go
index d8b1118cd..a9756337e 100644
--- a/builder/amazon/common/step_run_spot_instance.go
+++ b/builder/amazon/common/step_run_spot_instance.go
@@ -31,7 +31,6 @@ type StepRunSpotInstance struct {
 	Comm                              *communicator.Config
 	EbsOptimized                      bool
 	ExpectedRootDevice                string
-	IamInstanceProfile                string
 	InstanceInitiatedShutdownBehavior string
 	InstanceType                      string
 	SourceAMI                         string
@@ -69,12 +68,14 @@ func (s *StepRunSpotInstance) CreateTemplateData(userData *string, az string,
 		launchMappingRequests = append(launchMappingRequests, launchRequest)
 	}
 
+	iamInstanceProfile := aws.String(state.Get("iamInstanceProfile").(string))
+
 	// Create a launch template.
 	templateData := ec2.RequestLaunchTemplateData{
 		BlockDeviceMappings:   launchMappingRequests,
 		DisableApiTermination: aws.Bool(false),
 		EbsOptimized:          &s.EbsOptimized,
-		IamInstanceProfile:    &ec2.LaunchTemplateIamInstanceProfileSpecificationRequest{Name: &s.IamInstanceProfile},
+		IamInstanceProfile:    &ec2.LaunchTemplateIamInstanceProfileSpecificationRequest{Name: iamInstanceProfile},
 		ImageId:               &s.SourceAMI,
 		InstanceMarketOptions: marketOptions,
 		Placement: &ec2.LaunchTemplatePlacementRequest{
diff --git a/builder/amazon/common/step_run_spot_instance_test.go b/builder/amazon/common/step_run_spot_instance_test.go
index 62f2e7f6f..1d0f28460 100644
--- a/builder/amazon/common/step_run_spot_instance_test.go
+++ b/builder/amazon/common/step_run_spot_instance_test.go
@@ -73,6 +73,7 @@ func tStateSpot() multistep.StateBag {
 	})
 	state.Put("availability_zone", "us-east-1c")
 	state.Put("securityGroupIds", []string{"sg-0b8984db72f213dc3"})
+	state.Put("iamInstanceProfile", "packer-123")
 	state.Put("subnet_id", "subnet-077fde4e")
 	state.Put("source_image", "")
 	return state
@@ -91,7 +92,6 @@ func getBasicStep() *StepRunSpotInstance {
 		},
 		EbsOptimized:                      false,
 		ExpectedRootDevice:                "ebs",
-		IamInstanceProfile:                "",
 		InstanceInitiatedShutdownBehavior: "stop",
 		InstanceType:                      "t2.micro",
 		SourceAMI:                         "",
diff --git a/builder/amazon/ebs/builder.go b/builder/amazon/ebs/builder.go
index 2cbcbcbf4..167663c5b 100644
--- a/builder/amazon/ebs/builder.go
+++ b/builder/amazon/ebs/builder.go
@@ -12,6 +12,7 @@ import (
 	"fmt"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go/service/iam"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
 	"github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/communicator"
@@ -126,13 +127,14 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	}
 
 	ec2conn := ec2.New(session)
-
+	iam := iam.New(session)
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
 	state.Put("access_config", &b.config.AccessConfig)
 	state.Put("ami_config", &b.config.AMIConfig)
 	state.Put("ec2", ec2conn)
+	state.Put("iam", iam)
 	state.Put("awsSession", session)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
@@ -149,7 +151,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			Debug:                             b.config.PackerDebug,
 			EbsOptimized:                      b.config.EbsOptimized,
 			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
 			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
 			InstanceType:                      b.config.InstanceType,
 			SourceAMI:                         b.config.SourceAmi,
@@ -171,7 +172,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EbsOptimized:                      b.config.EbsOptimized,
 			EnableT2Unlimited:                 b.config.EnableT2Unlimited,
 			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
 			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
 			InstanceType:                      b.config.InstanceType,
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
@@ -217,6 +217,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			CommConfig:             &b.config.RunConfig.Comm,
 			TemporarySGSourceCidrs: b.config.TemporarySGSourceCidrs,
 		},
+		&awscommon.StepIamInstanceProfile{
+			IamInstanceProfile:                        b.config.IamInstanceProfile,
+			TemporaryIamInstanceProfilePolicyDocument: b.config.TemporaryIamInstanceProfilePolicyDocument,
+		},
 		&awscommon.StepCleanupVolumes{
 			LaunchMappings: b.config.LaunchMappings,
 		},
diff --git a/builder/amazon/ebssurrogate/builder.go b/builder/amazon/ebssurrogate/builder.go
index f1e2c8122..fb1c87a13 100644
--- a/builder/amazon/ebssurrogate/builder.go
+++ b/builder/amazon/ebssurrogate/builder.go
@@ -188,7 +188,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			Debug:                             b.config.PackerDebug,
 			EbsOptimized:                      b.config.EbsOptimized,
 			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
 			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
 			InstanceType:                      b.config.InstanceType,
 			SourceAMI:                         b.config.SourceAmi,
@@ -210,7 +209,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EbsOptimized:                      b.config.EbsOptimized,
 			EnableT2Unlimited:                 b.config.EnableT2Unlimited,
 			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
 			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
 			InstanceType:                      b.config.InstanceType,
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
diff --git a/builder/amazon/ebsvolume/builder.go b/builder/amazon/ebsvolume/builder.go
index a26a7ff85..5ed61279e 100644
--- a/builder/amazon/ebsvolume/builder.go
+++ b/builder/amazon/ebsvolume/builder.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/aws/aws-sdk-go/service/iam"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
 	"github.com/hashicorp/packer/common"
 	"github.com/hashicorp/packer/helper/communicator"
@@ -141,12 +142,14 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		return nil, err
 	}
 	ec2conn := ec2.New(session)
+	iam := iam.New(session)
 
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
 	state.Put("access_config", &b.config.AccessConfig)
 	state.Put("ec2", ec2conn)
+	state.Put("iam", iam)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
 
@@ -162,7 +165,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			Debug:                             b.config.PackerDebug,
 			EbsOptimized:                      b.config.EbsOptimized,
 			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
 			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
 			InstanceType:                      b.config.InstanceType,
 			SourceAMI:                         b.config.SourceAmi,
@@ -184,7 +186,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			EbsOptimized:                      b.config.EbsOptimized,
 			EnableT2Unlimited:                 b.config.EnableT2Unlimited,
 			ExpectedRootDevice:                "ebs",
-			IamInstanceProfile:                b.config.IamInstanceProfile,
 			InstanceInitiatedShutdownBehavior: b.config.InstanceInitiatedShutdownBehavior,
 			InstanceType:                      b.config.InstanceType,
 			IsRestricted:                      b.config.IsChinaCloud() || b.config.IsGovCloud(),
@@ -224,6 +225,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			CommConfig:             &b.config.RunConfig.Comm,
 			TemporarySGSourceCidrs: b.config.TemporarySGSourceCidrs,
 		},
+		&awscommon.StepIamInstanceProfile{
+			IamInstanceProfile:                        b.config.IamInstanceProfile,
+			TemporaryIamInstanceProfilePolicyDocument: b.config.TemporaryIamInstanceProfilePolicyDocument,
+		},
 		instanceStep,
 		&stepTagEBSVolumes{
 			VolumeMapping: b.config.VolumeMappings,
diff --git a/builder/amazon/instance/builder.go b/builder/amazon/instance/builder.go
index bcdb00d91..bc77de9b8 100644
--- a/builder/amazon/instance/builder.go
+++ b/builder/amazon/instance/builder.go
@@ -8,6 +8,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/aws/aws-sdk-go/service/iam"
 	"os"
 	"strings"
 
@@ -229,6 +230,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		return nil, err
 	}
 	ec2conn := ec2.New(session)
+	iam := iam.New(session)
 
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
@@ -236,6 +238,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	state.Put("access_config", &b.config.AccessConfig)
 	state.Put("ami_config", &b.config.AMIConfig)
 	state.Put("ec2", ec2conn)
+	state.Put("iam", iam)
 	state.Put("awsSession", session)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
@@ -251,7 +254,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			Comm:                     &b.config.RunConfig.Comm,
 			Debug:                    b.config.PackerDebug,
 			EbsOptimized:             b.config.EbsOptimized,
-			IamInstanceProfile:       b.config.IamInstanceProfile,
 			InstanceType:             b.config.InstanceType,
 			SourceAMI:                b.config.SourceAmi,
 			SpotPrice:                b.config.SpotPrice,
@@ -270,7 +272,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			Debug:                    b.config.PackerDebug,
 			EbsOptimized:             b.config.EbsOptimized,
 			EnableT2Unlimited:        b.config.EnableT2Unlimited,
-			IamInstanceProfile:       b.config.IamInstanceProfile,
 			InstanceType:             b.config.InstanceType,
 			IsRestricted:             b.config.IsChinaCloud() || b.config.IsGovCloud(),
 			SourceAMI:                b.config.SourceAmi,
@@ -313,6 +314,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			SecurityGroupIds:       b.config.SecurityGroupIds,
 			TemporarySGSourceCidrs: b.config.TemporarySGSourceCidrs,
 		},
+		&awscommon.StepIamInstanceProfile{
+			IamInstanceProfile:                        b.config.IamInstanceProfile,
+			TemporaryIamInstanceProfilePolicyDocument: b.config.TemporaryIamInstanceProfilePolicyDocument,
+		},
 		instanceStep,
 		&awscommon.StepGetPassword{
 			Debug:     b.config.PackerDebug,
diff --git a/vendor/github.com/aws/aws-sdk-go/service/iam/api.go b/vendor/github.com/aws/aws-sdk-go/service/iam/api.go
new file mode 100644
index 000000000..64f254326
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/iam/api.go
@@ -0,0 +1,33117 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package iam
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awsutil"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/private/protocol"
+	"github.com/aws/aws-sdk-go/private/protocol/query"
+)
+
+const opAddClientIDToOpenIDConnectProvider = "AddClientIDToOpenIDConnectProvider"
+
+// AddClientIDToOpenIDConnectProviderRequest generates a "aws/request.Request" representing the
+// client's request for the AddClientIDToOpenIDConnectProvider operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See AddClientIDToOpenIDConnectProvider for more information on using the AddClientIDToOpenIDConnectProvider
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the AddClientIDToOpenIDConnectProviderRequest method.
+//    req, resp := client.AddClientIDToOpenIDConnectProviderRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AddClientIDToOpenIDConnectProvider
+func (c *IAM) AddClientIDToOpenIDConnectProviderRequest(input *AddClientIDToOpenIDConnectProviderInput) (req *request.Request, output *AddClientIDToOpenIDConnectProviderOutput) {
+	op := &request.Operation{
+		Name:       opAddClientIDToOpenIDConnectProvider,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AddClientIDToOpenIDConnectProviderInput{}
+	}
+
+	output = &AddClientIDToOpenIDConnectProviderOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// AddClientIDToOpenIDConnectProvider API operation for AWS Identity and Access Management.
+//
+// Adds a new client ID (also known as audience) to the list of client IDs already
+// registered for the specified IAM OpenID Connect (OIDC) provider resource.
+//
+// This operation is idempotent; it does not fail or return an error if you
+// add an existing client ID to the provider.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation AddClientIDToOpenIDConnectProvider for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AddClientIDToOpenIDConnectProvider
+func (c *IAM) AddClientIDToOpenIDConnectProvider(input *AddClientIDToOpenIDConnectProviderInput) (*AddClientIDToOpenIDConnectProviderOutput, error) {
+	req, out := c.AddClientIDToOpenIDConnectProviderRequest(input)
+	return out, req.Send()
+}
+
+// AddClientIDToOpenIDConnectProviderWithContext is the same as AddClientIDToOpenIDConnectProvider with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AddClientIDToOpenIDConnectProvider for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) AddClientIDToOpenIDConnectProviderWithContext(ctx aws.Context, input *AddClientIDToOpenIDConnectProviderInput, opts ...request.Option) (*AddClientIDToOpenIDConnectProviderOutput, error) {
+	req, out := c.AddClientIDToOpenIDConnectProviderRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opAddRoleToInstanceProfile = "AddRoleToInstanceProfile"
+
+// AddRoleToInstanceProfileRequest generates a "aws/request.Request" representing the
+// client's request for the AddRoleToInstanceProfile operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See AddRoleToInstanceProfile for more information on using the AddRoleToInstanceProfile
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the AddRoleToInstanceProfileRequest method.
+//    req, resp := client.AddRoleToInstanceProfileRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AddRoleToInstanceProfile
+func (c *IAM) AddRoleToInstanceProfileRequest(input *AddRoleToInstanceProfileInput) (req *request.Request, output *AddRoleToInstanceProfileOutput) {
+	op := &request.Operation{
+		Name:       opAddRoleToInstanceProfile,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AddRoleToInstanceProfileInput{}
+	}
+
+	output = &AddRoleToInstanceProfileOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// AddRoleToInstanceProfile API operation for AWS Identity and Access Management.
+//
+// Adds the specified IAM role to the specified instance profile. An instance
+// profile can contain only one role, and this limit cannot be increased. You
+// can remove the existing role and then add a different role to an instance
+// profile. You must then wait for the change to appear across all of AWS because
+// of eventual consistency (https://en.wikipedia.org/wiki/Eventual_consistency).
+// To force the change, you must disassociate the instance profile (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateIamInstanceProfile.html)
+// and then associate the instance profile (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateIamInstanceProfile.html),
+// or you can stop your instance and then restart it.
+//
+// The caller of this API must be granted the PassRole permission on the IAM
+// role by a permissions policy.
+//
+// For more information about roles, go to Working with Roles (https://docs.aws.amazon.com/IAM/latest/UserGuide/WorkingWithRoles.html).
+// For more information about instance profiles, go to About Instance Profiles
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/AboutInstanceProfiles.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation AddRoleToInstanceProfile for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AddRoleToInstanceProfile
+func (c *IAM) AddRoleToInstanceProfile(input *AddRoleToInstanceProfileInput) (*AddRoleToInstanceProfileOutput, error) {
+	req, out := c.AddRoleToInstanceProfileRequest(input)
+	return out, req.Send()
+}
+
+// AddRoleToInstanceProfileWithContext is the same as AddRoleToInstanceProfile with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AddRoleToInstanceProfile for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) AddRoleToInstanceProfileWithContext(ctx aws.Context, input *AddRoleToInstanceProfileInput, opts ...request.Option) (*AddRoleToInstanceProfileOutput, error) {
+	req, out := c.AddRoleToInstanceProfileRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opAddUserToGroup = "AddUserToGroup"
+
+// AddUserToGroupRequest generates a "aws/request.Request" representing the
+// client's request for the AddUserToGroup operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See AddUserToGroup for more information on using the AddUserToGroup
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the AddUserToGroupRequest method.
+//    req, resp := client.AddUserToGroupRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AddUserToGroup
+func (c *IAM) AddUserToGroupRequest(input *AddUserToGroupInput) (req *request.Request, output *AddUserToGroupOutput) {
+	op := &request.Operation{
+		Name:       opAddUserToGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AddUserToGroupInput{}
+	}
+
+	output = &AddUserToGroupOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// AddUserToGroup API operation for AWS Identity and Access Management.
+//
+// Adds the specified user to the specified group.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation AddUserToGroup for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AddUserToGroup
+func (c *IAM) AddUserToGroup(input *AddUserToGroupInput) (*AddUserToGroupOutput, error) {
+	req, out := c.AddUserToGroupRequest(input)
+	return out, req.Send()
+}
+
+// AddUserToGroupWithContext is the same as AddUserToGroup with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AddUserToGroup for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) AddUserToGroupWithContext(ctx aws.Context, input *AddUserToGroupInput, opts ...request.Option) (*AddUserToGroupOutput, error) {
+	req, out := c.AddUserToGroupRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opAttachGroupPolicy = "AttachGroupPolicy"
+
+// AttachGroupPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the AttachGroupPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See AttachGroupPolicy for more information on using the AttachGroupPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the AttachGroupPolicyRequest method.
+//    req, resp := client.AttachGroupPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AttachGroupPolicy
+func (c *IAM) AttachGroupPolicyRequest(input *AttachGroupPolicyInput) (req *request.Request, output *AttachGroupPolicyOutput) {
+	op := &request.Operation{
+		Name:       opAttachGroupPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AttachGroupPolicyInput{}
+	}
+
+	output = &AttachGroupPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// AttachGroupPolicy API operation for AWS Identity and Access Management.
+//
+// Attaches the specified managed policy to the specified IAM group.
+//
+// You use this API to attach a managed policy to a group. To embed an inline
+// policy in a group, use PutGroupPolicy.
+//
+// For more information about policies, see Managed Policies and Inline Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation AttachGroupPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodePolicyNotAttachableException "PolicyNotAttachable"
+//   The request failed because AWS service role policies can only be attached
+//   to the service-linked role for that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AttachGroupPolicy
+func (c *IAM) AttachGroupPolicy(input *AttachGroupPolicyInput) (*AttachGroupPolicyOutput, error) {
+	req, out := c.AttachGroupPolicyRequest(input)
+	return out, req.Send()
+}
+
+// AttachGroupPolicyWithContext is the same as AttachGroupPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AttachGroupPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) AttachGroupPolicyWithContext(ctx aws.Context, input *AttachGroupPolicyInput, opts ...request.Option) (*AttachGroupPolicyOutput, error) {
+	req, out := c.AttachGroupPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opAttachRolePolicy = "AttachRolePolicy"
+
+// AttachRolePolicyRequest generates a "aws/request.Request" representing the
+// client's request for the AttachRolePolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See AttachRolePolicy for more information on using the AttachRolePolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the AttachRolePolicyRequest method.
+//    req, resp := client.AttachRolePolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AttachRolePolicy
+func (c *IAM) AttachRolePolicyRequest(input *AttachRolePolicyInput) (req *request.Request, output *AttachRolePolicyOutput) {
+	op := &request.Operation{
+		Name:       opAttachRolePolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AttachRolePolicyInput{}
+	}
+
+	output = &AttachRolePolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// AttachRolePolicy API operation for AWS Identity and Access Management.
+//
+// Attaches the specified managed policy to the specified IAM role. When you
+// attach a managed policy to a role, the managed policy becomes part of the
+// role's permission (access) policy.
+//
+// You cannot use a managed policy as the role's trust policy. The role's trust
+// policy is created at the same time as the role, using CreateRole. You can
+// update a role's trust policy using UpdateAssumeRolePolicy.
+//
+// Use this API to attach a managed policy to a role. To embed an inline policy
+// in a role, use PutRolePolicy. For more information about policies, see Managed
+// Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation AttachRolePolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodePolicyNotAttachableException "PolicyNotAttachable"
+//   The request failed because AWS service role policies can only be attached
+//   to the service-linked role for that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AttachRolePolicy
+func (c *IAM) AttachRolePolicy(input *AttachRolePolicyInput) (*AttachRolePolicyOutput, error) {
+	req, out := c.AttachRolePolicyRequest(input)
+	return out, req.Send()
+}
+
+// AttachRolePolicyWithContext is the same as AttachRolePolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AttachRolePolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) AttachRolePolicyWithContext(ctx aws.Context, input *AttachRolePolicyInput, opts ...request.Option) (*AttachRolePolicyOutput, error) {
+	req, out := c.AttachRolePolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opAttachUserPolicy = "AttachUserPolicy"
+
+// AttachUserPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the AttachUserPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See AttachUserPolicy for more information on using the AttachUserPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the AttachUserPolicyRequest method.
+//    req, resp := client.AttachUserPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AttachUserPolicy
+func (c *IAM) AttachUserPolicyRequest(input *AttachUserPolicyInput) (req *request.Request, output *AttachUserPolicyOutput) {
+	op := &request.Operation{
+		Name:       opAttachUserPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &AttachUserPolicyInput{}
+	}
+
+	output = &AttachUserPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// AttachUserPolicy API operation for AWS Identity and Access Management.
+//
+// Attaches the specified managed policy to the specified user.
+//
+// You use this API to attach a managed policy to a user. To embed an inline
+// policy in a user, use PutUserPolicy.
+//
+// For more information about policies, see Managed Policies and Inline Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation AttachUserPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodePolicyNotAttachableException "PolicyNotAttachable"
+//   The request failed because AWS service role policies can only be attached
+//   to the service-linked role for that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/AttachUserPolicy
+func (c *IAM) AttachUserPolicy(input *AttachUserPolicyInput) (*AttachUserPolicyOutput, error) {
+	req, out := c.AttachUserPolicyRequest(input)
+	return out, req.Send()
+}
+
+// AttachUserPolicyWithContext is the same as AttachUserPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See AttachUserPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) AttachUserPolicyWithContext(ctx aws.Context, input *AttachUserPolicyInput, opts ...request.Option) (*AttachUserPolicyOutput, error) {
+	req, out := c.AttachUserPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opChangePassword = "ChangePassword"
+
+// ChangePasswordRequest generates a "aws/request.Request" representing the
+// client's request for the ChangePassword operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ChangePassword for more information on using the ChangePassword
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ChangePasswordRequest method.
+//    req, resp := client.ChangePasswordRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ChangePassword
+func (c *IAM) ChangePasswordRequest(input *ChangePasswordInput) (req *request.Request, output *ChangePasswordOutput) {
+	op := &request.Operation{
+		Name:       opChangePassword,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ChangePasswordInput{}
+	}
+
+	output = &ChangePasswordOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// ChangePassword API operation for AWS Identity and Access Management.
+//
+// Changes the password of the IAM user who is calling this operation. The AWS
+// account root user password is not affected by this operation.
+//
+// To change the password for a different user, see UpdateLoginProfile. For
+// more information about modifying passwords, see Managing Passwords (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingLogins.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ChangePassword for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidUserTypeException "InvalidUserType"
+//   The request was rejected because the type of user for the transaction was
+//   incorrect.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeEntityTemporarilyUnmodifiableException "EntityTemporarilyUnmodifiable"
+//   The request was rejected because it referenced an entity that is temporarily
+//   unmodifiable, such as a user name that was deleted and then recreated. The
+//   error indicates that the request is likely to succeed if you try again after
+//   waiting several minutes. The error message describes the entity.
+//
+//   * ErrCodePasswordPolicyViolationException "PasswordPolicyViolation"
+//   The request was rejected because the provided password did not meet the requirements
+//   imposed by the account password policy.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ChangePassword
+func (c *IAM) ChangePassword(input *ChangePasswordInput) (*ChangePasswordOutput, error) {
+	req, out := c.ChangePasswordRequest(input)
+	return out, req.Send()
+}
+
+// ChangePasswordWithContext is the same as ChangePassword with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ChangePassword for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ChangePasswordWithContext(ctx aws.Context, input *ChangePasswordInput, opts ...request.Option) (*ChangePasswordOutput, error) {
+	req, out := c.ChangePasswordRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateAccessKey = "CreateAccessKey"
+
+// CreateAccessKeyRequest generates a "aws/request.Request" representing the
+// client's request for the CreateAccessKey operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateAccessKey for more information on using the CreateAccessKey
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateAccessKeyRequest method.
+//    req, resp := client.CreateAccessKeyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateAccessKey
+func (c *IAM) CreateAccessKeyRequest(input *CreateAccessKeyInput) (req *request.Request, output *CreateAccessKeyOutput) {
+	op := &request.Operation{
+		Name:       opCreateAccessKey,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateAccessKeyInput{}
+	}
+
+	output = &CreateAccessKeyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateAccessKey API operation for AWS Identity and Access Management.
+//
+// Creates a new AWS secret access key and corresponding AWS access key ID for
+// the specified user. The default status for new keys is Active.
+//
+// If you do not specify a user name, IAM determines the user name implicitly
+// based on the AWS access key ID signing the request. This operation works
+// for access keys under the AWS account. Consequently, you can use this operation
+// to manage AWS account root user credentials. This is true even if the AWS
+// account has no associated users.
+//
+// For information about limits on the number of keys you can create, see Limitations
+// on IAM Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// To ensure the security of your AWS account, the secret access key is accessible
+// only during key and user creation. You must save the key (for example, in
+// a text file) if you want to be able to access it again. If a secret key is
+// lost, you can delete the access keys for the associated user and then create
+// new keys.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateAccessKey for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateAccessKey
+func (c *IAM) CreateAccessKey(input *CreateAccessKeyInput) (*CreateAccessKeyOutput, error) {
+	req, out := c.CreateAccessKeyRequest(input)
+	return out, req.Send()
+}
+
+// CreateAccessKeyWithContext is the same as CreateAccessKey with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateAccessKey for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateAccessKeyWithContext(ctx aws.Context, input *CreateAccessKeyInput, opts ...request.Option) (*CreateAccessKeyOutput, error) {
+	req, out := c.CreateAccessKeyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateAccountAlias = "CreateAccountAlias"
+
+// CreateAccountAliasRequest generates a "aws/request.Request" representing the
+// client's request for the CreateAccountAlias operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateAccountAlias for more information on using the CreateAccountAlias
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateAccountAliasRequest method.
+//    req, resp := client.CreateAccountAliasRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateAccountAlias
+func (c *IAM) CreateAccountAliasRequest(input *CreateAccountAliasInput) (req *request.Request, output *CreateAccountAliasOutput) {
+	op := &request.Operation{
+		Name:       opCreateAccountAlias,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateAccountAliasInput{}
+	}
+
+	output = &CreateAccountAliasOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// CreateAccountAlias API operation for AWS Identity and Access Management.
+//
+// Creates an alias for your AWS account. For information about using an AWS
+// account alias, see Using an Alias for Your AWS Account ID (https://docs.aws.amazon.com/IAM/latest/UserGuide/AccountAlias.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateAccountAlias for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateAccountAlias
+func (c *IAM) CreateAccountAlias(input *CreateAccountAliasInput) (*CreateAccountAliasOutput, error) {
+	req, out := c.CreateAccountAliasRequest(input)
+	return out, req.Send()
+}
+
+// CreateAccountAliasWithContext is the same as CreateAccountAlias with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateAccountAlias for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateAccountAliasWithContext(ctx aws.Context, input *CreateAccountAliasInput, opts ...request.Option) (*CreateAccountAliasOutput, error) {
+	req, out := c.CreateAccountAliasRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateGroup = "CreateGroup"
+
+// CreateGroupRequest generates a "aws/request.Request" representing the
+// client's request for the CreateGroup operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateGroup for more information on using the CreateGroup
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateGroupRequest method.
+//    req, resp := client.CreateGroupRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateGroup
+func (c *IAM) CreateGroupRequest(input *CreateGroupInput) (req *request.Request, output *CreateGroupOutput) {
+	op := &request.Operation{
+		Name:       opCreateGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateGroupInput{}
+	}
+
+	output = &CreateGroupOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateGroup API operation for AWS Identity and Access Management.
+//
+// Creates a new group.
+//
+// For information about the number of groups you can create, see Limitations
+// on IAM Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateGroup for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateGroup
+func (c *IAM) CreateGroup(input *CreateGroupInput) (*CreateGroupOutput, error) {
+	req, out := c.CreateGroupRequest(input)
+	return out, req.Send()
+}
+
+// CreateGroupWithContext is the same as CreateGroup with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateGroup for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateGroupWithContext(ctx aws.Context, input *CreateGroupInput, opts ...request.Option) (*CreateGroupOutput, error) {
+	req, out := c.CreateGroupRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateInstanceProfile = "CreateInstanceProfile"
+
+// CreateInstanceProfileRequest generates a "aws/request.Request" representing the
+// client's request for the CreateInstanceProfile operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateInstanceProfile for more information on using the CreateInstanceProfile
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateInstanceProfileRequest method.
+//    req, resp := client.CreateInstanceProfileRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateInstanceProfile
+func (c *IAM) CreateInstanceProfileRequest(input *CreateInstanceProfileInput) (req *request.Request, output *CreateInstanceProfileOutput) {
+	op := &request.Operation{
+		Name:       opCreateInstanceProfile,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateInstanceProfileInput{}
+	}
+
+	output = &CreateInstanceProfileOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateInstanceProfile API operation for AWS Identity and Access Management.
+//
+// Creates a new instance profile. For information about instance profiles,
+// go to About Instance Profiles (https://docs.aws.amazon.com/IAM/latest/UserGuide/AboutInstanceProfiles.html).
+//
+// For information about the number of instance profiles you can create, see
+// Limitations on IAM Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateInstanceProfile for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateInstanceProfile
+func (c *IAM) CreateInstanceProfile(input *CreateInstanceProfileInput) (*CreateInstanceProfileOutput, error) {
+	req, out := c.CreateInstanceProfileRequest(input)
+	return out, req.Send()
+}
+
+// CreateInstanceProfileWithContext is the same as CreateInstanceProfile with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateInstanceProfile for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateInstanceProfileWithContext(ctx aws.Context, input *CreateInstanceProfileInput, opts ...request.Option) (*CreateInstanceProfileOutput, error) {
+	req, out := c.CreateInstanceProfileRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateLoginProfile = "CreateLoginProfile"
+
+// CreateLoginProfileRequest generates a "aws/request.Request" representing the
+// client's request for the CreateLoginProfile operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateLoginProfile for more information on using the CreateLoginProfile
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateLoginProfileRequest method.
+//    req, resp := client.CreateLoginProfileRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateLoginProfile
+func (c *IAM) CreateLoginProfileRequest(input *CreateLoginProfileInput) (req *request.Request, output *CreateLoginProfileOutput) {
+	op := &request.Operation{
+		Name:       opCreateLoginProfile,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateLoginProfileInput{}
+	}
+
+	output = &CreateLoginProfileOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateLoginProfile API operation for AWS Identity and Access Management.
+//
+// Creates a password for the specified user, giving the user the ability to
+// access AWS services through the AWS Management Console. For more information
+// about managing passwords, see Managing Passwords (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingLogins.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateLoginProfile for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodePasswordPolicyViolationException "PasswordPolicyViolation"
+//   The request was rejected because the provided password did not meet the requirements
+//   imposed by the account password policy.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateLoginProfile
+func (c *IAM) CreateLoginProfile(input *CreateLoginProfileInput) (*CreateLoginProfileOutput, error) {
+	req, out := c.CreateLoginProfileRequest(input)
+	return out, req.Send()
+}
+
+// CreateLoginProfileWithContext is the same as CreateLoginProfile with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateLoginProfile for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateLoginProfileWithContext(ctx aws.Context, input *CreateLoginProfileInput, opts ...request.Option) (*CreateLoginProfileOutput, error) {
+	req, out := c.CreateLoginProfileRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateOpenIDConnectProvider = "CreateOpenIDConnectProvider"
+
+// CreateOpenIDConnectProviderRequest generates a "aws/request.Request" representing the
+// client's request for the CreateOpenIDConnectProvider operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateOpenIDConnectProvider for more information on using the CreateOpenIDConnectProvider
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateOpenIDConnectProviderRequest method.
+//    req, resp := client.CreateOpenIDConnectProviderRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateOpenIDConnectProvider
+func (c *IAM) CreateOpenIDConnectProviderRequest(input *CreateOpenIDConnectProviderInput) (req *request.Request, output *CreateOpenIDConnectProviderOutput) {
+	op := &request.Operation{
+		Name:       opCreateOpenIDConnectProvider,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateOpenIDConnectProviderInput{}
+	}
+
+	output = &CreateOpenIDConnectProviderOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateOpenIDConnectProvider API operation for AWS Identity and Access Management.
+//
+// Creates an IAM entity to describe an identity provider (IdP) that supports
+// OpenID Connect (OIDC) (http://openid.net/connect/).
+//
+// The OIDC provider that you create with this operation can be used as a principal
+// in a role's trust policy. Such a policy establishes a trust relationship
+// between AWS and the OIDC provider.
+//
+// When you create the IAM OIDC provider, you specify the following:
+//
+//    * The URL of the OIDC identity provider (IdP) to trust
+//
+//    * A list of client IDs (also known as audiences) that identify the application
+//    or applications that are allowed to authenticate using the OIDC provider
+//
+//    * A list of thumbprints of the server certificate(s) that the IdP uses
+//
+// You get all of this information from the OIDC IdP that you want to use to
+// access AWS.
+//
+// The trust for the OIDC provider is derived from the IAM provider that this
+// operation creates. Therefore, it is best to limit access to the CreateOpenIDConnectProvider
+// operation to highly privileged users.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateOpenIDConnectProvider for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateOpenIDConnectProvider
+func (c *IAM) CreateOpenIDConnectProvider(input *CreateOpenIDConnectProviderInput) (*CreateOpenIDConnectProviderOutput, error) {
+	req, out := c.CreateOpenIDConnectProviderRequest(input)
+	return out, req.Send()
+}
+
+// CreateOpenIDConnectProviderWithContext is the same as CreateOpenIDConnectProvider with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateOpenIDConnectProvider for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateOpenIDConnectProviderWithContext(ctx aws.Context, input *CreateOpenIDConnectProviderInput, opts ...request.Option) (*CreateOpenIDConnectProviderOutput, error) {
+	req, out := c.CreateOpenIDConnectProviderRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreatePolicy = "CreatePolicy"
+
+// CreatePolicyRequest generates a "aws/request.Request" representing the
+// client's request for the CreatePolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreatePolicy for more information on using the CreatePolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreatePolicyRequest method.
+//    req, resp := client.CreatePolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreatePolicy
+func (c *IAM) CreatePolicyRequest(input *CreatePolicyInput) (req *request.Request, output *CreatePolicyOutput) {
+	op := &request.Operation{
+		Name:       opCreatePolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreatePolicyInput{}
+	}
+
+	output = &CreatePolicyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreatePolicy API operation for AWS Identity and Access Management.
+//
+// Creates a new managed policy for your AWS account.
+//
+// This operation creates a policy version with a version identifier of v1 and
+// sets v1 as the policy's default version. For more information about policy
+// versions, see Versioning for Managed Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html)
+// in the IAM User Guide.
+//
+// For more information about managed policies in general, see Managed Policies
+// and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreatePolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreatePolicy
+func (c *IAM) CreatePolicy(input *CreatePolicyInput) (*CreatePolicyOutput, error) {
+	req, out := c.CreatePolicyRequest(input)
+	return out, req.Send()
+}
+
+// CreatePolicyWithContext is the same as CreatePolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreatePolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreatePolicyWithContext(ctx aws.Context, input *CreatePolicyInput, opts ...request.Option) (*CreatePolicyOutput, error) {
+	req, out := c.CreatePolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreatePolicyVersion = "CreatePolicyVersion"
+
+// CreatePolicyVersionRequest generates a "aws/request.Request" representing the
+// client's request for the CreatePolicyVersion operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreatePolicyVersion for more information on using the CreatePolicyVersion
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreatePolicyVersionRequest method.
+//    req, resp := client.CreatePolicyVersionRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreatePolicyVersion
+func (c *IAM) CreatePolicyVersionRequest(input *CreatePolicyVersionInput) (req *request.Request, output *CreatePolicyVersionOutput) {
+	op := &request.Operation{
+		Name:       opCreatePolicyVersion,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreatePolicyVersionInput{}
+	}
+
+	output = &CreatePolicyVersionOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreatePolicyVersion API operation for AWS Identity and Access Management.
+//
+// Creates a new version of the specified managed policy. To update a managed
+// policy, you create a new policy version. A managed policy can have up to
+// five versions. If the policy has five versions, you must delete an existing
+// version using DeletePolicyVersion before you create a new version.
+//
+// Optionally, you can set the new version as the policy's default version.
+// The default version is the version that is in effect for the IAM users, groups,
+// and roles to which the policy is attached.
+//
+// For more information about managed policy versions, see Versioning for Managed
+// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreatePolicyVersion for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreatePolicyVersion
+func (c *IAM) CreatePolicyVersion(input *CreatePolicyVersionInput) (*CreatePolicyVersionOutput, error) {
+	req, out := c.CreatePolicyVersionRequest(input)
+	return out, req.Send()
+}
+
+// CreatePolicyVersionWithContext is the same as CreatePolicyVersion with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreatePolicyVersion for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreatePolicyVersionWithContext(ctx aws.Context, input *CreatePolicyVersionInput, opts ...request.Option) (*CreatePolicyVersionOutput, error) {
+	req, out := c.CreatePolicyVersionRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateRole = "CreateRole"
+
+// CreateRoleRequest generates a "aws/request.Request" representing the
+// client's request for the CreateRole operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateRole for more information on using the CreateRole
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateRoleRequest method.
+//    req, resp := client.CreateRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateRole
+func (c *IAM) CreateRoleRequest(input *CreateRoleInput) (req *request.Request, output *CreateRoleOutput) {
+	op := &request.Operation{
+		Name:       opCreateRole,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateRoleInput{}
+	}
+
+	output = &CreateRoleOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateRole API operation for AWS Identity and Access Management.
+//
+// Creates a new role for your AWS account. For more information about roles,
+// go to IAM Roles (https://docs.aws.amazon.com/IAM/latest/UserGuide/WorkingWithRoles.html).
+// For information about limitations on role names and the number of roles you
+// can create, go to Limitations on IAM Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodeConcurrentModificationException "ConcurrentModification"
+//   The request was rejected because multiple requests to change this object
+//   were submitted simultaneously. Wait a few minutes and submit your request
+//   again.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateRole
+func (c *IAM) CreateRole(input *CreateRoleInput) (*CreateRoleOutput, error) {
+	req, out := c.CreateRoleRequest(input)
+	return out, req.Send()
+}
+
+// CreateRoleWithContext is the same as CreateRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateRoleWithContext(ctx aws.Context, input *CreateRoleInput, opts ...request.Option) (*CreateRoleOutput, error) {
+	req, out := c.CreateRoleRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateSAMLProvider = "CreateSAMLProvider"
+
+// CreateSAMLProviderRequest generates a "aws/request.Request" representing the
+// client's request for the CreateSAMLProvider operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateSAMLProvider for more information on using the CreateSAMLProvider
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateSAMLProviderRequest method.
+//    req, resp := client.CreateSAMLProviderRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateSAMLProvider
+func (c *IAM) CreateSAMLProviderRequest(input *CreateSAMLProviderInput) (req *request.Request, output *CreateSAMLProviderOutput) {
+	op := &request.Operation{
+		Name:       opCreateSAMLProvider,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateSAMLProviderInput{}
+	}
+
+	output = &CreateSAMLProviderOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateSAMLProvider API operation for AWS Identity and Access Management.
+//
+// Creates an IAM resource that describes an identity provider (IdP) that supports
+// SAML 2.0.
+//
+// The SAML provider resource that you create with this operation can be used
+// as a principal in an IAM role's trust policy. Such a policy can enable federated
+// users who sign in using the SAML IdP to assume the role. You can create an
+// IAM role that supports Web-based single sign-on (SSO) to the AWS Management
+// Console or one that supports API access to AWS.
+//
+// When you create the SAML provider resource, you upload a SAML metadata document
+// that you get from your IdP. That document includes the issuer's name, expiration
+// information, and keys that can be used to validate the SAML authentication
+// response (assertions) that the IdP sends. You must generate the metadata
+// document using the identity management software that is used as your organization's
+// IdP.
+//
+// This operation requires Signature Version 4 (https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
+//
+// For more information, see Enabling SAML 2.0 Federated Users to Access the
+// AWS Management Console (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-saml.html)
+// and About SAML 2.0-based Federation (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateSAMLProvider for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateSAMLProvider
+func (c *IAM) CreateSAMLProvider(input *CreateSAMLProviderInput) (*CreateSAMLProviderOutput, error) {
+	req, out := c.CreateSAMLProviderRequest(input)
+	return out, req.Send()
+}
+
+// CreateSAMLProviderWithContext is the same as CreateSAMLProvider with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateSAMLProvider for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateSAMLProviderWithContext(ctx aws.Context, input *CreateSAMLProviderInput, opts ...request.Option) (*CreateSAMLProviderOutput, error) {
+	req, out := c.CreateSAMLProviderRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateServiceLinkedRole = "CreateServiceLinkedRole"
+
+// CreateServiceLinkedRoleRequest generates a "aws/request.Request" representing the
+// client's request for the CreateServiceLinkedRole operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateServiceLinkedRole for more information on using the CreateServiceLinkedRole
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateServiceLinkedRoleRequest method.
+//    req, resp := client.CreateServiceLinkedRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateServiceLinkedRole
+func (c *IAM) CreateServiceLinkedRoleRequest(input *CreateServiceLinkedRoleInput) (req *request.Request, output *CreateServiceLinkedRoleOutput) {
+	op := &request.Operation{
+		Name:       opCreateServiceLinkedRole,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateServiceLinkedRoleInput{}
+	}
+
+	output = &CreateServiceLinkedRoleOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateServiceLinkedRole API operation for AWS Identity and Access Management.
+//
+// Creates an IAM role that is linked to a specific AWS service. The service
+// controls the attached policies and when the role can be deleted. This helps
+// ensure that the service is not broken by an unexpectedly changed or deleted
+// role, which could put your AWS resources into an unknown state. Allowing
+// the service to control the role helps improve service stability and proper
+// cleanup when a service and its role are no longer needed. For more information,
+// see Using Service-Linked Roles (https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html)
+// in the IAM User Guide.
+//
+// To attach a policy to this service-linked role, you must make the request
+// using the AWS service that depends on this role.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateServiceLinkedRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateServiceLinkedRole
+func (c *IAM) CreateServiceLinkedRole(input *CreateServiceLinkedRoleInput) (*CreateServiceLinkedRoleOutput, error) {
+	req, out := c.CreateServiceLinkedRoleRequest(input)
+	return out, req.Send()
+}
+
+// CreateServiceLinkedRoleWithContext is the same as CreateServiceLinkedRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateServiceLinkedRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateServiceLinkedRoleWithContext(ctx aws.Context, input *CreateServiceLinkedRoleInput, opts ...request.Option) (*CreateServiceLinkedRoleOutput, error) {
+	req, out := c.CreateServiceLinkedRoleRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateServiceSpecificCredential = "CreateServiceSpecificCredential"
+
+// CreateServiceSpecificCredentialRequest generates a "aws/request.Request" representing the
+// client's request for the CreateServiceSpecificCredential operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateServiceSpecificCredential for more information on using the CreateServiceSpecificCredential
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateServiceSpecificCredentialRequest method.
+//    req, resp := client.CreateServiceSpecificCredentialRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateServiceSpecificCredential
+func (c *IAM) CreateServiceSpecificCredentialRequest(input *CreateServiceSpecificCredentialInput) (req *request.Request, output *CreateServiceSpecificCredentialOutput) {
+	op := &request.Operation{
+		Name:       opCreateServiceSpecificCredential,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateServiceSpecificCredentialInput{}
+	}
+
+	output = &CreateServiceSpecificCredentialOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateServiceSpecificCredential API operation for AWS Identity and Access Management.
+//
+// Generates a set of credentials consisting of a user name and password that
+// can be used to access the service specified in the request. These credentials
+// are generated by IAM, and can be used only for the specified service.
+//
+// You can have a maximum of two sets of service-specific credentials for each
+// supported service per user.
+//
+// The only supported service at this time is AWS CodeCommit.
+//
+// You can reset the password to a new service-generated value by calling ResetServiceSpecificCredential.
+//
+// For more information about service-specific credentials, see Using IAM with
+// AWS CodeCommit: Git Credentials, SSH Keys, and AWS Access Keys (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_ssh-keys.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateServiceSpecificCredential for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceNotSupportedException "NotSupportedService"
+//   The specified service does not support service-specific credentials.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateServiceSpecificCredential
+func (c *IAM) CreateServiceSpecificCredential(input *CreateServiceSpecificCredentialInput) (*CreateServiceSpecificCredentialOutput, error) {
+	req, out := c.CreateServiceSpecificCredentialRequest(input)
+	return out, req.Send()
+}
+
+// CreateServiceSpecificCredentialWithContext is the same as CreateServiceSpecificCredential with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateServiceSpecificCredential for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateServiceSpecificCredentialWithContext(ctx aws.Context, input *CreateServiceSpecificCredentialInput, opts ...request.Option) (*CreateServiceSpecificCredentialOutput, error) {
+	req, out := c.CreateServiceSpecificCredentialRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateUser = "CreateUser"
+
+// CreateUserRequest generates a "aws/request.Request" representing the
+// client's request for the CreateUser operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateUser for more information on using the CreateUser
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateUserRequest method.
+//    req, resp := client.CreateUserRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateUser
+func (c *IAM) CreateUserRequest(input *CreateUserInput) (req *request.Request, output *CreateUserOutput) {
+	op := &request.Operation{
+		Name:       opCreateUser,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateUserInput{}
+	}
+
+	output = &CreateUserOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateUser API operation for AWS Identity and Access Management.
+//
+// Creates a new IAM user for your AWS account.
+//
+// For information about limitations on the number of IAM users you can create,
+// see Limitations on IAM Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateUser for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeConcurrentModificationException "ConcurrentModification"
+//   The request was rejected because multiple requests to change this object
+//   were submitted simultaneously. Wait a few minutes and submit your request
+//   again.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateUser
+func (c *IAM) CreateUser(input *CreateUserInput) (*CreateUserOutput, error) {
+	req, out := c.CreateUserRequest(input)
+	return out, req.Send()
+}
+
+// CreateUserWithContext is the same as CreateUser with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateUser for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateUserWithContext(ctx aws.Context, input *CreateUserInput, opts ...request.Option) (*CreateUserOutput, error) {
+	req, out := c.CreateUserRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opCreateVirtualMFADevice = "CreateVirtualMFADevice"
+
+// CreateVirtualMFADeviceRequest generates a "aws/request.Request" representing the
+// client's request for the CreateVirtualMFADevice operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See CreateVirtualMFADevice for more information on using the CreateVirtualMFADevice
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the CreateVirtualMFADeviceRequest method.
+//    req, resp := client.CreateVirtualMFADeviceRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateVirtualMFADevice
+func (c *IAM) CreateVirtualMFADeviceRequest(input *CreateVirtualMFADeviceInput) (req *request.Request, output *CreateVirtualMFADeviceOutput) {
+	op := &request.Operation{
+		Name:       opCreateVirtualMFADevice,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &CreateVirtualMFADeviceInput{}
+	}
+
+	output = &CreateVirtualMFADeviceOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// CreateVirtualMFADevice API operation for AWS Identity and Access Management.
+//
+// Creates a new virtual MFA device for the AWS account. After creating the
+// virtual MFA, use EnableMFADevice to attach the MFA device to an IAM user.
+// For more information about creating and working with virtual MFA devices,
+// go to Using a Virtual MFA Device (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_VirtualMFA.html)
+// in the IAM User Guide.
+//
+// For information about limits on the number of MFA devices you can create,
+// see Limitations on Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// The seed information contained in the QR code and the Base32 string should
+// be treated like any other secret access information. In other words, protect
+// the seed information as you would your AWS access keys or your passwords.
+// After you provision your virtual device, you should ensure that the information
+// is destroyed following secure procedures.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation CreateVirtualMFADevice for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/CreateVirtualMFADevice
+func (c *IAM) CreateVirtualMFADevice(input *CreateVirtualMFADeviceInput) (*CreateVirtualMFADeviceOutput, error) {
+	req, out := c.CreateVirtualMFADeviceRequest(input)
+	return out, req.Send()
+}
+
+// CreateVirtualMFADeviceWithContext is the same as CreateVirtualMFADevice with the addition of
+// the ability to pass a context and additional request options.
+//
+// See CreateVirtualMFADevice for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) CreateVirtualMFADeviceWithContext(ctx aws.Context, input *CreateVirtualMFADeviceInput, opts ...request.Option) (*CreateVirtualMFADeviceOutput, error) {
+	req, out := c.CreateVirtualMFADeviceRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeactivateMFADevice = "DeactivateMFADevice"
+
+// DeactivateMFADeviceRequest generates a "aws/request.Request" representing the
+// client's request for the DeactivateMFADevice operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeactivateMFADevice for more information on using the DeactivateMFADevice
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeactivateMFADeviceRequest method.
+//    req, resp := client.DeactivateMFADeviceRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeactivateMFADevice
+func (c *IAM) DeactivateMFADeviceRequest(input *DeactivateMFADeviceInput) (req *request.Request, output *DeactivateMFADeviceOutput) {
+	op := &request.Operation{
+		Name:       opDeactivateMFADevice,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeactivateMFADeviceInput{}
+	}
+
+	output = &DeactivateMFADeviceOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeactivateMFADevice API operation for AWS Identity and Access Management.
+//
+// Deactivates the specified MFA device and removes it from association with
+// the user name for which it was originally enabled.
+//
+// For more information about creating and working with virtual MFA devices,
+// go to Enabling a Virtual Multi-factor Authentication (MFA) Device (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_VirtualMFA.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeactivateMFADevice for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeEntityTemporarilyUnmodifiableException "EntityTemporarilyUnmodifiable"
+//   The request was rejected because it referenced an entity that is temporarily
+//   unmodifiable, such as a user name that was deleted and then recreated. The
+//   error indicates that the request is likely to succeed if you try again after
+//   waiting several minutes. The error message describes the entity.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeactivateMFADevice
+func (c *IAM) DeactivateMFADevice(input *DeactivateMFADeviceInput) (*DeactivateMFADeviceOutput, error) {
+	req, out := c.DeactivateMFADeviceRequest(input)
+	return out, req.Send()
+}
+
+// DeactivateMFADeviceWithContext is the same as DeactivateMFADevice with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeactivateMFADevice for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeactivateMFADeviceWithContext(ctx aws.Context, input *DeactivateMFADeviceInput, opts ...request.Option) (*DeactivateMFADeviceOutput, error) {
+	req, out := c.DeactivateMFADeviceRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteAccessKey = "DeleteAccessKey"
+
+// DeleteAccessKeyRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteAccessKey operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteAccessKey for more information on using the DeleteAccessKey
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteAccessKeyRequest method.
+//    req, resp := client.DeleteAccessKeyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteAccessKey
+func (c *IAM) DeleteAccessKeyRequest(input *DeleteAccessKeyInput) (req *request.Request, output *DeleteAccessKeyOutput) {
+	op := &request.Operation{
+		Name:       opDeleteAccessKey,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteAccessKeyInput{}
+	}
+
+	output = &DeleteAccessKeyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteAccessKey API operation for AWS Identity and Access Management.
+//
+// Deletes the access key pair associated with the specified IAM user.
+//
+// If you do not specify a user name, IAM determines the user name implicitly
+// based on the AWS access key ID signing the request. This operation works
+// for access keys under the AWS account. Consequently, you can use this operation
+// to manage AWS account root user credentials even if the AWS account has no
+// associated users.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteAccessKey for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteAccessKey
+func (c *IAM) DeleteAccessKey(input *DeleteAccessKeyInput) (*DeleteAccessKeyOutput, error) {
+	req, out := c.DeleteAccessKeyRequest(input)
+	return out, req.Send()
+}
+
+// DeleteAccessKeyWithContext is the same as DeleteAccessKey with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteAccessKey for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteAccessKeyWithContext(ctx aws.Context, input *DeleteAccessKeyInput, opts ...request.Option) (*DeleteAccessKeyOutput, error) {
+	req, out := c.DeleteAccessKeyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteAccountAlias = "DeleteAccountAlias"
+
+// DeleteAccountAliasRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteAccountAlias operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteAccountAlias for more information on using the DeleteAccountAlias
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteAccountAliasRequest method.
+//    req, resp := client.DeleteAccountAliasRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteAccountAlias
+func (c *IAM) DeleteAccountAliasRequest(input *DeleteAccountAliasInput) (req *request.Request, output *DeleteAccountAliasOutput) {
+	op := &request.Operation{
+		Name:       opDeleteAccountAlias,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteAccountAliasInput{}
+	}
+
+	output = &DeleteAccountAliasOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteAccountAlias API operation for AWS Identity and Access Management.
+//
+// Deletes the specified AWS account alias. For information about using an AWS
+// account alias, see Using an Alias for Your AWS Account ID (https://docs.aws.amazon.com/IAM/latest/UserGuide/AccountAlias.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteAccountAlias for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteAccountAlias
+func (c *IAM) DeleteAccountAlias(input *DeleteAccountAliasInput) (*DeleteAccountAliasOutput, error) {
+	req, out := c.DeleteAccountAliasRequest(input)
+	return out, req.Send()
+}
+
+// DeleteAccountAliasWithContext is the same as DeleteAccountAlias with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteAccountAlias for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteAccountAliasWithContext(ctx aws.Context, input *DeleteAccountAliasInput, opts ...request.Option) (*DeleteAccountAliasOutput, error) {
+	req, out := c.DeleteAccountAliasRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteAccountPasswordPolicy = "DeleteAccountPasswordPolicy"
+
+// DeleteAccountPasswordPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteAccountPasswordPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteAccountPasswordPolicy for more information on using the DeleteAccountPasswordPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteAccountPasswordPolicyRequest method.
+//    req, resp := client.DeleteAccountPasswordPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteAccountPasswordPolicy
+func (c *IAM) DeleteAccountPasswordPolicyRequest(input *DeleteAccountPasswordPolicyInput) (req *request.Request, output *DeleteAccountPasswordPolicyOutput) {
+	op := &request.Operation{
+		Name:       opDeleteAccountPasswordPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteAccountPasswordPolicyInput{}
+	}
+
+	output = &DeleteAccountPasswordPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteAccountPasswordPolicy API operation for AWS Identity and Access Management.
+//
+// Deletes the password policy for the AWS account. There are no parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteAccountPasswordPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteAccountPasswordPolicy
+func (c *IAM) DeleteAccountPasswordPolicy(input *DeleteAccountPasswordPolicyInput) (*DeleteAccountPasswordPolicyOutput, error) {
+	req, out := c.DeleteAccountPasswordPolicyRequest(input)
+	return out, req.Send()
+}
+
+// DeleteAccountPasswordPolicyWithContext is the same as DeleteAccountPasswordPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteAccountPasswordPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteAccountPasswordPolicyWithContext(ctx aws.Context, input *DeleteAccountPasswordPolicyInput, opts ...request.Option) (*DeleteAccountPasswordPolicyOutput, error) {
+	req, out := c.DeleteAccountPasswordPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteGroup = "DeleteGroup"
+
+// DeleteGroupRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteGroup operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteGroup for more information on using the DeleteGroup
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteGroupRequest method.
+//    req, resp := client.DeleteGroupRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteGroup
+func (c *IAM) DeleteGroupRequest(input *DeleteGroupInput) (req *request.Request, output *DeleteGroupOutput) {
+	op := &request.Operation{
+		Name:       opDeleteGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteGroupInput{}
+	}
+
+	output = &DeleteGroupOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteGroup API operation for AWS Identity and Access Management.
+//
+// Deletes the specified IAM group. The group must not contain any users or
+// have any attached policies.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteGroup for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeDeleteConflictException "DeleteConflict"
+//   The request was rejected because it attempted to delete a resource that has
+//   attached subordinate entities. The error message describes these entities.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteGroup
+func (c *IAM) DeleteGroup(input *DeleteGroupInput) (*DeleteGroupOutput, error) {
+	req, out := c.DeleteGroupRequest(input)
+	return out, req.Send()
+}
+
+// DeleteGroupWithContext is the same as DeleteGroup with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteGroup for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteGroupWithContext(ctx aws.Context, input *DeleteGroupInput, opts ...request.Option) (*DeleteGroupOutput, error) {
+	req, out := c.DeleteGroupRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteGroupPolicy = "DeleteGroupPolicy"
+
+// DeleteGroupPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteGroupPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteGroupPolicy for more information on using the DeleteGroupPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteGroupPolicyRequest method.
+//    req, resp := client.DeleteGroupPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteGroupPolicy
+func (c *IAM) DeleteGroupPolicyRequest(input *DeleteGroupPolicyInput) (req *request.Request, output *DeleteGroupPolicyOutput) {
+	op := &request.Operation{
+		Name:       opDeleteGroupPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteGroupPolicyInput{}
+	}
+
+	output = &DeleteGroupPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteGroupPolicy API operation for AWS Identity and Access Management.
+//
+// Deletes the specified inline policy that is embedded in the specified IAM
+// group.
+//
+// A group can also have managed policies attached to it. To detach a managed
+// policy from a group, use DetachGroupPolicy. For more information about policies,
+// refer to Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteGroupPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteGroupPolicy
+func (c *IAM) DeleteGroupPolicy(input *DeleteGroupPolicyInput) (*DeleteGroupPolicyOutput, error) {
+	req, out := c.DeleteGroupPolicyRequest(input)
+	return out, req.Send()
+}
+
+// DeleteGroupPolicyWithContext is the same as DeleteGroupPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteGroupPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteGroupPolicyWithContext(ctx aws.Context, input *DeleteGroupPolicyInput, opts ...request.Option) (*DeleteGroupPolicyOutput, error) {
+	req, out := c.DeleteGroupPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteInstanceProfile = "DeleteInstanceProfile"
+
+// DeleteInstanceProfileRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteInstanceProfile operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteInstanceProfile for more information on using the DeleteInstanceProfile
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteInstanceProfileRequest method.
+//    req, resp := client.DeleteInstanceProfileRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteInstanceProfile
+func (c *IAM) DeleteInstanceProfileRequest(input *DeleteInstanceProfileInput) (req *request.Request, output *DeleteInstanceProfileOutput) {
+	op := &request.Operation{
+		Name:       opDeleteInstanceProfile,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteInstanceProfileInput{}
+	}
+
+	output = &DeleteInstanceProfileOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteInstanceProfile API operation for AWS Identity and Access Management.
+//
+// Deletes the specified instance profile. The instance profile must not have
+// an associated role.
+//
+// Make sure that you do not have any Amazon EC2 instances running with the
+// instance profile you are about to delete. Deleting a role or instance profile
+// that is associated with a running instance will break any applications running
+// on the instance.
+//
+// For more information about instance profiles, go to About Instance Profiles
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/AboutInstanceProfiles.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteInstanceProfile for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeDeleteConflictException "DeleteConflict"
+//   The request was rejected because it attempted to delete a resource that has
+//   attached subordinate entities. The error message describes these entities.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteInstanceProfile
+func (c *IAM) DeleteInstanceProfile(input *DeleteInstanceProfileInput) (*DeleteInstanceProfileOutput, error) {
+	req, out := c.DeleteInstanceProfileRequest(input)
+	return out, req.Send()
+}
+
+// DeleteInstanceProfileWithContext is the same as DeleteInstanceProfile with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteInstanceProfile for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteInstanceProfileWithContext(ctx aws.Context, input *DeleteInstanceProfileInput, opts ...request.Option) (*DeleteInstanceProfileOutput, error) {
+	req, out := c.DeleteInstanceProfileRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteLoginProfile = "DeleteLoginProfile"
+
+// DeleteLoginProfileRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteLoginProfile operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteLoginProfile for more information on using the DeleteLoginProfile
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteLoginProfileRequest method.
+//    req, resp := client.DeleteLoginProfileRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteLoginProfile
+func (c *IAM) DeleteLoginProfileRequest(input *DeleteLoginProfileInput) (req *request.Request, output *DeleteLoginProfileOutput) {
+	op := &request.Operation{
+		Name:       opDeleteLoginProfile,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteLoginProfileInput{}
+	}
+
+	output = &DeleteLoginProfileOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteLoginProfile API operation for AWS Identity and Access Management.
+//
+// Deletes the password for the specified IAM user, which terminates the user's
+// ability to access AWS services through the AWS Management Console.
+//
+// Deleting a user's password does not prevent a user from accessing AWS through
+// the command line interface or the API. To prevent all user access, you must
+// also either make any access keys inactive or delete them. For more information
+// about making keys inactive or deleting them, see UpdateAccessKey and DeleteAccessKey.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteLoginProfile for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeEntityTemporarilyUnmodifiableException "EntityTemporarilyUnmodifiable"
+//   The request was rejected because it referenced an entity that is temporarily
+//   unmodifiable, such as a user name that was deleted and then recreated. The
+//   error indicates that the request is likely to succeed if you try again after
+//   waiting several minutes. The error message describes the entity.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteLoginProfile
+func (c *IAM) DeleteLoginProfile(input *DeleteLoginProfileInput) (*DeleteLoginProfileOutput, error) {
+	req, out := c.DeleteLoginProfileRequest(input)
+	return out, req.Send()
+}
+
+// DeleteLoginProfileWithContext is the same as DeleteLoginProfile with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteLoginProfile for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteLoginProfileWithContext(ctx aws.Context, input *DeleteLoginProfileInput, opts ...request.Option) (*DeleteLoginProfileOutput, error) {
+	req, out := c.DeleteLoginProfileRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteOpenIDConnectProvider = "DeleteOpenIDConnectProvider"
+
+// DeleteOpenIDConnectProviderRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteOpenIDConnectProvider operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteOpenIDConnectProvider for more information on using the DeleteOpenIDConnectProvider
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteOpenIDConnectProviderRequest method.
+//    req, resp := client.DeleteOpenIDConnectProviderRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteOpenIDConnectProvider
+func (c *IAM) DeleteOpenIDConnectProviderRequest(input *DeleteOpenIDConnectProviderInput) (req *request.Request, output *DeleteOpenIDConnectProviderOutput) {
+	op := &request.Operation{
+		Name:       opDeleteOpenIDConnectProvider,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteOpenIDConnectProviderInput{}
+	}
+
+	output = &DeleteOpenIDConnectProviderOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteOpenIDConnectProvider API operation for AWS Identity and Access Management.
+//
+// Deletes an OpenID Connect identity provider (IdP) resource object in IAM.
+//
+// Deleting an IAM OIDC provider resource does not update any roles that reference
+// the provider as a principal in their trust policies. Any attempt to assume
+// a role that references a deleted provider fails.
+//
+// This operation is idempotent; it does not fail or return an error if you
+// call the operation for a provider that does not exist.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteOpenIDConnectProvider for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteOpenIDConnectProvider
+func (c *IAM) DeleteOpenIDConnectProvider(input *DeleteOpenIDConnectProviderInput) (*DeleteOpenIDConnectProviderOutput, error) {
+	req, out := c.DeleteOpenIDConnectProviderRequest(input)
+	return out, req.Send()
+}
+
+// DeleteOpenIDConnectProviderWithContext is the same as DeleteOpenIDConnectProvider with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteOpenIDConnectProvider for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteOpenIDConnectProviderWithContext(ctx aws.Context, input *DeleteOpenIDConnectProviderInput, opts ...request.Option) (*DeleteOpenIDConnectProviderOutput, error) {
+	req, out := c.DeleteOpenIDConnectProviderRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeletePolicy = "DeletePolicy"
+
+// DeletePolicyRequest generates a "aws/request.Request" representing the
+// client's request for the DeletePolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeletePolicy for more information on using the DeletePolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeletePolicyRequest method.
+//    req, resp := client.DeletePolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeletePolicy
+func (c *IAM) DeletePolicyRequest(input *DeletePolicyInput) (req *request.Request, output *DeletePolicyOutput) {
+	op := &request.Operation{
+		Name:       opDeletePolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeletePolicyInput{}
+	}
+
+	output = &DeletePolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeletePolicy API operation for AWS Identity and Access Management.
+//
+// Deletes the specified managed policy.
+//
+// Before you can delete a managed policy, you must first detach the policy
+// from all users, groups, and roles that it is attached to. In addition, you
+// must delete all the policy's versions. The following steps describe the process
+// for deleting a managed policy:
+//
+//    * Detach the policy from all users, groups, and roles that the policy
+//    is attached to, using the DetachUserPolicy, DetachGroupPolicy, or DetachRolePolicy
+//    API operations. To list all the users, groups, and roles that a policy
+//    is attached to, use ListEntitiesForPolicy.
+//
+//    * Delete all versions of the policy using DeletePolicyVersion. To list
+//    the policy's versions, use ListPolicyVersions. You cannot use DeletePolicyVersion
+//    to delete the version that is marked as the default version. You delete
+//    the policy's default version in the next step of the process.
+//
+//    * Delete the policy (this automatically deletes the policy's default version)
+//    using this API.
+//
+// For information about managed policies, see Managed Policies and Inline Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeletePolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeDeleteConflictException "DeleteConflict"
+//   The request was rejected because it attempted to delete a resource that has
+//   attached subordinate entities. The error message describes these entities.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeletePolicy
+func (c *IAM) DeletePolicy(input *DeletePolicyInput) (*DeletePolicyOutput, error) {
+	req, out := c.DeletePolicyRequest(input)
+	return out, req.Send()
+}
+
+// DeletePolicyWithContext is the same as DeletePolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeletePolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeletePolicyWithContext(ctx aws.Context, input *DeletePolicyInput, opts ...request.Option) (*DeletePolicyOutput, error) {
+	req, out := c.DeletePolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeletePolicyVersion = "DeletePolicyVersion"
+
+// DeletePolicyVersionRequest generates a "aws/request.Request" representing the
+// client's request for the DeletePolicyVersion operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeletePolicyVersion for more information on using the DeletePolicyVersion
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeletePolicyVersionRequest method.
+//    req, resp := client.DeletePolicyVersionRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeletePolicyVersion
+func (c *IAM) DeletePolicyVersionRequest(input *DeletePolicyVersionInput) (req *request.Request, output *DeletePolicyVersionOutput) {
+	op := &request.Operation{
+		Name:       opDeletePolicyVersion,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeletePolicyVersionInput{}
+	}
+
+	output = &DeletePolicyVersionOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeletePolicyVersion API operation for AWS Identity and Access Management.
+//
+// Deletes the specified version from the specified managed policy.
+//
+// You cannot delete the default version from a policy using this API. To delete
+// the default version from a policy, use DeletePolicy. To find out which version
+// of a policy is marked as the default version, use ListPolicyVersions.
+//
+// For information about versions for managed policies, see Versioning for Managed
+// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeletePolicyVersion for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeDeleteConflictException "DeleteConflict"
+//   The request was rejected because it attempted to delete a resource that has
+//   attached subordinate entities. The error message describes these entities.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeletePolicyVersion
+func (c *IAM) DeletePolicyVersion(input *DeletePolicyVersionInput) (*DeletePolicyVersionOutput, error) {
+	req, out := c.DeletePolicyVersionRequest(input)
+	return out, req.Send()
+}
+
+// DeletePolicyVersionWithContext is the same as DeletePolicyVersion with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeletePolicyVersion for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeletePolicyVersionWithContext(ctx aws.Context, input *DeletePolicyVersionInput, opts ...request.Option) (*DeletePolicyVersionOutput, error) {
+	req, out := c.DeletePolicyVersionRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteRole = "DeleteRole"
+
+// DeleteRoleRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteRole operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteRole for more information on using the DeleteRole
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteRoleRequest method.
+//    req, resp := client.DeleteRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteRole
+func (c *IAM) DeleteRoleRequest(input *DeleteRoleInput) (req *request.Request, output *DeleteRoleOutput) {
+	op := &request.Operation{
+		Name:       opDeleteRole,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteRoleInput{}
+	}
+
+	output = &DeleteRoleOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteRole API operation for AWS Identity and Access Management.
+//
+// Deletes the specified role. The role must not have any policies attached.
+// For more information about roles, go to Working with Roles (https://docs.aws.amazon.com/IAM/latest/UserGuide/WorkingWithRoles.html).
+//
+// Make sure that you do not have any Amazon EC2 instances running with the
+// role you are about to delete. Deleting a role or instance profile that is
+// associated with a running instance will break any applications running on
+// the instance.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeDeleteConflictException "DeleteConflict"
+//   The request was rejected because it attempted to delete a resource that has
+//   attached subordinate entities. The error message describes these entities.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeConcurrentModificationException "ConcurrentModification"
+//   The request was rejected because multiple requests to change this object
+//   were submitted simultaneously. Wait a few minutes and submit your request
+//   again.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteRole
+func (c *IAM) DeleteRole(input *DeleteRoleInput) (*DeleteRoleOutput, error) {
+	req, out := c.DeleteRoleRequest(input)
+	return out, req.Send()
+}
+
+// DeleteRoleWithContext is the same as DeleteRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteRoleWithContext(ctx aws.Context, input *DeleteRoleInput, opts ...request.Option) (*DeleteRoleOutput, error) {
+	req, out := c.DeleteRoleRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteRolePermissionsBoundary = "DeleteRolePermissionsBoundary"
+
+// DeleteRolePermissionsBoundaryRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteRolePermissionsBoundary operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteRolePermissionsBoundary for more information on using the DeleteRolePermissionsBoundary
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteRolePermissionsBoundaryRequest method.
+//    req, resp := client.DeleteRolePermissionsBoundaryRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteRolePermissionsBoundary
+func (c *IAM) DeleteRolePermissionsBoundaryRequest(input *DeleteRolePermissionsBoundaryInput) (req *request.Request, output *DeleteRolePermissionsBoundaryOutput) {
+	op := &request.Operation{
+		Name:       opDeleteRolePermissionsBoundary,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteRolePermissionsBoundaryInput{}
+	}
+
+	output = &DeleteRolePermissionsBoundaryOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteRolePermissionsBoundary API operation for AWS Identity and Access Management.
+//
+// Deletes the permissions boundary for the specified IAM role.
+//
+// Deleting the permissions boundary for a role might increase its permissions.
+// For example, it might allow anyone who assumes the role to perform all the
+// actions granted in its permissions policies.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteRolePermissionsBoundary for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteRolePermissionsBoundary
+func (c *IAM) DeleteRolePermissionsBoundary(input *DeleteRolePermissionsBoundaryInput) (*DeleteRolePermissionsBoundaryOutput, error) {
+	req, out := c.DeleteRolePermissionsBoundaryRequest(input)
+	return out, req.Send()
+}
+
+// DeleteRolePermissionsBoundaryWithContext is the same as DeleteRolePermissionsBoundary with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteRolePermissionsBoundary for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteRolePermissionsBoundaryWithContext(ctx aws.Context, input *DeleteRolePermissionsBoundaryInput, opts ...request.Option) (*DeleteRolePermissionsBoundaryOutput, error) {
+	req, out := c.DeleteRolePermissionsBoundaryRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteRolePolicy = "DeleteRolePolicy"
+
+// DeleteRolePolicyRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteRolePolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteRolePolicy for more information on using the DeleteRolePolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteRolePolicyRequest method.
+//    req, resp := client.DeleteRolePolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteRolePolicy
+func (c *IAM) DeleteRolePolicyRequest(input *DeleteRolePolicyInput) (req *request.Request, output *DeleteRolePolicyOutput) {
+	op := &request.Operation{
+		Name:       opDeleteRolePolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteRolePolicyInput{}
+	}
+
+	output = &DeleteRolePolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteRolePolicy API operation for AWS Identity and Access Management.
+//
+// Deletes the specified inline policy that is embedded in the specified IAM
+// role.
+//
+// A role can also have managed policies attached to it. To detach a managed
+// policy from a role, use DetachRolePolicy. For more information about policies,
+// refer to Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteRolePolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteRolePolicy
+func (c *IAM) DeleteRolePolicy(input *DeleteRolePolicyInput) (*DeleteRolePolicyOutput, error) {
+	req, out := c.DeleteRolePolicyRequest(input)
+	return out, req.Send()
+}
+
+// DeleteRolePolicyWithContext is the same as DeleteRolePolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteRolePolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteRolePolicyWithContext(ctx aws.Context, input *DeleteRolePolicyInput, opts ...request.Option) (*DeleteRolePolicyOutput, error) {
+	req, out := c.DeleteRolePolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteSAMLProvider = "DeleteSAMLProvider"
+
+// DeleteSAMLProviderRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteSAMLProvider operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteSAMLProvider for more information on using the DeleteSAMLProvider
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteSAMLProviderRequest method.
+//    req, resp := client.DeleteSAMLProviderRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteSAMLProvider
+func (c *IAM) DeleteSAMLProviderRequest(input *DeleteSAMLProviderInput) (req *request.Request, output *DeleteSAMLProviderOutput) {
+	op := &request.Operation{
+		Name:       opDeleteSAMLProvider,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteSAMLProviderInput{}
+	}
+
+	output = &DeleteSAMLProviderOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteSAMLProvider API operation for AWS Identity and Access Management.
+//
+// Deletes a SAML provider resource in IAM.
+//
+// Deleting the provider resource from IAM does not update any roles that reference
+// the SAML provider resource's ARN as a principal in their trust policies.
+// Any attempt to assume a role that references a non-existent provider resource
+// ARN fails.
+//
+// This operation requires Signature Version 4 (https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteSAMLProvider for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteSAMLProvider
+func (c *IAM) DeleteSAMLProvider(input *DeleteSAMLProviderInput) (*DeleteSAMLProviderOutput, error) {
+	req, out := c.DeleteSAMLProviderRequest(input)
+	return out, req.Send()
+}
+
+// DeleteSAMLProviderWithContext is the same as DeleteSAMLProvider with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteSAMLProvider for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteSAMLProviderWithContext(ctx aws.Context, input *DeleteSAMLProviderInput, opts ...request.Option) (*DeleteSAMLProviderOutput, error) {
+	req, out := c.DeleteSAMLProviderRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteSSHPublicKey = "DeleteSSHPublicKey"
+
+// DeleteSSHPublicKeyRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteSSHPublicKey operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteSSHPublicKey for more information on using the DeleteSSHPublicKey
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteSSHPublicKeyRequest method.
+//    req, resp := client.DeleteSSHPublicKeyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteSSHPublicKey
+func (c *IAM) DeleteSSHPublicKeyRequest(input *DeleteSSHPublicKeyInput) (req *request.Request, output *DeleteSSHPublicKeyOutput) {
+	op := &request.Operation{
+		Name:       opDeleteSSHPublicKey,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteSSHPublicKeyInput{}
+	}
+
+	output = &DeleteSSHPublicKeyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteSSHPublicKey API operation for AWS Identity and Access Management.
+//
+// Deletes the specified SSH public key.
+//
+// The SSH public key deleted by this operation is used only for authenticating
+// the associated IAM user to an AWS CodeCommit repository. For more information
+// about using SSH keys to authenticate to an AWS CodeCommit repository, see
+// Set up AWS CodeCommit for SSH Connections (https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html)
+// in the AWS CodeCommit User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteSSHPublicKey for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteSSHPublicKey
+func (c *IAM) DeleteSSHPublicKey(input *DeleteSSHPublicKeyInput) (*DeleteSSHPublicKeyOutput, error) {
+	req, out := c.DeleteSSHPublicKeyRequest(input)
+	return out, req.Send()
+}
+
+// DeleteSSHPublicKeyWithContext is the same as DeleteSSHPublicKey with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteSSHPublicKey for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteSSHPublicKeyWithContext(ctx aws.Context, input *DeleteSSHPublicKeyInput, opts ...request.Option) (*DeleteSSHPublicKeyOutput, error) {
+	req, out := c.DeleteSSHPublicKeyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteServerCertificate = "DeleteServerCertificate"
+
+// DeleteServerCertificateRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteServerCertificate operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteServerCertificate for more information on using the DeleteServerCertificate
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteServerCertificateRequest method.
+//    req, resp := client.DeleteServerCertificateRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteServerCertificate
+func (c *IAM) DeleteServerCertificateRequest(input *DeleteServerCertificateInput) (req *request.Request, output *DeleteServerCertificateOutput) {
+	op := &request.Operation{
+		Name:       opDeleteServerCertificate,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteServerCertificateInput{}
+	}
+
+	output = &DeleteServerCertificateOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteServerCertificate API operation for AWS Identity and Access Management.
+//
+// Deletes the specified server certificate.
+//
+// For more information about working with server certificates, see Working
+// with Server Certificates (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html)
+// in the IAM User Guide. This topic also includes a list of AWS services that
+// can use the server certificates that you manage with IAM.
+//
+// If you are using a server certificate with Elastic Load Balancing, deleting
+// the certificate could have implications for your application. If Elastic
+// Load Balancing doesn't detect the deletion of bound certificates, it may
+// continue to use the certificates. This could cause Elastic Load Balancing
+// to stop accepting traffic. We recommend that you remove the reference to
+// the certificate from Elastic Load Balancing before using this command to
+// delete the certificate. For more information, go to DeleteLoadBalancerListeners
+// (https://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_DeleteLoadBalancerListeners.html)
+// in the Elastic Load Balancing API Reference.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteServerCertificate for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeDeleteConflictException "DeleteConflict"
+//   The request was rejected because it attempted to delete a resource that has
+//   attached subordinate entities. The error message describes these entities.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteServerCertificate
+func (c *IAM) DeleteServerCertificate(input *DeleteServerCertificateInput) (*DeleteServerCertificateOutput, error) {
+	req, out := c.DeleteServerCertificateRequest(input)
+	return out, req.Send()
+}
+
+// DeleteServerCertificateWithContext is the same as DeleteServerCertificate with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteServerCertificate for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteServerCertificateWithContext(ctx aws.Context, input *DeleteServerCertificateInput, opts ...request.Option) (*DeleteServerCertificateOutput, error) {
+	req, out := c.DeleteServerCertificateRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteServiceLinkedRole = "DeleteServiceLinkedRole"
+
+// DeleteServiceLinkedRoleRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteServiceLinkedRole operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteServiceLinkedRole for more information on using the DeleteServiceLinkedRole
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteServiceLinkedRoleRequest method.
+//    req, resp := client.DeleteServiceLinkedRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteServiceLinkedRole
+func (c *IAM) DeleteServiceLinkedRoleRequest(input *DeleteServiceLinkedRoleInput) (req *request.Request, output *DeleteServiceLinkedRoleOutput) {
+	op := &request.Operation{
+		Name:       opDeleteServiceLinkedRole,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteServiceLinkedRoleInput{}
+	}
+
+	output = &DeleteServiceLinkedRoleOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// DeleteServiceLinkedRole API operation for AWS Identity and Access Management.
+//
+// Submits a service-linked role deletion request and returns a DeletionTaskId,
+// which you can use to check the status of the deletion. Before you call this
+// operation, confirm that the role has no active sessions and that any resources
+// used by the role in the linked service are deleted. If you call this operation
+// more than once for the same service-linked role and an earlier deletion task
+// is not complete, then the DeletionTaskId of the earlier request is returned.
+//
+// If you submit a deletion request for a service-linked role whose linked service
+// is still accessing a resource, then the deletion task fails. If it fails,
+// the GetServiceLinkedRoleDeletionStatus API operation returns the reason for
+// the failure, usually including the resources that must be deleted. To delete
+// the service-linked role, you must first remove those resources from the linked
+// service and then submit the deletion request again. Resources are specific
+// to the service that is linked to the role. For more information about removing
+// resources from a service, see the AWS documentation (http://docs.aws.amazon.com/)
+// for your service.
+//
+// For more information about service-linked roles, see Roles Terms and Concepts:
+// AWS Service-Linked Role (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteServiceLinkedRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteServiceLinkedRole
+func (c *IAM) DeleteServiceLinkedRole(input *DeleteServiceLinkedRoleInput) (*DeleteServiceLinkedRoleOutput, error) {
+	req, out := c.DeleteServiceLinkedRoleRequest(input)
+	return out, req.Send()
+}
+
+// DeleteServiceLinkedRoleWithContext is the same as DeleteServiceLinkedRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteServiceLinkedRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteServiceLinkedRoleWithContext(ctx aws.Context, input *DeleteServiceLinkedRoleInput, opts ...request.Option) (*DeleteServiceLinkedRoleOutput, error) {
+	req, out := c.DeleteServiceLinkedRoleRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteServiceSpecificCredential = "DeleteServiceSpecificCredential"
+
+// DeleteServiceSpecificCredentialRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteServiceSpecificCredential operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteServiceSpecificCredential for more information on using the DeleteServiceSpecificCredential
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteServiceSpecificCredentialRequest method.
+//    req, resp := client.DeleteServiceSpecificCredentialRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteServiceSpecificCredential
+func (c *IAM) DeleteServiceSpecificCredentialRequest(input *DeleteServiceSpecificCredentialInput) (req *request.Request, output *DeleteServiceSpecificCredentialOutput) {
+	op := &request.Operation{
+		Name:       opDeleteServiceSpecificCredential,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteServiceSpecificCredentialInput{}
+	}
+
+	output = &DeleteServiceSpecificCredentialOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteServiceSpecificCredential API operation for AWS Identity and Access Management.
+//
+// Deletes the specified service-specific credential.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteServiceSpecificCredential for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteServiceSpecificCredential
+func (c *IAM) DeleteServiceSpecificCredential(input *DeleteServiceSpecificCredentialInput) (*DeleteServiceSpecificCredentialOutput, error) {
+	req, out := c.DeleteServiceSpecificCredentialRequest(input)
+	return out, req.Send()
+}
+
+// DeleteServiceSpecificCredentialWithContext is the same as DeleteServiceSpecificCredential with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteServiceSpecificCredential for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteServiceSpecificCredentialWithContext(ctx aws.Context, input *DeleteServiceSpecificCredentialInput, opts ...request.Option) (*DeleteServiceSpecificCredentialOutput, error) {
+	req, out := c.DeleteServiceSpecificCredentialRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteSigningCertificate = "DeleteSigningCertificate"
+
+// DeleteSigningCertificateRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteSigningCertificate operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteSigningCertificate for more information on using the DeleteSigningCertificate
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteSigningCertificateRequest method.
+//    req, resp := client.DeleteSigningCertificateRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteSigningCertificate
+func (c *IAM) DeleteSigningCertificateRequest(input *DeleteSigningCertificateInput) (req *request.Request, output *DeleteSigningCertificateOutput) {
+	op := &request.Operation{
+		Name:       opDeleteSigningCertificate,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteSigningCertificateInput{}
+	}
+
+	output = &DeleteSigningCertificateOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteSigningCertificate API operation for AWS Identity and Access Management.
+//
+// Deletes a signing certificate associated with the specified IAM user.
+//
+// If you do not specify a user name, IAM determines the user name implicitly
+// based on the AWS access key ID signing the request. This operation works
+// for access keys under the AWS account. Consequently, you can use this operation
+// to manage AWS account root user credentials even if the AWS account has no
+// associated IAM users.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteSigningCertificate for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteSigningCertificate
+func (c *IAM) DeleteSigningCertificate(input *DeleteSigningCertificateInput) (*DeleteSigningCertificateOutput, error) {
+	req, out := c.DeleteSigningCertificateRequest(input)
+	return out, req.Send()
+}
+
+// DeleteSigningCertificateWithContext is the same as DeleteSigningCertificate with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteSigningCertificate for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteSigningCertificateWithContext(ctx aws.Context, input *DeleteSigningCertificateInput, opts ...request.Option) (*DeleteSigningCertificateOutput, error) {
+	req, out := c.DeleteSigningCertificateRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteUser = "DeleteUser"
+
+// DeleteUserRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteUser operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteUser for more information on using the DeleteUser
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteUserRequest method.
+//    req, resp := client.DeleteUserRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteUser
+func (c *IAM) DeleteUserRequest(input *DeleteUserInput) (req *request.Request, output *DeleteUserOutput) {
+	op := &request.Operation{
+		Name:       opDeleteUser,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteUserInput{}
+	}
+
+	output = &DeleteUserOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteUser API operation for AWS Identity and Access Management.
+//
+// Deletes the specified IAM user. Unlike the AWS Management Console, when you
+// delete a user programmatically, you must delete the items attached to the
+// user manually, or the deletion fails. For more information, see Deleting
+// an IAM User (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html#id_users_deleting_cli).
+// Before attempting to delete a user, remove the following items:
+//
+//    * Password (DeleteLoginProfile)
+//
+//    * Access keys (DeleteAccessKey)
+//
+//    * Signing certificate (DeleteSigningCertificate)
+//
+//    * SSH public key (DeleteSSHPublicKey)
+//
+//    * Git credentials (DeleteServiceSpecificCredential)
+//
+//    * Multi-factor authentication (MFA) device (DeactivateMFADevice, DeleteVirtualMFADevice)
+//
+//    * Inline policies (DeleteUserPolicy)
+//
+//    * Attached managed policies (DetachUserPolicy)
+//
+//    * Group memberships (RemoveUserFromGroup)
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteUser for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeDeleteConflictException "DeleteConflict"
+//   The request was rejected because it attempted to delete a resource that has
+//   attached subordinate entities. The error message describes these entities.
+//
+//   * ErrCodeConcurrentModificationException "ConcurrentModification"
+//   The request was rejected because multiple requests to change this object
+//   were submitted simultaneously. Wait a few minutes and submit your request
+//   again.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteUser
+func (c *IAM) DeleteUser(input *DeleteUserInput) (*DeleteUserOutput, error) {
+	req, out := c.DeleteUserRequest(input)
+	return out, req.Send()
+}
+
+// DeleteUserWithContext is the same as DeleteUser with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteUser for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteUserWithContext(ctx aws.Context, input *DeleteUserInput, opts ...request.Option) (*DeleteUserOutput, error) {
+	req, out := c.DeleteUserRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteUserPermissionsBoundary = "DeleteUserPermissionsBoundary"
+
+// DeleteUserPermissionsBoundaryRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteUserPermissionsBoundary operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteUserPermissionsBoundary for more information on using the DeleteUserPermissionsBoundary
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteUserPermissionsBoundaryRequest method.
+//    req, resp := client.DeleteUserPermissionsBoundaryRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteUserPermissionsBoundary
+func (c *IAM) DeleteUserPermissionsBoundaryRequest(input *DeleteUserPermissionsBoundaryInput) (req *request.Request, output *DeleteUserPermissionsBoundaryOutput) {
+	op := &request.Operation{
+		Name:       opDeleteUserPermissionsBoundary,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteUserPermissionsBoundaryInput{}
+	}
+
+	output = &DeleteUserPermissionsBoundaryOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteUserPermissionsBoundary API operation for AWS Identity and Access Management.
+//
+// Deletes the permissions boundary for the specified IAM user.
+//
+// Deleting the permissions boundary for a user might increase its permissions
+// by allowing the user to perform all the actions granted in its permissions
+// policies.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteUserPermissionsBoundary for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteUserPermissionsBoundary
+func (c *IAM) DeleteUserPermissionsBoundary(input *DeleteUserPermissionsBoundaryInput) (*DeleteUserPermissionsBoundaryOutput, error) {
+	req, out := c.DeleteUserPermissionsBoundaryRequest(input)
+	return out, req.Send()
+}
+
+// DeleteUserPermissionsBoundaryWithContext is the same as DeleteUserPermissionsBoundary with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteUserPermissionsBoundary for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteUserPermissionsBoundaryWithContext(ctx aws.Context, input *DeleteUserPermissionsBoundaryInput, opts ...request.Option) (*DeleteUserPermissionsBoundaryOutput, error) {
+	req, out := c.DeleteUserPermissionsBoundaryRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteUserPolicy = "DeleteUserPolicy"
+
+// DeleteUserPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteUserPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteUserPolicy for more information on using the DeleteUserPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteUserPolicyRequest method.
+//    req, resp := client.DeleteUserPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteUserPolicy
+func (c *IAM) DeleteUserPolicyRequest(input *DeleteUserPolicyInput) (req *request.Request, output *DeleteUserPolicyOutput) {
+	op := &request.Operation{
+		Name:       opDeleteUserPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteUserPolicyInput{}
+	}
+
+	output = &DeleteUserPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteUserPolicy API operation for AWS Identity and Access Management.
+//
+// Deletes the specified inline policy that is embedded in the specified IAM
+// user.
+//
+// A user can also have managed policies attached to it. To detach a managed
+// policy from a user, use DetachUserPolicy. For more information about policies,
+// refer to Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteUserPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteUserPolicy
+func (c *IAM) DeleteUserPolicy(input *DeleteUserPolicyInput) (*DeleteUserPolicyOutput, error) {
+	req, out := c.DeleteUserPolicyRequest(input)
+	return out, req.Send()
+}
+
+// DeleteUserPolicyWithContext is the same as DeleteUserPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteUserPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteUserPolicyWithContext(ctx aws.Context, input *DeleteUserPolicyInput, opts ...request.Option) (*DeleteUserPolicyOutput, error) {
+	req, out := c.DeleteUserPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDeleteVirtualMFADevice = "DeleteVirtualMFADevice"
+
+// DeleteVirtualMFADeviceRequest generates a "aws/request.Request" representing the
+// client's request for the DeleteVirtualMFADevice operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DeleteVirtualMFADevice for more information on using the DeleteVirtualMFADevice
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DeleteVirtualMFADeviceRequest method.
+//    req, resp := client.DeleteVirtualMFADeviceRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteVirtualMFADevice
+func (c *IAM) DeleteVirtualMFADeviceRequest(input *DeleteVirtualMFADeviceInput) (req *request.Request, output *DeleteVirtualMFADeviceOutput) {
+	op := &request.Operation{
+		Name:       opDeleteVirtualMFADevice,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DeleteVirtualMFADeviceInput{}
+	}
+
+	output = &DeleteVirtualMFADeviceOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DeleteVirtualMFADevice API operation for AWS Identity and Access Management.
+//
+// Deletes a virtual MFA device.
+//
+// You must deactivate a user's virtual MFA device before you can delete it.
+// For information about deactivating MFA devices, see DeactivateMFADevice.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DeleteVirtualMFADevice for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeDeleteConflictException "DeleteConflict"
+//   The request was rejected because it attempted to delete a resource that has
+//   attached subordinate entities. The error message describes these entities.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DeleteVirtualMFADevice
+func (c *IAM) DeleteVirtualMFADevice(input *DeleteVirtualMFADeviceInput) (*DeleteVirtualMFADeviceOutput, error) {
+	req, out := c.DeleteVirtualMFADeviceRequest(input)
+	return out, req.Send()
+}
+
+// DeleteVirtualMFADeviceWithContext is the same as DeleteVirtualMFADevice with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DeleteVirtualMFADevice for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DeleteVirtualMFADeviceWithContext(ctx aws.Context, input *DeleteVirtualMFADeviceInput, opts ...request.Option) (*DeleteVirtualMFADeviceOutput, error) {
+	req, out := c.DeleteVirtualMFADeviceRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDetachGroupPolicy = "DetachGroupPolicy"
+
+// DetachGroupPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the DetachGroupPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DetachGroupPolicy for more information on using the DetachGroupPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DetachGroupPolicyRequest method.
+//    req, resp := client.DetachGroupPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DetachGroupPolicy
+func (c *IAM) DetachGroupPolicyRequest(input *DetachGroupPolicyInput) (req *request.Request, output *DetachGroupPolicyOutput) {
+	op := &request.Operation{
+		Name:       opDetachGroupPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DetachGroupPolicyInput{}
+	}
+
+	output = &DetachGroupPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DetachGroupPolicy API operation for AWS Identity and Access Management.
+//
+// Removes the specified managed policy from the specified IAM group.
+//
+// A group can also have inline policies embedded with it. To delete an inline
+// policy, use the DeleteGroupPolicy API. For information about policies, see
+// Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DetachGroupPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DetachGroupPolicy
+func (c *IAM) DetachGroupPolicy(input *DetachGroupPolicyInput) (*DetachGroupPolicyOutput, error) {
+	req, out := c.DetachGroupPolicyRequest(input)
+	return out, req.Send()
+}
+
+// DetachGroupPolicyWithContext is the same as DetachGroupPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DetachGroupPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DetachGroupPolicyWithContext(ctx aws.Context, input *DetachGroupPolicyInput, opts ...request.Option) (*DetachGroupPolicyOutput, error) {
+	req, out := c.DetachGroupPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDetachRolePolicy = "DetachRolePolicy"
+
+// DetachRolePolicyRequest generates a "aws/request.Request" representing the
+// client's request for the DetachRolePolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DetachRolePolicy for more information on using the DetachRolePolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DetachRolePolicyRequest method.
+//    req, resp := client.DetachRolePolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DetachRolePolicy
+func (c *IAM) DetachRolePolicyRequest(input *DetachRolePolicyInput) (req *request.Request, output *DetachRolePolicyOutput) {
+	op := &request.Operation{
+		Name:       opDetachRolePolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DetachRolePolicyInput{}
+	}
+
+	output = &DetachRolePolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DetachRolePolicy API operation for AWS Identity and Access Management.
+//
+// Removes the specified managed policy from the specified role.
+//
+// A role can also have inline policies embedded with it. To delete an inline
+// policy, use the DeleteRolePolicy API. For information about policies, see
+// Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DetachRolePolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DetachRolePolicy
+func (c *IAM) DetachRolePolicy(input *DetachRolePolicyInput) (*DetachRolePolicyOutput, error) {
+	req, out := c.DetachRolePolicyRequest(input)
+	return out, req.Send()
+}
+
+// DetachRolePolicyWithContext is the same as DetachRolePolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DetachRolePolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DetachRolePolicyWithContext(ctx aws.Context, input *DetachRolePolicyInput, opts ...request.Option) (*DetachRolePolicyOutput, error) {
+	req, out := c.DetachRolePolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opDetachUserPolicy = "DetachUserPolicy"
+
+// DetachUserPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the DetachUserPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See DetachUserPolicy for more information on using the DetachUserPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the DetachUserPolicyRequest method.
+//    req, resp := client.DetachUserPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DetachUserPolicy
+func (c *IAM) DetachUserPolicyRequest(input *DetachUserPolicyInput) (req *request.Request, output *DetachUserPolicyOutput) {
+	op := &request.Operation{
+		Name:       opDetachUserPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &DetachUserPolicyInput{}
+	}
+
+	output = &DetachUserPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// DetachUserPolicy API operation for AWS Identity and Access Management.
+//
+// Removes the specified managed policy from the specified user.
+//
+// A user can also have inline policies embedded with it. To delete an inline
+// policy, use the DeleteUserPolicy API. For information about policies, see
+// Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation DetachUserPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/DetachUserPolicy
+func (c *IAM) DetachUserPolicy(input *DetachUserPolicyInput) (*DetachUserPolicyOutput, error) {
+	req, out := c.DetachUserPolicyRequest(input)
+	return out, req.Send()
+}
+
+// DetachUserPolicyWithContext is the same as DetachUserPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See DetachUserPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) DetachUserPolicyWithContext(ctx aws.Context, input *DetachUserPolicyInput, opts ...request.Option) (*DetachUserPolicyOutput, error) {
+	req, out := c.DetachUserPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opEnableMFADevice = "EnableMFADevice"
+
+// EnableMFADeviceRequest generates a "aws/request.Request" representing the
+// client's request for the EnableMFADevice operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See EnableMFADevice for more information on using the EnableMFADevice
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the EnableMFADeviceRequest method.
+//    req, resp := client.EnableMFADeviceRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/EnableMFADevice
+func (c *IAM) EnableMFADeviceRequest(input *EnableMFADeviceInput) (req *request.Request, output *EnableMFADeviceOutput) {
+	op := &request.Operation{
+		Name:       opEnableMFADevice,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &EnableMFADeviceInput{}
+	}
+
+	output = &EnableMFADeviceOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// EnableMFADevice API operation for AWS Identity and Access Management.
+//
+// Enables the specified MFA device and associates it with the specified IAM
+// user. When enabled, the MFA device is required for every subsequent login
+// by the IAM user associated with the device.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation EnableMFADevice for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeEntityTemporarilyUnmodifiableException "EntityTemporarilyUnmodifiable"
+//   The request was rejected because it referenced an entity that is temporarily
+//   unmodifiable, such as a user name that was deleted and then recreated. The
+//   error indicates that the request is likely to succeed if you try again after
+//   waiting several minutes. The error message describes the entity.
+//
+//   * ErrCodeInvalidAuthenticationCodeException "InvalidAuthenticationCode"
+//   The request was rejected because the authentication code was not recognized.
+//   The error message describes the specific error.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/EnableMFADevice
+func (c *IAM) EnableMFADevice(input *EnableMFADeviceInput) (*EnableMFADeviceOutput, error) {
+	req, out := c.EnableMFADeviceRequest(input)
+	return out, req.Send()
+}
+
+// EnableMFADeviceWithContext is the same as EnableMFADevice with the addition of
+// the ability to pass a context and additional request options.
+//
+// See EnableMFADevice for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) EnableMFADeviceWithContext(ctx aws.Context, input *EnableMFADeviceInput, opts ...request.Option) (*EnableMFADeviceOutput, error) {
+	req, out := c.EnableMFADeviceRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGenerateCredentialReport = "GenerateCredentialReport"
+
+// GenerateCredentialReportRequest generates a "aws/request.Request" representing the
+// client's request for the GenerateCredentialReport operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GenerateCredentialReport for more information on using the GenerateCredentialReport
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GenerateCredentialReportRequest method.
+//    req, resp := client.GenerateCredentialReportRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GenerateCredentialReport
+func (c *IAM) GenerateCredentialReportRequest(input *GenerateCredentialReportInput) (req *request.Request, output *GenerateCredentialReportOutput) {
+	op := &request.Operation{
+		Name:       opGenerateCredentialReport,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GenerateCredentialReportInput{}
+	}
+
+	output = &GenerateCredentialReportOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GenerateCredentialReport API operation for AWS Identity and Access Management.
+//
+// Generates a credential report for the AWS account. For more information about
+// the credential report, see Getting Credential Reports (https://docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GenerateCredentialReport for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GenerateCredentialReport
+func (c *IAM) GenerateCredentialReport(input *GenerateCredentialReportInput) (*GenerateCredentialReportOutput, error) {
+	req, out := c.GenerateCredentialReportRequest(input)
+	return out, req.Send()
+}
+
+// GenerateCredentialReportWithContext is the same as GenerateCredentialReport with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GenerateCredentialReport for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GenerateCredentialReportWithContext(ctx aws.Context, input *GenerateCredentialReportInput, opts ...request.Option) (*GenerateCredentialReportOutput, error) {
+	req, out := c.GenerateCredentialReportRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGenerateOrganizationsAccessReport = "GenerateOrganizationsAccessReport"
+
+// GenerateOrganizationsAccessReportRequest generates a "aws/request.Request" representing the
+// client's request for the GenerateOrganizationsAccessReport operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GenerateOrganizationsAccessReport for more information on using the GenerateOrganizationsAccessReport
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GenerateOrganizationsAccessReportRequest method.
+//    req, resp := client.GenerateOrganizationsAccessReportRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GenerateOrganizationsAccessReport
+func (c *IAM) GenerateOrganizationsAccessReportRequest(input *GenerateOrganizationsAccessReportInput) (req *request.Request, output *GenerateOrganizationsAccessReportOutput) {
+	op := &request.Operation{
+		Name:       opGenerateOrganizationsAccessReport,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GenerateOrganizationsAccessReportInput{}
+	}
+
+	output = &GenerateOrganizationsAccessReportOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GenerateOrganizationsAccessReport API operation for AWS Identity and Access Management.
+//
+// Generates a report for service last accessed data for AWS Organizations.
+// You can generate a report for any entities (organization root, organizational
+// unit, or account) or policies in your organization.
+//
+// To call this operation, you must be signed in using your AWS Organizations
+// master account credentials. You can use your long-term IAM user or root user
+// credentials, or temporary credentials from assuming an IAM role. SCPs must
+// be enabled for your organization root. You must have the required IAM and
+// AWS Organizations permissions. For more information, see Refining Permissions
+// Using Service Last Accessed Data (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html)
+// in the IAM User Guide.
+//
+// You can generate a service last accessed data report for entities by specifying
+// only the entity's path. This data includes a list of services that are allowed
+// by any service control policies (SCPs) that apply to the entity.
+//
+// You can generate a service last accessed data report for a policy by specifying
+// an entity's path and an optional AWS Organizations policy ID. This data includes
+// a list of services that are allowed by the specified SCP.
+//
+// For each service in both report types, the data includes the most recent
+// account activity that the policy allows to account principals in the entity
+// or the entity's children. For important information about the data, reporting
+// period, permissions required, troubleshooting, and supported Regions see
+// Reducing Permissions Using Service Last Accessed Data (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html)
+// in the IAM User Guide.
+//
+// The data includes all attempts to access AWS, not just the successful ones.
+// This includes all attempts that were made using the AWS Management Console,
+// the AWS API through any of the SDKs, or any of the command line tools. An
+// unexpected entry in the service last accessed data does not mean that an
+// account has been compromised, because the request might have been denied.
+// Refer to your CloudTrail logs as the authoritative source for information
+// about all API calls and whether they were successful or denied access. For
+// more information, see Logging IAM Events with CloudTrail (https://docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-integration.html)
+// in the IAM User Guide.
+//
+// This operation returns a JobId. Use this parameter in the GetOrganizationsAccessReport
+// operation to check the status of the report generation. To check the status
+// of this request, use the JobId parameter in the GetOrganizationsAccessReport
+// operation and test the JobStatus response parameter. When the job is complete,
+// you can retrieve the report.
+//
+// To generate a service last accessed data report for entities, specify an
+// entity path without specifying the optional AWS Organizations policy ID.
+// The type of entity that you specify determines the data returned in the report.
+//
+//    * Root – When you specify the organizations root as the entity, the
+//    resulting report lists all of the services allowed by SCPs that are attached
+//    to your root. For each service, the report includes data for all accounts
+//    in your organization except the master account, because the master account
+//    is not limited by SCPs.
+//
+//    * OU – When you specify an organizational unit (OU) as the entity, the
+//    resulting report lists all of the services allowed by SCPs that are attached
+//    to the OU and its parents. For each service, the report includes data
+//    for all accounts in the OU or its children. This data excludes the master
+//    account, because the master account is not limited by SCPs.
+//
+//    * Master account – When you specify the master account, the resulting
+//    report lists all AWS services, because the master account is not limited
+//    by SCPs. For each service, the report includes data for only the master
+//    account.
+//
+//    * Account – When you specify another account as the entity, the resulting
+//    report lists all of the services allowed by SCPs that are attached to
+//    the account and its parents. For each service, the report includes data
+//    for only the specified account.
+//
+// To generate a service last accessed data report for policies, specify an
+// entity path and the optional AWS Organizations policy ID. The type of entity
+// that you specify determines the data returned for each service.
+//
+//    * Root – When you specify the root entity and a policy ID, the resulting
+//    report lists all of the services that are allowed by the specified SCP.
+//    For each service, the report includes data for all accounts in your organization
+//    to which the SCP applies. This data excludes the master account, because
+//    the master account is not limited by SCPs. If the SCP is not attached
+//    to any entities in the organization, then the report will return a list
+//    of services with no data.
+//
+//    * OU – When you specify an OU entity and a policy ID, the resulting
+//    report lists all of the services that are allowed by the specified SCP.
+//    For each service, the report includes data for all accounts in the OU
+//    or its children to which the SCP applies. This means that other accounts
+//    outside the OU that are affected by the SCP might not be included in the
+//    data. This data excludes the master account, because the master account
+//    is not limited by SCPs. If the SCP is not attached to the OU or one of
+//    its children, the report will return a list of services with no data.
+//
+//    * Master account – When you specify the master account, the resulting
+//    report lists all AWS services, because the master account is not limited
+//    by SCPs. If you specify a policy ID in the CLI or API, the policy is ignored.
+//    For each service, the report includes data for only the master account.
+//
+//    * Account – When you specify another account entity and a policy ID,
+//    the resulting report lists all of the services that are allowed by the
+//    specified SCP. For each service, the report includes data for only the
+//    specified account. This means that other accounts in the organization
+//    that are affected by the SCP might not be included in the data. If the
+//    SCP is not attached to the account, the report will return a list of services
+//    with no data.
+//
+// Service last accessed data does not use other policy types when determining
+// whether a principal could access a service. These other policy types include
+// identity-based policies, resource-based policies, access control lists, IAM
+// permissions boundaries, and STS assume role policies. It only applies SCP
+// logic. For more about the evaluation of policy types, see Evaluating Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics)
+// in the IAM User Guide.
+//
+// For more information about service last accessed data, see Reducing Policy
+// Scope by Viewing User Activity (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GenerateOrganizationsAccessReport for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeReportGenerationLimitExceededException "ReportGenerationLimitExceeded"
+//   The request failed because the maximum number of concurrent requests for
+//   this account are already running.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GenerateOrganizationsAccessReport
+func (c *IAM) GenerateOrganizationsAccessReport(input *GenerateOrganizationsAccessReportInput) (*GenerateOrganizationsAccessReportOutput, error) {
+	req, out := c.GenerateOrganizationsAccessReportRequest(input)
+	return out, req.Send()
+}
+
+// GenerateOrganizationsAccessReportWithContext is the same as GenerateOrganizationsAccessReport with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GenerateOrganizationsAccessReport for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GenerateOrganizationsAccessReportWithContext(ctx aws.Context, input *GenerateOrganizationsAccessReportInput, opts ...request.Option) (*GenerateOrganizationsAccessReportOutput, error) {
+	req, out := c.GenerateOrganizationsAccessReportRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGenerateServiceLastAccessedDetails = "GenerateServiceLastAccessedDetails"
+
+// GenerateServiceLastAccessedDetailsRequest generates a "aws/request.Request" representing the
+// client's request for the GenerateServiceLastAccessedDetails operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GenerateServiceLastAccessedDetails for more information on using the GenerateServiceLastAccessedDetails
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GenerateServiceLastAccessedDetailsRequest method.
+//    req, resp := client.GenerateServiceLastAccessedDetailsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GenerateServiceLastAccessedDetails
+func (c *IAM) GenerateServiceLastAccessedDetailsRequest(input *GenerateServiceLastAccessedDetailsInput) (req *request.Request, output *GenerateServiceLastAccessedDetailsOutput) {
+	op := &request.Operation{
+		Name:       opGenerateServiceLastAccessedDetails,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GenerateServiceLastAccessedDetailsInput{}
+	}
+
+	output = &GenerateServiceLastAccessedDetailsOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GenerateServiceLastAccessedDetails API operation for AWS Identity and Access Management.
+//
+// Generates a report that includes details about when an IAM resource (user,
+// group, role, or policy) was last used in an attempt to access AWS services.
+// Recent activity usually appears within four hours. IAM reports activity for
+// the last 365 days, or less if your Region began supporting this feature within
+// the last year. For more information, see Regions Where Data Is Tracked (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#access-advisor_tracking-period).
+//
+// The service last accessed data includes all attempts to access an AWS API,
+// not just the successful ones. This includes all attempts that were made using
+// the AWS Management Console, the AWS API through any of the SDKs, or any of
+// the command line tools. An unexpected entry in the service last accessed
+// data does not mean that your account has been compromised, because the request
+// might have been denied. Refer to your CloudTrail logs as the authoritative
+// source for information about all API calls and whether they were successful
+// or denied access. For more information, see Logging IAM Events with CloudTrail
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-integration.html)
+// in the IAM User Guide.
+//
+// The GenerateServiceLastAccessedDetails operation returns a JobId. Use this
+// parameter in the following operations to retrieve the following details from
+// your report:
+//
+//    * GetServiceLastAccessedDetails – Use this operation for users, groups,
+//    roles, or policies to list every AWS service that the resource could access
+//    using permissions policies. For each service, the response includes information
+//    about the most recent access attempt.
+//
+//    * GetServiceLastAccessedDetailsWithEntities – Use this operation for
+//    groups and policies to list information about the associated entities
+//    (users or roles) that attempted to access a specific AWS service.
+//
+// To check the status of the GenerateServiceLastAccessedDetails request, use
+// the JobId parameter in the same operations and test the JobStatus response
+// parameter.
+//
+// For additional information about the permissions policies that allow an identity
+// (user, group, or role) to access specific services, use the ListPoliciesGrantingServiceAccess
+// operation.
+//
+// Service last accessed data does not use other policy types when determining
+// whether a resource could access a service. These other policy types include
+// resource-based policies, access control lists, AWS Organizations policies,
+// IAM permissions boundaries, and AWS STS assume role policies. It only applies
+// permissions policy logic. For more about the evaluation of policy types,
+// see Evaluating Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics)
+// in the IAM User Guide.
+//
+// For more information about service last accessed data, see Reducing Policy
+// Scope by Viewing User Activity (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GenerateServiceLastAccessedDetails for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GenerateServiceLastAccessedDetails
+func (c *IAM) GenerateServiceLastAccessedDetails(input *GenerateServiceLastAccessedDetailsInput) (*GenerateServiceLastAccessedDetailsOutput, error) {
+	req, out := c.GenerateServiceLastAccessedDetailsRequest(input)
+	return out, req.Send()
+}
+
+// GenerateServiceLastAccessedDetailsWithContext is the same as GenerateServiceLastAccessedDetails with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GenerateServiceLastAccessedDetails for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GenerateServiceLastAccessedDetailsWithContext(ctx aws.Context, input *GenerateServiceLastAccessedDetailsInput, opts ...request.Option) (*GenerateServiceLastAccessedDetailsOutput, error) {
+	req, out := c.GenerateServiceLastAccessedDetailsRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetAccessKeyLastUsed = "GetAccessKeyLastUsed"
+
+// GetAccessKeyLastUsedRequest generates a "aws/request.Request" representing the
+// client's request for the GetAccessKeyLastUsed operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetAccessKeyLastUsed for more information on using the GetAccessKeyLastUsed
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetAccessKeyLastUsedRequest method.
+//    req, resp := client.GetAccessKeyLastUsedRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccessKeyLastUsed
+func (c *IAM) GetAccessKeyLastUsedRequest(input *GetAccessKeyLastUsedInput) (req *request.Request, output *GetAccessKeyLastUsedOutput) {
+	op := &request.Operation{
+		Name:       opGetAccessKeyLastUsed,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetAccessKeyLastUsedInput{}
+	}
+
+	output = &GetAccessKeyLastUsedOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetAccessKeyLastUsed API operation for AWS Identity and Access Management.
+//
+// Retrieves information about when the specified access key was last used.
+// The information includes the date and time of last use, along with the AWS
+// service and Region that were specified in the last request made with that
+// key.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetAccessKeyLastUsed for usage and error information.
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccessKeyLastUsed
+func (c *IAM) GetAccessKeyLastUsed(input *GetAccessKeyLastUsedInput) (*GetAccessKeyLastUsedOutput, error) {
+	req, out := c.GetAccessKeyLastUsedRequest(input)
+	return out, req.Send()
+}
+
+// GetAccessKeyLastUsedWithContext is the same as GetAccessKeyLastUsed with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetAccessKeyLastUsed for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetAccessKeyLastUsedWithContext(ctx aws.Context, input *GetAccessKeyLastUsedInput, opts ...request.Option) (*GetAccessKeyLastUsedOutput, error) {
+	req, out := c.GetAccessKeyLastUsedRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetAccountAuthorizationDetails = "GetAccountAuthorizationDetails"
+
+// GetAccountAuthorizationDetailsRequest generates a "aws/request.Request" representing the
+// client's request for the GetAccountAuthorizationDetails operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetAccountAuthorizationDetails for more information on using the GetAccountAuthorizationDetails
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetAccountAuthorizationDetailsRequest method.
+//    req, resp := client.GetAccountAuthorizationDetailsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccountAuthorizationDetails
+func (c *IAM) GetAccountAuthorizationDetailsRequest(input *GetAccountAuthorizationDetailsInput) (req *request.Request, output *GetAccountAuthorizationDetailsOutput) {
+	op := &request.Operation{
+		Name:       opGetAccountAuthorizationDetails,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &GetAccountAuthorizationDetailsInput{}
+	}
+
+	output = &GetAccountAuthorizationDetailsOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetAccountAuthorizationDetails API operation for AWS Identity and Access Management.
+//
+// Retrieves information about all IAM users, groups, roles, and policies in
+// your AWS account, including their relationships to one another. Use this
+// API to obtain a snapshot of the configuration of IAM permissions (users,
+// groups, roles, and policies) in your account.
+//
+// Policies returned by this API are URL-encoded compliant with RFC 3986 (https://tools.ietf.org/html/rfc3986).
+// You can use a URL decoding method to convert the policy back to plain JSON
+// text. For example, if you use Java, you can use the decode method of the
+// java.net.URLDecoder utility class in the Java SDK. Other languages and SDKs
+// provide similar functionality.
+//
+// You can optionally filter the results using the Filter parameter. You can
+// paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetAccountAuthorizationDetails for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccountAuthorizationDetails
+func (c *IAM) GetAccountAuthorizationDetails(input *GetAccountAuthorizationDetailsInput) (*GetAccountAuthorizationDetailsOutput, error) {
+	req, out := c.GetAccountAuthorizationDetailsRequest(input)
+	return out, req.Send()
+}
+
+// GetAccountAuthorizationDetailsWithContext is the same as GetAccountAuthorizationDetails with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetAccountAuthorizationDetails for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetAccountAuthorizationDetailsWithContext(ctx aws.Context, input *GetAccountAuthorizationDetailsInput, opts ...request.Option) (*GetAccountAuthorizationDetailsOutput, error) {
+	req, out := c.GetAccountAuthorizationDetailsRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// GetAccountAuthorizationDetailsPages iterates over the pages of a GetAccountAuthorizationDetails operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See GetAccountAuthorizationDetails method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a GetAccountAuthorizationDetails operation.
+//    pageNum := 0
+//    err := client.GetAccountAuthorizationDetailsPages(params,
+//        func(page *iam.GetAccountAuthorizationDetailsOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) GetAccountAuthorizationDetailsPages(input *GetAccountAuthorizationDetailsInput, fn func(*GetAccountAuthorizationDetailsOutput, bool) bool) error {
+	return c.GetAccountAuthorizationDetailsPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// GetAccountAuthorizationDetailsPagesWithContext same as GetAccountAuthorizationDetailsPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetAccountAuthorizationDetailsPagesWithContext(ctx aws.Context, input *GetAccountAuthorizationDetailsInput, fn func(*GetAccountAuthorizationDetailsOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *GetAccountAuthorizationDetailsInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.GetAccountAuthorizationDetailsRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*GetAccountAuthorizationDetailsOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opGetAccountPasswordPolicy = "GetAccountPasswordPolicy"
+
+// GetAccountPasswordPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the GetAccountPasswordPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetAccountPasswordPolicy for more information on using the GetAccountPasswordPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetAccountPasswordPolicyRequest method.
+//    req, resp := client.GetAccountPasswordPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccountPasswordPolicy
+func (c *IAM) GetAccountPasswordPolicyRequest(input *GetAccountPasswordPolicyInput) (req *request.Request, output *GetAccountPasswordPolicyOutput) {
+	op := &request.Operation{
+		Name:       opGetAccountPasswordPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetAccountPasswordPolicyInput{}
+	}
+
+	output = &GetAccountPasswordPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetAccountPasswordPolicy API operation for AWS Identity and Access Management.
+//
+// Retrieves the password policy for the AWS account. For more information about
+// using a password policy, go to Managing an IAM Password Policy (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingPasswordPolicies.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetAccountPasswordPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccountPasswordPolicy
+func (c *IAM) GetAccountPasswordPolicy(input *GetAccountPasswordPolicyInput) (*GetAccountPasswordPolicyOutput, error) {
+	req, out := c.GetAccountPasswordPolicyRequest(input)
+	return out, req.Send()
+}
+
+// GetAccountPasswordPolicyWithContext is the same as GetAccountPasswordPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetAccountPasswordPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetAccountPasswordPolicyWithContext(ctx aws.Context, input *GetAccountPasswordPolicyInput, opts ...request.Option) (*GetAccountPasswordPolicyOutput, error) {
+	req, out := c.GetAccountPasswordPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetAccountSummary = "GetAccountSummary"
+
+// GetAccountSummaryRequest generates a "aws/request.Request" representing the
+// client's request for the GetAccountSummary operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetAccountSummary for more information on using the GetAccountSummary
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetAccountSummaryRequest method.
+//    req, resp := client.GetAccountSummaryRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccountSummary
+func (c *IAM) GetAccountSummaryRequest(input *GetAccountSummaryInput) (req *request.Request, output *GetAccountSummaryOutput) {
+	op := &request.Operation{
+		Name:       opGetAccountSummary,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetAccountSummaryInput{}
+	}
+
+	output = &GetAccountSummaryOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetAccountSummary API operation for AWS Identity and Access Management.
+//
+// Retrieves information about IAM entity usage and IAM quotas in the AWS account.
+//
+// For information about limitations on IAM entities, see Limitations on IAM
+// Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetAccountSummary for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetAccountSummary
+func (c *IAM) GetAccountSummary(input *GetAccountSummaryInput) (*GetAccountSummaryOutput, error) {
+	req, out := c.GetAccountSummaryRequest(input)
+	return out, req.Send()
+}
+
+// GetAccountSummaryWithContext is the same as GetAccountSummary with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetAccountSummary for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetAccountSummaryWithContext(ctx aws.Context, input *GetAccountSummaryInput, opts ...request.Option) (*GetAccountSummaryOutput, error) {
+	req, out := c.GetAccountSummaryRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetContextKeysForCustomPolicy = "GetContextKeysForCustomPolicy"
+
+// GetContextKeysForCustomPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the GetContextKeysForCustomPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetContextKeysForCustomPolicy for more information on using the GetContextKeysForCustomPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetContextKeysForCustomPolicyRequest method.
+//    req, resp := client.GetContextKeysForCustomPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetContextKeysForCustomPolicy
+func (c *IAM) GetContextKeysForCustomPolicyRequest(input *GetContextKeysForCustomPolicyInput) (req *request.Request, output *GetContextKeysForPolicyResponse) {
+	op := &request.Operation{
+		Name:       opGetContextKeysForCustomPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetContextKeysForCustomPolicyInput{}
+	}
+
+	output = &GetContextKeysForPolicyResponse{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetContextKeysForCustomPolicy API operation for AWS Identity and Access Management.
+//
+// Gets a list of all of the context keys referenced in the input policies.
+// The policies are supplied as a list of one or more strings. To get the context
+// keys from policies associated with an IAM user, group, or role, use GetContextKeysForPrincipalPolicy.
+//
+// Context keys are variables maintained by AWS and its services that provide
+// details about the context of an API query request. Context keys can be evaluated
+// by testing against a value specified in an IAM policy. Use GetContextKeysForCustomPolicy
+// to understand what key names and values you must supply when you call SimulateCustomPolicy.
+// Note that all parameters are shown in unencoded form here for clarity but
+// must be URL encoded to be included as a part of a real HTML request.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetContextKeysForCustomPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetContextKeysForCustomPolicy
+func (c *IAM) GetContextKeysForCustomPolicy(input *GetContextKeysForCustomPolicyInput) (*GetContextKeysForPolicyResponse, error) {
+	req, out := c.GetContextKeysForCustomPolicyRequest(input)
+	return out, req.Send()
+}
+
+// GetContextKeysForCustomPolicyWithContext is the same as GetContextKeysForCustomPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetContextKeysForCustomPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetContextKeysForCustomPolicyWithContext(ctx aws.Context, input *GetContextKeysForCustomPolicyInput, opts ...request.Option) (*GetContextKeysForPolicyResponse, error) {
+	req, out := c.GetContextKeysForCustomPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetContextKeysForPrincipalPolicy = "GetContextKeysForPrincipalPolicy"
+
+// GetContextKeysForPrincipalPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the GetContextKeysForPrincipalPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetContextKeysForPrincipalPolicy for more information on using the GetContextKeysForPrincipalPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetContextKeysForPrincipalPolicyRequest method.
+//    req, resp := client.GetContextKeysForPrincipalPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetContextKeysForPrincipalPolicy
+func (c *IAM) GetContextKeysForPrincipalPolicyRequest(input *GetContextKeysForPrincipalPolicyInput) (req *request.Request, output *GetContextKeysForPolicyResponse) {
+	op := &request.Operation{
+		Name:       opGetContextKeysForPrincipalPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetContextKeysForPrincipalPolicyInput{}
+	}
+
+	output = &GetContextKeysForPolicyResponse{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetContextKeysForPrincipalPolicy API operation for AWS Identity and Access Management.
+//
+// Gets a list of all of the context keys referenced in all the IAM policies
+// that are attached to the specified IAM entity. The entity can be an IAM user,
+// group, or role. If you specify a user, then the request also includes all
+// of the policies attached to groups that the user is a member of.
+//
+// You can optionally include a list of one or more additional policies, specified
+// as strings. If you want to include only a list of policies by string, use
+// GetContextKeysForCustomPolicy instead.
+//
+// Note: This API discloses information about the permissions granted to other
+// users. If you do not want users to see other user's permissions, then consider
+// allowing them to use GetContextKeysForCustomPolicy instead.
+//
+// Context keys are variables maintained by AWS and its services that provide
+// details about the context of an API query request. Context keys can be evaluated
+// by testing against a value in an IAM policy. Use GetContextKeysForPrincipalPolicy
+// to understand what key names and values you must supply when you call SimulatePrincipalPolicy.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetContextKeysForPrincipalPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetContextKeysForPrincipalPolicy
+func (c *IAM) GetContextKeysForPrincipalPolicy(input *GetContextKeysForPrincipalPolicyInput) (*GetContextKeysForPolicyResponse, error) {
+	req, out := c.GetContextKeysForPrincipalPolicyRequest(input)
+	return out, req.Send()
+}
+
+// GetContextKeysForPrincipalPolicyWithContext is the same as GetContextKeysForPrincipalPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetContextKeysForPrincipalPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetContextKeysForPrincipalPolicyWithContext(ctx aws.Context, input *GetContextKeysForPrincipalPolicyInput, opts ...request.Option) (*GetContextKeysForPolicyResponse, error) {
+	req, out := c.GetContextKeysForPrincipalPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetCredentialReport = "GetCredentialReport"
+
+// GetCredentialReportRequest generates a "aws/request.Request" representing the
+// client's request for the GetCredentialReport operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetCredentialReport for more information on using the GetCredentialReport
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetCredentialReportRequest method.
+//    req, resp := client.GetCredentialReportRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetCredentialReport
+func (c *IAM) GetCredentialReportRequest(input *GetCredentialReportInput) (req *request.Request, output *GetCredentialReportOutput) {
+	op := &request.Operation{
+		Name:       opGetCredentialReport,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetCredentialReportInput{}
+	}
+
+	output = &GetCredentialReportOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetCredentialReport API operation for AWS Identity and Access Management.
+//
+// Retrieves a credential report for the AWS account. For more information about
+// the credential report, see Getting Credential Reports (https://docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetCredentialReport for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeCredentialReportNotPresentException "ReportNotPresent"
+//   The request was rejected because the credential report does not exist. To
+//   generate a credential report, use GenerateCredentialReport.
+//
+//   * ErrCodeCredentialReportExpiredException "ReportExpired"
+//   The request was rejected because the most recent credential report has expired.
+//   To generate a new credential report, use GenerateCredentialReport. For more
+//   information about credential report expiration, see Getting Credential Reports
+//   (https://docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html)
+//   in the IAM User Guide.
+//
+//   * ErrCodeCredentialReportNotReadyException "ReportInProgress"
+//   The request was rejected because the credential report is still being generated.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetCredentialReport
+func (c *IAM) GetCredentialReport(input *GetCredentialReportInput) (*GetCredentialReportOutput, error) {
+	req, out := c.GetCredentialReportRequest(input)
+	return out, req.Send()
+}
+
+// GetCredentialReportWithContext is the same as GetCredentialReport with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetCredentialReport for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetCredentialReportWithContext(ctx aws.Context, input *GetCredentialReportInput, opts ...request.Option) (*GetCredentialReportOutput, error) {
+	req, out := c.GetCredentialReportRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetGroup = "GetGroup"
+
+// GetGroupRequest generates a "aws/request.Request" representing the
+// client's request for the GetGroup operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetGroup for more information on using the GetGroup
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetGroupRequest method.
+//    req, resp := client.GetGroupRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetGroup
+func (c *IAM) GetGroupRequest(input *GetGroupInput) (req *request.Request, output *GetGroupOutput) {
+	op := &request.Operation{
+		Name:       opGetGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &GetGroupInput{}
+	}
+
+	output = &GetGroupOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetGroup API operation for AWS Identity and Access Management.
+//
+// Returns a list of IAM users that are in the specified IAM group. You can
+// paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetGroup for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetGroup
+func (c *IAM) GetGroup(input *GetGroupInput) (*GetGroupOutput, error) {
+	req, out := c.GetGroupRequest(input)
+	return out, req.Send()
+}
+
+// GetGroupWithContext is the same as GetGroup with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetGroup for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetGroupWithContext(ctx aws.Context, input *GetGroupInput, opts ...request.Option) (*GetGroupOutput, error) {
+	req, out := c.GetGroupRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// GetGroupPages iterates over the pages of a GetGroup operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See GetGroup method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a GetGroup operation.
+//    pageNum := 0
+//    err := client.GetGroupPages(params,
+//        func(page *iam.GetGroupOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) GetGroupPages(input *GetGroupInput, fn func(*GetGroupOutput, bool) bool) error {
+	return c.GetGroupPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// GetGroupPagesWithContext same as GetGroupPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetGroupPagesWithContext(ctx aws.Context, input *GetGroupInput, fn func(*GetGroupOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *GetGroupInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.GetGroupRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*GetGroupOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opGetGroupPolicy = "GetGroupPolicy"
+
+// GetGroupPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the GetGroupPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetGroupPolicy for more information on using the GetGroupPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetGroupPolicyRequest method.
+//    req, resp := client.GetGroupPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetGroupPolicy
+func (c *IAM) GetGroupPolicyRequest(input *GetGroupPolicyInput) (req *request.Request, output *GetGroupPolicyOutput) {
+	op := &request.Operation{
+		Name:       opGetGroupPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetGroupPolicyInput{}
+	}
+
+	output = &GetGroupPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetGroupPolicy API operation for AWS Identity and Access Management.
+//
+// Retrieves the specified inline policy document that is embedded in the specified
+// IAM group.
+//
+// Policies returned by this API are URL-encoded compliant with RFC 3986 (https://tools.ietf.org/html/rfc3986).
+// You can use a URL decoding method to convert the policy back to plain JSON
+// text. For example, if you use Java, you can use the decode method of the
+// java.net.URLDecoder utility class in the Java SDK. Other languages and SDKs
+// provide similar functionality.
+//
+// An IAM group can also have managed policies attached to it. To retrieve a
+// managed policy document that is attached to a group, use GetPolicy to determine
+// the policy's default version, then use GetPolicyVersion to retrieve the policy
+// document.
+//
+// For more information about policies, see Managed Policies and Inline Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetGroupPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetGroupPolicy
+func (c *IAM) GetGroupPolicy(input *GetGroupPolicyInput) (*GetGroupPolicyOutput, error) {
+	req, out := c.GetGroupPolicyRequest(input)
+	return out, req.Send()
+}
+
+// GetGroupPolicyWithContext is the same as GetGroupPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetGroupPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetGroupPolicyWithContext(ctx aws.Context, input *GetGroupPolicyInput, opts ...request.Option) (*GetGroupPolicyOutput, error) {
+	req, out := c.GetGroupPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetInstanceProfile = "GetInstanceProfile"
+
+// GetInstanceProfileRequest generates a "aws/request.Request" representing the
+// client's request for the GetInstanceProfile operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetInstanceProfile for more information on using the GetInstanceProfile
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetInstanceProfileRequest method.
+//    req, resp := client.GetInstanceProfileRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetInstanceProfile
+func (c *IAM) GetInstanceProfileRequest(input *GetInstanceProfileInput) (req *request.Request, output *GetInstanceProfileOutput) {
+	op := &request.Operation{
+		Name:       opGetInstanceProfile,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetInstanceProfileInput{}
+	}
+
+	output = &GetInstanceProfileOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetInstanceProfile API operation for AWS Identity and Access Management.
+//
+// Retrieves information about the specified instance profile, including the
+// instance profile's path, GUID, ARN, and role. For more information about
+// instance profiles, see About Instance Profiles (https://docs.aws.amazon.com/IAM/latest/UserGuide/AboutInstanceProfiles.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetInstanceProfile for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetInstanceProfile
+func (c *IAM) GetInstanceProfile(input *GetInstanceProfileInput) (*GetInstanceProfileOutput, error) {
+	req, out := c.GetInstanceProfileRequest(input)
+	return out, req.Send()
+}
+
+// GetInstanceProfileWithContext is the same as GetInstanceProfile with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetInstanceProfile for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetInstanceProfileWithContext(ctx aws.Context, input *GetInstanceProfileInput, opts ...request.Option) (*GetInstanceProfileOutput, error) {
+	req, out := c.GetInstanceProfileRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetLoginProfile = "GetLoginProfile"
+
+// GetLoginProfileRequest generates a "aws/request.Request" representing the
+// client's request for the GetLoginProfile operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetLoginProfile for more information on using the GetLoginProfile
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetLoginProfileRequest method.
+//    req, resp := client.GetLoginProfileRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetLoginProfile
+func (c *IAM) GetLoginProfileRequest(input *GetLoginProfileInput) (req *request.Request, output *GetLoginProfileOutput) {
+	op := &request.Operation{
+		Name:       opGetLoginProfile,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetLoginProfileInput{}
+	}
+
+	output = &GetLoginProfileOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetLoginProfile API operation for AWS Identity and Access Management.
+//
+// Retrieves the user name and password-creation date for the specified IAM
+// user. If the user has not been assigned a password, the operation returns
+// a 404 (NoSuchEntity) error.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetLoginProfile for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetLoginProfile
+func (c *IAM) GetLoginProfile(input *GetLoginProfileInput) (*GetLoginProfileOutput, error) {
+	req, out := c.GetLoginProfileRequest(input)
+	return out, req.Send()
+}
+
+// GetLoginProfileWithContext is the same as GetLoginProfile with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetLoginProfile for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetLoginProfileWithContext(ctx aws.Context, input *GetLoginProfileInput, opts ...request.Option) (*GetLoginProfileOutput, error) {
+	req, out := c.GetLoginProfileRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetOpenIDConnectProvider = "GetOpenIDConnectProvider"
+
+// GetOpenIDConnectProviderRequest generates a "aws/request.Request" representing the
+// client's request for the GetOpenIDConnectProvider operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetOpenIDConnectProvider for more information on using the GetOpenIDConnectProvider
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetOpenIDConnectProviderRequest method.
+//    req, resp := client.GetOpenIDConnectProviderRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetOpenIDConnectProvider
+func (c *IAM) GetOpenIDConnectProviderRequest(input *GetOpenIDConnectProviderInput) (req *request.Request, output *GetOpenIDConnectProviderOutput) {
+	op := &request.Operation{
+		Name:       opGetOpenIDConnectProvider,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetOpenIDConnectProviderInput{}
+	}
+
+	output = &GetOpenIDConnectProviderOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetOpenIDConnectProvider API operation for AWS Identity and Access Management.
+//
+// Returns information about the specified OpenID Connect (OIDC) provider resource
+// object in IAM.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetOpenIDConnectProvider for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetOpenIDConnectProvider
+func (c *IAM) GetOpenIDConnectProvider(input *GetOpenIDConnectProviderInput) (*GetOpenIDConnectProviderOutput, error) {
+	req, out := c.GetOpenIDConnectProviderRequest(input)
+	return out, req.Send()
+}
+
+// GetOpenIDConnectProviderWithContext is the same as GetOpenIDConnectProvider with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetOpenIDConnectProvider for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetOpenIDConnectProviderWithContext(ctx aws.Context, input *GetOpenIDConnectProviderInput, opts ...request.Option) (*GetOpenIDConnectProviderOutput, error) {
+	req, out := c.GetOpenIDConnectProviderRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetOrganizationsAccessReport = "GetOrganizationsAccessReport"
+
+// GetOrganizationsAccessReportRequest generates a "aws/request.Request" representing the
+// client's request for the GetOrganizationsAccessReport operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetOrganizationsAccessReport for more information on using the GetOrganizationsAccessReport
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetOrganizationsAccessReportRequest method.
+//    req, resp := client.GetOrganizationsAccessReportRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetOrganizationsAccessReport
+func (c *IAM) GetOrganizationsAccessReportRequest(input *GetOrganizationsAccessReportInput) (req *request.Request, output *GetOrganizationsAccessReportOutput) {
+	op := &request.Operation{
+		Name:       opGetOrganizationsAccessReport,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetOrganizationsAccessReportInput{}
+	}
+
+	output = &GetOrganizationsAccessReportOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetOrganizationsAccessReport API operation for AWS Identity and Access Management.
+//
+// Retrieves the service last accessed data report for AWS Organizations that
+// was previously generated using the GenerateOrganizationsAccessReport operation.
+// This operation retrieves the status of your report job and the report contents.
+//
+// Depending on the parameters that you passed when you generated the report,
+// the data returned could include different information. For details, see GenerateOrganizationsAccessReport.
+//
+// To call this operation, you must be signed in to the master account in your
+// organization. SCPs must be enabled for your organization root. You must have
+// permissions to perform this operation. For more information, see Refining
+// Permissions Using Service Last Accessed Data (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html)
+// in the IAM User Guide.
+//
+// For each service that principals in an account (root users, IAM users, or
+// IAM roles) could access using SCPs, the operation returns details about the
+// most recent access attempt. If there was no attempt, the service is listed
+// without details about the most recent attempt to access the service. If the
+// operation fails, it returns the reason that it failed.
+//
+// By default, the list is sorted by service namespace.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetOrganizationsAccessReport for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetOrganizationsAccessReport
+func (c *IAM) GetOrganizationsAccessReport(input *GetOrganizationsAccessReportInput) (*GetOrganizationsAccessReportOutput, error) {
+	req, out := c.GetOrganizationsAccessReportRequest(input)
+	return out, req.Send()
+}
+
+// GetOrganizationsAccessReportWithContext is the same as GetOrganizationsAccessReport with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetOrganizationsAccessReport for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetOrganizationsAccessReportWithContext(ctx aws.Context, input *GetOrganizationsAccessReportInput, opts ...request.Option) (*GetOrganizationsAccessReportOutput, error) {
+	req, out := c.GetOrganizationsAccessReportRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetPolicy = "GetPolicy"
+
+// GetPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the GetPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetPolicy for more information on using the GetPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetPolicyRequest method.
+//    req, resp := client.GetPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetPolicy
+func (c *IAM) GetPolicyRequest(input *GetPolicyInput) (req *request.Request, output *GetPolicyOutput) {
+	op := &request.Operation{
+		Name:       opGetPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetPolicyInput{}
+	}
+
+	output = &GetPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetPolicy API operation for AWS Identity and Access Management.
+//
+// Retrieves information about the specified managed policy, including the policy's
+// default version and the total number of IAM users, groups, and roles to which
+// the policy is attached. To retrieve the list of the specific users, groups,
+// and roles that the policy is attached to, use the ListEntitiesForPolicy API.
+// This API returns metadata about the policy. To retrieve the actual policy
+// document for a specific version of the policy, use GetPolicyVersion.
+//
+// This API retrieves information about managed policies. To retrieve information
+// about an inline policy that is embedded with an IAM user, group, or role,
+// use the GetUserPolicy, GetGroupPolicy, or GetRolePolicy API.
+//
+// For more information about policies, see Managed Policies and Inline Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetPolicy
+func (c *IAM) GetPolicy(input *GetPolicyInput) (*GetPolicyOutput, error) {
+	req, out := c.GetPolicyRequest(input)
+	return out, req.Send()
+}
+
+// GetPolicyWithContext is the same as GetPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetPolicyWithContext(ctx aws.Context, input *GetPolicyInput, opts ...request.Option) (*GetPolicyOutput, error) {
+	req, out := c.GetPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetPolicyVersion = "GetPolicyVersion"
+
+// GetPolicyVersionRequest generates a "aws/request.Request" representing the
+// client's request for the GetPolicyVersion operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetPolicyVersion for more information on using the GetPolicyVersion
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetPolicyVersionRequest method.
+//    req, resp := client.GetPolicyVersionRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetPolicyVersion
+func (c *IAM) GetPolicyVersionRequest(input *GetPolicyVersionInput) (req *request.Request, output *GetPolicyVersionOutput) {
+	op := &request.Operation{
+		Name:       opGetPolicyVersion,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetPolicyVersionInput{}
+	}
+
+	output = &GetPolicyVersionOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetPolicyVersion API operation for AWS Identity and Access Management.
+//
+// Retrieves information about the specified version of the specified managed
+// policy, including the policy document.
+//
+// Policies returned by this API are URL-encoded compliant with RFC 3986 (https://tools.ietf.org/html/rfc3986).
+// You can use a URL decoding method to convert the policy back to plain JSON
+// text. For example, if you use Java, you can use the decode method of the
+// java.net.URLDecoder utility class in the Java SDK. Other languages and SDKs
+// provide similar functionality.
+//
+// To list the available versions for a policy, use ListPolicyVersions.
+//
+// This API retrieves information about managed policies. To retrieve information
+// about an inline policy that is embedded in a user, group, or role, use the
+// GetUserPolicy, GetGroupPolicy, or GetRolePolicy API.
+//
+// For more information about the types of policies, see Managed Policies and
+// Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// For more information about managed policy versions, see Versioning for Managed
+// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetPolicyVersion for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetPolicyVersion
+func (c *IAM) GetPolicyVersion(input *GetPolicyVersionInput) (*GetPolicyVersionOutput, error) {
+	req, out := c.GetPolicyVersionRequest(input)
+	return out, req.Send()
+}
+
+// GetPolicyVersionWithContext is the same as GetPolicyVersion with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetPolicyVersion for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetPolicyVersionWithContext(ctx aws.Context, input *GetPolicyVersionInput, opts ...request.Option) (*GetPolicyVersionOutput, error) {
+	req, out := c.GetPolicyVersionRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetRole = "GetRole"
+
+// GetRoleRequest generates a "aws/request.Request" representing the
+// client's request for the GetRole operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetRole for more information on using the GetRole
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetRoleRequest method.
+//    req, resp := client.GetRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetRole
+func (c *IAM) GetRoleRequest(input *GetRoleInput) (req *request.Request, output *GetRoleOutput) {
+	op := &request.Operation{
+		Name:       opGetRole,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetRoleInput{}
+	}
+
+	output = &GetRoleOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetRole API operation for AWS Identity and Access Management.
+//
+// Retrieves information about the specified role, including the role's path,
+// GUID, ARN, and the role's trust policy that grants permission to assume the
+// role. For more information about roles, see Working with Roles (https://docs.aws.amazon.com/IAM/latest/UserGuide/WorkingWithRoles.html).
+//
+// Policies returned by this API are URL-encoded compliant with RFC 3986 (https://tools.ietf.org/html/rfc3986).
+// You can use a URL decoding method to convert the policy back to plain JSON
+// text. For example, if you use Java, you can use the decode method of the
+// java.net.URLDecoder utility class in the Java SDK. Other languages and SDKs
+// provide similar functionality.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetRole
+func (c *IAM) GetRole(input *GetRoleInput) (*GetRoleOutput, error) {
+	req, out := c.GetRoleRequest(input)
+	return out, req.Send()
+}
+
+// GetRoleWithContext is the same as GetRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetRoleWithContext(ctx aws.Context, input *GetRoleInput, opts ...request.Option) (*GetRoleOutput, error) {
+	req, out := c.GetRoleRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetRolePolicy = "GetRolePolicy"
+
+// GetRolePolicyRequest generates a "aws/request.Request" representing the
+// client's request for the GetRolePolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetRolePolicy for more information on using the GetRolePolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetRolePolicyRequest method.
+//    req, resp := client.GetRolePolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetRolePolicy
+func (c *IAM) GetRolePolicyRequest(input *GetRolePolicyInput) (req *request.Request, output *GetRolePolicyOutput) {
+	op := &request.Operation{
+		Name:       opGetRolePolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetRolePolicyInput{}
+	}
+
+	output = &GetRolePolicyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetRolePolicy API operation for AWS Identity and Access Management.
+//
+// Retrieves the specified inline policy document that is embedded with the
+// specified IAM role.
+//
+// Policies returned by this API are URL-encoded compliant with RFC 3986 (https://tools.ietf.org/html/rfc3986).
+// You can use a URL decoding method to convert the policy back to plain JSON
+// text. For example, if you use Java, you can use the decode method of the
+// java.net.URLDecoder utility class in the Java SDK. Other languages and SDKs
+// provide similar functionality.
+//
+// An IAM role can also have managed policies attached to it. To retrieve a
+// managed policy document that is attached to a role, use GetPolicy to determine
+// the policy's default version, then use GetPolicyVersion to retrieve the policy
+// document.
+//
+// For more information about policies, see Managed Policies and Inline Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// For more information about roles, see Using Roles to Delegate Permissions
+// and Federate Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-toplevel.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetRolePolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetRolePolicy
+func (c *IAM) GetRolePolicy(input *GetRolePolicyInput) (*GetRolePolicyOutput, error) {
+	req, out := c.GetRolePolicyRequest(input)
+	return out, req.Send()
+}
+
+// GetRolePolicyWithContext is the same as GetRolePolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetRolePolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetRolePolicyWithContext(ctx aws.Context, input *GetRolePolicyInput, opts ...request.Option) (*GetRolePolicyOutput, error) {
+	req, out := c.GetRolePolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetSAMLProvider = "GetSAMLProvider"
+
+// GetSAMLProviderRequest generates a "aws/request.Request" representing the
+// client's request for the GetSAMLProvider operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetSAMLProvider for more information on using the GetSAMLProvider
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetSAMLProviderRequest method.
+//    req, resp := client.GetSAMLProviderRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetSAMLProvider
+func (c *IAM) GetSAMLProviderRequest(input *GetSAMLProviderInput) (req *request.Request, output *GetSAMLProviderOutput) {
+	op := &request.Operation{
+		Name:       opGetSAMLProvider,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetSAMLProviderInput{}
+	}
+
+	output = &GetSAMLProviderOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetSAMLProvider API operation for AWS Identity and Access Management.
+//
+// Returns the SAML provider metadocument that was uploaded when the IAM SAML
+// provider resource object was created or updated.
+//
+// This operation requires Signature Version 4 (https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetSAMLProvider for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetSAMLProvider
+func (c *IAM) GetSAMLProvider(input *GetSAMLProviderInput) (*GetSAMLProviderOutput, error) {
+	req, out := c.GetSAMLProviderRequest(input)
+	return out, req.Send()
+}
+
+// GetSAMLProviderWithContext is the same as GetSAMLProvider with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetSAMLProvider for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetSAMLProviderWithContext(ctx aws.Context, input *GetSAMLProviderInput, opts ...request.Option) (*GetSAMLProviderOutput, error) {
+	req, out := c.GetSAMLProviderRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetSSHPublicKey = "GetSSHPublicKey"
+
+// GetSSHPublicKeyRequest generates a "aws/request.Request" representing the
+// client's request for the GetSSHPublicKey operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetSSHPublicKey for more information on using the GetSSHPublicKey
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetSSHPublicKeyRequest method.
+//    req, resp := client.GetSSHPublicKeyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetSSHPublicKey
+func (c *IAM) GetSSHPublicKeyRequest(input *GetSSHPublicKeyInput) (req *request.Request, output *GetSSHPublicKeyOutput) {
+	op := &request.Operation{
+		Name:       opGetSSHPublicKey,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetSSHPublicKeyInput{}
+	}
+
+	output = &GetSSHPublicKeyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetSSHPublicKey API operation for AWS Identity and Access Management.
+//
+// Retrieves the specified SSH public key, including metadata about the key.
+//
+// The SSH public key retrieved by this operation is used only for authenticating
+// the associated IAM user to an AWS CodeCommit repository. For more information
+// about using SSH keys to authenticate to an AWS CodeCommit repository, see
+// Set up AWS CodeCommit for SSH Connections (https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html)
+// in the AWS CodeCommit User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetSSHPublicKey for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeUnrecognizedPublicKeyEncodingException "UnrecognizedPublicKeyEncoding"
+//   The request was rejected because the public key encoding format is unsupported
+//   or unrecognized.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetSSHPublicKey
+func (c *IAM) GetSSHPublicKey(input *GetSSHPublicKeyInput) (*GetSSHPublicKeyOutput, error) {
+	req, out := c.GetSSHPublicKeyRequest(input)
+	return out, req.Send()
+}
+
+// GetSSHPublicKeyWithContext is the same as GetSSHPublicKey with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetSSHPublicKey for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetSSHPublicKeyWithContext(ctx aws.Context, input *GetSSHPublicKeyInput, opts ...request.Option) (*GetSSHPublicKeyOutput, error) {
+	req, out := c.GetSSHPublicKeyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetServerCertificate = "GetServerCertificate"
+
+// GetServerCertificateRequest generates a "aws/request.Request" representing the
+// client's request for the GetServerCertificate operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetServerCertificate for more information on using the GetServerCertificate
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetServerCertificateRequest method.
+//    req, resp := client.GetServerCertificateRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServerCertificate
+func (c *IAM) GetServerCertificateRequest(input *GetServerCertificateInput) (req *request.Request, output *GetServerCertificateOutput) {
+	op := &request.Operation{
+		Name:       opGetServerCertificate,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetServerCertificateInput{}
+	}
+
+	output = &GetServerCertificateOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetServerCertificate API operation for AWS Identity and Access Management.
+//
+// Retrieves information about the specified server certificate stored in IAM.
+//
+// For more information about working with server certificates, see Working
+// with Server Certificates (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html)
+// in the IAM User Guide. This topic includes a list of AWS services that can
+// use the server certificates that you manage with IAM.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetServerCertificate for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServerCertificate
+func (c *IAM) GetServerCertificate(input *GetServerCertificateInput) (*GetServerCertificateOutput, error) {
+	req, out := c.GetServerCertificateRequest(input)
+	return out, req.Send()
+}
+
+// GetServerCertificateWithContext is the same as GetServerCertificate with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetServerCertificate for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetServerCertificateWithContext(ctx aws.Context, input *GetServerCertificateInput, opts ...request.Option) (*GetServerCertificateOutput, error) {
+	req, out := c.GetServerCertificateRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetServiceLastAccessedDetails = "GetServiceLastAccessedDetails"
+
+// GetServiceLastAccessedDetailsRequest generates a "aws/request.Request" representing the
+// client's request for the GetServiceLastAccessedDetails operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetServiceLastAccessedDetails for more information on using the GetServiceLastAccessedDetails
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetServiceLastAccessedDetailsRequest method.
+//    req, resp := client.GetServiceLastAccessedDetailsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServiceLastAccessedDetails
+func (c *IAM) GetServiceLastAccessedDetailsRequest(input *GetServiceLastAccessedDetailsInput) (req *request.Request, output *GetServiceLastAccessedDetailsOutput) {
+	op := &request.Operation{
+		Name:       opGetServiceLastAccessedDetails,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetServiceLastAccessedDetailsInput{}
+	}
+
+	output = &GetServiceLastAccessedDetailsOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetServiceLastAccessedDetails API operation for AWS Identity and Access Management.
+//
+// Retrieves a service last accessed report that was created using the GenerateServiceLastAccessedDetails
+// operation. You can use the JobId parameter in GetServiceLastAccessedDetails
+// to retrieve the status of your report job. When the report is complete, you
+// can retrieve the generated report. The report includes a list of AWS services
+// that the resource (user, group, role, or managed policy) can access.
+//
+// Service last accessed data does not use other policy types when determining
+// whether a resource could access a service. These other policy types include
+// resource-based policies, access control lists, AWS Organizations policies,
+// IAM permissions boundaries, and AWS STS assume role policies. It only applies
+// permissions policy logic. For more about the evaluation of policy types,
+// see Evaluating Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics)
+// in the IAM User Guide.
+//
+// For each service that the resource could access using permissions policies,
+// the operation returns details about the most recent access attempt. If there
+// was no attempt, the service is listed without details about the most recent
+// attempt to access the service. If the operation fails, the GetServiceLastAccessedDetails
+// operation returns the reason that it failed.
+//
+// The GetServiceLastAccessedDetails operation returns a list of services. This
+// list includes the number of entities that have attempted to access the service
+// and the date and time of the last attempt. It also returns the ARN of the
+// following entity, depending on the resource ARN that you used to generate
+// the report:
+//
+//    * User – Returns the user ARN that you used to generate the report
+//
+//    * Group – Returns the ARN of the group member (user) that last attempted
+//    to access the service
+//
+//    * Role – Returns the role ARN that you used to generate the report
+//
+//    * Policy – Returns the ARN of the user or role that last used the policy
+//    to attempt to access the service
+//
+// By default, the list is sorted by service namespace.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetServiceLastAccessedDetails for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServiceLastAccessedDetails
+func (c *IAM) GetServiceLastAccessedDetails(input *GetServiceLastAccessedDetailsInput) (*GetServiceLastAccessedDetailsOutput, error) {
+	req, out := c.GetServiceLastAccessedDetailsRequest(input)
+	return out, req.Send()
+}
+
+// GetServiceLastAccessedDetailsWithContext is the same as GetServiceLastAccessedDetails with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetServiceLastAccessedDetails for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetServiceLastAccessedDetailsWithContext(ctx aws.Context, input *GetServiceLastAccessedDetailsInput, opts ...request.Option) (*GetServiceLastAccessedDetailsOutput, error) {
+	req, out := c.GetServiceLastAccessedDetailsRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetServiceLastAccessedDetailsWithEntities = "GetServiceLastAccessedDetailsWithEntities"
+
+// GetServiceLastAccessedDetailsWithEntitiesRequest generates a "aws/request.Request" representing the
+// client's request for the GetServiceLastAccessedDetailsWithEntities operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetServiceLastAccessedDetailsWithEntities for more information on using the GetServiceLastAccessedDetailsWithEntities
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetServiceLastAccessedDetailsWithEntitiesRequest method.
+//    req, resp := client.GetServiceLastAccessedDetailsWithEntitiesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServiceLastAccessedDetailsWithEntities
+func (c *IAM) GetServiceLastAccessedDetailsWithEntitiesRequest(input *GetServiceLastAccessedDetailsWithEntitiesInput) (req *request.Request, output *GetServiceLastAccessedDetailsWithEntitiesOutput) {
+	op := &request.Operation{
+		Name:       opGetServiceLastAccessedDetailsWithEntities,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetServiceLastAccessedDetailsWithEntitiesInput{}
+	}
+
+	output = &GetServiceLastAccessedDetailsWithEntitiesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetServiceLastAccessedDetailsWithEntities API operation for AWS Identity and Access Management.
+//
+// After you generate a group or policy report using the GenerateServiceLastAccessedDetails
+// operation, you can use the JobId parameter in GetServiceLastAccessedDetailsWithEntities.
+// This operation retrieves the status of your report job and a list of entities
+// that could have used group or policy permissions to access the specified
+// service.
+//
+//    * Group – For a group report, this operation returns a list of users
+//    in the group that could have used the group’s policies in an attempt
+//    to access the service.
+//
+//    * Policy – For a policy report, this operation returns a list of entities
+//    (users or roles) that could have used the policy in an attempt to access
+//    the service.
+//
+// You can also use this operation for user or role reports to retrieve details
+// about those entities.
+//
+// If the operation fails, the GetServiceLastAccessedDetailsWithEntities operation
+// returns the reason that it failed.
+//
+// By default, the list of associated entities is sorted by date, with the most
+// recent access listed first.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetServiceLastAccessedDetailsWithEntities for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServiceLastAccessedDetailsWithEntities
+func (c *IAM) GetServiceLastAccessedDetailsWithEntities(input *GetServiceLastAccessedDetailsWithEntitiesInput) (*GetServiceLastAccessedDetailsWithEntitiesOutput, error) {
+	req, out := c.GetServiceLastAccessedDetailsWithEntitiesRequest(input)
+	return out, req.Send()
+}
+
+// GetServiceLastAccessedDetailsWithEntitiesWithContext is the same as GetServiceLastAccessedDetailsWithEntities with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetServiceLastAccessedDetailsWithEntities for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetServiceLastAccessedDetailsWithEntitiesWithContext(ctx aws.Context, input *GetServiceLastAccessedDetailsWithEntitiesInput, opts ...request.Option) (*GetServiceLastAccessedDetailsWithEntitiesOutput, error) {
+	req, out := c.GetServiceLastAccessedDetailsWithEntitiesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetServiceLinkedRoleDeletionStatus = "GetServiceLinkedRoleDeletionStatus"
+
+// GetServiceLinkedRoleDeletionStatusRequest generates a "aws/request.Request" representing the
+// client's request for the GetServiceLinkedRoleDeletionStatus operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetServiceLinkedRoleDeletionStatus for more information on using the GetServiceLinkedRoleDeletionStatus
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetServiceLinkedRoleDeletionStatusRequest method.
+//    req, resp := client.GetServiceLinkedRoleDeletionStatusRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServiceLinkedRoleDeletionStatus
+func (c *IAM) GetServiceLinkedRoleDeletionStatusRequest(input *GetServiceLinkedRoleDeletionStatusInput) (req *request.Request, output *GetServiceLinkedRoleDeletionStatusOutput) {
+	op := &request.Operation{
+		Name:       opGetServiceLinkedRoleDeletionStatus,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetServiceLinkedRoleDeletionStatusInput{}
+	}
+
+	output = &GetServiceLinkedRoleDeletionStatusOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetServiceLinkedRoleDeletionStatus API operation for AWS Identity and Access Management.
+//
+// Retrieves the status of your service-linked role deletion. After you use
+// the DeleteServiceLinkedRole API operation to submit a service-linked role
+// for deletion, you can use the DeletionTaskId parameter in GetServiceLinkedRoleDeletionStatus
+// to check the status of the deletion. If the deletion fails, this operation
+// returns the reason that it failed, if that information is returned by the
+// service.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetServiceLinkedRoleDeletionStatus for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetServiceLinkedRoleDeletionStatus
+func (c *IAM) GetServiceLinkedRoleDeletionStatus(input *GetServiceLinkedRoleDeletionStatusInput) (*GetServiceLinkedRoleDeletionStatusOutput, error) {
+	req, out := c.GetServiceLinkedRoleDeletionStatusRequest(input)
+	return out, req.Send()
+}
+
+// GetServiceLinkedRoleDeletionStatusWithContext is the same as GetServiceLinkedRoleDeletionStatus with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetServiceLinkedRoleDeletionStatus for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetServiceLinkedRoleDeletionStatusWithContext(ctx aws.Context, input *GetServiceLinkedRoleDeletionStatusInput, opts ...request.Option) (*GetServiceLinkedRoleDeletionStatusOutput, error) {
+	req, out := c.GetServiceLinkedRoleDeletionStatusRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetUser = "GetUser"
+
+// GetUserRequest generates a "aws/request.Request" representing the
+// client's request for the GetUser operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetUser for more information on using the GetUser
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetUserRequest method.
+//    req, resp := client.GetUserRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetUser
+func (c *IAM) GetUserRequest(input *GetUserInput) (req *request.Request, output *GetUserOutput) {
+	op := &request.Operation{
+		Name:       opGetUser,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetUserInput{}
+	}
+
+	output = &GetUserOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetUser API operation for AWS Identity and Access Management.
+//
+// Retrieves information about the specified IAM user, including the user's
+// creation date, path, unique ID, and ARN.
+//
+// If you do not specify a user name, IAM determines the user name implicitly
+// based on the AWS access key ID used to sign the request to this API.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetUser for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetUser
+func (c *IAM) GetUser(input *GetUserInput) (*GetUserOutput, error) {
+	req, out := c.GetUserRequest(input)
+	return out, req.Send()
+}
+
+// GetUserWithContext is the same as GetUser with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetUser for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetUserWithContext(ctx aws.Context, input *GetUserInput, opts ...request.Option) (*GetUserOutput, error) {
+	req, out := c.GetUserRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opGetUserPolicy = "GetUserPolicy"
+
+// GetUserPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the GetUserPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See GetUserPolicy for more information on using the GetUserPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the GetUserPolicyRequest method.
+//    req, resp := client.GetUserPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetUserPolicy
+func (c *IAM) GetUserPolicyRequest(input *GetUserPolicyInput) (req *request.Request, output *GetUserPolicyOutput) {
+	op := &request.Operation{
+		Name:       opGetUserPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &GetUserPolicyInput{}
+	}
+
+	output = &GetUserPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// GetUserPolicy API operation for AWS Identity and Access Management.
+//
+// Retrieves the specified inline policy document that is embedded in the specified
+// IAM user.
+//
+// Policies returned by this API are URL-encoded compliant with RFC 3986 (https://tools.ietf.org/html/rfc3986).
+// You can use a URL decoding method to convert the policy back to plain JSON
+// text. For example, if you use Java, you can use the decode method of the
+// java.net.URLDecoder utility class in the Java SDK. Other languages and SDKs
+// provide similar functionality.
+//
+// An IAM user can also have managed policies attached to it. To retrieve a
+// managed policy document that is attached to a user, use GetPolicy to determine
+// the policy's default version. Then use GetPolicyVersion to retrieve the policy
+// document.
+//
+// For more information about policies, see Managed Policies and Inline Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation GetUserPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/GetUserPolicy
+func (c *IAM) GetUserPolicy(input *GetUserPolicyInput) (*GetUserPolicyOutput, error) {
+	req, out := c.GetUserPolicyRequest(input)
+	return out, req.Send()
+}
+
+// GetUserPolicyWithContext is the same as GetUserPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See GetUserPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) GetUserPolicyWithContext(ctx aws.Context, input *GetUserPolicyInput, opts ...request.Option) (*GetUserPolicyOutput, error) {
+	req, out := c.GetUserPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opListAccessKeys = "ListAccessKeys"
+
+// ListAccessKeysRequest generates a "aws/request.Request" representing the
+// client's request for the ListAccessKeys operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListAccessKeys for more information on using the ListAccessKeys
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListAccessKeysRequest method.
+//    req, resp := client.ListAccessKeysRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAccessKeys
+func (c *IAM) ListAccessKeysRequest(input *ListAccessKeysInput) (req *request.Request, output *ListAccessKeysOutput) {
+	op := &request.Operation{
+		Name:       opListAccessKeys,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListAccessKeysInput{}
+	}
+
+	output = &ListAccessKeysOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListAccessKeys API operation for AWS Identity and Access Management.
+//
+// Returns information about the access key IDs associated with the specified
+// IAM user. If there is none, the operation returns an empty list.
+//
+// Although each user is limited to a small number of keys, you can still paginate
+// the results using the MaxItems and Marker parameters.
+//
+// If the UserName field is not specified, the user name is determined implicitly
+// based on the AWS access key ID used to sign the request. This operation works
+// for access keys under the AWS account. Consequently, you can use this operation
+// to manage AWS account root user credentials even if the AWS account has no
+// associated users.
+//
+// To ensure the security of your AWS account, the secret access key is accessible
+// only during key and user creation.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListAccessKeys for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAccessKeys
+func (c *IAM) ListAccessKeys(input *ListAccessKeysInput) (*ListAccessKeysOutput, error) {
+	req, out := c.ListAccessKeysRequest(input)
+	return out, req.Send()
+}
+
+// ListAccessKeysWithContext is the same as ListAccessKeys with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListAccessKeys for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAccessKeysWithContext(ctx aws.Context, input *ListAccessKeysInput, opts ...request.Option) (*ListAccessKeysOutput, error) {
+	req, out := c.ListAccessKeysRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListAccessKeysPages iterates over the pages of a ListAccessKeys operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListAccessKeys method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListAccessKeys operation.
+//    pageNum := 0
+//    err := client.ListAccessKeysPages(params,
+//        func(page *iam.ListAccessKeysOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListAccessKeysPages(input *ListAccessKeysInput, fn func(*ListAccessKeysOutput, bool) bool) error {
+	return c.ListAccessKeysPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListAccessKeysPagesWithContext same as ListAccessKeysPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAccessKeysPagesWithContext(ctx aws.Context, input *ListAccessKeysInput, fn func(*ListAccessKeysOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListAccessKeysInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListAccessKeysRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListAccessKeysOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListAccountAliases = "ListAccountAliases"
+
+// ListAccountAliasesRequest generates a "aws/request.Request" representing the
+// client's request for the ListAccountAliases operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListAccountAliases for more information on using the ListAccountAliases
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListAccountAliasesRequest method.
+//    req, resp := client.ListAccountAliasesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAccountAliases
+func (c *IAM) ListAccountAliasesRequest(input *ListAccountAliasesInput) (req *request.Request, output *ListAccountAliasesOutput) {
+	op := &request.Operation{
+		Name:       opListAccountAliases,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListAccountAliasesInput{}
+	}
+
+	output = &ListAccountAliasesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListAccountAliases API operation for AWS Identity and Access Management.
+//
+// Lists the account alias associated with the AWS account (Note: you can have
+// only one). For information about using an AWS account alias, see Using an
+// Alias for Your AWS Account ID (https://docs.aws.amazon.com/IAM/latest/UserGuide/AccountAlias.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListAccountAliases for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAccountAliases
+func (c *IAM) ListAccountAliases(input *ListAccountAliasesInput) (*ListAccountAliasesOutput, error) {
+	req, out := c.ListAccountAliasesRequest(input)
+	return out, req.Send()
+}
+
+// ListAccountAliasesWithContext is the same as ListAccountAliases with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListAccountAliases for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAccountAliasesWithContext(ctx aws.Context, input *ListAccountAliasesInput, opts ...request.Option) (*ListAccountAliasesOutput, error) {
+	req, out := c.ListAccountAliasesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListAccountAliasesPages iterates over the pages of a ListAccountAliases operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListAccountAliases method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListAccountAliases operation.
+//    pageNum := 0
+//    err := client.ListAccountAliasesPages(params,
+//        func(page *iam.ListAccountAliasesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListAccountAliasesPages(input *ListAccountAliasesInput, fn func(*ListAccountAliasesOutput, bool) bool) error {
+	return c.ListAccountAliasesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListAccountAliasesPagesWithContext same as ListAccountAliasesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAccountAliasesPagesWithContext(ctx aws.Context, input *ListAccountAliasesInput, fn func(*ListAccountAliasesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListAccountAliasesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListAccountAliasesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListAccountAliasesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListAttachedGroupPolicies = "ListAttachedGroupPolicies"
+
+// ListAttachedGroupPoliciesRequest generates a "aws/request.Request" representing the
+// client's request for the ListAttachedGroupPolicies operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListAttachedGroupPolicies for more information on using the ListAttachedGroupPolicies
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListAttachedGroupPoliciesRequest method.
+//    req, resp := client.ListAttachedGroupPoliciesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAttachedGroupPolicies
+func (c *IAM) ListAttachedGroupPoliciesRequest(input *ListAttachedGroupPoliciesInput) (req *request.Request, output *ListAttachedGroupPoliciesOutput) {
+	op := &request.Operation{
+		Name:       opListAttachedGroupPolicies,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListAttachedGroupPoliciesInput{}
+	}
+
+	output = &ListAttachedGroupPoliciesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListAttachedGroupPolicies API operation for AWS Identity and Access Management.
+//
+// Lists all managed policies that are attached to the specified IAM group.
+//
+// An IAM group can also have inline policies embedded with it. To list the
+// inline policies for a group, use the ListGroupPolicies API. For information
+// about policies, see Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// You can paginate the results using the MaxItems and Marker parameters. You
+// can use the PathPrefix parameter to limit the list of policies to only those
+// matching the specified path prefix. If there are no policies attached to
+// the specified group (or none that match the specified path prefix), the operation
+// returns an empty list.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListAttachedGroupPolicies for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAttachedGroupPolicies
+func (c *IAM) ListAttachedGroupPolicies(input *ListAttachedGroupPoliciesInput) (*ListAttachedGroupPoliciesOutput, error) {
+	req, out := c.ListAttachedGroupPoliciesRequest(input)
+	return out, req.Send()
+}
+
+// ListAttachedGroupPoliciesWithContext is the same as ListAttachedGroupPolicies with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListAttachedGroupPolicies for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAttachedGroupPoliciesWithContext(ctx aws.Context, input *ListAttachedGroupPoliciesInput, opts ...request.Option) (*ListAttachedGroupPoliciesOutput, error) {
+	req, out := c.ListAttachedGroupPoliciesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListAttachedGroupPoliciesPages iterates over the pages of a ListAttachedGroupPolicies operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListAttachedGroupPolicies method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListAttachedGroupPolicies operation.
+//    pageNum := 0
+//    err := client.ListAttachedGroupPoliciesPages(params,
+//        func(page *iam.ListAttachedGroupPoliciesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListAttachedGroupPoliciesPages(input *ListAttachedGroupPoliciesInput, fn func(*ListAttachedGroupPoliciesOutput, bool) bool) error {
+	return c.ListAttachedGroupPoliciesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListAttachedGroupPoliciesPagesWithContext same as ListAttachedGroupPoliciesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAttachedGroupPoliciesPagesWithContext(ctx aws.Context, input *ListAttachedGroupPoliciesInput, fn func(*ListAttachedGroupPoliciesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListAttachedGroupPoliciesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListAttachedGroupPoliciesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListAttachedGroupPoliciesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListAttachedRolePolicies = "ListAttachedRolePolicies"
+
+// ListAttachedRolePoliciesRequest generates a "aws/request.Request" representing the
+// client's request for the ListAttachedRolePolicies operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListAttachedRolePolicies for more information on using the ListAttachedRolePolicies
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListAttachedRolePoliciesRequest method.
+//    req, resp := client.ListAttachedRolePoliciesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAttachedRolePolicies
+func (c *IAM) ListAttachedRolePoliciesRequest(input *ListAttachedRolePoliciesInput) (req *request.Request, output *ListAttachedRolePoliciesOutput) {
+	op := &request.Operation{
+		Name:       opListAttachedRolePolicies,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListAttachedRolePoliciesInput{}
+	}
+
+	output = &ListAttachedRolePoliciesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListAttachedRolePolicies API operation for AWS Identity and Access Management.
+//
+// Lists all managed policies that are attached to the specified IAM role.
+//
+// An IAM role can also have inline policies embedded with it. To list the inline
+// policies for a role, use the ListRolePolicies API. For information about
+// policies, see Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// You can paginate the results using the MaxItems and Marker parameters. You
+// can use the PathPrefix parameter to limit the list of policies to only those
+// matching the specified path prefix. If there are no policies attached to
+// the specified role (or none that match the specified path prefix), the operation
+// returns an empty list.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListAttachedRolePolicies for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAttachedRolePolicies
+func (c *IAM) ListAttachedRolePolicies(input *ListAttachedRolePoliciesInput) (*ListAttachedRolePoliciesOutput, error) {
+	req, out := c.ListAttachedRolePoliciesRequest(input)
+	return out, req.Send()
+}
+
+// ListAttachedRolePoliciesWithContext is the same as ListAttachedRolePolicies with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListAttachedRolePolicies for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAttachedRolePoliciesWithContext(ctx aws.Context, input *ListAttachedRolePoliciesInput, opts ...request.Option) (*ListAttachedRolePoliciesOutput, error) {
+	req, out := c.ListAttachedRolePoliciesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListAttachedRolePoliciesPages iterates over the pages of a ListAttachedRolePolicies operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListAttachedRolePolicies method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListAttachedRolePolicies operation.
+//    pageNum := 0
+//    err := client.ListAttachedRolePoliciesPages(params,
+//        func(page *iam.ListAttachedRolePoliciesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListAttachedRolePoliciesPages(input *ListAttachedRolePoliciesInput, fn func(*ListAttachedRolePoliciesOutput, bool) bool) error {
+	return c.ListAttachedRolePoliciesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListAttachedRolePoliciesPagesWithContext same as ListAttachedRolePoliciesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAttachedRolePoliciesPagesWithContext(ctx aws.Context, input *ListAttachedRolePoliciesInput, fn func(*ListAttachedRolePoliciesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListAttachedRolePoliciesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListAttachedRolePoliciesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListAttachedRolePoliciesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListAttachedUserPolicies = "ListAttachedUserPolicies"
+
+// ListAttachedUserPoliciesRequest generates a "aws/request.Request" representing the
+// client's request for the ListAttachedUserPolicies operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListAttachedUserPolicies for more information on using the ListAttachedUserPolicies
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListAttachedUserPoliciesRequest method.
+//    req, resp := client.ListAttachedUserPoliciesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAttachedUserPolicies
+func (c *IAM) ListAttachedUserPoliciesRequest(input *ListAttachedUserPoliciesInput) (req *request.Request, output *ListAttachedUserPoliciesOutput) {
+	op := &request.Operation{
+		Name:       opListAttachedUserPolicies,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListAttachedUserPoliciesInput{}
+	}
+
+	output = &ListAttachedUserPoliciesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListAttachedUserPolicies API operation for AWS Identity and Access Management.
+//
+// Lists all managed policies that are attached to the specified IAM user.
+//
+// An IAM user can also have inline policies embedded with it. To list the inline
+// policies for a user, use the ListUserPolicies API. For information about
+// policies, see Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// You can paginate the results using the MaxItems and Marker parameters. You
+// can use the PathPrefix parameter to limit the list of policies to only those
+// matching the specified path prefix. If there are no policies attached to
+// the specified group (or none that match the specified path prefix), the operation
+// returns an empty list.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListAttachedUserPolicies for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListAttachedUserPolicies
+func (c *IAM) ListAttachedUserPolicies(input *ListAttachedUserPoliciesInput) (*ListAttachedUserPoliciesOutput, error) {
+	req, out := c.ListAttachedUserPoliciesRequest(input)
+	return out, req.Send()
+}
+
+// ListAttachedUserPoliciesWithContext is the same as ListAttachedUserPolicies with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListAttachedUserPolicies for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAttachedUserPoliciesWithContext(ctx aws.Context, input *ListAttachedUserPoliciesInput, opts ...request.Option) (*ListAttachedUserPoliciesOutput, error) {
+	req, out := c.ListAttachedUserPoliciesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListAttachedUserPoliciesPages iterates over the pages of a ListAttachedUserPolicies operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListAttachedUserPolicies method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListAttachedUserPolicies operation.
+//    pageNum := 0
+//    err := client.ListAttachedUserPoliciesPages(params,
+//        func(page *iam.ListAttachedUserPoliciesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListAttachedUserPoliciesPages(input *ListAttachedUserPoliciesInput, fn func(*ListAttachedUserPoliciesOutput, bool) bool) error {
+	return c.ListAttachedUserPoliciesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListAttachedUserPoliciesPagesWithContext same as ListAttachedUserPoliciesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListAttachedUserPoliciesPagesWithContext(ctx aws.Context, input *ListAttachedUserPoliciesInput, fn func(*ListAttachedUserPoliciesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListAttachedUserPoliciesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListAttachedUserPoliciesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListAttachedUserPoliciesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListEntitiesForPolicy = "ListEntitiesForPolicy"
+
+// ListEntitiesForPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the ListEntitiesForPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListEntitiesForPolicy for more information on using the ListEntitiesForPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListEntitiesForPolicyRequest method.
+//    req, resp := client.ListEntitiesForPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListEntitiesForPolicy
+func (c *IAM) ListEntitiesForPolicyRequest(input *ListEntitiesForPolicyInput) (req *request.Request, output *ListEntitiesForPolicyOutput) {
+	op := &request.Operation{
+		Name:       opListEntitiesForPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListEntitiesForPolicyInput{}
+	}
+
+	output = &ListEntitiesForPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListEntitiesForPolicy API operation for AWS Identity and Access Management.
+//
+// Lists all IAM users, groups, and roles that the specified managed policy
+// is attached to.
+//
+// You can use the optional EntityFilter parameter to limit the results to a
+// particular type of entity (users, groups, or roles). For example, to list
+// only the roles that are attached to the specified policy, set EntityFilter
+// to Role.
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListEntitiesForPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListEntitiesForPolicy
+func (c *IAM) ListEntitiesForPolicy(input *ListEntitiesForPolicyInput) (*ListEntitiesForPolicyOutput, error) {
+	req, out := c.ListEntitiesForPolicyRequest(input)
+	return out, req.Send()
+}
+
+// ListEntitiesForPolicyWithContext is the same as ListEntitiesForPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListEntitiesForPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListEntitiesForPolicyWithContext(ctx aws.Context, input *ListEntitiesForPolicyInput, opts ...request.Option) (*ListEntitiesForPolicyOutput, error) {
+	req, out := c.ListEntitiesForPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListEntitiesForPolicyPages iterates over the pages of a ListEntitiesForPolicy operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListEntitiesForPolicy method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListEntitiesForPolicy operation.
+//    pageNum := 0
+//    err := client.ListEntitiesForPolicyPages(params,
+//        func(page *iam.ListEntitiesForPolicyOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListEntitiesForPolicyPages(input *ListEntitiesForPolicyInput, fn func(*ListEntitiesForPolicyOutput, bool) bool) error {
+	return c.ListEntitiesForPolicyPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListEntitiesForPolicyPagesWithContext same as ListEntitiesForPolicyPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListEntitiesForPolicyPagesWithContext(ctx aws.Context, input *ListEntitiesForPolicyInput, fn func(*ListEntitiesForPolicyOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListEntitiesForPolicyInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListEntitiesForPolicyRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListEntitiesForPolicyOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListGroupPolicies = "ListGroupPolicies"
+
+// ListGroupPoliciesRequest generates a "aws/request.Request" representing the
+// client's request for the ListGroupPolicies operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListGroupPolicies for more information on using the ListGroupPolicies
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListGroupPoliciesRequest method.
+//    req, resp := client.ListGroupPoliciesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListGroupPolicies
+func (c *IAM) ListGroupPoliciesRequest(input *ListGroupPoliciesInput) (req *request.Request, output *ListGroupPoliciesOutput) {
+	op := &request.Operation{
+		Name:       opListGroupPolicies,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListGroupPoliciesInput{}
+	}
+
+	output = &ListGroupPoliciesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListGroupPolicies API operation for AWS Identity and Access Management.
+//
+// Lists the names of the inline policies that are embedded in the specified
+// IAM group.
+//
+// An IAM group can also have managed policies attached to it. To list the managed
+// policies that are attached to a group, use ListAttachedGroupPolicies. For
+// more information about policies, see Managed Policies and Inline Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// You can paginate the results using the MaxItems and Marker parameters. If
+// there are no inline policies embedded with the specified group, the operation
+// returns an empty list.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListGroupPolicies for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListGroupPolicies
+func (c *IAM) ListGroupPolicies(input *ListGroupPoliciesInput) (*ListGroupPoliciesOutput, error) {
+	req, out := c.ListGroupPoliciesRequest(input)
+	return out, req.Send()
+}
+
+// ListGroupPoliciesWithContext is the same as ListGroupPolicies with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListGroupPolicies for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListGroupPoliciesWithContext(ctx aws.Context, input *ListGroupPoliciesInput, opts ...request.Option) (*ListGroupPoliciesOutput, error) {
+	req, out := c.ListGroupPoliciesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListGroupPoliciesPages iterates over the pages of a ListGroupPolicies operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListGroupPolicies method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListGroupPolicies operation.
+//    pageNum := 0
+//    err := client.ListGroupPoliciesPages(params,
+//        func(page *iam.ListGroupPoliciesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListGroupPoliciesPages(input *ListGroupPoliciesInput, fn func(*ListGroupPoliciesOutput, bool) bool) error {
+	return c.ListGroupPoliciesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListGroupPoliciesPagesWithContext same as ListGroupPoliciesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListGroupPoliciesPagesWithContext(ctx aws.Context, input *ListGroupPoliciesInput, fn func(*ListGroupPoliciesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListGroupPoliciesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListGroupPoliciesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListGroupPoliciesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListGroups = "ListGroups"
+
+// ListGroupsRequest generates a "aws/request.Request" representing the
+// client's request for the ListGroups operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListGroups for more information on using the ListGroups
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListGroupsRequest method.
+//    req, resp := client.ListGroupsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListGroups
+func (c *IAM) ListGroupsRequest(input *ListGroupsInput) (req *request.Request, output *ListGroupsOutput) {
+	op := &request.Operation{
+		Name:       opListGroups,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListGroupsInput{}
+	}
+
+	output = &ListGroupsOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListGroups API operation for AWS Identity and Access Management.
+//
+// Lists the IAM groups that have the specified path prefix.
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListGroups for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListGroups
+func (c *IAM) ListGroups(input *ListGroupsInput) (*ListGroupsOutput, error) {
+	req, out := c.ListGroupsRequest(input)
+	return out, req.Send()
+}
+
+// ListGroupsWithContext is the same as ListGroups with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListGroups for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListGroupsWithContext(ctx aws.Context, input *ListGroupsInput, opts ...request.Option) (*ListGroupsOutput, error) {
+	req, out := c.ListGroupsRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListGroupsPages iterates over the pages of a ListGroups operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListGroups method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListGroups operation.
+//    pageNum := 0
+//    err := client.ListGroupsPages(params,
+//        func(page *iam.ListGroupsOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListGroupsPages(input *ListGroupsInput, fn func(*ListGroupsOutput, bool) bool) error {
+	return c.ListGroupsPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListGroupsPagesWithContext same as ListGroupsPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListGroupsPagesWithContext(ctx aws.Context, input *ListGroupsInput, fn func(*ListGroupsOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListGroupsInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListGroupsRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListGroupsOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListGroupsForUser = "ListGroupsForUser"
+
+// ListGroupsForUserRequest generates a "aws/request.Request" representing the
+// client's request for the ListGroupsForUser operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListGroupsForUser for more information on using the ListGroupsForUser
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListGroupsForUserRequest method.
+//    req, resp := client.ListGroupsForUserRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListGroupsForUser
+func (c *IAM) ListGroupsForUserRequest(input *ListGroupsForUserInput) (req *request.Request, output *ListGroupsForUserOutput) {
+	op := &request.Operation{
+		Name:       opListGroupsForUser,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListGroupsForUserInput{}
+	}
+
+	output = &ListGroupsForUserOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListGroupsForUser API operation for AWS Identity and Access Management.
+//
+// Lists the IAM groups that the specified IAM user belongs to.
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListGroupsForUser for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListGroupsForUser
+func (c *IAM) ListGroupsForUser(input *ListGroupsForUserInput) (*ListGroupsForUserOutput, error) {
+	req, out := c.ListGroupsForUserRequest(input)
+	return out, req.Send()
+}
+
+// ListGroupsForUserWithContext is the same as ListGroupsForUser with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListGroupsForUser for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListGroupsForUserWithContext(ctx aws.Context, input *ListGroupsForUserInput, opts ...request.Option) (*ListGroupsForUserOutput, error) {
+	req, out := c.ListGroupsForUserRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListGroupsForUserPages iterates over the pages of a ListGroupsForUser operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListGroupsForUser method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListGroupsForUser operation.
+//    pageNum := 0
+//    err := client.ListGroupsForUserPages(params,
+//        func(page *iam.ListGroupsForUserOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListGroupsForUserPages(input *ListGroupsForUserInput, fn func(*ListGroupsForUserOutput, bool) bool) error {
+	return c.ListGroupsForUserPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListGroupsForUserPagesWithContext same as ListGroupsForUserPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListGroupsForUserPagesWithContext(ctx aws.Context, input *ListGroupsForUserInput, fn func(*ListGroupsForUserOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListGroupsForUserInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListGroupsForUserRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListGroupsForUserOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListInstanceProfiles = "ListInstanceProfiles"
+
+// ListInstanceProfilesRequest generates a "aws/request.Request" representing the
+// client's request for the ListInstanceProfiles operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListInstanceProfiles for more information on using the ListInstanceProfiles
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListInstanceProfilesRequest method.
+//    req, resp := client.ListInstanceProfilesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListInstanceProfiles
+func (c *IAM) ListInstanceProfilesRequest(input *ListInstanceProfilesInput) (req *request.Request, output *ListInstanceProfilesOutput) {
+	op := &request.Operation{
+		Name:       opListInstanceProfiles,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListInstanceProfilesInput{}
+	}
+
+	output = &ListInstanceProfilesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListInstanceProfiles API operation for AWS Identity and Access Management.
+//
+// Lists the instance profiles that have the specified path prefix. If there
+// are none, the operation returns an empty list. For more information about
+// instance profiles, go to About Instance Profiles (https://docs.aws.amazon.com/IAM/latest/UserGuide/AboutInstanceProfiles.html).
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListInstanceProfiles for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListInstanceProfiles
+func (c *IAM) ListInstanceProfiles(input *ListInstanceProfilesInput) (*ListInstanceProfilesOutput, error) {
+	req, out := c.ListInstanceProfilesRequest(input)
+	return out, req.Send()
+}
+
+// ListInstanceProfilesWithContext is the same as ListInstanceProfiles with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListInstanceProfiles for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListInstanceProfilesWithContext(ctx aws.Context, input *ListInstanceProfilesInput, opts ...request.Option) (*ListInstanceProfilesOutput, error) {
+	req, out := c.ListInstanceProfilesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListInstanceProfilesPages iterates over the pages of a ListInstanceProfiles operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListInstanceProfiles method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListInstanceProfiles operation.
+//    pageNum := 0
+//    err := client.ListInstanceProfilesPages(params,
+//        func(page *iam.ListInstanceProfilesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListInstanceProfilesPages(input *ListInstanceProfilesInput, fn func(*ListInstanceProfilesOutput, bool) bool) error {
+	return c.ListInstanceProfilesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListInstanceProfilesPagesWithContext same as ListInstanceProfilesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListInstanceProfilesPagesWithContext(ctx aws.Context, input *ListInstanceProfilesInput, fn func(*ListInstanceProfilesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListInstanceProfilesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListInstanceProfilesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListInstanceProfilesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListInstanceProfilesForRole = "ListInstanceProfilesForRole"
+
+// ListInstanceProfilesForRoleRequest generates a "aws/request.Request" representing the
+// client's request for the ListInstanceProfilesForRole operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListInstanceProfilesForRole for more information on using the ListInstanceProfilesForRole
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListInstanceProfilesForRoleRequest method.
+//    req, resp := client.ListInstanceProfilesForRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListInstanceProfilesForRole
+func (c *IAM) ListInstanceProfilesForRoleRequest(input *ListInstanceProfilesForRoleInput) (req *request.Request, output *ListInstanceProfilesForRoleOutput) {
+	op := &request.Operation{
+		Name:       opListInstanceProfilesForRole,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListInstanceProfilesForRoleInput{}
+	}
+
+	output = &ListInstanceProfilesForRoleOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListInstanceProfilesForRole API operation for AWS Identity and Access Management.
+//
+// Lists the instance profiles that have the specified associated IAM role.
+// If there are none, the operation returns an empty list. For more information
+// about instance profiles, go to About Instance Profiles (https://docs.aws.amazon.com/IAM/latest/UserGuide/AboutInstanceProfiles.html).
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListInstanceProfilesForRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListInstanceProfilesForRole
+func (c *IAM) ListInstanceProfilesForRole(input *ListInstanceProfilesForRoleInput) (*ListInstanceProfilesForRoleOutput, error) {
+	req, out := c.ListInstanceProfilesForRoleRequest(input)
+	return out, req.Send()
+}
+
+// ListInstanceProfilesForRoleWithContext is the same as ListInstanceProfilesForRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListInstanceProfilesForRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListInstanceProfilesForRoleWithContext(ctx aws.Context, input *ListInstanceProfilesForRoleInput, opts ...request.Option) (*ListInstanceProfilesForRoleOutput, error) {
+	req, out := c.ListInstanceProfilesForRoleRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListInstanceProfilesForRolePages iterates over the pages of a ListInstanceProfilesForRole operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListInstanceProfilesForRole method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListInstanceProfilesForRole operation.
+//    pageNum := 0
+//    err := client.ListInstanceProfilesForRolePages(params,
+//        func(page *iam.ListInstanceProfilesForRoleOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListInstanceProfilesForRolePages(input *ListInstanceProfilesForRoleInput, fn func(*ListInstanceProfilesForRoleOutput, bool) bool) error {
+	return c.ListInstanceProfilesForRolePagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListInstanceProfilesForRolePagesWithContext same as ListInstanceProfilesForRolePages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListInstanceProfilesForRolePagesWithContext(ctx aws.Context, input *ListInstanceProfilesForRoleInput, fn func(*ListInstanceProfilesForRoleOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListInstanceProfilesForRoleInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListInstanceProfilesForRoleRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListInstanceProfilesForRoleOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListMFADevices = "ListMFADevices"
+
+// ListMFADevicesRequest generates a "aws/request.Request" representing the
+// client's request for the ListMFADevices operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListMFADevices for more information on using the ListMFADevices
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListMFADevicesRequest method.
+//    req, resp := client.ListMFADevicesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListMFADevices
+func (c *IAM) ListMFADevicesRequest(input *ListMFADevicesInput) (req *request.Request, output *ListMFADevicesOutput) {
+	op := &request.Operation{
+		Name:       opListMFADevices,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListMFADevicesInput{}
+	}
+
+	output = &ListMFADevicesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListMFADevices API operation for AWS Identity and Access Management.
+//
+// Lists the MFA devices for an IAM user. If the request includes a IAM user
+// name, then this operation lists all the MFA devices associated with the specified
+// user. If you do not specify a user name, IAM determines the user name implicitly
+// based on the AWS access key ID signing the request for this API.
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListMFADevices for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListMFADevices
+func (c *IAM) ListMFADevices(input *ListMFADevicesInput) (*ListMFADevicesOutput, error) {
+	req, out := c.ListMFADevicesRequest(input)
+	return out, req.Send()
+}
+
+// ListMFADevicesWithContext is the same as ListMFADevices with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListMFADevices for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListMFADevicesWithContext(ctx aws.Context, input *ListMFADevicesInput, opts ...request.Option) (*ListMFADevicesOutput, error) {
+	req, out := c.ListMFADevicesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListMFADevicesPages iterates over the pages of a ListMFADevices operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListMFADevices method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListMFADevices operation.
+//    pageNum := 0
+//    err := client.ListMFADevicesPages(params,
+//        func(page *iam.ListMFADevicesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListMFADevicesPages(input *ListMFADevicesInput, fn func(*ListMFADevicesOutput, bool) bool) error {
+	return c.ListMFADevicesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListMFADevicesPagesWithContext same as ListMFADevicesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListMFADevicesPagesWithContext(ctx aws.Context, input *ListMFADevicesInput, fn func(*ListMFADevicesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListMFADevicesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListMFADevicesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListMFADevicesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListOpenIDConnectProviders = "ListOpenIDConnectProviders"
+
+// ListOpenIDConnectProvidersRequest generates a "aws/request.Request" representing the
+// client's request for the ListOpenIDConnectProviders operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListOpenIDConnectProviders for more information on using the ListOpenIDConnectProviders
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListOpenIDConnectProvidersRequest method.
+//    req, resp := client.ListOpenIDConnectProvidersRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListOpenIDConnectProviders
+func (c *IAM) ListOpenIDConnectProvidersRequest(input *ListOpenIDConnectProvidersInput) (req *request.Request, output *ListOpenIDConnectProvidersOutput) {
+	op := &request.Operation{
+		Name:       opListOpenIDConnectProviders,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ListOpenIDConnectProvidersInput{}
+	}
+
+	output = &ListOpenIDConnectProvidersOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListOpenIDConnectProviders API operation for AWS Identity and Access Management.
+//
+// Lists information about the IAM OpenID Connect (OIDC) provider resource objects
+// defined in the AWS account.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListOpenIDConnectProviders for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListOpenIDConnectProviders
+func (c *IAM) ListOpenIDConnectProviders(input *ListOpenIDConnectProvidersInput) (*ListOpenIDConnectProvidersOutput, error) {
+	req, out := c.ListOpenIDConnectProvidersRequest(input)
+	return out, req.Send()
+}
+
+// ListOpenIDConnectProvidersWithContext is the same as ListOpenIDConnectProviders with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListOpenIDConnectProviders for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListOpenIDConnectProvidersWithContext(ctx aws.Context, input *ListOpenIDConnectProvidersInput, opts ...request.Option) (*ListOpenIDConnectProvidersOutput, error) {
+	req, out := c.ListOpenIDConnectProvidersRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opListPolicies = "ListPolicies"
+
+// ListPoliciesRequest generates a "aws/request.Request" representing the
+// client's request for the ListPolicies operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListPolicies for more information on using the ListPolicies
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListPoliciesRequest method.
+//    req, resp := client.ListPoliciesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPolicies
+func (c *IAM) ListPoliciesRequest(input *ListPoliciesInput) (req *request.Request, output *ListPoliciesOutput) {
+	op := &request.Operation{
+		Name:       opListPolicies,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListPoliciesInput{}
+	}
+
+	output = &ListPoliciesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListPolicies API operation for AWS Identity and Access Management.
+//
+// Lists all the managed policies that are available in your AWS account, including
+// your own customer-defined managed policies and all AWS managed policies.
+//
+// You can filter the list of policies that is returned using the optional OnlyAttached,
+// Scope, and PathPrefix parameters. For example, to list only the customer
+// managed policies in your AWS account, set Scope to Local. To list only AWS
+// managed policies, set Scope to AWS.
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// For more information about managed policies, see Managed Policies and Inline
+// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListPolicies for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPolicies
+func (c *IAM) ListPolicies(input *ListPoliciesInput) (*ListPoliciesOutput, error) {
+	req, out := c.ListPoliciesRequest(input)
+	return out, req.Send()
+}
+
+// ListPoliciesWithContext is the same as ListPolicies with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListPolicies for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListPoliciesWithContext(ctx aws.Context, input *ListPoliciesInput, opts ...request.Option) (*ListPoliciesOutput, error) {
+	req, out := c.ListPoliciesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListPoliciesPages iterates over the pages of a ListPolicies operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListPolicies method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListPolicies operation.
+//    pageNum := 0
+//    err := client.ListPoliciesPages(params,
+//        func(page *iam.ListPoliciesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListPoliciesPages(input *ListPoliciesInput, fn func(*ListPoliciesOutput, bool) bool) error {
+	return c.ListPoliciesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListPoliciesPagesWithContext same as ListPoliciesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListPoliciesPagesWithContext(ctx aws.Context, input *ListPoliciesInput, fn func(*ListPoliciesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListPoliciesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListPoliciesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListPoliciesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListPoliciesGrantingServiceAccess = "ListPoliciesGrantingServiceAccess"
+
+// ListPoliciesGrantingServiceAccessRequest generates a "aws/request.Request" representing the
+// client's request for the ListPoliciesGrantingServiceAccess operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListPoliciesGrantingServiceAccess for more information on using the ListPoliciesGrantingServiceAccess
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListPoliciesGrantingServiceAccessRequest method.
+//    req, resp := client.ListPoliciesGrantingServiceAccessRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPoliciesGrantingServiceAccess
+func (c *IAM) ListPoliciesGrantingServiceAccessRequest(input *ListPoliciesGrantingServiceAccessInput) (req *request.Request, output *ListPoliciesGrantingServiceAccessOutput) {
+	op := &request.Operation{
+		Name:       opListPoliciesGrantingServiceAccess,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ListPoliciesGrantingServiceAccessInput{}
+	}
+
+	output = &ListPoliciesGrantingServiceAccessOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListPoliciesGrantingServiceAccess API operation for AWS Identity and Access Management.
+//
+// Retrieves a list of policies that the IAM identity (user, group, or role)
+// can use to access each specified service.
+//
+// This operation does not use other policy types when determining whether a
+// resource could access a service. These other policy types include resource-based
+// policies, access control lists, AWS Organizations policies, IAM permissions
+// boundaries, and AWS STS assume role policies. It only applies permissions
+// policy logic. For more about the evaluation of policy types, see Evaluating
+// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-basics)
+// in the IAM User Guide.
+//
+// The list of policies returned by the operation depends on the ARN of the
+// identity that you provide.
+//
+//    * User – The list of policies includes the managed and inline policies
+//    that are attached to the user directly. The list also includes any additional
+//    managed and inline policies that are attached to the group to which the
+//    user belongs.
+//
+//    * Group – The list of policies includes only the managed and inline
+//    policies that are attached to the group directly. Policies that are attached
+//    to the group’s user are not included.
+//
+//    * Role – The list of policies includes only the managed and inline policies
+//    that are attached to the role.
+//
+// For each managed policy, this operation returns the ARN and policy name.
+// For each inline policy, it returns the policy name and the entity to which
+// it is attached. Inline policies do not have an ARN. For more information
+// about these policy types, see Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Policies that are attached to users and roles as permissions boundaries are
+// not returned. To view which managed policy is currently used to set the permissions
+// boundary for a user or role, use the GetUser or GetRole operations.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListPoliciesGrantingServiceAccess for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPoliciesGrantingServiceAccess
+func (c *IAM) ListPoliciesGrantingServiceAccess(input *ListPoliciesGrantingServiceAccessInput) (*ListPoliciesGrantingServiceAccessOutput, error) {
+	req, out := c.ListPoliciesGrantingServiceAccessRequest(input)
+	return out, req.Send()
+}
+
+// ListPoliciesGrantingServiceAccessWithContext is the same as ListPoliciesGrantingServiceAccess with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListPoliciesGrantingServiceAccess for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListPoliciesGrantingServiceAccessWithContext(ctx aws.Context, input *ListPoliciesGrantingServiceAccessInput, opts ...request.Option) (*ListPoliciesGrantingServiceAccessOutput, error) {
+	req, out := c.ListPoliciesGrantingServiceAccessRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opListPolicyVersions = "ListPolicyVersions"
+
+// ListPolicyVersionsRequest generates a "aws/request.Request" representing the
+// client's request for the ListPolicyVersions operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListPolicyVersions for more information on using the ListPolicyVersions
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListPolicyVersionsRequest method.
+//    req, resp := client.ListPolicyVersionsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPolicyVersions
+func (c *IAM) ListPolicyVersionsRequest(input *ListPolicyVersionsInput) (req *request.Request, output *ListPolicyVersionsOutput) {
+	op := &request.Operation{
+		Name:       opListPolicyVersions,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListPolicyVersionsInput{}
+	}
+
+	output = &ListPolicyVersionsOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListPolicyVersions API operation for AWS Identity and Access Management.
+//
+// Lists information about the versions of the specified managed policy, including
+// the version that is currently set as the policy's default version.
+//
+// For more information about managed policies, see Managed Policies and Inline
+// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListPolicyVersions for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListPolicyVersions
+func (c *IAM) ListPolicyVersions(input *ListPolicyVersionsInput) (*ListPolicyVersionsOutput, error) {
+	req, out := c.ListPolicyVersionsRequest(input)
+	return out, req.Send()
+}
+
+// ListPolicyVersionsWithContext is the same as ListPolicyVersions with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListPolicyVersions for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListPolicyVersionsWithContext(ctx aws.Context, input *ListPolicyVersionsInput, opts ...request.Option) (*ListPolicyVersionsOutput, error) {
+	req, out := c.ListPolicyVersionsRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListPolicyVersionsPages iterates over the pages of a ListPolicyVersions operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListPolicyVersions method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListPolicyVersions operation.
+//    pageNum := 0
+//    err := client.ListPolicyVersionsPages(params,
+//        func(page *iam.ListPolicyVersionsOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListPolicyVersionsPages(input *ListPolicyVersionsInput, fn func(*ListPolicyVersionsOutput, bool) bool) error {
+	return c.ListPolicyVersionsPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListPolicyVersionsPagesWithContext same as ListPolicyVersionsPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListPolicyVersionsPagesWithContext(ctx aws.Context, input *ListPolicyVersionsInput, fn func(*ListPolicyVersionsOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListPolicyVersionsInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListPolicyVersionsRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListPolicyVersionsOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListRolePolicies = "ListRolePolicies"
+
+// ListRolePoliciesRequest generates a "aws/request.Request" representing the
+// client's request for the ListRolePolicies operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListRolePolicies for more information on using the ListRolePolicies
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListRolePoliciesRequest method.
+//    req, resp := client.ListRolePoliciesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListRolePolicies
+func (c *IAM) ListRolePoliciesRequest(input *ListRolePoliciesInput) (req *request.Request, output *ListRolePoliciesOutput) {
+	op := &request.Operation{
+		Name:       opListRolePolicies,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListRolePoliciesInput{}
+	}
+
+	output = &ListRolePoliciesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListRolePolicies API operation for AWS Identity and Access Management.
+//
+// Lists the names of the inline policies that are embedded in the specified
+// IAM role.
+//
+// An IAM role can also have managed policies attached to it. To list the managed
+// policies that are attached to a role, use ListAttachedRolePolicies. For more
+// information about policies, see Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// You can paginate the results using the MaxItems and Marker parameters. If
+// there are no inline policies embedded with the specified role, the operation
+// returns an empty list.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListRolePolicies for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListRolePolicies
+func (c *IAM) ListRolePolicies(input *ListRolePoliciesInput) (*ListRolePoliciesOutput, error) {
+	req, out := c.ListRolePoliciesRequest(input)
+	return out, req.Send()
+}
+
+// ListRolePoliciesWithContext is the same as ListRolePolicies with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListRolePolicies for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListRolePoliciesWithContext(ctx aws.Context, input *ListRolePoliciesInput, opts ...request.Option) (*ListRolePoliciesOutput, error) {
+	req, out := c.ListRolePoliciesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListRolePoliciesPages iterates over the pages of a ListRolePolicies operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListRolePolicies method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListRolePolicies operation.
+//    pageNum := 0
+//    err := client.ListRolePoliciesPages(params,
+//        func(page *iam.ListRolePoliciesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListRolePoliciesPages(input *ListRolePoliciesInput, fn func(*ListRolePoliciesOutput, bool) bool) error {
+	return c.ListRolePoliciesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListRolePoliciesPagesWithContext same as ListRolePoliciesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListRolePoliciesPagesWithContext(ctx aws.Context, input *ListRolePoliciesInput, fn func(*ListRolePoliciesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListRolePoliciesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListRolePoliciesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListRolePoliciesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListRoleTags = "ListRoleTags"
+
+// ListRoleTagsRequest generates a "aws/request.Request" representing the
+// client's request for the ListRoleTags operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListRoleTags for more information on using the ListRoleTags
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListRoleTagsRequest method.
+//    req, resp := client.ListRoleTagsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListRoleTags
+func (c *IAM) ListRoleTagsRequest(input *ListRoleTagsInput) (req *request.Request, output *ListRoleTagsOutput) {
+	op := &request.Operation{
+		Name:       opListRoleTags,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ListRoleTagsInput{}
+	}
+
+	output = &ListRoleTagsOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListRoleTags API operation for AWS Identity and Access Management.
+//
+// Lists the tags that are attached to the specified role. The returned list
+// of tags is sorted by tag key. For more information about tagging, see Tagging
+// IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListRoleTags for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListRoleTags
+func (c *IAM) ListRoleTags(input *ListRoleTagsInput) (*ListRoleTagsOutput, error) {
+	req, out := c.ListRoleTagsRequest(input)
+	return out, req.Send()
+}
+
+// ListRoleTagsWithContext is the same as ListRoleTags with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListRoleTags for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListRoleTagsWithContext(ctx aws.Context, input *ListRoleTagsInput, opts ...request.Option) (*ListRoleTagsOutput, error) {
+	req, out := c.ListRoleTagsRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opListRoles = "ListRoles"
+
+// ListRolesRequest generates a "aws/request.Request" representing the
+// client's request for the ListRoles operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListRoles for more information on using the ListRoles
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListRolesRequest method.
+//    req, resp := client.ListRolesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListRoles
+func (c *IAM) ListRolesRequest(input *ListRolesInput) (req *request.Request, output *ListRolesOutput) {
+	op := &request.Operation{
+		Name:       opListRoles,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListRolesInput{}
+	}
+
+	output = &ListRolesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListRoles API operation for AWS Identity and Access Management.
+//
+// Lists the IAM roles that have the specified path prefix. If there are none,
+// the operation returns an empty list. For more information about roles, go
+// to Working with Roles (https://docs.aws.amazon.com/IAM/latest/UserGuide/WorkingWithRoles.html).
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListRoles for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListRoles
+func (c *IAM) ListRoles(input *ListRolesInput) (*ListRolesOutput, error) {
+	req, out := c.ListRolesRequest(input)
+	return out, req.Send()
+}
+
+// ListRolesWithContext is the same as ListRoles with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListRoles for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListRolesWithContext(ctx aws.Context, input *ListRolesInput, opts ...request.Option) (*ListRolesOutput, error) {
+	req, out := c.ListRolesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListRolesPages iterates over the pages of a ListRoles operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListRoles method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListRoles operation.
+//    pageNum := 0
+//    err := client.ListRolesPages(params,
+//        func(page *iam.ListRolesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListRolesPages(input *ListRolesInput, fn func(*ListRolesOutput, bool) bool) error {
+	return c.ListRolesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListRolesPagesWithContext same as ListRolesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListRolesPagesWithContext(ctx aws.Context, input *ListRolesInput, fn func(*ListRolesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListRolesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListRolesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListRolesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListSAMLProviders = "ListSAMLProviders"
+
+// ListSAMLProvidersRequest generates a "aws/request.Request" representing the
+// client's request for the ListSAMLProviders operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListSAMLProviders for more information on using the ListSAMLProviders
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListSAMLProvidersRequest method.
+//    req, resp := client.ListSAMLProvidersRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSAMLProviders
+func (c *IAM) ListSAMLProvidersRequest(input *ListSAMLProvidersInput) (req *request.Request, output *ListSAMLProvidersOutput) {
+	op := &request.Operation{
+		Name:       opListSAMLProviders,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ListSAMLProvidersInput{}
+	}
+
+	output = &ListSAMLProvidersOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListSAMLProviders API operation for AWS Identity and Access Management.
+//
+// Lists the SAML provider resource objects defined in IAM in the account.
+//
+// This operation requires Signature Version 4 (https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListSAMLProviders for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSAMLProviders
+func (c *IAM) ListSAMLProviders(input *ListSAMLProvidersInput) (*ListSAMLProvidersOutput, error) {
+	req, out := c.ListSAMLProvidersRequest(input)
+	return out, req.Send()
+}
+
+// ListSAMLProvidersWithContext is the same as ListSAMLProviders with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListSAMLProviders for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListSAMLProvidersWithContext(ctx aws.Context, input *ListSAMLProvidersInput, opts ...request.Option) (*ListSAMLProvidersOutput, error) {
+	req, out := c.ListSAMLProvidersRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opListSSHPublicKeys = "ListSSHPublicKeys"
+
+// ListSSHPublicKeysRequest generates a "aws/request.Request" representing the
+// client's request for the ListSSHPublicKeys operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListSSHPublicKeys for more information on using the ListSSHPublicKeys
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListSSHPublicKeysRequest method.
+//    req, resp := client.ListSSHPublicKeysRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSSHPublicKeys
+func (c *IAM) ListSSHPublicKeysRequest(input *ListSSHPublicKeysInput) (req *request.Request, output *ListSSHPublicKeysOutput) {
+	op := &request.Operation{
+		Name:       opListSSHPublicKeys,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListSSHPublicKeysInput{}
+	}
+
+	output = &ListSSHPublicKeysOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListSSHPublicKeys API operation for AWS Identity and Access Management.
+//
+// Returns information about the SSH public keys associated with the specified
+// IAM user. If none exists, the operation returns an empty list.
+//
+// The SSH public keys returned by this operation are used only for authenticating
+// the IAM user to an AWS CodeCommit repository. For more information about
+// using SSH keys to authenticate to an AWS CodeCommit repository, see Set up
+// AWS CodeCommit for SSH Connections (https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html)
+// in the AWS CodeCommit User Guide.
+//
+// Although each user is limited to a small number of keys, you can still paginate
+// the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListSSHPublicKeys for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSSHPublicKeys
+func (c *IAM) ListSSHPublicKeys(input *ListSSHPublicKeysInput) (*ListSSHPublicKeysOutput, error) {
+	req, out := c.ListSSHPublicKeysRequest(input)
+	return out, req.Send()
+}
+
+// ListSSHPublicKeysWithContext is the same as ListSSHPublicKeys with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListSSHPublicKeys for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListSSHPublicKeysWithContext(ctx aws.Context, input *ListSSHPublicKeysInput, opts ...request.Option) (*ListSSHPublicKeysOutput, error) {
+	req, out := c.ListSSHPublicKeysRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListSSHPublicKeysPages iterates over the pages of a ListSSHPublicKeys operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListSSHPublicKeys method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListSSHPublicKeys operation.
+//    pageNum := 0
+//    err := client.ListSSHPublicKeysPages(params,
+//        func(page *iam.ListSSHPublicKeysOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListSSHPublicKeysPages(input *ListSSHPublicKeysInput, fn func(*ListSSHPublicKeysOutput, bool) bool) error {
+	return c.ListSSHPublicKeysPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListSSHPublicKeysPagesWithContext same as ListSSHPublicKeysPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListSSHPublicKeysPagesWithContext(ctx aws.Context, input *ListSSHPublicKeysInput, fn func(*ListSSHPublicKeysOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListSSHPublicKeysInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListSSHPublicKeysRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListSSHPublicKeysOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListServerCertificates = "ListServerCertificates"
+
+// ListServerCertificatesRequest generates a "aws/request.Request" representing the
+// client's request for the ListServerCertificates operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListServerCertificates for more information on using the ListServerCertificates
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListServerCertificatesRequest method.
+//    req, resp := client.ListServerCertificatesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListServerCertificates
+func (c *IAM) ListServerCertificatesRequest(input *ListServerCertificatesInput) (req *request.Request, output *ListServerCertificatesOutput) {
+	op := &request.Operation{
+		Name:       opListServerCertificates,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListServerCertificatesInput{}
+	}
+
+	output = &ListServerCertificatesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListServerCertificates API operation for AWS Identity and Access Management.
+//
+// Lists the server certificates stored in IAM that have the specified path
+// prefix. If none exist, the operation returns an empty list.
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// For more information about working with server certificates, see Working
+// with Server Certificates (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html)
+// in the IAM User Guide. This topic also includes a list of AWS services that
+// can use the server certificates that you manage with IAM.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListServerCertificates for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListServerCertificates
+func (c *IAM) ListServerCertificates(input *ListServerCertificatesInput) (*ListServerCertificatesOutput, error) {
+	req, out := c.ListServerCertificatesRequest(input)
+	return out, req.Send()
+}
+
+// ListServerCertificatesWithContext is the same as ListServerCertificates with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListServerCertificates for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListServerCertificatesWithContext(ctx aws.Context, input *ListServerCertificatesInput, opts ...request.Option) (*ListServerCertificatesOutput, error) {
+	req, out := c.ListServerCertificatesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListServerCertificatesPages iterates over the pages of a ListServerCertificates operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListServerCertificates method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListServerCertificates operation.
+//    pageNum := 0
+//    err := client.ListServerCertificatesPages(params,
+//        func(page *iam.ListServerCertificatesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListServerCertificatesPages(input *ListServerCertificatesInput, fn func(*ListServerCertificatesOutput, bool) bool) error {
+	return c.ListServerCertificatesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListServerCertificatesPagesWithContext same as ListServerCertificatesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListServerCertificatesPagesWithContext(ctx aws.Context, input *ListServerCertificatesInput, fn func(*ListServerCertificatesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListServerCertificatesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListServerCertificatesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListServerCertificatesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListServiceSpecificCredentials = "ListServiceSpecificCredentials"
+
+// ListServiceSpecificCredentialsRequest generates a "aws/request.Request" representing the
+// client's request for the ListServiceSpecificCredentials operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListServiceSpecificCredentials for more information on using the ListServiceSpecificCredentials
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListServiceSpecificCredentialsRequest method.
+//    req, resp := client.ListServiceSpecificCredentialsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListServiceSpecificCredentials
+func (c *IAM) ListServiceSpecificCredentialsRequest(input *ListServiceSpecificCredentialsInput) (req *request.Request, output *ListServiceSpecificCredentialsOutput) {
+	op := &request.Operation{
+		Name:       opListServiceSpecificCredentials,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ListServiceSpecificCredentialsInput{}
+	}
+
+	output = &ListServiceSpecificCredentialsOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListServiceSpecificCredentials API operation for AWS Identity and Access Management.
+//
+// Returns information about the service-specific credentials associated with
+// the specified IAM user. If none exists, the operation returns an empty list.
+// The service-specific credentials returned by this operation are used only
+// for authenticating the IAM user to a specific service. For more information
+// about using service-specific credentials to authenticate to an AWS service,
+// see Set Up service-specific credentials (https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-gc.html)
+// in the AWS CodeCommit User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListServiceSpecificCredentials for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceNotSupportedException "NotSupportedService"
+//   The specified service does not support service-specific credentials.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListServiceSpecificCredentials
+func (c *IAM) ListServiceSpecificCredentials(input *ListServiceSpecificCredentialsInput) (*ListServiceSpecificCredentialsOutput, error) {
+	req, out := c.ListServiceSpecificCredentialsRequest(input)
+	return out, req.Send()
+}
+
+// ListServiceSpecificCredentialsWithContext is the same as ListServiceSpecificCredentials with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListServiceSpecificCredentials for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListServiceSpecificCredentialsWithContext(ctx aws.Context, input *ListServiceSpecificCredentialsInput, opts ...request.Option) (*ListServiceSpecificCredentialsOutput, error) {
+	req, out := c.ListServiceSpecificCredentialsRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opListSigningCertificates = "ListSigningCertificates"
+
+// ListSigningCertificatesRequest generates a "aws/request.Request" representing the
+// client's request for the ListSigningCertificates operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListSigningCertificates for more information on using the ListSigningCertificates
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListSigningCertificatesRequest method.
+//    req, resp := client.ListSigningCertificatesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSigningCertificates
+func (c *IAM) ListSigningCertificatesRequest(input *ListSigningCertificatesInput) (req *request.Request, output *ListSigningCertificatesOutput) {
+	op := &request.Operation{
+		Name:       opListSigningCertificates,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListSigningCertificatesInput{}
+	}
+
+	output = &ListSigningCertificatesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListSigningCertificates API operation for AWS Identity and Access Management.
+//
+// Returns information about the signing certificates associated with the specified
+// IAM user. If none exists, the operation returns an empty list.
+//
+// Although each user is limited to a small number of signing certificates,
+// you can still paginate the results using the MaxItems and Marker parameters.
+//
+// If the UserName field is not specified, the user name is determined implicitly
+// based on the AWS access key ID used to sign the request for this API. This
+// operation works for access keys under the AWS account. Consequently, you
+// can use this operation to manage AWS account root user credentials even if
+// the AWS account has no associated users.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListSigningCertificates for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListSigningCertificates
+func (c *IAM) ListSigningCertificates(input *ListSigningCertificatesInput) (*ListSigningCertificatesOutput, error) {
+	req, out := c.ListSigningCertificatesRequest(input)
+	return out, req.Send()
+}
+
+// ListSigningCertificatesWithContext is the same as ListSigningCertificates with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListSigningCertificates for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListSigningCertificatesWithContext(ctx aws.Context, input *ListSigningCertificatesInput, opts ...request.Option) (*ListSigningCertificatesOutput, error) {
+	req, out := c.ListSigningCertificatesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListSigningCertificatesPages iterates over the pages of a ListSigningCertificates operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListSigningCertificates method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListSigningCertificates operation.
+//    pageNum := 0
+//    err := client.ListSigningCertificatesPages(params,
+//        func(page *iam.ListSigningCertificatesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListSigningCertificatesPages(input *ListSigningCertificatesInput, fn func(*ListSigningCertificatesOutput, bool) bool) error {
+	return c.ListSigningCertificatesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListSigningCertificatesPagesWithContext same as ListSigningCertificatesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListSigningCertificatesPagesWithContext(ctx aws.Context, input *ListSigningCertificatesInput, fn func(*ListSigningCertificatesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListSigningCertificatesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListSigningCertificatesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListSigningCertificatesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListUserPolicies = "ListUserPolicies"
+
+// ListUserPoliciesRequest generates a "aws/request.Request" representing the
+// client's request for the ListUserPolicies operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListUserPolicies for more information on using the ListUserPolicies
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListUserPoliciesRequest method.
+//    req, resp := client.ListUserPoliciesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListUserPolicies
+func (c *IAM) ListUserPoliciesRequest(input *ListUserPoliciesInput) (req *request.Request, output *ListUserPoliciesOutput) {
+	op := &request.Operation{
+		Name:       opListUserPolicies,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListUserPoliciesInput{}
+	}
+
+	output = &ListUserPoliciesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListUserPolicies API operation for AWS Identity and Access Management.
+//
+// Lists the names of the inline policies embedded in the specified IAM user.
+//
+// An IAM user can also have managed policies attached to it. To list the managed
+// policies that are attached to a user, use ListAttachedUserPolicies. For more
+// information about policies, see Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// You can paginate the results using the MaxItems and Marker parameters. If
+// there are no inline policies embedded with the specified user, the operation
+// returns an empty list.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListUserPolicies for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListUserPolicies
+func (c *IAM) ListUserPolicies(input *ListUserPoliciesInput) (*ListUserPoliciesOutput, error) {
+	req, out := c.ListUserPoliciesRequest(input)
+	return out, req.Send()
+}
+
+// ListUserPoliciesWithContext is the same as ListUserPolicies with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListUserPolicies for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListUserPoliciesWithContext(ctx aws.Context, input *ListUserPoliciesInput, opts ...request.Option) (*ListUserPoliciesOutput, error) {
+	req, out := c.ListUserPoliciesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListUserPoliciesPages iterates over the pages of a ListUserPolicies operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListUserPolicies method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListUserPolicies operation.
+//    pageNum := 0
+//    err := client.ListUserPoliciesPages(params,
+//        func(page *iam.ListUserPoliciesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListUserPoliciesPages(input *ListUserPoliciesInput, fn func(*ListUserPoliciesOutput, bool) bool) error {
+	return c.ListUserPoliciesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListUserPoliciesPagesWithContext same as ListUserPoliciesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListUserPoliciesPagesWithContext(ctx aws.Context, input *ListUserPoliciesInput, fn func(*ListUserPoliciesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListUserPoliciesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListUserPoliciesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListUserPoliciesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListUserTags = "ListUserTags"
+
+// ListUserTagsRequest generates a "aws/request.Request" representing the
+// client's request for the ListUserTags operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListUserTags for more information on using the ListUserTags
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListUserTagsRequest method.
+//    req, resp := client.ListUserTagsRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListUserTags
+func (c *IAM) ListUserTagsRequest(input *ListUserTagsInput) (req *request.Request, output *ListUserTagsOutput) {
+	op := &request.Operation{
+		Name:       opListUserTags,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ListUserTagsInput{}
+	}
+
+	output = &ListUserTagsOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListUserTags API operation for AWS Identity and Access Management.
+//
+// Lists the tags that are attached to the specified user. The returned list
+// of tags is sorted by tag key. For more information about tagging, see Tagging
+// IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListUserTags for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListUserTags
+func (c *IAM) ListUserTags(input *ListUserTagsInput) (*ListUserTagsOutput, error) {
+	req, out := c.ListUserTagsRequest(input)
+	return out, req.Send()
+}
+
+// ListUserTagsWithContext is the same as ListUserTags with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListUserTags for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListUserTagsWithContext(ctx aws.Context, input *ListUserTagsInput, opts ...request.Option) (*ListUserTagsOutput, error) {
+	req, out := c.ListUserTagsRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opListUsers = "ListUsers"
+
+// ListUsersRequest generates a "aws/request.Request" representing the
+// client's request for the ListUsers operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListUsers for more information on using the ListUsers
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListUsersRequest method.
+//    req, resp := client.ListUsersRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListUsers
+func (c *IAM) ListUsersRequest(input *ListUsersInput) (req *request.Request, output *ListUsersOutput) {
+	op := &request.Operation{
+		Name:       opListUsers,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListUsersInput{}
+	}
+
+	output = &ListUsersOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListUsers API operation for AWS Identity and Access Management.
+//
+// Lists the IAM users that have the specified path prefix. If no path prefix
+// is specified, the operation returns all users in the AWS account. If there
+// are none, the operation returns an empty list.
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListUsers for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListUsers
+func (c *IAM) ListUsers(input *ListUsersInput) (*ListUsersOutput, error) {
+	req, out := c.ListUsersRequest(input)
+	return out, req.Send()
+}
+
+// ListUsersWithContext is the same as ListUsers with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListUsers for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListUsersWithContext(ctx aws.Context, input *ListUsersInput, opts ...request.Option) (*ListUsersOutput, error) {
+	req, out := c.ListUsersRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListUsersPages iterates over the pages of a ListUsers operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListUsers method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListUsers operation.
+//    pageNum := 0
+//    err := client.ListUsersPages(params,
+//        func(page *iam.ListUsersOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListUsersPages(input *ListUsersInput, fn func(*ListUsersOutput, bool) bool) error {
+	return c.ListUsersPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListUsersPagesWithContext same as ListUsersPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListUsersPagesWithContext(ctx aws.Context, input *ListUsersInput, fn func(*ListUsersOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListUsersInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListUsersRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListUsersOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opListVirtualMFADevices = "ListVirtualMFADevices"
+
+// ListVirtualMFADevicesRequest generates a "aws/request.Request" representing the
+// client's request for the ListVirtualMFADevices operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ListVirtualMFADevices for more information on using the ListVirtualMFADevices
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ListVirtualMFADevicesRequest method.
+//    req, resp := client.ListVirtualMFADevicesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListVirtualMFADevices
+func (c *IAM) ListVirtualMFADevicesRequest(input *ListVirtualMFADevicesInput) (req *request.Request, output *ListVirtualMFADevicesOutput) {
+	op := &request.Operation{
+		Name:       opListVirtualMFADevices,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &ListVirtualMFADevicesInput{}
+	}
+
+	output = &ListVirtualMFADevicesOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ListVirtualMFADevices API operation for AWS Identity and Access Management.
+//
+// Lists the virtual MFA devices defined in the AWS account by assignment status.
+// If you do not specify an assignment status, the operation returns a list
+// of all virtual MFA devices. Assignment status can be Assigned, Unassigned,
+// or Any.
+//
+// You can paginate the results using the MaxItems and Marker parameters.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ListVirtualMFADevices for usage and error information.
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ListVirtualMFADevices
+func (c *IAM) ListVirtualMFADevices(input *ListVirtualMFADevicesInput) (*ListVirtualMFADevicesOutput, error) {
+	req, out := c.ListVirtualMFADevicesRequest(input)
+	return out, req.Send()
+}
+
+// ListVirtualMFADevicesWithContext is the same as ListVirtualMFADevices with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ListVirtualMFADevices for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListVirtualMFADevicesWithContext(ctx aws.Context, input *ListVirtualMFADevicesInput, opts ...request.Option) (*ListVirtualMFADevicesOutput, error) {
+	req, out := c.ListVirtualMFADevicesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// ListVirtualMFADevicesPages iterates over the pages of a ListVirtualMFADevices operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See ListVirtualMFADevices method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a ListVirtualMFADevices operation.
+//    pageNum := 0
+//    err := client.ListVirtualMFADevicesPages(params,
+//        func(page *iam.ListVirtualMFADevicesOutput, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) ListVirtualMFADevicesPages(input *ListVirtualMFADevicesInput, fn func(*ListVirtualMFADevicesOutput, bool) bool) error {
+	return c.ListVirtualMFADevicesPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// ListVirtualMFADevicesPagesWithContext same as ListVirtualMFADevicesPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ListVirtualMFADevicesPagesWithContext(ctx aws.Context, input *ListVirtualMFADevicesInput, fn func(*ListVirtualMFADevicesOutput, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *ListVirtualMFADevicesInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.ListVirtualMFADevicesRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*ListVirtualMFADevicesOutput), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opPutGroupPolicy = "PutGroupPolicy"
+
+// PutGroupPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the PutGroupPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See PutGroupPolicy for more information on using the PutGroupPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the PutGroupPolicyRequest method.
+//    req, resp := client.PutGroupPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutGroupPolicy
+func (c *IAM) PutGroupPolicyRequest(input *PutGroupPolicyInput) (req *request.Request, output *PutGroupPolicyOutput) {
+	op := &request.Operation{
+		Name:       opPutGroupPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &PutGroupPolicyInput{}
+	}
+
+	output = &PutGroupPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// PutGroupPolicy API operation for AWS Identity and Access Management.
+//
+// Adds or updates an inline policy document that is embedded in the specified
+// IAM group.
+//
+// A user can also have managed policies attached to it. To attach a managed
+// policy to a group, use AttachGroupPolicy. To create a new managed policy,
+// use CreatePolicy. For information about policies, see Managed Policies and
+// Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// For information about limits on the number of inline policies that you can
+// embed in a group, see Limitations on IAM Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// Because policy documents can be large, you should use POST rather than GET
+// when calling PutGroupPolicy. For general information about using the Query
+// API with IAM, go to Making Query Requests (https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation PutGroupPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutGroupPolicy
+func (c *IAM) PutGroupPolicy(input *PutGroupPolicyInput) (*PutGroupPolicyOutput, error) {
+	req, out := c.PutGroupPolicyRequest(input)
+	return out, req.Send()
+}
+
+// PutGroupPolicyWithContext is the same as PutGroupPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutGroupPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) PutGroupPolicyWithContext(ctx aws.Context, input *PutGroupPolicyInput, opts ...request.Option) (*PutGroupPolicyOutput, error) {
+	req, out := c.PutGroupPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opPutRolePermissionsBoundary = "PutRolePermissionsBoundary"
+
+// PutRolePermissionsBoundaryRequest generates a "aws/request.Request" representing the
+// client's request for the PutRolePermissionsBoundary operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See PutRolePermissionsBoundary for more information on using the PutRolePermissionsBoundary
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the PutRolePermissionsBoundaryRequest method.
+//    req, resp := client.PutRolePermissionsBoundaryRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutRolePermissionsBoundary
+func (c *IAM) PutRolePermissionsBoundaryRequest(input *PutRolePermissionsBoundaryInput) (req *request.Request, output *PutRolePermissionsBoundaryOutput) {
+	op := &request.Operation{
+		Name:       opPutRolePermissionsBoundary,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &PutRolePermissionsBoundaryInput{}
+	}
+
+	output = &PutRolePermissionsBoundaryOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// PutRolePermissionsBoundary API operation for AWS Identity and Access Management.
+//
+// Adds or updates the policy that is specified as the IAM role's permissions
+// boundary. You can use an AWS managed policy or a customer managed policy
+// to set the boundary for a role. Use the boundary to control the maximum permissions
+// that the role can have. Setting a permissions boundary is an advanced feature
+// that can affect the permissions for the role.
+//
+// You cannot set the boundary for a service-linked role.
+//
+// Policies used as permissions boundaries do not provide permissions. You must
+// also attach a permissions policy to the role. To learn how the effective
+// permissions for a role are evaluated, see IAM JSON Policy Evaluation Logic
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation PutRolePermissionsBoundary for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodePolicyNotAttachableException "PolicyNotAttachable"
+//   The request failed because AWS service role policies can only be attached
+//   to the service-linked role for that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutRolePermissionsBoundary
+func (c *IAM) PutRolePermissionsBoundary(input *PutRolePermissionsBoundaryInput) (*PutRolePermissionsBoundaryOutput, error) {
+	req, out := c.PutRolePermissionsBoundaryRequest(input)
+	return out, req.Send()
+}
+
+// PutRolePermissionsBoundaryWithContext is the same as PutRolePermissionsBoundary with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutRolePermissionsBoundary for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) PutRolePermissionsBoundaryWithContext(ctx aws.Context, input *PutRolePermissionsBoundaryInput, opts ...request.Option) (*PutRolePermissionsBoundaryOutput, error) {
+	req, out := c.PutRolePermissionsBoundaryRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opPutRolePolicy = "PutRolePolicy"
+
+// PutRolePolicyRequest generates a "aws/request.Request" representing the
+// client's request for the PutRolePolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See PutRolePolicy for more information on using the PutRolePolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the PutRolePolicyRequest method.
+//    req, resp := client.PutRolePolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutRolePolicy
+func (c *IAM) PutRolePolicyRequest(input *PutRolePolicyInput) (req *request.Request, output *PutRolePolicyOutput) {
+	op := &request.Operation{
+		Name:       opPutRolePolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &PutRolePolicyInput{}
+	}
+
+	output = &PutRolePolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// PutRolePolicy API operation for AWS Identity and Access Management.
+//
+// Adds or updates an inline policy document that is embedded in the specified
+// IAM role.
+//
+// When you embed an inline policy in a role, the inline policy is used as part
+// of the role's access (permissions) policy. The role's trust policy is created
+// at the same time as the role, using CreateRole. You can update a role's trust
+// policy using UpdateAssumeRolePolicy. For more information about IAM roles,
+// go to Using Roles to Delegate Permissions and Federate Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-toplevel.html).
+//
+// A role can also have a managed policy attached to it. To attach a managed
+// policy to a role, use AttachRolePolicy. To create a new managed policy, use
+// CreatePolicy. For information about policies, see Managed Policies and Inline
+// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// For information about limits on the number of inline policies that you can
+// embed with a role, see Limitations on IAM Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// Because policy documents can be large, you should use POST rather than GET
+// when calling PutRolePolicy. For general information about using the Query
+// API with IAM, go to Making Query Requests (https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation PutRolePolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutRolePolicy
+func (c *IAM) PutRolePolicy(input *PutRolePolicyInput) (*PutRolePolicyOutput, error) {
+	req, out := c.PutRolePolicyRequest(input)
+	return out, req.Send()
+}
+
+// PutRolePolicyWithContext is the same as PutRolePolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutRolePolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) PutRolePolicyWithContext(ctx aws.Context, input *PutRolePolicyInput, opts ...request.Option) (*PutRolePolicyOutput, error) {
+	req, out := c.PutRolePolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opPutUserPermissionsBoundary = "PutUserPermissionsBoundary"
+
+// PutUserPermissionsBoundaryRequest generates a "aws/request.Request" representing the
+// client's request for the PutUserPermissionsBoundary operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See PutUserPermissionsBoundary for more information on using the PutUserPermissionsBoundary
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the PutUserPermissionsBoundaryRequest method.
+//    req, resp := client.PutUserPermissionsBoundaryRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutUserPermissionsBoundary
+func (c *IAM) PutUserPermissionsBoundaryRequest(input *PutUserPermissionsBoundaryInput) (req *request.Request, output *PutUserPermissionsBoundaryOutput) {
+	op := &request.Operation{
+		Name:       opPutUserPermissionsBoundary,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &PutUserPermissionsBoundaryInput{}
+	}
+
+	output = &PutUserPermissionsBoundaryOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// PutUserPermissionsBoundary API operation for AWS Identity and Access Management.
+//
+// Adds or updates the policy that is specified as the IAM user's permissions
+// boundary. You can use an AWS managed policy or a customer managed policy
+// to set the boundary for a user. Use the boundary to control the maximum permissions
+// that the user can have. Setting a permissions boundary is an advanced feature
+// that can affect the permissions for the user.
+//
+// Policies that are used as permissions boundaries do not provide permissions.
+// You must also attach a permissions policy to the user. To learn how the effective
+// permissions for a user are evaluated, see IAM JSON Policy Evaluation Logic
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation PutUserPermissionsBoundary for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodePolicyNotAttachableException "PolicyNotAttachable"
+//   The request failed because AWS service role policies can only be attached
+//   to the service-linked role for that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutUserPermissionsBoundary
+func (c *IAM) PutUserPermissionsBoundary(input *PutUserPermissionsBoundaryInput) (*PutUserPermissionsBoundaryOutput, error) {
+	req, out := c.PutUserPermissionsBoundaryRequest(input)
+	return out, req.Send()
+}
+
+// PutUserPermissionsBoundaryWithContext is the same as PutUserPermissionsBoundary with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutUserPermissionsBoundary for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) PutUserPermissionsBoundaryWithContext(ctx aws.Context, input *PutUserPermissionsBoundaryInput, opts ...request.Option) (*PutUserPermissionsBoundaryOutput, error) {
+	req, out := c.PutUserPermissionsBoundaryRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opPutUserPolicy = "PutUserPolicy"
+
+// PutUserPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the PutUserPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See PutUserPolicy for more information on using the PutUserPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the PutUserPolicyRequest method.
+//    req, resp := client.PutUserPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutUserPolicy
+func (c *IAM) PutUserPolicyRequest(input *PutUserPolicyInput) (req *request.Request, output *PutUserPolicyOutput) {
+	op := &request.Operation{
+		Name:       opPutUserPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &PutUserPolicyInput{}
+	}
+
+	output = &PutUserPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// PutUserPolicy API operation for AWS Identity and Access Management.
+//
+// Adds or updates an inline policy document that is embedded in the specified
+// IAM user.
+//
+// An IAM user can also have a managed policy attached to it. To attach a managed
+// policy to a user, use AttachUserPolicy. To create a new managed policy, use
+// CreatePolicy. For information about policies, see Managed Policies and Inline
+// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// For information about limits on the number of inline policies that you can
+// embed in a user, see Limitations on IAM Entities (https://docs.aws.amazon.com/IAM/latest/UserGuide/LimitationsOnEntities.html)
+// in the IAM User Guide.
+//
+// Because policy documents can be large, you should use POST rather than GET
+// when calling PutUserPolicy. For general information about using the Query
+// API with IAM, go to Making Query Requests (https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation PutUserPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/PutUserPolicy
+func (c *IAM) PutUserPolicy(input *PutUserPolicyInput) (*PutUserPolicyOutput, error) {
+	req, out := c.PutUserPolicyRequest(input)
+	return out, req.Send()
+}
+
+// PutUserPolicyWithContext is the same as PutUserPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See PutUserPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) PutUserPolicyWithContext(ctx aws.Context, input *PutUserPolicyInput, opts ...request.Option) (*PutUserPolicyOutput, error) {
+	req, out := c.PutUserPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opRemoveClientIDFromOpenIDConnectProvider = "RemoveClientIDFromOpenIDConnectProvider"
+
+// RemoveClientIDFromOpenIDConnectProviderRequest generates a "aws/request.Request" representing the
+// client's request for the RemoveClientIDFromOpenIDConnectProvider operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See RemoveClientIDFromOpenIDConnectProvider for more information on using the RemoveClientIDFromOpenIDConnectProvider
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the RemoveClientIDFromOpenIDConnectProviderRequest method.
+//    req, resp := client.RemoveClientIDFromOpenIDConnectProviderRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RemoveClientIDFromOpenIDConnectProvider
+func (c *IAM) RemoveClientIDFromOpenIDConnectProviderRequest(input *RemoveClientIDFromOpenIDConnectProviderInput) (req *request.Request, output *RemoveClientIDFromOpenIDConnectProviderOutput) {
+	op := &request.Operation{
+		Name:       opRemoveClientIDFromOpenIDConnectProvider,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RemoveClientIDFromOpenIDConnectProviderInput{}
+	}
+
+	output = &RemoveClientIDFromOpenIDConnectProviderOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// RemoveClientIDFromOpenIDConnectProvider API operation for AWS Identity and Access Management.
+//
+// Removes the specified client ID (also known as audience) from the list of
+// client IDs registered for the specified IAM OpenID Connect (OIDC) provider
+// resource object.
+//
+// This operation is idempotent; it does not fail or return an error if you
+// try to remove a client ID that does not exist.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation RemoveClientIDFromOpenIDConnectProvider for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RemoveClientIDFromOpenIDConnectProvider
+func (c *IAM) RemoveClientIDFromOpenIDConnectProvider(input *RemoveClientIDFromOpenIDConnectProviderInput) (*RemoveClientIDFromOpenIDConnectProviderOutput, error) {
+	req, out := c.RemoveClientIDFromOpenIDConnectProviderRequest(input)
+	return out, req.Send()
+}
+
+// RemoveClientIDFromOpenIDConnectProviderWithContext is the same as RemoveClientIDFromOpenIDConnectProvider with the addition of
+// the ability to pass a context and additional request options.
+//
+// See RemoveClientIDFromOpenIDConnectProvider for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) RemoveClientIDFromOpenIDConnectProviderWithContext(ctx aws.Context, input *RemoveClientIDFromOpenIDConnectProviderInput, opts ...request.Option) (*RemoveClientIDFromOpenIDConnectProviderOutput, error) {
+	req, out := c.RemoveClientIDFromOpenIDConnectProviderRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opRemoveRoleFromInstanceProfile = "RemoveRoleFromInstanceProfile"
+
+// RemoveRoleFromInstanceProfileRequest generates a "aws/request.Request" representing the
+// client's request for the RemoveRoleFromInstanceProfile operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See RemoveRoleFromInstanceProfile for more information on using the RemoveRoleFromInstanceProfile
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the RemoveRoleFromInstanceProfileRequest method.
+//    req, resp := client.RemoveRoleFromInstanceProfileRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RemoveRoleFromInstanceProfile
+func (c *IAM) RemoveRoleFromInstanceProfileRequest(input *RemoveRoleFromInstanceProfileInput) (req *request.Request, output *RemoveRoleFromInstanceProfileOutput) {
+	op := &request.Operation{
+		Name:       opRemoveRoleFromInstanceProfile,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RemoveRoleFromInstanceProfileInput{}
+	}
+
+	output = &RemoveRoleFromInstanceProfileOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// RemoveRoleFromInstanceProfile API operation for AWS Identity and Access Management.
+//
+// Removes the specified IAM role from the specified EC2 instance profile.
+//
+// Make sure that you do not have any Amazon EC2 instances running with the
+// role you are about to remove from the instance profile. Removing a role from
+// an instance profile that is associated with a running instance might break
+// any applications running on the instance.
+//
+// For more information about IAM roles, go to Working with Roles (https://docs.aws.amazon.com/IAM/latest/UserGuide/WorkingWithRoles.html).
+// For more information about instance profiles, go to About Instance Profiles
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/AboutInstanceProfiles.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation RemoveRoleFromInstanceProfile for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RemoveRoleFromInstanceProfile
+func (c *IAM) RemoveRoleFromInstanceProfile(input *RemoveRoleFromInstanceProfileInput) (*RemoveRoleFromInstanceProfileOutput, error) {
+	req, out := c.RemoveRoleFromInstanceProfileRequest(input)
+	return out, req.Send()
+}
+
+// RemoveRoleFromInstanceProfileWithContext is the same as RemoveRoleFromInstanceProfile with the addition of
+// the ability to pass a context and additional request options.
+//
+// See RemoveRoleFromInstanceProfile for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) RemoveRoleFromInstanceProfileWithContext(ctx aws.Context, input *RemoveRoleFromInstanceProfileInput, opts ...request.Option) (*RemoveRoleFromInstanceProfileOutput, error) {
+	req, out := c.RemoveRoleFromInstanceProfileRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opRemoveUserFromGroup = "RemoveUserFromGroup"
+
+// RemoveUserFromGroupRequest generates a "aws/request.Request" representing the
+// client's request for the RemoveUserFromGroup operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See RemoveUserFromGroup for more information on using the RemoveUserFromGroup
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the RemoveUserFromGroupRequest method.
+//    req, resp := client.RemoveUserFromGroupRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RemoveUserFromGroup
+func (c *IAM) RemoveUserFromGroupRequest(input *RemoveUserFromGroupInput) (req *request.Request, output *RemoveUserFromGroupOutput) {
+	op := &request.Operation{
+		Name:       opRemoveUserFromGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &RemoveUserFromGroupInput{}
+	}
+
+	output = &RemoveUserFromGroupOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// RemoveUserFromGroup API operation for AWS Identity and Access Management.
+//
+// Removes the specified user from the specified group.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation RemoveUserFromGroup for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/RemoveUserFromGroup
+func (c *IAM) RemoveUserFromGroup(input *RemoveUserFromGroupInput) (*RemoveUserFromGroupOutput, error) {
+	req, out := c.RemoveUserFromGroupRequest(input)
+	return out, req.Send()
+}
+
+// RemoveUserFromGroupWithContext is the same as RemoveUserFromGroup with the addition of
+// the ability to pass a context and additional request options.
+//
+// See RemoveUserFromGroup for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) RemoveUserFromGroupWithContext(ctx aws.Context, input *RemoveUserFromGroupInput, opts ...request.Option) (*RemoveUserFromGroupOutput, error) {
+	req, out := c.RemoveUserFromGroupRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opResetServiceSpecificCredential = "ResetServiceSpecificCredential"
+
+// ResetServiceSpecificCredentialRequest generates a "aws/request.Request" representing the
+// client's request for the ResetServiceSpecificCredential operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ResetServiceSpecificCredential for more information on using the ResetServiceSpecificCredential
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ResetServiceSpecificCredentialRequest method.
+//    req, resp := client.ResetServiceSpecificCredentialRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ResetServiceSpecificCredential
+func (c *IAM) ResetServiceSpecificCredentialRequest(input *ResetServiceSpecificCredentialInput) (req *request.Request, output *ResetServiceSpecificCredentialOutput) {
+	op := &request.Operation{
+		Name:       opResetServiceSpecificCredential,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ResetServiceSpecificCredentialInput{}
+	}
+
+	output = &ResetServiceSpecificCredentialOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// ResetServiceSpecificCredential API operation for AWS Identity and Access Management.
+//
+// Resets the password for a service-specific credential. The new password is
+// AWS generated and cryptographically strong. It cannot be configured by the
+// user. Resetting the password immediately invalidates the previous password
+// associated with this user.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ResetServiceSpecificCredential for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ResetServiceSpecificCredential
+func (c *IAM) ResetServiceSpecificCredential(input *ResetServiceSpecificCredentialInput) (*ResetServiceSpecificCredentialOutput, error) {
+	req, out := c.ResetServiceSpecificCredentialRequest(input)
+	return out, req.Send()
+}
+
+// ResetServiceSpecificCredentialWithContext is the same as ResetServiceSpecificCredential with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ResetServiceSpecificCredential for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ResetServiceSpecificCredentialWithContext(ctx aws.Context, input *ResetServiceSpecificCredentialInput, opts ...request.Option) (*ResetServiceSpecificCredentialOutput, error) {
+	req, out := c.ResetServiceSpecificCredentialRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opResyncMFADevice = "ResyncMFADevice"
+
+// ResyncMFADeviceRequest generates a "aws/request.Request" representing the
+// client's request for the ResyncMFADevice operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See ResyncMFADevice for more information on using the ResyncMFADevice
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the ResyncMFADeviceRequest method.
+//    req, resp := client.ResyncMFADeviceRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ResyncMFADevice
+func (c *IAM) ResyncMFADeviceRequest(input *ResyncMFADeviceInput) (req *request.Request, output *ResyncMFADeviceOutput) {
+	op := &request.Operation{
+		Name:       opResyncMFADevice,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &ResyncMFADeviceInput{}
+	}
+
+	output = &ResyncMFADeviceOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// ResyncMFADevice API operation for AWS Identity and Access Management.
+//
+// Synchronizes the specified MFA device with its IAM resource object on the
+// AWS servers.
+//
+// For more information about creating and working with virtual MFA devices,
+// go to Using a Virtual MFA Device (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_VirtualMFA.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation ResyncMFADevice for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidAuthenticationCodeException "InvalidAuthenticationCode"
+//   The request was rejected because the authentication code was not recognized.
+//   The error message describes the specific error.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/ResyncMFADevice
+func (c *IAM) ResyncMFADevice(input *ResyncMFADeviceInput) (*ResyncMFADeviceOutput, error) {
+	req, out := c.ResyncMFADeviceRequest(input)
+	return out, req.Send()
+}
+
+// ResyncMFADeviceWithContext is the same as ResyncMFADevice with the addition of
+// the ability to pass a context and additional request options.
+//
+// See ResyncMFADevice for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) ResyncMFADeviceWithContext(ctx aws.Context, input *ResyncMFADeviceInput, opts ...request.Option) (*ResyncMFADeviceOutput, error) {
+	req, out := c.ResyncMFADeviceRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opSetDefaultPolicyVersion = "SetDefaultPolicyVersion"
+
+// SetDefaultPolicyVersionRequest generates a "aws/request.Request" representing the
+// client's request for the SetDefaultPolicyVersion operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See SetDefaultPolicyVersion for more information on using the SetDefaultPolicyVersion
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the SetDefaultPolicyVersionRequest method.
+//    req, resp := client.SetDefaultPolicyVersionRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SetDefaultPolicyVersion
+func (c *IAM) SetDefaultPolicyVersionRequest(input *SetDefaultPolicyVersionInput) (req *request.Request, output *SetDefaultPolicyVersionOutput) {
+	op := &request.Operation{
+		Name:       opSetDefaultPolicyVersion,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &SetDefaultPolicyVersionInput{}
+	}
+
+	output = &SetDefaultPolicyVersionOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// SetDefaultPolicyVersion API operation for AWS Identity and Access Management.
+//
+// Sets the specified version of the specified policy as the policy's default
+// (operative) version.
+//
+// This operation affects all users, groups, and roles that the policy is attached
+// to. To list the users, groups, and roles that the policy is attached to,
+// use the ListEntitiesForPolicy API.
+//
+// For information about managed policies, see Managed Policies and Inline Policies
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation SetDefaultPolicyVersion for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SetDefaultPolicyVersion
+func (c *IAM) SetDefaultPolicyVersion(input *SetDefaultPolicyVersionInput) (*SetDefaultPolicyVersionOutput, error) {
+	req, out := c.SetDefaultPolicyVersionRequest(input)
+	return out, req.Send()
+}
+
+// SetDefaultPolicyVersionWithContext is the same as SetDefaultPolicyVersion with the addition of
+// the ability to pass a context and additional request options.
+//
+// See SetDefaultPolicyVersion for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) SetDefaultPolicyVersionWithContext(ctx aws.Context, input *SetDefaultPolicyVersionInput, opts ...request.Option) (*SetDefaultPolicyVersionOutput, error) {
+	req, out := c.SetDefaultPolicyVersionRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opSetSecurityTokenServicePreferences = "SetSecurityTokenServicePreferences"
+
+// SetSecurityTokenServicePreferencesRequest generates a "aws/request.Request" representing the
+// client's request for the SetSecurityTokenServicePreferences operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See SetSecurityTokenServicePreferences for more information on using the SetSecurityTokenServicePreferences
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the SetSecurityTokenServicePreferencesRequest method.
+//    req, resp := client.SetSecurityTokenServicePreferencesRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SetSecurityTokenServicePreferences
+func (c *IAM) SetSecurityTokenServicePreferencesRequest(input *SetSecurityTokenServicePreferencesInput) (req *request.Request, output *SetSecurityTokenServicePreferencesOutput) {
+	op := &request.Operation{
+		Name:       opSetSecurityTokenServicePreferences,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &SetSecurityTokenServicePreferencesInput{}
+	}
+
+	output = &SetSecurityTokenServicePreferencesOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// SetSecurityTokenServicePreferences API operation for AWS Identity and Access Management.
+//
+// Sets the specified version of the global endpoint token as the token version
+// used for the AWS account.
+//
+// By default, AWS Security Token Service (STS) is available as a global service,
+// and all STS requests go to a single endpoint at https://sts.amazonaws.com.
+// AWS recommends using Regional STS endpoints to reduce latency, build in redundancy,
+// and increase session token availability. For information about Regional endpoints
+// for STS, see AWS Regions and Endpoints (https://docs.aws.amazon.com/general/latest/gr/rande.html#sts_region)
+// in the AWS General Reference.
+//
+// If you make an STS call to the global endpoint, the resulting session tokens
+// might be valid in some Regions but not others. It depends on the version
+// that is set in this operation. Version 1 tokens are valid only in AWS Regions
+// that are available by default. These tokens do not work in manually enabled
+// Regions, such as Asia Pacific (Hong Kong). Version 2 tokens are valid in
+// all Regions. However, version 2 tokens are longer and might affect systems
+// where you temporarily store tokens. For information, see Activating and Deactivating
+// STS in an AWS Region (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
+// in the IAM User Guide.
+//
+// To view the current session token version, see the GlobalEndpointTokenVersion
+// entry in the response of the GetAccountSummary operation.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation SetSecurityTokenServicePreferences for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SetSecurityTokenServicePreferences
+func (c *IAM) SetSecurityTokenServicePreferences(input *SetSecurityTokenServicePreferencesInput) (*SetSecurityTokenServicePreferencesOutput, error) {
+	req, out := c.SetSecurityTokenServicePreferencesRequest(input)
+	return out, req.Send()
+}
+
+// SetSecurityTokenServicePreferencesWithContext is the same as SetSecurityTokenServicePreferences with the addition of
+// the ability to pass a context and additional request options.
+//
+// See SetSecurityTokenServicePreferences for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) SetSecurityTokenServicePreferencesWithContext(ctx aws.Context, input *SetSecurityTokenServicePreferencesInput, opts ...request.Option) (*SetSecurityTokenServicePreferencesOutput, error) {
+	req, out := c.SetSecurityTokenServicePreferencesRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opSimulateCustomPolicy = "SimulateCustomPolicy"
+
+// SimulateCustomPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the SimulateCustomPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See SimulateCustomPolicy for more information on using the SimulateCustomPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the SimulateCustomPolicyRequest method.
+//    req, resp := client.SimulateCustomPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SimulateCustomPolicy
+func (c *IAM) SimulateCustomPolicyRequest(input *SimulateCustomPolicyInput) (req *request.Request, output *SimulatePolicyResponse) {
+	op := &request.Operation{
+		Name:       opSimulateCustomPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &SimulateCustomPolicyInput{}
+	}
+
+	output = &SimulatePolicyResponse{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// SimulateCustomPolicy API operation for AWS Identity and Access Management.
+//
+// Simulate how a set of IAM policies and optionally a resource-based policy
+// works with a list of API operations and AWS resources to determine the policies'
+// effective permissions. The policies are provided as strings.
+//
+// The simulation does not perform the API operations; it only checks the authorization
+// to determine if the simulated policies allow or deny the operations.
+//
+// If you want to simulate existing policies attached to an IAM user, group,
+// or role, use SimulatePrincipalPolicy instead.
+//
+// Context keys are variables maintained by AWS and its services that provide
+// details about the context of an API query request. You can use the Condition
+// element of an IAM policy to evaluate context keys. To get the list of context
+// keys that the policies require for correct simulation, use GetContextKeysForCustomPolicy.
+//
+// If the output is long, you can use MaxItems and Marker parameters to paginate
+// the results.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation SimulateCustomPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodePolicyEvaluationException "PolicyEvaluation"
+//   The request failed because a provided policy could not be successfully evaluated.
+//   An additional detailed message indicates the source of the failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SimulateCustomPolicy
+func (c *IAM) SimulateCustomPolicy(input *SimulateCustomPolicyInput) (*SimulatePolicyResponse, error) {
+	req, out := c.SimulateCustomPolicyRequest(input)
+	return out, req.Send()
+}
+
+// SimulateCustomPolicyWithContext is the same as SimulateCustomPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See SimulateCustomPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) SimulateCustomPolicyWithContext(ctx aws.Context, input *SimulateCustomPolicyInput, opts ...request.Option) (*SimulatePolicyResponse, error) {
+	req, out := c.SimulateCustomPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// SimulateCustomPolicyPages iterates over the pages of a SimulateCustomPolicy operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See SimulateCustomPolicy method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a SimulateCustomPolicy operation.
+//    pageNum := 0
+//    err := client.SimulateCustomPolicyPages(params,
+//        func(page *iam.SimulatePolicyResponse, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) SimulateCustomPolicyPages(input *SimulateCustomPolicyInput, fn func(*SimulatePolicyResponse, bool) bool) error {
+	return c.SimulateCustomPolicyPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// SimulateCustomPolicyPagesWithContext same as SimulateCustomPolicyPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) SimulateCustomPolicyPagesWithContext(ctx aws.Context, input *SimulateCustomPolicyInput, fn func(*SimulatePolicyResponse, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *SimulateCustomPolicyInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.SimulateCustomPolicyRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*SimulatePolicyResponse), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opSimulatePrincipalPolicy = "SimulatePrincipalPolicy"
+
+// SimulatePrincipalPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the SimulatePrincipalPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See SimulatePrincipalPolicy for more information on using the SimulatePrincipalPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the SimulatePrincipalPolicyRequest method.
+//    req, resp := client.SimulatePrincipalPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SimulatePrincipalPolicy
+func (c *IAM) SimulatePrincipalPolicyRequest(input *SimulatePrincipalPolicyInput) (req *request.Request, output *SimulatePolicyResponse) {
+	op := &request.Operation{
+		Name:       opSimulatePrincipalPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+		Paginator: &request.Paginator{
+			InputTokens:     []string{"Marker"},
+			OutputTokens:    []string{"Marker"},
+			LimitToken:      "MaxItems",
+			TruncationToken: "IsTruncated",
+		},
+	}
+
+	if input == nil {
+		input = &SimulatePrincipalPolicyInput{}
+	}
+
+	output = &SimulatePolicyResponse{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// SimulatePrincipalPolicy API operation for AWS Identity and Access Management.
+//
+// Simulate how a set of IAM policies attached to an IAM entity works with a
+// list of API operations and AWS resources to determine the policies' effective
+// permissions. The entity can be an IAM user, group, or role. If you specify
+// a user, then the simulation also includes all of the policies that are attached
+// to groups that the user belongs to.
+//
+// You can optionally include a list of one or more additional policies specified
+// as strings to include in the simulation. If you want to simulate only policies
+// specified as strings, use SimulateCustomPolicy instead.
+//
+// You can also optionally include one resource-based policy to be evaluated
+// with each of the resources included in the simulation.
+//
+// The simulation does not perform the API operations; it only checks the authorization
+// to determine if the simulated policies allow or deny the operations.
+//
+// Note: This API discloses information about the permissions granted to other
+// users. If you do not want users to see other user's permissions, then consider
+// allowing them to use SimulateCustomPolicy instead.
+//
+// Context keys are variables maintained by AWS and its services that provide
+// details about the context of an API query request. You can use the Condition
+// element of an IAM policy to evaluate context keys. To get the list of context
+// keys that the policies require for correct simulation, use GetContextKeysForPrincipalPolicy.
+//
+// If the output is long, you can use the MaxItems and Marker parameters to
+// paginate the results.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation SimulatePrincipalPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodePolicyEvaluationException "PolicyEvaluation"
+//   The request failed because a provided policy could not be successfully evaluated.
+//   An additional detailed message indicates the source of the failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/SimulatePrincipalPolicy
+func (c *IAM) SimulatePrincipalPolicy(input *SimulatePrincipalPolicyInput) (*SimulatePolicyResponse, error) {
+	req, out := c.SimulatePrincipalPolicyRequest(input)
+	return out, req.Send()
+}
+
+// SimulatePrincipalPolicyWithContext is the same as SimulatePrincipalPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See SimulatePrincipalPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) SimulatePrincipalPolicyWithContext(ctx aws.Context, input *SimulatePrincipalPolicyInput, opts ...request.Option) (*SimulatePolicyResponse, error) {
+	req, out := c.SimulatePrincipalPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// SimulatePrincipalPolicyPages iterates over the pages of a SimulatePrincipalPolicy operation,
+// calling the "fn" function with the response data for each page. To stop
+// iterating, return false from the fn function.
+//
+// See SimulatePrincipalPolicy method for more information on how to use this operation.
+//
+// Note: This operation can generate multiple requests to a service.
+//
+//    // Example iterating over at most 3 pages of a SimulatePrincipalPolicy operation.
+//    pageNum := 0
+//    err := client.SimulatePrincipalPolicyPages(params,
+//        func(page *iam.SimulatePolicyResponse, lastPage bool) bool {
+//            pageNum++
+//            fmt.Println(page)
+//            return pageNum <= 3
+//        })
+//
+func (c *IAM) SimulatePrincipalPolicyPages(input *SimulatePrincipalPolicyInput, fn func(*SimulatePolicyResponse, bool) bool) error {
+	return c.SimulatePrincipalPolicyPagesWithContext(aws.BackgroundContext(), input, fn)
+}
+
+// SimulatePrincipalPolicyPagesWithContext same as SimulatePrincipalPolicyPages except
+// it takes a Context and allows setting request options on the pages.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) SimulatePrincipalPolicyPagesWithContext(ctx aws.Context, input *SimulatePrincipalPolicyInput, fn func(*SimulatePolicyResponse, bool) bool, opts ...request.Option) error {
+	p := request.Pagination{
+		NewRequest: func() (*request.Request, error) {
+			var inCpy *SimulatePrincipalPolicyInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.SimulatePrincipalPolicyRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+
+	cont := true
+	for p.Next() && cont {
+		cont = fn(p.Page().(*SimulatePolicyResponse), !p.HasNextPage())
+	}
+	return p.Err()
+}
+
+const opTagRole = "TagRole"
+
+// TagRoleRequest generates a "aws/request.Request" representing the
+// client's request for the TagRole operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See TagRole for more information on using the TagRole
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the TagRoleRequest method.
+//    req, resp := client.TagRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagRole
+func (c *IAM) TagRoleRequest(input *TagRoleInput) (req *request.Request, output *TagRoleOutput) {
+	op := &request.Operation{
+		Name:       opTagRole,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &TagRoleInput{}
+	}
+
+	output = &TagRoleOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// TagRole API operation for AWS Identity and Access Management.
+//
+// Adds one or more tags to an IAM role. The role can be a regular role or a
+// service-linked role. If a tag with the same key name already exists, then
+// that tag is overwritten with the new value.
+//
+// A tag consists of a key name and an associated value. By assigning tags to
+// your resources, you can do the following:
+//
+//    * Administrative grouping and discovery - Attach tags to resources to
+//    aid in organization and search. For example, you could search for all
+//    resources with the key name Project and the value MyImportantProject.
+//    Or search for all resources with the key name Cost Center and the value
+//    41200.
+//
+//    * Access control - Reference tags in IAM user-based and resource-based
+//    policies. You can use tags to restrict access to only an IAM user or role
+//    that has a specified tag attached. You can also restrict access to only
+//    those resources that have a certain tag attached. For examples of policies
+//    that show how to use tags to control access, see Control Access Using
+//    IAM Tags (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)
+//    in the IAM User Guide.
+//
+//    * Cost allocation - Use tags to help track which individuals and teams
+//    are using which AWS resources.
+//
+//    * Make sure that you have no invalid tags and that you do not exceed the
+//    allowed number of tags per role. In either case, the entire request fails
+//    and no tags are added to the role.
+//
+//    * AWS always interprets the tag Value as a single string. If you need
+//    to store an array, you can store comma-separated values in the string.
+//    However, you must interpret the value in your code.
+//
+// For more information about tagging, see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation TagRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeConcurrentModificationException "ConcurrentModification"
+//   The request was rejected because multiple requests to change this object
+//   were submitted simultaneously. Wait a few minutes and submit your request
+//   again.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagRole
+func (c *IAM) TagRole(input *TagRoleInput) (*TagRoleOutput, error) {
+	req, out := c.TagRoleRequest(input)
+	return out, req.Send()
+}
+
+// TagRoleWithContext is the same as TagRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See TagRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) TagRoleWithContext(ctx aws.Context, input *TagRoleInput, opts ...request.Option) (*TagRoleOutput, error) {
+	req, out := c.TagRoleRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opTagUser = "TagUser"
+
+// TagUserRequest generates a "aws/request.Request" representing the
+// client's request for the TagUser operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See TagUser for more information on using the TagUser
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the TagUserRequest method.
+//    req, resp := client.TagUserRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagUser
+func (c *IAM) TagUserRequest(input *TagUserInput) (req *request.Request, output *TagUserOutput) {
+	op := &request.Operation{
+		Name:       opTagUser,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &TagUserInput{}
+	}
+
+	output = &TagUserOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// TagUser API operation for AWS Identity and Access Management.
+//
+// Adds one or more tags to an IAM user. If a tag with the same key name already
+// exists, then that tag is overwritten with the new value.
+//
+// A tag consists of a key name and an associated value. By assigning tags to
+// your resources, you can do the following:
+//
+//    * Administrative grouping and discovery - Attach tags to resources to
+//    aid in organization and search. For example, you could search for all
+//    resources with the key name Project and the value MyImportantProject.
+//    Or search for all resources with the key name Cost Center and the value
+//    41200.
+//
+//    * Access control - Reference tags in IAM user-based and resource-based
+//    policies. You can use tags to restrict access to only an IAM requesting
+//    user or to a role that has a specified tag attached. You can also restrict
+//    access to only those resources that have a certain tag attached. For examples
+//    of policies that show how to use tags to control access, see Control Access
+//    Using IAM Tags (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)
+//    in the IAM User Guide.
+//
+//    * Cost allocation - Use tags to help track which individuals and teams
+//    are using which AWS resources.
+//
+//    * Make sure that you have no invalid tags and that you do not exceed the
+//    allowed number of tags per role. In either case, the entire request fails
+//    and no tags are added to the role.
+//
+//    * AWS always interprets the tag Value as a single string. If you need
+//    to store an array, you can store comma-separated values in the string.
+//    However, you must interpret the value in your code.
+//
+// For more information about tagging, see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation TagUser for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeConcurrentModificationException "ConcurrentModification"
+//   The request was rejected because multiple requests to change this object
+//   were submitted simultaneously. Wait a few minutes and submit your request
+//   again.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/TagUser
+func (c *IAM) TagUser(input *TagUserInput) (*TagUserOutput, error) {
+	req, out := c.TagUserRequest(input)
+	return out, req.Send()
+}
+
+// TagUserWithContext is the same as TagUser with the addition of
+// the ability to pass a context and additional request options.
+//
+// See TagUser for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) TagUserWithContext(ctx aws.Context, input *TagUserInput, opts ...request.Option) (*TagUserOutput, error) {
+	req, out := c.TagUserRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUntagRole = "UntagRole"
+
+// UntagRoleRequest generates a "aws/request.Request" representing the
+// client's request for the UntagRole operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UntagRole for more information on using the UntagRole
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UntagRoleRequest method.
+//    req, resp := client.UntagRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagRole
+func (c *IAM) UntagRoleRequest(input *UntagRoleInput) (req *request.Request, output *UntagRoleOutput) {
+	op := &request.Operation{
+		Name:       opUntagRole,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UntagRoleInput{}
+	}
+
+	output = &UntagRoleOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UntagRole API operation for AWS Identity and Access Management.
+//
+// Removes the specified tags from the role. For more information about tagging,
+// see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UntagRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeConcurrentModificationException "ConcurrentModification"
+//   The request was rejected because multiple requests to change this object
+//   were submitted simultaneously. Wait a few minutes and submit your request
+//   again.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagRole
+func (c *IAM) UntagRole(input *UntagRoleInput) (*UntagRoleOutput, error) {
+	req, out := c.UntagRoleRequest(input)
+	return out, req.Send()
+}
+
+// UntagRoleWithContext is the same as UntagRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UntagRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UntagRoleWithContext(ctx aws.Context, input *UntagRoleInput, opts ...request.Option) (*UntagRoleOutput, error) {
+	req, out := c.UntagRoleRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUntagUser = "UntagUser"
+
+// UntagUserRequest generates a "aws/request.Request" representing the
+// client's request for the UntagUser operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UntagUser for more information on using the UntagUser
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UntagUserRequest method.
+//    req, resp := client.UntagUserRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagUser
+func (c *IAM) UntagUserRequest(input *UntagUserInput) (req *request.Request, output *UntagUserOutput) {
+	op := &request.Operation{
+		Name:       opUntagUser,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UntagUserInput{}
+	}
+
+	output = &UntagUserOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UntagUser API operation for AWS Identity and Access Management.
+//
+// Removes the specified tags from the user. For more information about tagging,
+// see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UntagUser for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeConcurrentModificationException "ConcurrentModification"
+//   The request was rejected because multiple requests to change this object
+//   were submitted simultaneously. Wait a few minutes and submit your request
+//   again.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UntagUser
+func (c *IAM) UntagUser(input *UntagUserInput) (*UntagUserOutput, error) {
+	req, out := c.UntagUserRequest(input)
+	return out, req.Send()
+}
+
+// UntagUserWithContext is the same as UntagUser with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UntagUser for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UntagUserWithContext(ctx aws.Context, input *UntagUserInput, opts ...request.Option) (*UntagUserOutput, error) {
+	req, out := c.UntagUserRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateAccessKey = "UpdateAccessKey"
+
+// UpdateAccessKeyRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateAccessKey operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateAccessKey for more information on using the UpdateAccessKey
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateAccessKeyRequest method.
+//    req, resp := client.UpdateAccessKeyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateAccessKey
+func (c *IAM) UpdateAccessKeyRequest(input *UpdateAccessKeyInput) (req *request.Request, output *UpdateAccessKeyOutput) {
+	op := &request.Operation{
+		Name:       opUpdateAccessKey,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateAccessKeyInput{}
+	}
+
+	output = &UpdateAccessKeyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateAccessKey API operation for AWS Identity and Access Management.
+//
+// Changes the status of the specified access key from Active to Inactive, or
+// vice versa. This operation can be used to disable a user's key as part of
+// a key rotation workflow.
+//
+// If the UserName is not specified, the user name is determined implicitly
+// based on the AWS access key ID used to sign the request. This operation works
+// for access keys under the AWS account. Consequently, you can use this operation
+// to manage AWS account root user credentials even if the AWS account has no
+// associated users.
+//
+// For information about rotating keys, see Managing Keys and Certificates (https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingCredentials.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateAccessKey for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateAccessKey
+func (c *IAM) UpdateAccessKey(input *UpdateAccessKeyInput) (*UpdateAccessKeyOutput, error) {
+	req, out := c.UpdateAccessKeyRequest(input)
+	return out, req.Send()
+}
+
+// UpdateAccessKeyWithContext is the same as UpdateAccessKey with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateAccessKey for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateAccessKeyWithContext(ctx aws.Context, input *UpdateAccessKeyInput, opts ...request.Option) (*UpdateAccessKeyOutput, error) {
+	req, out := c.UpdateAccessKeyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateAccountPasswordPolicy = "UpdateAccountPasswordPolicy"
+
+// UpdateAccountPasswordPolicyRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateAccountPasswordPolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateAccountPasswordPolicy for more information on using the UpdateAccountPasswordPolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateAccountPasswordPolicyRequest method.
+//    req, resp := client.UpdateAccountPasswordPolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateAccountPasswordPolicy
+func (c *IAM) UpdateAccountPasswordPolicyRequest(input *UpdateAccountPasswordPolicyInput) (req *request.Request, output *UpdateAccountPasswordPolicyOutput) {
+	op := &request.Operation{
+		Name:       opUpdateAccountPasswordPolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateAccountPasswordPolicyInput{}
+	}
+
+	output = &UpdateAccountPasswordPolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateAccountPasswordPolicy API operation for AWS Identity and Access Management.
+//
+// Updates the password policy settings for the AWS account.
+//
+//    * This operation does not support partial updates. No parameters are required,
+//    but if you do not specify a parameter, that parameter's value reverts
+//    to its default value. See the Request Parameters section for each parameter's
+//    default value. Also note that some parameters do not allow the default
+//    parameter to be explicitly set. Instead, to invoke the default value,
+//    do not include that parameter when you invoke the operation.
+//
+// For more information about using a password policy, see Managing an IAM Password
+// Policy (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingPasswordPolicies.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateAccountPasswordPolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateAccountPasswordPolicy
+func (c *IAM) UpdateAccountPasswordPolicy(input *UpdateAccountPasswordPolicyInput) (*UpdateAccountPasswordPolicyOutput, error) {
+	req, out := c.UpdateAccountPasswordPolicyRequest(input)
+	return out, req.Send()
+}
+
+// UpdateAccountPasswordPolicyWithContext is the same as UpdateAccountPasswordPolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateAccountPasswordPolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateAccountPasswordPolicyWithContext(ctx aws.Context, input *UpdateAccountPasswordPolicyInput, opts ...request.Option) (*UpdateAccountPasswordPolicyOutput, error) {
+	req, out := c.UpdateAccountPasswordPolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateAssumeRolePolicy = "UpdateAssumeRolePolicy"
+
+// UpdateAssumeRolePolicyRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateAssumeRolePolicy operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateAssumeRolePolicy for more information on using the UpdateAssumeRolePolicy
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateAssumeRolePolicyRequest method.
+//    req, resp := client.UpdateAssumeRolePolicyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateAssumeRolePolicy
+func (c *IAM) UpdateAssumeRolePolicyRequest(input *UpdateAssumeRolePolicyInput) (req *request.Request, output *UpdateAssumeRolePolicyOutput) {
+	op := &request.Operation{
+		Name:       opUpdateAssumeRolePolicy,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateAssumeRolePolicyInput{}
+	}
+
+	output = &UpdateAssumeRolePolicyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateAssumeRolePolicy API operation for AWS Identity and Access Management.
+//
+// Updates the policy that grants an IAM entity permission to assume a role.
+// This is typically referred to as the "role trust policy". For more information
+// about roles, go to Using Roles to Delegate Permissions and Federate Identities
+// (https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-toplevel.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateAssumeRolePolicy for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeMalformedPolicyDocumentException "MalformedPolicyDocument"
+//   The request was rejected because the policy document was malformed. The error
+//   message describes the specific error.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateAssumeRolePolicy
+func (c *IAM) UpdateAssumeRolePolicy(input *UpdateAssumeRolePolicyInput) (*UpdateAssumeRolePolicyOutput, error) {
+	req, out := c.UpdateAssumeRolePolicyRequest(input)
+	return out, req.Send()
+}
+
+// UpdateAssumeRolePolicyWithContext is the same as UpdateAssumeRolePolicy with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateAssumeRolePolicy for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateAssumeRolePolicyWithContext(ctx aws.Context, input *UpdateAssumeRolePolicyInput, opts ...request.Option) (*UpdateAssumeRolePolicyOutput, error) {
+	req, out := c.UpdateAssumeRolePolicyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateGroup = "UpdateGroup"
+
+// UpdateGroupRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateGroup operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateGroup for more information on using the UpdateGroup
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateGroupRequest method.
+//    req, resp := client.UpdateGroupRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateGroup
+func (c *IAM) UpdateGroupRequest(input *UpdateGroupInput) (req *request.Request, output *UpdateGroupOutput) {
+	op := &request.Operation{
+		Name:       opUpdateGroup,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateGroupInput{}
+	}
+
+	output = &UpdateGroupOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateGroup API operation for AWS Identity and Access Management.
+//
+// Updates the name and/or the path of the specified IAM group.
+//
+// You should understand the implications of changing a group's path or name.
+// For more information, see Renaming Users and Groups (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_WorkingWithGroupsAndUsers.html)
+// in the IAM User Guide.
+//
+// The person making the request (the principal), must have permission to change
+// the role group with the old name and the new name. For example, to change
+// the group named Managers to MGRs, the principal must have a policy that allows
+// them to update both groups. If the principal has permission to update the
+// Managers group, but not the MGRs group, then the update fails. For more information
+// about permissions, see Access Management (https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateGroup for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateGroup
+func (c *IAM) UpdateGroup(input *UpdateGroupInput) (*UpdateGroupOutput, error) {
+	req, out := c.UpdateGroupRequest(input)
+	return out, req.Send()
+}
+
+// UpdateGroupWithContext is the same as UpdateGroup with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateGroup for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateGroupWithContext(ctx aws.Context, input *UpdateGroupInput, opts ...request.Option) (*UpdateGroupOutput, error) {
+	req, out := c.UpdateGroupRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateLoginProfile = "UpdateLoginProfile"
+
+// UpdateLoginProfileRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateLoginProfile operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateLoginProfile for more information on using the UpdateLoginProfile
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateLoginProfileRequest method.
+//    req, resp := client.UpdateLoginProfileRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateLoginProfile
+func (c *IAM) UpdateLoginProfileRequest(input *UpdateLoginProfileInput) (req *request.Request, output *UpdateLoginProfileOutput) {
+	op := &request.Operation{
+		Name:       opUpdateLoginProfile,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateLoginProfileInput{}
+	}
+
+	output = &UpdateLoginProfileOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateLoginProfile API operation for AWS Identity and Access Management.
+//
+// Changes the password for the specified IAM user.
+//
+// IAM users can change their own passwords by calling ChangePassword. For more
+// information about modifying passwords, see Managing Passwords (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingLogins.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateLoginProfile for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeEntityTemporarilyUnmodifiableException "EntityTemporarilyUnmodifiable"
+//   The request was rejected because it referenced an entity that is temporarily
+//   unmodifiable, such as a user name that was deleted and then recreated. The
+//   error indicates that the request is likely to succeed if you try again after
+//   waiting several minutes. The error message describes the entity.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodePasswordPolicyViolationException "PasswordPolicyViolation"
+//   The request was rejected because the provided password did not meet the requirements
+//   imposed by the account password policy.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateLoginProfile
+func (c *IAM) UpdateLoginProfile(input *UpdateLoginProfileInput) (*UpdateLoginProfileOutput, error) {
+	req, out := c.UpdateLoginProfileRequest(input)
+	return out, req.Send()
+}
+
+// UpdateLoginProfileWithContext is the same as UpdateLoginProfile with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateLoginProfile for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateLoginProfileWithContext(ctx aws.Context, input *UpdateLoginProfileInput, opts ...request.Option) (*UpdateLoginProfileOutput, error) {
+	req, out := c.UpdateLoginProfileRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateOpenIDConnectProviderThumbprint = "UpdateOpenIDConnectProviderThumbprint"
+
+// UpdateOpenIDConnectProviderThumbprintRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateOpenIDConnectProviderThumbprint operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateOpenIDConnectProviderThumbprint for more information on using the UpdateOpenIDConnectProviderThumbprint
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateOpenIDConnectProviderThumbprintRequest method.
+//    req, resp := client.UpdateOpenIDConnectProviderThumbprintRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateOpenIDConnectProviderThumbprint
+func (c *IAM) UpdateOpenIDConnectProviderThumbprintRequest(input *UpdateOpenIDConnectProviderThumbprintInput) (req *request.Request, output *UpdateOpenIDConnectProviderThumbprintOutput) {
+	op := &request.Operation{
+		Name:       opUpdateOpenIDConnectProviderThumbprint,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateOpenIDConnectProviderThumbprintInput{}
+	}
+
+	output = &UpdateOpenIDConnectProviderThumbprintOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateOpenIDConnectProviderThumbprint API operation for AWS Identity and Access Management.
+//
+// Replaces the existing list of server certificate thumbprints associated with
+// an OpenID Connect (OIDC) provider resource object with a new list of thumbprints.
+//
+// The list that you pass with this operation completely replaces the existing
+// list of thumbprints. (The lists are not merged.)
+//
+// Typically, you need to update a thumbprint only when the identity provider's
+// certificate changes, which occurs rarely. However, if the provider's certificate
+// does change, any attempt to assume an IAM role that specifies the OIDC provider
+// as a principal fails until the certificate thumbprint is updated.
+//
+// Trust for the OIDC provider is derived from the provider's certificate and
+// is validated by the thumbprint. Therefore, it is best to limit access to
+// the UpdateOpenIDConnectProviderThumbprint operation to highly privileged
+// users.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateOpenIDConnectProviderThumbprint for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateOpenIDConnectProviderThumbprint
+func (c *IAM) UpdateOpenIDConnectProviderThumbprint(input *UpdateOpenIDConnectProviderThumbprintInput) (*UpdateOpenIDConnectProviderThumbprintOutput, error) {
+	req, out := c.UpdateOpenIDConnectProviderThumbprintRequest(input)
+	return out, req.Send()
+}
+
+// UpdateOpenIDConnectProviderThumbprintWithContext is the same as UpdateOpenIDConnectProviderThumbprint with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateOpenIDConnectProviderThumbprint for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateOpenIDConnectProviderThumbprintWithContext(ctx aws.Context, input *UpdateOpenIDConnectProviderThumbprintInput, opts ...request.Option) (*UpdateOpenIDConnectProviderThumbprintOutput, error) {
+	req, out := c.UpdateOpenIDConnectProviderThumbprintRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateRole = "UpdateRole"
+
+// UpdateRoleRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateRole operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateRole for more information on using the UpdateRole
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateRoleRequest method.
+//    req, resp := client.UpdateRoleRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateRole
+func (c *IAM) UpdateRoleRequest(input *UpdateRoleInput) (req *request.Request, output *UpdateRoleOutput) {
+	op := &request.Operation{
+		Name:       opUpdateRole,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateRoleInput{}
+	}
+
+	output = &UpdateRoleOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateRole API operation for AWS Identity and Access Management.
+//
+// Updates the description or maximum session duration setting of a role.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateRole for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateRole
+func (c *IAM) UpdateRole(input *UpdateRoleInput) (*UpdateRoleOutput, error) {
+	req, out := c.UpdateRoleRequest(input)
+	return out, req.Send()
+}
+
+// UpdateRoleWithContext is the same as UpdateRole with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateRole for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateRoleWithContext(ctx aws.Context, input *UpdateRoleInput, opts ...request.Option) (*UpdateRoleOutput, error) {
+	req, out := c.UpdateRoleRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateRoleDescription = "UpdateRoleDescription"
+
+// UpdateRoleDescriptionRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateRoleDescription operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateRoleDescription for more information on using the UpdateRoleDescription
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateRoleDescriptionRequest method.
+//    req, resp := client.UpdateRoleDescriptionRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateRoleDescription
+func (c *IAM) UpdateRoleDescriptionRequest(input *UpdateRoleDescriptionInput) (req *request.Request, output *UpdateRoleDescriptionOutput) {
+	op := &request.Operation{
+		Name:       opUpdateRoleDescription,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateRoleDescriptionInput{}
+	}
+
+	output = &UpdateRoleDescriptionOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// UpdateRoleDescription API operation for AWS Identity and Access Management.
+//
+// Use UpdateRole instead.
+//
+// Modifies only the description of a role. This operation performs the same
+// function as the Description parameter in the UpdateRole operation.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateRoleDescription for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeUnmodifiableEntityException "UnmodifiableEntity"
+//   The request was rejected because only the service that depends on the service-linked
+//   role can modify or delete the role on your behalf. The error message includes
+//   the name of the service that depends on this service-linked role. You must
+//   request the change through that service.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateRoleDescription
+func (c *IAM) UpdateRoleDescription(input *UpdateRoleDescriptionInput) (*UpdateRoleDescriptionOutput, error) {
+	req, out := c.UpdateRoleDescriptionRequest(input)
+	return out, req.Send()
+}
+
+// UpdateRoleDescriptionWithContext is the same as UpdateRoleDescription with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateRoleDescription for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateRoleDescriptionWithContext(ctx aws.Context, input *UpdateRoleDescriptionInput, opts ...request.Option) (*UpdateRoleDescriptionOutput, error) {
+	req, out := c.UpdateRoleDescriptionRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateSAMLProvider = "UpdateSAMLProvider"
+
+// UpdateSAMLProviderRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateSAMLProvider operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateSAMLProvider for more information on using the UpdateSAMLProvider
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateSAMLProviderRequest method.
+//    req, resp := client.UpdateSAMLProviderRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateSAMLProvider
+func (c *IAM) UpdateSAMLProviderRequest(input *UpdateSAMLProviderInput) (req *request.Request, output *UpdateSAMLProviderOutput) {
+	op := &request.Operation{
+		Name:       opUpdateSAMLProvider,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateSAMLProviderInput{}
+	}
+
+	output = &UpdateSAMLProviderOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// UpdateSAMLProvider API operation for AWS Identity and Access Management.
+//
+// Updates the metadata document for an existing SAML provider resource object.
+//
+// This operation requires Signature Version 4 (https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateSAMLProvider for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidInputException "InvalidInput"
+//   The request was rejected because an invalid or out-of-range value was supplied
+//   for an input parameter.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateSAMLProvider
+func (c *IAM) UpdateSAMLProvider(input *UpdateSAMLProviderInput) (*UpdateSAMLProviderOutput, error) {
+	req, out := c.UpdateSAMLProviderRequest(input)
+	return out, req.Send()
+}
+
+// UpdateSAMLProviderWithContext is the same as UpdateSAMLProvider with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateSAMLProvider for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateSAMLProviderWithContext(ctx aws.Context, input *UpdateSAMLProviderInput, opts ...request.Option) (*UpdateSAMLProviderOutput, error) {
+	req, out := c.UpdateSAMLProviderRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateSSHPublicKey = "UpdateSSHPublicKey"
+
+// UpdateSSHPublicKeyRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateSSHPublicKey operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateSSHPublicKey for more information on using the UpdateSSHPublicKey
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateSSHPublicKeyRequest method.
+//    req, resp := client.UpdateSSHPublicKeyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateSSHPublicKey
+func (c *IAM) UpdateSSHPublicKeyRequest(input *UpdateSSHPublicKeyInput) (req *request.Request, output *UpdateSSHPublicKeyOutput) {
+	op := &request.Operation{
+		Name:       opUpdateSSHPublicKey,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateSSHPublicKeyInput{}
+	}
+
+	output = &UpdateSSHPublicKeyOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateSSHPublicKey API operation for AWS Identity and Access Management.
+//
+// Sets the status of an IAM user's SSH public key to active or inactive. SSH
+// public keys that are inactive cannot be used for authentication. This operation
+// can be used to disable a user's SSH public key as part of a key rotation
+// work flow.
+//
+// The SSH public key affected by this operation is used only for authenticating
+// the associated IAM user to an AWS CodeCommit repository. For more information
+// about using SSH keys to authenticate to an AWS CodeCommit repository, see
+// Set up AWS CodeCommit for SSH Connections (https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html)
+// in the AWS CodeCommit User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateSSHPublicKey for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateSSHPublicKey
+func (c *IAM) UpdateSSHPublicKey(input *UpdateSSHPublicKeyInput) (*UpdateSSHPublicKeyOutput, error) {
+	req, out := c.UpdateSSHPublicKeyRequest(input)
+	return out, req.Send()
+}
+
+// UpdateSSHPublicKeyWithContext is the same as UpdateSSHPublicKey with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateSSHPublicKey for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateSSHPublicKeyWithContext(ctx aws.Context, input *UpdateSSHPublicKeyInput, opts ...request.Option) (*UpdateSSHPublicKeyOutput, error) {
+	req, out := c.UpdateSSHPublicKeyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateServerCertificate = "UpdateServerCertificate"
+
+// UpdateServerCertificateRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateServerCertificate operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateServerCertificate for more information on using the UpdateServerCertificate
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateServerCertificateRequest method.
+//    req, resp := client.UpdateServerCertificateRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateServerCertificate
+func (c *IAM) UpdateServerCertificateRequest(input *UpdateServerCertificateInput) (req *request.Request, output *UpdateServerCertificateOutput) {
+	op := &request.Operation{
+		Name:       opUpdateServerCertificate,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateServerCertificateInput{}
+	}
+
+	output = &UpdateServerCertificateOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateServerCertificate API operation for AWS Identity and Access Management.
+//
+// Updates the name and/or the path of the specified server certificate stored
+// in IAM.
+//
+// For more information about working with server certificates, see Working
+// with Server Certificates (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html)
+// in the IAM User Guide. This topic also includes a list of AWS services that
+// can use the server certificates that you manage with IAM.
+//
+// You should understand the implications of changing a server certificate's
+// path or name. For more information, see Renaming a Server Certificate (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs_manage.html#RenamingServerCerts)
+// in the IAM User Guide.
+//
+// The person making the request (the principal), must have permission to change
+// the server certificate with the old name and the new name. For example, to
+// change the certificate named ProductionCert to ProdCert, the principal must
+// have a policy that allows them to update both certificates. If the principal
+// has permission to update the ProductionCert group, but not the ProdCert certificate,
+// then the update fails. For more information about permissions, see Access
+// Management (https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateServerCertificate for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateServerCertificate
+func (c *IAM) UpdateServerCertificate(input *UpdateServerCertificateInput) (*UpdateServerCertificateOutput, error) {
+	req, out := c.UpdateServerCertificateRequest(input)
+	return out, req.Send()
+}
+
+// UpdateServerCertificateWithContext is the same as UpdateServerCertificate with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateServerCertificate for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateServerCertificateWithContext(ctx aws.Context, input *UpdateServerCertificateInput, opts ...request.Option) (*UpdateServerCertificateOutput, error) {
+	req, out := c.UpdateServerCertificateRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateServiceSpecificCredential = "UpdateServiceSpecificCredential"
+
+// UpdateServiceSpecificCredentialRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateServiceSpecificCredential operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateServiceSpecificCredential for more information on using the UpdateServiceSpecificCredential
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateServiceSpecificCredentialRequest method.
+//    req, resp := client.UpdateServiceSpecificCredentialRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateServiceSpecificCredential
+func (c *IAM) UpdateServiceSpecificCredentialRequest(input *UpdateServiceSpecificCredentialInput) (req *request.Request, output *UpdateServiceSpecificCredentialOutput) {
+	op := &request.Operation{
+		Name:       opUpdateServiceSpecificCredential,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateServiceSpecificCredentialInput{}
+	}
+
+	output = &UpdateServiceSpecificCredentialOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateServiceSpecificCredential API operation for AWS Identity and Access Management.
+//
+// Sets the status of a service-specific credential to Active or Inactive. Service-specific
+// credentials that are inactive cannot be used for authentication to the service.
+// This operation can be used to disable a user's service-specific credential
+// as part of a credential rotation work flow.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateServiceSpecificCredential for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateServiceSpecificCredential
+func (c *IAM) UpdateServiceSpecificCredential(input *UpdateServiceSpecificCredentialInput) (*UpdateServiceSpecificCredentialOutput, error) {
+	req, out := c.UpdateServiceSpecificCredentialRequest(input)
+	return out, req.Send()
+}
+
+// UpdateServiceSpecificCredentialWithContext is the same as UpdateServiceSpecificCredential with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateServiceSpecificCredential for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateServiceSpecificCredentialWithContext(ctx aws.Context, input *UpdateServiceSpecificCredentialInput, opts ...request.Option) (*UpdateServiceSpecificCredentialOutput, error) {
+	req, out := c.UpdateServiceSpecificCredentialRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateSigningCertificate = "UpdateSigningCertificate"
+
+// UpdateSigningCertificateRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateSigningCertificate operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateSigningCertificate for more information on using the UpdateSigningCertificate
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateSigningCertificateRequest method.
+//    req, resp := client.UpdateSigningCertificateRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateSigningCertificate
+func (c *IAM) UpdateSigningCertificateRequest(input *UpdateSigningCertificateInput) (req *request.Request, output *UpdateSigningCertificateOutput) {
+	op := &request.Operation{
+		Name:       opUpdateSigningCertificate,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateSigningCertificateInput{}
+	}
+
+	output = &UpdateSigningCertificateOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateSigningCertificate API operation for AWS Identity and Access Management.
+//
+// Changes the status of the specified user signing certificate from active
+// to disabled, or vice versa. This operation can be used to disable an IAM
+// user's signing certificate as part of a certificate rotation work flow.
+//
+// If the UserName field is not specified, the user name is determined implicitly
+// based on the AWS access key ID used to sign the request. This operation works
+// for access keys under the AWS account. Consequently, you can use this operation
+// to manage AWS account root user credentials even if the AWS account has no
+// associated users.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateSigningCertificate for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateSigningCertificate
+func (c *IAM) UpdateSigningCertificate(input *UpdateSigningCertificateInput) (*UpdateSigningCertificateOutput, error) {
+	req, out := c.UpdateSigningCertificateRequest(input)
+	return out, req.Send()
+}
+
+// UpdateSigningCertificateWithContext is the same as UpdateSigningCertificate with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateSigningCertificate for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateSigningCertificateWithContext(ctx aws.Context, input *UpdateSigningCertificateInput, opts ...request.Option) (*UpdateSigningCertificateOutput, error) {
+	req, out := c.UpdateSigningCertificateRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUpdateUser = "UpdateUser"
+
+// UpdateUserRequest generates a "aws/request.Request" representing the
+// client's request for the UpdateUser operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UpdateUser for more information on using the UpdateUser
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UpdateUserRequest method.
+//    req, resp := client.UpdateUserRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateUser
+func (c *IAM) UpdateUserRequest(input *UpdateUserInput) (req *request.Request, output *UpdateUserOutput) {
+	op := &request.Operation{
+		Name:       opUpdateUser,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UpdateUserInput{}
+	}
+
+	output = &UpdateUserOutput{}
+	req = c.newRequest(op, input, output)
+	req.Handlers.Unmarshal.Swap(query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler)
+	return
+}
+
+// UpdateUser API operation for AWS Identity and Access Management.
+//
+// Updates the name and/or the path of the specified IAM user.
+//
+// You should understand the implications of changing an IAM user's path or
+// name. For more information, see Renaming an IAM User (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_manage.html#id_users_renaming)
+// and Renaming an IAM Group (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups_manage_rename.html)
+// in the IAM User Guide.
+//
+// To change a user name, the requester must have appropriate permissions on
+// both the source object and the target object. For example, to change Bob
+// to Robert, the entity making the request must have permission on Bob and
+// Robert, or must have permission on all (*). For more information about permissions,
+// see Permissions and Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/PermissionsAndPolicies.html).
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UpdateUser for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeEntityTemporarilyUnmodifiableException "EntityTemporarilyUnmodifiable"
+//   The request was rejected because it referenced an entity that is temporarily
+//   unmodifiable, such as a user name that was deleted and then recreated. The
+//   error indicates that the request is likely to succeed if you try again after
+//   waiting several minutes. The error message describes the entity.
+//
+//   * ErrCodeConcurrentModificationException "ConcurrentModification"
+//   The request was rejected because multiple requests to change this object
+//   were submitted simultaneously. Wait a few minutes and submit your request
+//   again.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UpdateUser
+func (c *IAM) UpdateUser(input *UpdateUserInput) (*UpdateUserOutput, error) {
+	req, out := c.UpdateUserRequest(input)
+	return out, req.Send()
+}
+
+// UpdateUserWithContext is the same as UpdateUser with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UpdateUser for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UpdateUserWithContext(ctx aws.Context, input *UpdateUserInput, opts ...request.Option) (*UpdateUserOutput, error) {
+	req, out := c.UpdateUserRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUploadSSHPublicKey = "UploadSSHPublicKey"
+
+// UploadSSHPublicKeyRequest generates a "aws/request.Request" representing the
+// client's request for the UploadSSHPublicKey operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UploadSSHPublicKey for more information on using the UploadSSHPublicKey
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UploadSSHPublicKeyRequest method.
+//    req, resp := client.UploadSSHPublicKeyRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UploadSSHPublicKey
+func (c *IAM) UploadSSHPublicKeyRequest(input *UploadSSHPublicKeyInput) (req *request.Request, output *UploadSSHPublicKeyOutput) {
+	op := &request.Operation{
+		Name:       opUploadSSHPublicKey,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UploadSSHPublicKeyInput{}
+	}
+
+	output = &UploadSSHPublicKeyOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// UploadSSHPublicKey API operation for AWS Identity and Access Management.
+//
+// Uploads an SSH public key and associates it with the specified IAM user.
+//
+// The SSH public key uploaded by this operation can be used only for authenticating
+// the associated IAM user to an AWS CodeCommit repository. For more information
+// about using SSH keys to authenticate to an AWS CodeCommit repository, see
+// Set up AWS CodeCommit for SSH Connections (https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-credentials-ssh.html)
+// in the AWS CodeCommit User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UploadSSHPublicKey for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeInvalidPublicKeyException "InvalidPublicKey"
+//   The request was rejected because the public key is malformed or otherwise
+//   invalid.
+//
+//   * ErrCodeDuplicateSSHPublicKeyException "DuplicateSSHPublicKey"
+//   The request was rejected because the SSH public key is already associated
+//   with the specified IAM user.
+//
+//   * ErrCodeUnrecognizedPublicKeyEncodingException "UnrecognizedPublicKeyEncoding"
+//   The request was rejected because the public key encoding format is unsupported
+//   or unrecognized.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UploadSSHPublicKey
+func (c *IAM) UploadSSHPublicKey(input *UploadSSHPublicKeyInput) (*UploadSSHPublicKeyOutput, error) {
+	req, out := c.UploadSSHPublicKeyRequest(input)
+	return out, req.Send()
+}
+
+// UploadSSHPublicKeyWithContext is the same as UploadSSHPublicKey with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UploadSSHPublicKey for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UploadSSHPublicKeyWithContext(ctx aws.Context, input *UploadSSHPublicKeyInput, opts ...request.Option) (*UploadSSHPublicKeyOutput, error) {
+	req, out := c.UploadSSHPublicKeyRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUploadServerCertificate = "UploadServerCertificate"
+
+// UploadServerCertificateRequest generates a "aws/request.Request" representing the
+// client's request for the UploadServerCertificate operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UploadServerCertificate for more information on using the UploadServerCertificate
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UploadServerCertificateRequest method.
+//    req, resp := client.UploadServerCertificateRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UploadServerCertificate
+func (c *IAM) UploadServerCertificateRequest(input *UploadServerCertificateInput) (req *request.Request, output *UploadServerCertificateOutput) {
+	op := &request.Operation{
+		Name:       opUploadServerCertificate,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UploadServerCertificateInput{}
+	}
+
+	output = &UploadServerCertificateOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// UploadServerCertificate API operation for AWS Identity and Access Management.
+//
+// Uploads a server certificate entity for the AWS account. The server certificate
+// entity includes a public key certificate, a private key, and an optional
+// certificate chain, which should all be PEM-encoded.
+//
+// We recommend that you use AWS Certificate Manager (https://docs.aws.amazon.com/acm/)
+// to provision, manage, and deploy your server certificates. With ACM you can
+// request a certificate, deploy it to AWS resources, and let ACM handle certificate
+// renewals for you. Certificates provided by ACM are free. For more information
+// about using ACM, see the AWS Certificate Manager User Guide (https://docs.aws.amazon.com/acm/latest/userguide/).
+//
+// For more information about working with server certificates, see Working
+// with Server Certificates (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_server-certs.html)
+// in the IAM User Guide. This topic includes a list of AWS services that can
+// use the server certificates that you manage with IAM.
+//
+// For information about the number of server certificates you can upload, see
+// Limitations on IAM Entities and Objects (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html)
+// in the IAM User Guide.
+//
+// Because the body of the public key certificate, private key, and the certificate
+// chain can be large, you should use POST rather than GET when calling UploadServerCertificate.
+// For information about setting up signatures and authorization through the
+// API, go to Signing AWS API Requests (https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html)
+// in the AWS General Reference. For general information about using the Query
+// API with IAM, go to Calling the API by Making HTTP Query Requests (https://docs.aws.amazon.com/IAM/latest/UserGuide/programming.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UploadServerCertificate for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeMalformedCertificateException "MalformedCertificate"
+//   The request was rejected because the certificate was malformed or expired.
+//   The error message describes the specific error.
+//
+//   * ErrCodeKeyPairMismatchException "KeyPairMismatch"
+//   The request was rejected because the public key certificate and the private
+//   key do not match.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UploadServerCertificate
+func (c *IAM) UploadServerCertificate(input *UploadServerCertificateInput) (*UploadServerCertificateOutput, error) {
+	req, out := c.UploadServerCertificateRequest(input)
+	return out, req.Send()
+}
+
+// UploadServerCertificateWithContext is the same as UploadServerCertificate with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UploadServerCertificate for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UploadServerCertificateWithContext(ctx aws.Context, input *UploadServerCertificateInput, opts ...request.Option) (*UploadServerCertificateOutput, error) {
+	req, out := c.UploadServerCertificateRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+const opUploadSigningCertificate = "UploadSigningCertificate"
+
+// UploadSigningCertificateRequest generates a "aws/request.Request" representing the
+// client's request for the UploadSigningCertificate operation. The "output" return
+// value will be populated with the request's response once the request completes
+// successfully.
+//
+// Use "Send" method on the returned Request to send the API call to the service.
+// the "output" return value is not valid until after Send returns without error.
+//
+// See UploadSigningCertificate for more information on using the UploadSigningCertificate
+// API call, and error handling.
+//
+// This method is useful when you want to inject custom logic or configuration
+// into the SDK's request lifecycle. Such as custom headers, or retry logic.
+//
+//
+//    // Example sending a request using the UploadSigningCertificateRequest method.
+//    req, resp := client.UploadSigningCertificateRequest(params)
+//
+//    err := req.Send()
+//    if err == nil { // resp is now filled
+//        fmt.Println(resp)
+//    }
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UploadSigningCertificate
+func (c *IAM) UploadSigningCertificateRequest(input *UploadSigningCertificateInput) (req *request.Request, output *UploadSigningCertificateOutput) {
+	op := &request.Operation{
+		Name:       opUploadSigningCertificate,
+		HTTPMethod: "POST",
+		HTTPPath:   "/",
+	}
+
+	if input == nil {
+		input = &UploadSigningCertificateInput{}
+	}
+
+	output = &UploadSigningCertificateOutput{}
+	req = c.newRequest(op, input, output)
+	return
+}
+
+// UploadSigningCertificate API operation for AWS Identity and Access Management.
+//
+// Uploads an X.509 signing certificate and associates it with the specified
+// IAM user. Some AWS services use X.509 signing certificates to validate requests
+// that are signed with a corresponding private key. When you upload the certificate,
+// its default status is Active.
+//
+// If the UserName is not specified, the IAM user name is determined implicitly
+// based on the AWS access key ID used to sign the request. This operation works
+// for access keys under the AWS account. Consequently, you can use this operation
+// to manage AWS account root user credentials even if the AWS account has no
+// associated users.
+//
+// Because the body of an X.509 certificate can be large, you should use POST
+// rather than GET when calling UploadSigningCertificate. For information about
+// setting up signatures and authorization through the API, go to Signing AWS
+// API Requests (https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html)
+// in the AWS General Reference. For general information about using the Query
+// API with IAM, go to Making Query Requests (https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html)
+// in the IAM User Guide.
+//
+// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
+// with awserr.Error's Code and Message methods to get detailed information about
+// the error.
+//
+// See the AWS API reference guide for AWS Identity and Access Management's
+// API operation UploadSigningCertificate for usage and error information.
+//
+// Returned Error Codes:
+//   * ErrCodeLimitExceededException "LimitExceeded"
+//   The request was rejected because it attempted to create resources beyond
+//   the current AWS account limits. The error message describes the limit exceeded.
+//
+//   * ErrCodeEntityAlreadyExistsException "EntityAlreadyExists"
+//   The request was rejected because it attempted to create a resource that already
+//   exists.
+//
+//   * ErrCodeMalformedCertificateException "MalformedCertificate"
+//   The request was rejected because the certificate was malformed or expired.
+//   The error message describes the specific error.
+//
+//   * ErrCodeInvalidCertificateException "InvalidCertificate"
+//   The request was rejected because the certificate is invalid.
+//
+//   * ErrCodeDuplicateCertificateException "DuplicateCertificate"
+//   The request was rejected because the same certificate is associated with
+//   an IAM user in the account.
+//
+//   * ErrCodeNoSuchEntityException "NoSuchEntity"
+//   The request was rejected because it referenced a resource entity that does
+//   not exist. The error message describes the resource.
+//
+//   * ErrCodeServiceFailureException "ServiceFailure"
+//   The request processing has failed because of an unknown error, exception
+//   or failure.
+//
+// See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08/UploadSigningCertificate
+func (c *IAM) UploadSigningCertificate(input *UploadSigningCertificateInput) (*UploadSigningCertificateOutput, error) {
+	req, out := c.UploadSigningCertificateRequest(input)
+	return out, req.Send()
+}
+
+// UploadSigningCertificateWithContext is the same as UploadSigningCertificate with the addition of
+// the ability to pass a context and additional request options.
+//
+// See UploadSigningCertificate for details on how to use this API operation.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) UploadSigningCertificateWithContext(ctx aws.Context, input *UploadSigningCertificateInput, opts ...request.Option) (*UploadSigningCertificateOutput, error) {
+	req, out := c.UploadSigningCertificateRequest(input)
+	req.SetContext(ctx)
+	req.ApplyOptions(opts...)
+	return out, req.Send()
+}
+
+// An object that contains details about when a principal in the reported AWS
+// Organizations entity last attempted to access an AWS service. A principal
+// can be an IAM user, an IAM role, or the AWS account root user within the
+// reported Organizations entity.
+//
+// This data type is a response element in the GetOrganizationsAccessReport
+// operation.
+type AccessDetail struct {
+	_ struct{} `type:"structure"`
+
+	// The path of the Organizations entity (root, organizational unit, or account)
+	// from which an authenticated principal last attempted to access the service.
+	// AWS does not report unauthenticated requests.
+	//
+	// This field is null if no principals (IAM users, IAM roles, or root users)
+	// in the reported Organizations entity attempted to access the service within
+	// the reporting period (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#service-last-accessed-reporting-period).
+	EntityPath *string `min:"19" type:"string"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when an authenticated principal most recently attempted to access the service.
+	// AWS does not report unauthenticated requests.
+	//
+	// This field is null if no principals in the reported Organizations entity
+	// attempted to access the service within the reporting period (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#service-last-accessed-reporting-period).
+	LastAuthenticatedTime *time.Time `type:"timestamp"`
+
+	// The Region where the last service access attempt occurred.
+	//
+	// This field is null if no principals in the reported Organizations entity
+	// attempted to access the service within the reporting period (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#service-last-accessed-reporting-period).
+	Region *string `type:"string"`
+
+	// The name of the service in which access was attempted.
+	//
+	// ServiceName is a required field
+	ServiceName *string `type:"string" required:"true"`
+
+	// The namespace of the service in which access was attempted.
+	//
+	// To learn the service namespace of a service, go to Actions, Resources, and
+	// Condition Keys for AWS Services (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_actions-resources-contextkeys.html)
+	// in the IAM User Guide. Choose the name of the service to view details for
+	// that service. In the first paragraph, find the service prefix. For example,
+	// (service prefix: a4b). For more information about service namespaces, see
+	// AWS Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces)
+	// in the AWS General Reference.
+	//
+	// ServiceNamespace is a required field
+	ServiceNamespace *string `min:"1" type:"string" required:"true"`
+
+	// The number of accounts with authenticated principals (root users, IAM users,
+	// and IAM roles) that attempted to access the service in the reporting period.
+	TotalAuthenticatedEntities *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s AccessDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AccessDetail) GoString() string {
+	return s.String()
+}
+
+// SetEntityPath sets the EntityPath field's value.
+func (s *AccessDetail) SetEntityPath(v string) *AccessDetail {
+	s.EntityPath = &v
+	return s
+}
+
+// SetLastAuthenticatedTime sets the LastAuthenticatedTime field's value.
+func (s *AccessDetail) SetLastAuthenticatedTime(v time.Time) *AccessDetail {
+	s.LastAuthenticatedTime = &v
+	return s
+}
+
+// SetRegion sets the Region field's value.
+func (s *AccessDetail) SetRegion(v string) *AccessDetail {
+	s.Region = &v
+	return s
+}
+
+// SetServiceName sets the ServiceName field's value.
+func (s *AccessDetail) SetServiceName(v string) *AccessDetail {
+	s.ServiceName = &v
+	return s
+}
+
+// SetServiceNamespace sets the ServiceNamespace field's value.
+func (s *AccessDetail) SetServiceNamespace(v string) *AccessDetail {
+	s.ServiceNamespace = &v
+	return s
+}
+
+// SetTotalAuthenticatedEntities sets the TotalAuthenticatedEntities field's value.
+func (s *AccessDetail) SetTotalAuthenticatedEntities(v int64) *AccessDetail {
+	s.TotalAuthenticatedEntities = &v
+	return s
+}
+
+// Contains information about an AWS access key.
+//
+// This data type is used as a response element in the CreateAccessKey and ListAccessKeys
+// operations.
+//
+// The SecretAccessKey value is returned only in response to CreateAccessKey.
+// You can get a secret access key only when you first create an access key;
+// you cannot recover the secret access key later. If you lose a secret access
+// key, you must create a new access key.
+type AccessKey struct {
+	_ struct{} `type:"structure"`
+
+	// The ID for this access key.
+	//
+	// AccessKeyId is a required field
+	AccessKeyId *string `min:"16" type:"string" required:"true"`
+
+	// The date when the access key was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// The secret key used to sign requests.
+	//
+	// SecretAccessKey is a required field
+	SecretAccessKey *string `type:"string" required:"true" sensitive:"true"`
+
+	// The status of the access key. Active means that the key is valid for API
+	// calls, while Inactive means it is not.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The name of the IAM user that the access key is associated with.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AccessKey) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AccessKey) GoString() string {
+	return s.String()
+}
+
+// SetAccessKeyId sets the AccessKeyId field's value.
+func (s *AccessKey) SetAccessKeyId(v string) *AccessKey {
+	s.AccessKeyId = &v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *AccessKey) SetCreateDate(v time.Time) *AccessKey {
+	s.CreateDate = &v
+	return s
+}
+
+// SetSecretAccessKey sets the SecretAccessKey field's value.
+func (s *AccessKey) SetSecretAccessKey(v string) *AccessKey {
+	s.SecretAccessKey = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *AccessKey) SetStatus(v string) *AccessKey {
+	s.Status = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *AccessKey) SetUserName(v string) *AccessKey {
+	s.UserName = &v
+	return s
+}
+
+// Contains information about the last time an AWS access key was used since
+// IAM began tracking this information on April 22, 2015.
+//
+// This data type is used as a response element in the GetAccessKeyLastUsed
+// operation.
+type AccessKeyLastUsed struct {
+	_ struct{} `type:"structure"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the access key was most recently used. This field is null in the following
+	// situations:
+	//
+	//    * The user does not have an access key.
+	//
+	//    * An access key exists but has not been used since IAM began tracking
+	//    this information.
+	//
+	//    * There is no sign-in data associated with the user.
+	//
+	// LastUsedDate is a required field
+	LastUsedDate *time.Time `type:"timestamp" required:"true"`
+
+	// The AWS Region where this access key was most recently used. The value for
+	// this field is "N/A" in the following situations:
+	//
+	//    * The user does not have an access key.
+	//
+	//    * An access key exists but has not been used since IAM began tracking
+	//    this information.
+	//
+	//    * There is no sign-in data associated with the user.
+	//
+	// For more information about AWS Regions, see Regions and Endpoints (https://docs.aws.amazon.com/general/latest/gr/rande.html)
+	// in the Amazon Web Services General Reference.
+	//
+	// Region is a required field
+	Region *string `type:"string" required:"true"`
+
+	// The name of the AWS service with which this access key was most recently
+	// used. The value of this field is "N/A" in the following situations:
+	//
+	//    * The user does not have an access key.
+	//
+	//    * An access key exists but has not been used since IAM started tracking
+	//    this information.
+	//
+	//    * There is no sign-in data associated with the user.
+	//
+	// ServiceName is a required field
+	ServiceName *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AccessKeyLastUsed) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AccessKeyLastUsed) GoString() string {
+	return s.String()
+}
+
+// SetLastUsedDate sets the LastUsedDate field's value.
+func (s *AccessKeyLastUsed) SetLastUsedDate(v time.Time) *AccessKeyLastUsed {
+	s.LastUsedDate = &v
+	return s
+}
+
+// SetRegion sets the Region field's value.
+func (s *AccessKeyLastUsed) SetRegion(v string) *AccessKeyLastUsed {
+	s.Region = &v
+	return s
+}
+
+// SetServiceName sets the ServiceName field's value.
+func (s *AccessKeyLastUsed) SetServiceName(v string) *AccessKeyLastUsed {
+	s.ServiceName = &v
+	return s
+}
+
+// Contains information about an AWS access key, without its secret key.
+//
+// This data type is used as a response element in the ListAccessKeys operation.
+type AccessKeyMetadata struct {
+	_ struct{} `type:"structure"`
+
+	// The ID for this access key.
+	AccessKeyId *string `min:"16" type:"string"`
+
+	// The date when the access key was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// The status of the access key. Active means that the key is valid for API
+	// calls; Inactive means it is not.
+	Status *string `type:"string" enum:"statusType"`
+
+	// The name of the IAM user that the key is associated with.
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s AccessKeyMetadata) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AccessKeyMetadata) GoString() string {
+	return s.String()
+}
+
+// SetAccessKeyId sets the AccessKeyId field's value.
+func (s *AccessKeyMetadata) SetAccessKeyId(v string) *AccessKeyMetadata {
+	s.AccessKeyId = &v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *AccessKeyMetadata) SetCreateDate(v time.Time) *AccessKeyMetadata {
+	s.CreateDate = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *AccessKeyMetadata) SetStatus(v string) *AccessKeyMetadata {
+	s.Status = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *AccessKeyMetadata) SetUserName(v string) *AccessKeyMetadata {
+	s.UserName = &v
+	return s
+}
+
+type AddClientIDToOpenIDConnectProviderInput struct {
+	_ struct{} `type:"structure"`
+
+	// The client ID (also known as audience) to add to the IAM OpenID Connect provider
+	// resource.
+	//
+	// ClientID is a required field
+	ClientID *string `min:"1" type:"string" required:"true"`
+
+	// The Amazon Resource Name (ARN) of the IAM OpenID Connect (OIDC) provider
+	// resource to add the client ID to. You can get a list of OIDC provider ARNs
+	// by using the ListOpenIDConnectProviders operation.
+	//
+	// OpenIDConnectProviderArn is a required field
+	OpenIDConnectProviderArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AddClientIDToOpenIDConnectProviderInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AddClientIDToOpenIDConnectProviderInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AddClientIDToOpenIDConnectProviderInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "AddClientIDToOpenIDConnectProviderInput"}
+	if s.ClientID == nil {
+		invalidParams.Add(request.NewErrParamRequired("ClientID"))
+	}
+	if s.ClientID != nil && len(*s.ClientID) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ClientID", 1))
+	}
+	if s.OpenIDConnectProviderArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("OpenIDConnectProviderArn"))
+	}
+	if s.OpenIDConnectProviderArn != nil && len(*s.OpenIDConnectProviderArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("OpenIDConnectProviderArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetClientID sets the ClientID field's value.
+func (s *AddClientIDToOpenIDConnectProviderInput) SetClientID(v string) *AddClientIDToOpenIDConnectProviderInput {
+	s.ClientID = &v
+	return s
+}
+
+// SetOpenIDConnectProviderArn sets the OpenIDConnectProviderArn field's value.
+func (s *AddClientIDToOpenIDConnectProviderInput) SetOpenIDConnectProviderArn(v string) *AddClientIDToOpenIDConnectProviderInput {
+	s.OpenIDConnectProviderArn = &v
+	return s
+}
+
+type AddClientIDToOpenIDConnectProviderOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s AddClientIDToOpenIDConnectProviderOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AddClientIDToOpenIDConnectProviderOutput) GoString() string {
+	return s.String()
+}
+
+type AddRoleToInstanceProfileInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the instance profile to update.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// InstanceProfileName is a required field
+	InstanceProfileName *string `min:"1" type:"string" required:"true"`
+
+	// The name of the role to add.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AddRoleToInstanceProfileInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AddRoleToInstanceProfileInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AddRoleToInstanceProfileInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "AddRoleToInstanceProfileInput"}
+	if s.InstanceProfileName == nil {
+		invalidParams.Add(request.NewErrParamRequired("InstanceProfileName"))
+	}
+	if s.InstanceProfileName != nil && len(*s.InstanceProfileName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("InstanceProfileName", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetInstanceProfileName sets the InstanceProfileName field's value.
+func (s *AddRoleToInstanceProfileInput) SetInstanceProfileName(v string) *AddRoleToInstanceProfileInput {
+	s.InstanceProfileName = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *AddRoleToInstanceProfileInput) SetRoleName(v string) *AddRoleToInstanceProfileInput {
+	s.RoleName = &v
+	return s
+}
+
+type AddRoleToInstanceProfileOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s AddRoleToInstanceProfileOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AddRoleToInstanceProfileOutput) GoString() string {
+	return s.String()
+}
+
+type AddUserToGroupInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the group to update.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The name of the user to add.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AddUserToGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AddUserToGroupInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AddUserToGroupInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "AddUserToGroupInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *AddUserToGroupInput) SetGroupName(v string) *AddUserToGroupInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *AddUserToGroupInput) SetUserName(v string) *AddUserToGroupInput {
+	s.UserName = &v
+	return s
+}
+
+type AddUserToGroupOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s AddUserToGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AddUserToGroupOutput) GoString() string {
+	return s.String()
+}
+
+type AttachGroupPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name (friendly name, not ARN) of the group to attach the policy to.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy you want to attach.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AttachGroupPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachGroupPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AttachGroupPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "AttachGroupPolicyInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *AttachGroupPolicyInput) SetGroupName(v string) *AttachGroupPolicyInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *AttachGroupPolicyInput) SetPolicyArn(v string) *AttachGroupPolicyInput {
+	s.PolicyArn = &v
+	return s
+}
+
+type AttachGroupPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachGroupPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachGroupPolicyOutput) GoString() string {
+	return s.String()
+}
+
+type AttachRolePolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy you want to attach.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+
+	// The name (friendly name, not ARN) of the role to attach the policy to.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AttachRolePolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachRolePolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AttachRolePolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "AttachRolePolicyInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *AttachRolePolicyInput) SetPolicyArn(v string) *AttachRolePolicyInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *AttachRolePolicyInput) SetRoleName(v string) *AttachRolePolicyInput {
+	s.RoleName = &v
+	return s
+}
+
+type AttachRolePolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachRolePolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachRolePolicyOutput) GoString() string {
+	return s.String()
+}
+
+type AttachUserPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy you want to attach.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+
+	// The name (friendly name, not ARN) of the IAM user to attach the policy to.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s AttachUserPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachUserPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *AttachUserPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "AttachUserPolicyInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *AttachUserPolicyInput) SetPolicyArn(v string) *AttachUserPolicyInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *AttachUserPolicyInput) SetUserName(v string) *AttachUserPolicyInput {
+	s.UserName = &v
+	return s
+}
+
+type AttachUserPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s AttachUserPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachUserPolicyOutput) GoString() string {
+	return s.String()
+}
+
+// Contains information about an attached permissions boundary.
+//
+// An attached permissions boundary is a managed policy that has been attached
+// to a user or role to set the permissions boundary.
+//
+// For more information about permissions boundaries, see Permissions Boundaries
+// for IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)
+// in the IAM User Guide.
+type AttachedPermissionsBoundary struct {
+	_ struct{} `type:"structure"`
+
+	// The ARN of the policy used to set the permissions boundary for the user or
+	// role.
+	PermissionsBoundaryArn *string `min:"20" type:"string"`
+
+	// The permissions boundary usage type that indicates what type of IAM resource
+	// is used as the permissions boundary for an entity. This data type can only
+	// have a value of Policy.
+	PermissionsBoundaryType *string `type:"string" enum:"PermissionsBoundaryAttachmentType"`
+}
+
+// String returns the string representation
+func (s AttachedPermissionsBoundary) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachedPermissionsBoundary) GoString() string {
+	return s.String()
+}
+
+// SetPermissionsBoundaryArn sets the PermissionsBoundaryArn field's value.
+func (s *AttachedPermissionsBoundary) SetPermissionsBoundaryArn(v string) *AttachedPermissionsBoundary {
+	s.PermissionsBoundaryArn = &v
+	return s
+}
+
+// SetPermissionsBoundaryType sets the PermissionsBoundaryType field's value.
+func (s *AttachedPermissionsBoundary) SetPermissionsBoundaryType(v string) *AttachedPermissionsBoundary {
+	s.PermissionsBoundaryType = &v
+	return s
+}
+
+// Contains information about an attached policy.
+//
+// An attached policy is a managed policy that has been attached to a user,
+// group, or role. This data type is used as a response element in the ListAttachedGroupPolicies,
+// ListAttachedRolePolicies, ListAttachedUserPolicies, and GetAccountAuthorizationDetails
+// operations.
+//
+// For more information about managed policies, refer to Managed Policies and
+// Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the Using IAM guide.
+type AttachedPolicy struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN). ARNs are unique identifiers for AWS resources.
+	//
+	// For more information about ARNs, go to Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	PolicyArn *string `min:"20" type:"string"`
+
+	// The friendly name of the attached policy.
+	PolicyName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s AttachedPolicy) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s AttachedPolicy) GoString() string {
+	return s.String()
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *AttachedPolicy) SetPolicyArn(v string) *AttachedPolicy {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *AttachedPolicy) SetPolicyName(v string) *AttachedPolicy {
+	s.PolicyName = &v
+	return s
+}
+
+type ChangePasswordInput struct {
+	_ struct{} `type:"structure"`
+
+	// The new password. The new password must conform to the AWS account's password
+	// policy, if one exists.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) that is used to validate
+	// this parameter is a string of characters. That string can include almost
+	// any printable ASCII character from the space (\u0020) through the end of
+	// the ASCII character range (\u00FF). You can also include the tab (\u0009),
+	// line feed (\u000A), and carriage return (\u000D) characters. Any of these
+	// characters are valid in a password. However, many tools, such as the AWS
+	// Management Console, might restrict the ability to type certain characters
+	// because they have special meaning within that tool.
+	//
+	// NewPassword is a required field
+	NewPassword *string `min:"1" type:"string" required:"true" sensitive:"true"`
+
+	// The IAM user's current password.
+	//
+	// OldPassword is a required field
+	OldPassword *string `min:"1" type:"string" required:"true" sensitive:"true"`
+}
+
+// String returns the string representation
+func (s ChangePasswordInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ChangePasswordInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ChangePasswordInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ChangePasswordInput"}
+	if s.NewPassword == nil {
+		invalidParams.Add(request.NewErrParamRequired("NewPassword"))
+	}
+	if s.NewPassword != nil && len(*s.NewPassword) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("NewPassword", 1))
+	}
+	if s.OldPassword == nil {
+		invalidParams.Add(request.NewErrParamRequired("OldPassword"))
+	}
+	if s.OldPassword != nil && len(*s.OldPassword) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("OldPassword", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetNewPassword sets the NewPassword field's value.
+func (s *ChangePasswordInput) SetNewPassword(v string) *ChangePasswordInput {
+	s.NewPassword = &v
+	return s
+}
+
+// SetOldPassword sets the OldPassword field's value.
+func (s *ChangePasswordInput) SetOldPassword(v string) *ChangePasswordInput {
+	s.OldPassword = &v
+	return s
+}
+
+type ChangePasswordOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s ChangePasswordOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ChangePasswordOutput) GoString() string {
+	return s.String()
+}
+
+// Contains information about a condition context key. It includes the name
+// of the key and specifies the value (or values, if the context key supports
+// multiple values) to use in the simulation. This information is used when
+// evaluating the Condition elements of the input policies.
+//
+// This data type is used as an input parameter to SimulateCustomPolicy and
+// SimulatePrincipalPolicy .
+type ContextEntry struct {
+	_ struct{} `type:"structure"`
+
+	// The full name of a condition context key, including the service prefix. For
+	// example, aws:SourceIp or s3:VersionId.
+	ContextKeyName *string `min:"5" type:"string"`
+
+	// The data type of the value (or values) specified in the ContextKeyValues
+	// parameter.
+	ContextKeyType *string `type:"string" enum:"ContextKeyTypeEnum"`
+
+	// The value (or values, if the condition context key supports multiple values)
+	// to provide to the simulation when the key is referenced by a Condition element
+	// in an input policy.
+	ContextKeyValues []*string `type:"list"`
+}
+
+// String returns the string representation
+func (s ContextEntry) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ContextEntry) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ContextEntry) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ContextEntry"}
+	if s.ContextKeyName != nil && len(*s.ContextKeyName) < 5 {
+		invalidParams.Add(request.NewErrParamMinLen("ContextKeyName", 5))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetContextKeyName sets the ContextKeyName field's value.
+func (s *ContextEntry) SetContextKeyName(v string) *ContextEntry {
+	s.ContextKeyName = &v
+	return s
+}
+
+// SetContextKeyType sets the ContextKeyType field's value.
+func (s *ContextEntry) SetContextKeyType(v string) *ContextEntry {
+	s.ContextKeyType = &v
+	return s
+}
+
+// SetContextKeyValues sets the ContextKeyValues field's value.
+func (s *ContextEntry) SetContextKeyValues(v []*string) *ContextEntry {
+	s.ContextKeyValues = v
+	return s
+}
+
+type CreateAccessKeyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the IAM user that the new key will belong to.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s CreateAccessKeyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateAccessKeyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateAccessKeyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateAccessKeyInput"}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetUserName sets the UserName field's value.
+func (s *CreateAccessKeyInput) SetUserName(v string) *CreateAccessKeyInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful CreateAccessKey request.
+type CreateAccessKeyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure with details about the access key.
+	//
+	// AccessKey is a required field
+	AccessKey *AccessKey `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateAccessKeyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateAccessKeyOutput) GoString() string {
+	return s.String()
+}
+
+// SetAccessKey sets the AccessKey field's value.
+func (s *CreateAccessKeyOutput) SetAccessKey(v *AccessKey) *CreateAccessKeyOutput {
+	s.AccessKey = v
+	return s
+}
+
+type CreateAccountAliasInput struct {
+	_ struct{} `type:"structure"`
+
+	// The account alias to create.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of lowercase letters, digits, and dashes.
+	// You cannot start or finish with a dash, nor can you have two dashes in a
+	// row.
+	//
+	// AccountAlias is a required field
+	AccountAlias *string `min:"3" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateAccountAliasInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateAccountAliasInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateAccountAliasInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateAccountAliasInput"}
+	if s.AccountAlias == nil {
+		invalidParams.Add(request.NewErrParamRequired("AccountAlias"))
+	}
+	if s.AccountAlias != nil && len(*s.AccountAlias) < 3 {
+		invalidParams.Add(request.NewErrParamMinLen("AccountAlias", 3))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAccountAlias sets the AccountAlias field's value.
+func (s *CreateAccountAliasInput) SetAccountAlias(v string) *CreateAccountAliasInput {
+	s.AccountAlias = &v
+	return s
+}
+
+type CreateAccountAliasOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateAccountAliasOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateAccountAliasOutput) GoString() string {
+	return s.String()
+}
+
+type CreateGroupInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the group to create. Do not include the path in this value.
+	//
+	// IAM user, group, role, and policy names must be unique within the account.
+	// Names are not distinguished by case. For example, you cannot create resources
+	// named both "MyResource" and "myresource".
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The path to the group. For more information about paths, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the IAM User Guide.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/).
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	Path *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s CreateGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateGroupInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateGroupInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateGroupInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.Path != nil && len(*s.Path) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Path", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *CreateGroupInput) SetGroupName(v string) *CreateGroupInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *CreateGroupInput) SetPath(v string) *CreateGroupInput {
+	s.Path = &v
+	return s
+}
+
+// Contains the response to a successful CreateGroup request.
+type CreateGroupOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the new group.
+	//
+	// Group is a required field
+	Group *Group `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateGroupOutput) GoString() string {
+	return s.String()
+}
+
+// SetGroup sets the Group field's value.
+func (s *CreateGroupOutput) SetGroup(v *Group) *CreateGroupOutput {
+	s.Group = v
+	return s
+}
+
+type CreateInstanceProfileInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the instance profile to create.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// InstanceProfileName is a required field
+	InstanceProfileName *string `min:"1" type:"string" required:"true"`
+
+	// The path to the instance profile. For more information about paths, see IAM
+	// Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the IAM User Guide.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/).
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	Path *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s CreateInstanceProfileInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateInstanceProfileInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateInstanceProfileInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateInstanceProfileInput"}
+	if s.InstanceProfileName == nil {
+		invalidParams.Add(request.NewErrParamRequired("InstanceProfileName"))
+	}
+	if s.InstanceProfileName != nil && len(*s.InstanceProfileName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("InstanceProfileName", 1))
+	}
+	if s.Path != nil && len(*s.Path) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Path", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetInstanceProfileName sets the InstanceProfileName field's value.
+func (s *CreateInstanceProfileInput) SetInstanceProfileName(v string) *CreateInstanceProfileInput {
+	s.InstanceProfileName = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *CreateInstanceProfileInput) SetPath(v string) *CreateInstanceProfileInput {
+	s.Path = &v
+	return s
+}
+
+// Contains the response to a successful CreateInstanceProfile request.
+type CreateInstanceProfileOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the new instance profile.
+	//
+	// InstanceProfile is a required field
+	InstanceProfile *InstanceProfile `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateInstanceProfileOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateInstanceProfileOutput) GoString() string {
+	return s.String()
+}
+
+// SetInstanceProfile sets the InstanceProfile field's value.
+func (s *CreateInstanceProfileOutput) SetInstanceProfile(v *InstanceProfile) *CreateInstanceProfileOutput {
+	s.InstanceProfile = v
+	return s
+}
+
+type CreateLoginProfileInput struct {
+	_ struct{} `type:"structure"`
+
+	// The new password for the user.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) that is used to validate
+	// this parameter is a string of characters. That string can include almost
+	// any printable ASCII character from the space (\u0020) through the end of
+	// the ASCII character range (\u00FF). You can also include the tab (\u0009),
+	// line feed (\u000A), and carriage return (\u000D) characters. Any of these
+	// characters are valid in a password. However, many tools, such as the AWS
+	// Management Console, might restrict the ability to type certain characters
+	// because they have special meaning within that tool.
+	//
+	// Password is a required field
+	Password *string `min:"1" type:"string" required:"true" sensitive:"true"`
+
+	// Specifies whether the user is required to set a new password on next sign-in.
+	PasswordResetRequired *bool `type:"boolean"`
+
+	// The name of the IAM user to create a password for. The user must already
+	// exist.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateLoginProfileInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateLoginProfileInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateLoginProfileInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateLoginProfileInput"}
+	if s.Password == nil {
+		invalidParams.Add(request.NewErrParamRequired("Password"))
+	}
+	if s.Password != nil && len(*s.Password) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Password", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPassword sets the Password field's value.
+func (s *CreateLoginProfileInput) SetPassword(v string) *CreateLoginProfileInput {
+	s.Password = &v
+	return s
+}
+
+// SetPasswordResetRequired sets the PasswordResetRequired field's value.
+func (s *CreateLoginProfileInput) SetPasswordResetRequired(v bool) *CreateLoginProfileInput {
+	s.PasswordResetRequired = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *CreateLoginProfileInput) SetUserName(v string) *CreateLoginProfileInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful CreateLoginProfile request.
+type CreateLoginProfileOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing the user name and password create date.
+	//
+	// LoginProfile is a required field
+	LoginProfile *LoginProfile `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateLoginProfileOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateLoginProfileOutput) GoString() string {
+	return s.String()
+}
+
+// SetLoginProfile sets the LoginProfile field's value.
+func (s *CreateLoginProfileOutput) SetLoginProfile(v *LoginProfile) *CreateLoginProfileOutput {
+	s.LoginProfile = v
+	return s
+}
+
+type CreateOpenIDConnectProviderInput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of client IDs (also known as audiences). When a mobile or web app
+	// registers with an OpenID Connect provider, they establish a value that identifies
+	// the application. (This is the value that's sent as the client_id parameter
+	// on OAuth requests.)
+	//
+	// You can register multiple client IDs with the same provider. For example,
+	// you might have multiple applications that use the same OIDC provider. You
+	// cannot register more than 100 client IDs with a single IAM OIDC provider.
+	//
+	// There is no defined format for a client ID. The CreateOpenIDConnectProviderRequest
+	// operation accepts client IDs up to 255 characters long.
+	ClientIDList []*string `type:"list"`
+
+	// A list of server certificate thumbprints for the OpenID Connect (OIDC) identity
+	// provider's server certificates. Typically this list includes only one entry.
+	// However, IAM lets you have up to five thumbprints for an OIDC provider. This
+	// lets you maintain multiple thumbprints if the identity provider is rotating
+	// certificates.
+	//
+	// The server certificate thumbprint is the hex-encoded SHA-1 hash value of
+	// the X.509 certificate used by the domain where the OpenID Connect provider
+	// makes its keys available. It is always a 40-character string.
+	//
+	// You must provide at least one thumbprint when creating an IAM OIDC provider.
+	// For example, assume that the OIDC provider is server.example.com and the
+	// provider stores its keys at https://keys.server.example.com/openid-connect.
+	// In that case, the thumbprint string would be the hex-encoded SHA-1 hash value
+	// of the certificate used by https://keys.server.example.com.
+	//
+	// For more information about obtaining the OIDC provider's thumbprint, see
+	// Obtaining the Thumbprint for an OpenID Connect Provider (https://docs.aws.amazon.com/IAM/latest/UserGuide/identity-providers-oidc-obtain-thumbprint.html)
+	// in the IAM User Guide.
+	//
+	// ThumbprintList is a required field
+	ThumbprintList []*string `type:"list" required:"true"`
+
+	// The URL of the identity provider. The URL must begin with https:// and should
+	// correspond to the iss claim in the provider's OpenID Connect ID tokens. Per
+	// the OIDC standard, path components are allowed but query parameters are not.
+	// Typically the URL consists of only a hostname, like https://server.example.org
+	// or https://example.com.
+	//
+	// You cannot register the same provider multiple times in a single AWS account.
+	// If you try to submit a URL that has already been used for an OpenID Connect
+	// provider in the AWS account, you will get an error.
+	//
+	// Url is a required field
+	Url *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateOpenIDConnectProviderInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateOpenIDConnectProviderInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateOpenIDConnectProviderInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateOpenIDConnectProviderInput"}
+	if s.ThumbprintList == nil {
+		invalidParams.Add(request.NewErrParamRequired("ThumbprintList"))
+	}
+	if s.Url == nil {
+		invalidParams.Add(request.NewErrParamRequired("Url"))
+	}
+	if s.Url != nil && len(*s.Url) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Url", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetClientIDList sets the ClientIDList field's value.
+func (s *CreateOpenIDConnectProviderInput) SetClientIDList(v []*string) *CreateOpenIDConnectProviderInput {
+	s.ClientIDList = v
+	return s
+}
+
+// SetThumbprintList sets the ThumbprintList field's value.
+func (s *CreateOpenIDConnectProviderInput) SetThumbprintList(v []*string) *CreateOpenIDConnectProviderInput {
+	s.ThumbprintList = v
+	return s
+}
+
+// SetUrl sets the Url field's value.
+func (s *CreateOpenIDConnectProviderInput) SetUrl(v string) *CreateOpenIDConnectProviderInput {
+	s.Url = &v
+	return s
+}
+
+// Contains the response to a successful CreateOpenIDConnectProvider request.
+type CreateOpenIDConnectProviderOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the new IAM OpenID Connect provider that
+	// is created. For more information, see OpenIDConnectProviderListEntry.
+	OpenIDConnectProviderArn *string `min:"20" type:"string"`
+}
+
+// String returns the string representation
+func (s CreateOpenIDConnectProviderOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateOpenIDConnectProviderOutput) GoString() string {
+	return s.String()
+}
+
+// SetOpenIDConnectProviderArn sets the OpenIDConnectProviderArn field's value.
+func (s *CreateOpenIDConnectProviderOutput) SetOpenIDConnectProviderArn(v string) *CreateOpenIDConnectProviderOutput {
+	s.OpenIDConnectProviderArn = &v
+	return s
+}
+
+type CreatePolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// A friendly description of the policy.
+	//
+	// Typically used to store information about the permissions defined in the
+	// policy. For example, "Grants access to production DynamoDB tables."
+	//
+	// The policy description is immutable. After a value is assigned, it cannot
+	// be changed.
+	Description *string `type:"string"`
+
+	// The path for the policy.
+	//
+	// For more information about paths, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the IAM User Guide.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/).
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	Path *string `min:"1" type:"string"`
+
+	// The JSON policy document that you want to use as the content for the new
+	// policy.
+	//
+	// You must provide policies in JSON format in IAM. However, for AWS CloudFormation
+	// templates formatted in YAML, you can provide the policy in JSON or YAML format.
+	// AWS CloudFormation always converts a YAML policy to JSON format before submitting
+	// it to IAM.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// PolicyDocument is a required field
+	PolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// The friendly name of the policy.
+	//
+	// IAM user, group, role, and policy names must be unique within the account.
+	// Names are not distinguished by case. For example, you cannot create resources
+	// named both "MyResource" and "myresource".
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s CreatePolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreatePolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreatePolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreatePolicyInput"}
+	if s.Path != nil && len(*s.Path) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Path", 1))
+	}
+	if s.PolicyDocument == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyDocument"))
+	}
+	if s.PolicyDocument != nil && len(*s.PolicyDocument) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyDocument", 1))
+	}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetDescription sets the Description field's value.
+func (s *CreatePolicyInput) SetDescription(v string) *CreatePolicyInput {
+	s.Description = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *CreatePolicyInput) SetPath(v string) *CreatePolicyInput {
+	s.Path = &v
+	return s
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *CreatePolicyInput) SetPolicyDocument(v string) *CreatePolicyInput {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *CreatePolicyInput) SetPolicyName(v string) *CreatePolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+// Contains the response to a successful CreatePolicy request.
+type CreatePolicyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the new policy.
+	Policy *Policy `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreatePolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreatePolicyOutput) GoString() string {
+	return s.String()
+}
+
+// SetPolicy sets the Policy field's value.
+func (s *CreatePolicyOutput) SetPolicy(v *Policy) *CreatePolicyOutput {
+	s.Policy = v
+	return s
+}
+
+type CreatePolicyVersionInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy to which you want to add
+	// a new version.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+
+	// The JSON policy document that you want to use as the content for this new
+	// version of the policy.
+	//
+	// You must provide policies in JSON format in IAM. However, for AWS CloudFormation
+	// templates formatted in YAML, you can provide the policy in JSON or YAML format.
+	// AWS CloudFormation always converts a YAML policy to JSON format before submitting
+	// it to IAM.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// PolicyDocument is a required field
+	PolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// Specifies whether to set this version as the policy's default version.
+	//
+	// When this parameter is true, the new policy version becomes the operative
+	// version. That is, it becomes the version that is in effect for the IAM users,
+	// groups, and roles that the policy is attached to.
+	//
+	// For more information about managed policy versions, see Versioning for Managed
+	// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html)
+	// in the IAM User Guide.
+	SetAsDefault *bool `type:"boolean"`
+}
+
+// String returns the string representation
+func (s CreatePolicyVersionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreatePolicyVersionInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreatePolicyVersionInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreatePolicyVersionInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+	if s.PolicyDocument == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyDocument"))
+	}
+	if s.PolicyDocument != nil && len(*s.PolicyDocument) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyDocument", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *CreatePolicyVersionInput) SetPolicyArn(v string) *CreatePolicyVersionInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *CreatePolicyVersionInput) SetPolicyDocument(v string) *CreatePolicyVersionInput {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetSetAsDefault sets the SetAsDefault field's value.
+func (s *CreatePolicyVersionInput) SetSetAsDefault(v bool) *CreatePolicyVersionInput {
+	s.SetAsDefault = &v
+	return s
+}
+
+// Contains the response to a successful CreatePolicyVersion request.
+type CreatePolicyVersionOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the new policy version.
+	PolicyVersion *PolicyVersion `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreatePolicyVersionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreatePolicyVersionOutput) GoString() string {
+	return s.String()
+}
+
+// SetPolicyVersion sets the PolicyVersion field's value.
+func (s *CreatePolicyVersionOutput) SetPolicyVersion(v *PolicyVersion) *CreatePolicyVersionOutput {
+	s.PolicyVersion = v
+	return s
+}
+
+type CreateRoleInput struct {
+	_ struct{} `type:"structure"`
+
+	// The trust relationship policy document that grants an entity permission to
+	// assume the role.
+	//
+	// In IAM, you must provide a JSON policy that has been converted to a string.
+	// However, for AWS CloudFormation templates formatted in YAML, you can provide
+	// the policy in JSON or YAML format. AWS CloudFormation always converts a YAML
+	// policy to JSON format before submitting it to IAM.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// Upon success, the response includes the same trust policy in JSON format.
+	//
+	// AssumeRolePolicyDocument is a required field
+	AssumeRolePolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// A description of the role.
+	Description *string `type:"string"`
+
+	// The maximum session duration (in seconds) that you want to set for the specified
+	// role. If you do not specify a value for this setting, the default maximum
+	// of one hour is applied. This setting can have a value from 1 hour to 12 hours.
+	//
+	// Anyone who assumes the role from the AWS CLI or API can use the DurationSeconds
+	// API parameter or the duration-seconds CLI parameter to request a longer session.
+	// The MaxSessionDuration setting determines the maximum duration that can be
+	// requested using the DurationSeconds parameter. If users don't specify a value
+	// for the DurationSeconds parameter, their security credentials are valid for
+	// one hour by default. This applies when you use the AssumeRole* API operations
+	// or the assume-role* CLI operations but does not apply when you use those
+	// operations to create a console URL. For more information, see Using IAM Roles
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) in the
+	// IAM User Guide.
+	MaxSessionDuration *int64 `min:"3600" type:"integer"`
+
+	// The path to the role. For more information about paths, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the IAM User Guide.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/).
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	Path *string `min:"1" type:"string"`
+
+	// The ARN of the policy that is used to set the permissions boundary for the
+	// role.
+	PermissionsBoundary *string `min:"20" type:"string"`
+
+	// The name of the role to create.
+	//
+	// IAM user, group, role, and policy names must be unique within the account.
+	// Names are not distinguished by case. For example, you cannot create resources
+	// named both "MyResource" and "myresource".
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+
+	// A list of tags that you want to attach to the newly created role. Each tag
+	// consists of a key name and an associated value. For more information about
+	// tagging, see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+	// in the IAM User Guide.
+	//
+	// If any one of the tags is invalid or if you exceed the allowed number of
+	// tags per role, then the entire request fails and the role is not created.
+	Tags []*Tag `type:"list"`
+}
+
+// String returns the string representation
+func (s CreateRoleInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateRoleInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateRoleInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateRoleInput"}
+	if s.AssumeRolePolicyDocument == nil {
+		invalidParams.Add(request.NewErrParamRequired("AssumeRolePolicyDocument"))
+	}
+	if s.AssumeRolePolicyDocument != nil && len(*s.AssumeRolePolicyDocument) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("AssumeRolePolicyDocument", 1))
+	}
+	if s.MaxSessionDuration != nil && *s.MaxSessionDuration < 3600 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxSessionDuration", 3600))
+	}
+	if s.Path != nil && len(*s.Path) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Path", 1))
+	}
+	if s.PermissionsBoundary != nil && len(*s.PermissionsBoundary) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PermissionsBoundary", 20))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+	if s.Tags != nil {
+		for i, v := range s.Tags {
+			if v == nil {
+				continue
+			}
+			if err := v.Validate(); err != nil {
+				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
+			}
+		}
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAssumeRolePolicyDocument sets the AssumeRolePolicyDocument field's value.
+func (s *CreateRoleInput) SetAssumeRolePolicyDocument(v string) *CreateRoleInput {
+	s.AssumeRolePolicyDocument = &v
+	return s
+}
+
+// SetDescription sets the Description field's value.
+func (s *CreateRoleInput) SetDescription(v string) *CreateRoleInput {
+	s.Description = &v
+	return s
+}
+
+// SetMaxSessionDuration sets the MaxSessionDuration field's value.
+func (s *CreateRoleInput) SetMaxSessionDuration(v int64) *CreateRoleInput {
+	s.MaxSessionDuration = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *CreateRoleInput) SetPath(v string) *CreateRoleInput {
+	s.Path = &v
+	return s
+}
+
+// SetPermissionsBoundary sets the PermissionsBoundary field's value.
+func (s *CreateRoleInput) SetPermissionsBoundary(v string) *CreateRoleInput {
+	s.PermissionsBoundary = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *CreateRoleInput) SetRoleName(v string) *CreateRoleInput {
+	s.RoleName = &v
+	return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *CreateRoleInput) SetTags(v []*Tag) *CreateRoleInput {
+	s.Tags = v
+	return s
+}
+
+// Contains the response to a successful CreateRole request.
+type CreateRoleOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the new role.
+	//
+	// Role is a required field
+	Role *Role `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateRoleOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateRoleOutput) GoString() string {
+	return s.String()
+}
+
+// SetRole sets the Role field's value.
+func (s *CreateRoleOutput) SetRole(v *Role) *CreateRoleOutput {
+	s.Role = v
+	return s
+}
+
+type CreateSAMLProviderInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the provider to create.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// Name is a required field
+	Name *string `min:"1" type:"string" required:"true"`
+
+	// An XML document generated by an identity provider (IdP) that supports SAML
+	// 2.0. The document includes the issuer's name, expiration information, and
+	// keys that can be used to validate the SAML authentication response (assertions)
+	// that are received from the IdP. You must generate the metadata document using
+	// the identity management software that is used as your organization's IdP.
+	//
+	// For more information, see About SAML 2.0-based Federation (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html)
+	// in the IAM User Guide
+	//
+	// SAMLMetadataDocument is a required field
+	SAMLMetadataDocument *string `min:"1000" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateSAMLProviderInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateSAMLProviderInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateSAMLProviderInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateSAMLProviderInput"}
+	if s.Name == nil {
+		invalidParams.Add(request.NewErrParamRequired("Name"))
+	}
+	if s.Name != nil && len(*s.Name) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Name", 1))
+	}
+	if s.SAMLMetadataDocument == nil {
+		invalidParams.Add(request.NewErrParamRequired("SAMLMetadataDocument"))
+	}
+	if s.SAMLMetadataDocument != nil && len(*s.SAMLMetadataDocument) < 1000 {
+		invalidParams.Add(request.NewErrParamMinLen("SAMLMetadataDocument", 1000))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetName sets the Name field's value.
+func (s *CreateSAMLProviderInput) SetName(v string) *CreateSAMLProviderInput {
+	s.Name = &v
+	return s
+}
+
+// SetSAMLMetadataDocument sets the SAMLMetadataDocument field's value.
+func (s *CreateSAMLProviderInput) SetSAMLMetadataDocument(v string) *CreateSAMLProviderInput {
+	s.SAMLMetadataDocument = &v
+	return s
+}
+
+// Contains the response to a successful CreateSAMLProvider request.
+type CreateSAMLProviderOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the new SAML provider resource in IAM.
+	SAMLProviderArn *string `min:"20" type:"string"`
+}
+
+// String returns the string representation
+func (s CreateSAMLProviderOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateSAMLProviderOutput) GoString() string {
+	return s.String()
+}
+
+// SetSAMLProviderArn sets the SAMLProviderArn field's value.
+func (s *CreateSAMLProviderOutput) SetSAMLProviderArn(v string) *CreateSAMLProviderOutput {
+	s.SAMLProviderArn = &v
+	return s
+}
+
+type CreateServiceLinkedRoleInput struct {
+	_ struct{} `type:"structure"`
+
+	// The service principal for the AWS service to which this role is attached.
+	// You use a string similar to a URL but without the http:// in front. For example:
+	// elasticbeanstalk.amazonaws.com.
+	//
+	// Service principals are unique and case-sensitive. To find the exact service
+	// principal for your service-linked role, see AWS Services That Work with IAM
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html)
+	// in the IAM User Guide. Look for the services that have Yes in the Service-Linked
+	// Role column. Choose the Yes link to view the service-linked role documentation
+	// for that service.
+	//
+	// AWSServiceName is a required field
+	AWSServiceName *string `min:"1" type:"string" required:"true"`
+
+	// A string that you provide, which is combined with the service-provided prefix
+	// to form the complete role name. If you make multiple requests for the same
+	// service, then you must supply a different CustomSuffix for each request.
+	// Otherwise the request fails with a duplicate role name error. For example,
+	// you could add -1 or -debug to the suffix.
+	//
+	// Some services do not support the CustomSuffix parameter. If you provide an
+	// optional suffix and the operation fails, try the operation again without
+	// the suffix.
+	CustomSuffix *string `min:"1" type:"string"`
+
+	// The description of the role.
+	Description *string `type:"string"`
+}
+
+// String returns the string representation
+func (s CreateServiceLinkedRoleInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateServiceLinkedRoleInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateServiceLinkedRoleInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateServiceLinkedRoleInput"}
+	if s.AWSServiceName == nil {
+		invalidParams.Add(request.NewErrParamRequired("AWSServiceName"))
+	}
+	if s.AWSServiceName != nil && len(*s.AWSServiceName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("AWSServiceName", 1))
+	}
+	if s.CustomSuffix != nil && len(*s.CustomSuffix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("CustomSuffix", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAWSServiceName sets the AWSServiceName field's value.
+func (s *CreateServiceLinkedRoleInput) SetAWSServiceName(v string) *CreateServiceLinkedRoleInput {
+	s.AWSServiceName = &v
+	return s
+}
+
+// SetCustomSuffix sets the CustomSuffix field's value.
+func (s *CreateServiceLinkedRoleInput) SetCustomSuffix(v string) *CreateServiceLinkedRoleInput {
+	s.CustomSuffix = &v
+	return s
+}
+
+// SetDescription sets the Description field's value.
+func (s *CreateServiceLinkedRoleInput) SetDescription(v string) *CreateServiceLinkedRoleInput {
+	s.Description = &v
+	return s
+}
+
+type CreateServiceLinkedRoleOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A Role object that contains details about the newly created role.
+	Role *Role `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateServiceLinkedRoleOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateServiceLinkedRoleOutput) GoString() string {
+	return s.String()
+}
+
+// SetRole sets the Role field's value.
+func (s *CreateServiceLinkedRoleOutput) SetRole(v *Role) *CreateServiceLinkedRoleOutput {
+	s.Role = v
+	return s
+}
+
+type CreateServiceSpecificCredentialInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the AWS service that is to be associated with the credentials.
+	// The service you specify here is the only service that can be accessed using
+	// these credentials.
+	//
+	// ServiceName is a required field
+	ServiceName *string `type:"string" required:"true"`
+
+	// The name of the IAM user that is to be associated with the credentials. The
+	// new service-specific credentials have the same permissions as the associated
+	// user except that they can be used only to access the specified service.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateServiceSpecificCredentialInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateServiceSpecificCredentialInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateServiceSpecificCredentialInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateServiceSpecificCredentialInput"}
+	if s.ServiceName == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServiceName"))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetServiceName sets the ServiceName field's value.
+func (s *CreateServiceSpecificCredentialInput) SetServiceName(v string) *CreateServiceSpecificCredentialInput {
+	s.ServiceName = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *CreateServiceSpecificCredentialInput) SetUserName(v string) *CreateServiceSpecificCredentialInput {
+	s.UserName = &v
+	return s
+}
+
+type CreateServiceSpecificCredentialOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure that contains information about the newly created service-specific
+	// credential.
+	//
+	// This is the only time that the password for this credential set is available.
+	// It cannot be recovered later. Instead, you must reset the password with ResetServiceSpecificCredential.
+	ServiceSpecificCredential *ServiceSpecificCredential `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateServiceSpecificCredentialOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateServiceSpecificCredentialOutput) GoString() string {
+	return s.String()
+}
+
+// SetServiceSpecificCredential sets the ServiceSpecificCredential field's value.
+func (s *CreateServiceSpecificCredentialOutput) SetServiceSpecificCredential(v *ServiceSpecificCredential) *CreateServiceSpecificCredentialOutput {
+	s.ServiceSpecificCredential = v
+	return s
+}
+
+type CreateUserInput struct {
+	_ struct{} `type:"structure"`
+
+	// The path for the user name. For more information about paths, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the IAM User Guide.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/).
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	Path *string `min:"1" type:"string"`
+
+	// The ARN of the policy that is used to set the permissions boundary for the
+	// user.
+	PermissionsBoundary *string `min:"20" type:"string"`
+
+	// A list of tags that you want to attach to the newly created user. Each tag
+	// consists of a key name and an associated value. For more information about
+	// tagging, see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+	// in the IAM User Guide.
+	//
+	// If any one of the tags is invalid or if you exceed the allowed number of
+	// tags per user, then the entire request fails and the user is not created.
+	Tags []*Tag `type:"list"`
+
+	// The name of the user to create.
+	//
+	// IAM user, group, role, and policy names must be unique within the account.
+	// Names are not distinguished by case. For example, you cannot create resources
+	// named both "MyResource" and "myresource".
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateUserInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateUserInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateUserInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateUserInput"}
+	if s.Path != nil && len(*s.Path) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Path", 1))
+	}
+	if s.PermissionsBoundary != nil && len(*s.PermissionsBoundary) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PermissionsBoundary", 20))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+	if s.Tags != nil {
+		for i, v := range s.Tags {
+			if v == nil {
+				continue
+			}
+			if err := v.Validate(); err != nil {
+				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
+			}
+		}
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPath sets the Path field's value.
+func (s *CreateUserInput) SetPath(v string) *CreateUserInput {
+	s.Path = &v
+	return s
+}
+
+// SetPermissionsBoundary sets the PermissionsBoundary field's value.
+func (s *CreateUserInput) SetPermissionsBoundary(v string) *CreateUserInput {
+	s.PermissionsBoundary = &v
+	return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *CreateUserInput) SetTags(v []*Tag) *CreateUserInput {
+	s.Tags = v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *CreateUserInput) SetUserName(v string) *CreateUserInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful CreateUser request.
+type CreateUserOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure with details about the new IAM user.
+	User *User `type:"structure"`
+}
+
+// String returns the string representation
+func (s CreateUserOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateUserOutput) GoString() string {
+	return s.String()
+}
+
+// SetUser sets the User field's value.
+func (s *CreateUserOutput) SetUser(v *User) *CreateUserOutput {
+	s.User = v
+	return s
+}
+
+type CreateVirtualMFADeviceInput struct {
+	_ struct{} `type:"structure"`
+
+	// The path for the virtual MFA device. For more information about paths, see
+	// IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the IAM User Guide.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/).
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	Path *string `min:"1" type:"string"`
+
+	// The name of the virtual MFA device. Use with path to uniquely identify a
+	// virtual MFA device.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// VirtualMFADeviceName is a required field
+	VirtualMFADeviceName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateVirtualMFADeviceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVirtualMFADeviceInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *CreateVirtualMFADeviceInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "CreateVirtualMFADeviceInput"}
+	if s.Path != nil && len(*s.Path) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Path", 1))
+	}
+	if s.VirtualMFADeviceName == nil {
+		invalidParams.Add(request.NewErrParamRequired("VirtualMFADeviceName"))
+	}
+	if s.VirtualMFADeviceName != nil && len(*s.VirtualMFADeviceName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("VirtualMFADeviceName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPath sets the Path field's value.
+func (s *CreateVirtualMFADeviceInput) SetPath(v string) *CreateVirtualMFADeviceInput {
+	s.Path = &v
+	return s
+}
+
+// SetVirtualMFADeviceName sets the VirtualMFADeviceName field's value.
+func (s *CreateVirtualMFADeviceInput) SetVirtualMFADeviceName(v string) *CreateVirtualMFADeviceInput {
+	s.VirtualMFADeviceName = &v
+	return s
+}
+
+// Contains the response to a successful CreateVirtualMFADevice request.
+type CreateVirtualMFADeviceOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the new virtual MFA device.
+	//
+	// VirtualMFADevice is a required field
+	VirtualMFADevice *VirtualMFADevice `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s CreateVirtualMFADeviceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s CreateVirtualMFADeviceOutput) GoString() string {
+	return s.String()
+}
+
+// SetVirtualMFADevice sets the VirtualMFADevice field's value.
+func (s *CreateVirtualMFADeviceOutput) SetVirtualMFADevice(v *VirtualMFADevice) *CreateVirtualMFADeviceOutput {
+	s.VirtualMFADevice = v
+	return s
+}
+
+type DeactivateMFADeviceInput struct {
+	_ struct{} `type:"structure"`
+
+	// The serial number that uniquely identifies the MFA device. For virtual MFA
+	// devices, the serial number is the device ARN.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: =,.@:/-
+	//
+	// SerialNumber is a required field
+	SerialNumber *string `min:"9" type:"string" required:"true"`
+
+	// The name of the user whose MFA device you want to deactivate.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeactivateMFADeviceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeactivateMFADeviceInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeactivateMFADeviceInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeactivateMFADeviceInput"}
+	if s.SerialNumber == nil {
+		invalidParams.Add(request.NewErrParamRequired("SerialNumber"))
+	}
+	if s.SerialNumber != nil && len(*s.SerialNumber) < 9 {
+		invalidParams.Add(request.NewErrParamMinLen("SerialNumber", 9))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetSerialNumber sets the SerialNumber field's value.
+func (s *DeactivateMFADeviceInput) SetSerialNumber(v string) *DeactivateMFADeviceInput {
+	s.SerialNumber = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DeactivateMFADeviceInput) SetUserName(v string) *DeactivateMFADeviceInput {
+	s.UserName = &v
+	return s
+}
+
+type DeactivateMFADeviceOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeactivateMFADeviceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeactivateMFADeviceOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteAccessKeyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The access key ID for the access key ID and secret access key you want to
+	// delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// AccessKeyId is a required field
+	AccessKeyId *string `min:"16" type:"string" required:"true"`
+
+	// The name of the user whose access key pair you want to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s DeleteAccessKeyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteAccessKeyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteAccessKeyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteAccessKeyInput"}
+	if s.AccessKeyId == nil {
+		invalidParams.Add(request.NewErrParamRequired("AccessKeyId"))
+	}
+	if s.AccessKeyId != nil && len(*s.AccessKeyId) < 16 {
+		invalidParams.Add(request.NewErrParamMinLen("AccessKeyId", 16))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAccessKeyId sets the AccessKeyId field's value.
+func (s *DeleteAccessKeyInput) SetAccessKeyId(v string) *DeleteAccessKeyInput {
+	s.AccessKeyId = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DeleteAccessKeyInput) SetUserName(v string) *DeleteAccessKeyInput {
+	s.UserName = &v
+	return s
+}
+
+type DeleteAccessKeyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteAccessKeyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteAccessKeyOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteAccountAliasInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the account alias to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of lowercase letters, digits, and dashes.
+	// You cannot start or finish with a dash, nor can you have two dashes in a
+	// row.
+	//
+	// AccountAlias is a required field
+	AccountAlias *string `min:"3" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteAccountAliasInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteAccountAliasInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteAccountAliasInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteAccountAliasInput"}
+	if s.AccountAlias == nil {
+		invalidParams.Add(request.NewErrParamRequired("AccountAlias"))
+	}
+	if s.AccountAlias != nil && len(*s.AccountAlias) < 3 {
+		invalidParams.Add(request.NewErrParamMinLen("AccountAlias", 3))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAccountAlias sets the AccountAlias field's value.
+func (s *DeleteAccountAliasInput) SetAccountAlias(v string) *DeleteAccountAliasInput {
+	s.AccountAlias = &v
+	return s
+}
+
+type DeleteAccountAliasOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteAccountAliasOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteAccountAliasOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteAccountPasswordPolicyInput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteAccountPasswordPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteAccountPasswordPolicyInput) GoString() string {
+	return s.String()
+}
+
+type DeleteAccountPasswordPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteAccountPasswordPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteAccountPasswordPolicyOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteGroupInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the IAM group to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteGroupInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteGroupInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteGroupInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *DeleteGroupInput) SetGroupName(v string) *DeleteGroupInput {
+	s.GroupName = &v
+	return s
+}
+
+type DeleteGroupOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteGroupOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteGroupPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name (friendly name, not ARN) identifying the group that the policy is
+	// embedded in.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The name identifying the policy document to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteGroupPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteGroupPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteGroupPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteGroupPolicyInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *DeleteGroupPolicyInput) SetGroupName(v string) *DeleteGroupPolicyInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *DeleteGroupPolicyInput) SetPolicyName(v string) *DeleteGroupPolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+type DeleteGroupPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteGroupPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteGroupPolicyOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteInstanceProfileInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the instance profile to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// InstanceProfileName is a required field
+	InstanceProfileName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteInstanceProfileInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteInstanceProfileInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteInstanceProfileInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteInstanceProfileInput"}
+	if s.InstanceProfileName == nil {
+		invalidParams.Add(request.NewErrParamRequired("InstanceProfileName"))
+	}
+	if s.InstanceProfileName != nil && len(*s.InstanceProfileName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("InstanceProfileName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetInstanceProfileName sets the InstanceProfileName field's value.
+func (s *DeleteInstanceProfileInput) SetInstanceProfileName(v string) *DeleteInstanceProfileInput {
+	s.InstanceProfileName = &v
+	return s
+}
+
+type DeleteInstanceProfileOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteInstanceProfileOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteInstanceProfileOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteLoginProfileInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the user whose password you want to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteLoginProfileInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteLoginProfileInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteLoginProfileInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteLoginProfileInput"}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DeleteLoginProfileInput) SetUserName(v string) *DeleteLoginProfileInput {
+	s.UserName = &v
+	return s
+}
+
+type DeleteLoginProfileOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteLoginProfileOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteLoginProfileOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteOpenIDConnectProviderInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM OpenID Connect provider resource
+	// object to delete. You can get a list of OpenID Connect provider resource
+	// ARNs by using the ListOpenIDConnectProviders operation.
+	//
+	// OpenIDConnectProviderArn is a required field
+	OpenIDConnectProviderArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteOpenIDConnectProviderInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteOpenIDConnectProviderInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteOpenIDConnectProviderInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteOpenIDConnectProviderInput"}
+	if s.OpenIDConnectProviderArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("OpenIDConnectProviderArn"))
+	}
+	if s.OpenIDConnectProviderArn != nil && len(*s.OpenIDConnectProviderArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("OpenIDConnectProviderArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetOpenIDConnectProviderArn sets the OpenIDConnectProviderArn field's value.
+func (s *DeleteOpenIDConnectProviderInput) SetOpenIDConnectProviderArn(v string) *DeleteOpenIDConnectProviderInput {
+	s.OpenIDConnectProviderArn = &v
+	return s
+}
+
+type DeleteOpenIDConnectProviderOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteOpenIDConnectProviderOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteOpenIDConnectProviderOutput) GoString() string {
+	return s.String()
+}
+
+type DeletePolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy you want to delete.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeletePolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeletePolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeletePolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeletePolicyInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *DeletePolicyInput) SetPolicyArn(v string) *DeletePolicyInput {
+	s.PolicyArn = &v
+	return s
+}
+
+type DeletePolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeletePolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeletePolicyOutput) GoString() string {
+	return s.String()
+}
+
+type DeletePolicyVersionInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy from which you want to delete
+	// a version.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+
+	// The policy version to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that consists of the lowercase letter 'v' followed
+	// by one or two digits, and optionally followed by a period '.' and a string
+	// of letters and digits.
+	//
+	// For more information about managed policy versions, see Versioning for Managed
+	// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html)
+	// in the IAM User Guide.
+	//
+	// VersionId is a required field
+	VersionId *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeletePolicyVersionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeletePolicyVersionInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeletePolicyVersionInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeletePolicyVersionInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+	if s.VersionId == nil {
+		invalidParams.Add(request.NewErrParamRequired("VersionId"))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *DeletePolicyVersionInput) SetPolicyArn(v string) *DeletePolicyVersionInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *DeletePolicyVersionInput) SetVersionId(v string) *DeletePolicyVersionInput {
+	s.VersionId = &v
+	return s
+}
+
+type DeletePolicyVersionOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeletePolicyVersionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeletePolicyVersionOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteRoleInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the role to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteRoleInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRoleInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteRoleInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteRoleInput"}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *DeleteRoleInput) SetRoleName(v string) *DeleteRoleInput {
+	s.RoleName = &v
+	return s
+}
+
+type DeleteRoleOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteRoleOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRoleOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteRolePermissionsBoundaryInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name (friendly name, not ARN) of the IAM role from which you want to
+	// remove the permissions boundary.
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteRolePermissionsBoundaryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRolePermissionsBoundaryInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteRolePermissionsBoundaryInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteRolePermissionsBoundaryInput"}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *DeleteRolePermissionsBoundaryInput) SetRoleName(v string) *DeleteRolePermissionsBoundaryInput {
+	s.RoleName = &v
+	return s
+}
+
+type DeleteRolePermissionsBoundaryOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteRolePermissionsBoundaryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRolePermissionsBoundaryOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteRolePolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the inline policy to delete from the specified IAM role.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+
+	// The name (friendly name, not ARN) identifying the role that the policy is
+	// embedded in.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteRolePolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRolePolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteRolePolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteRolePolicyInput"}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *DeleteRolePolicyInput) SetPolicyName(v string) *DeleteRolePolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *DeleteRolePolicyInput) SetRoleName(v string) *DeleteRolePolicyInput {
+	s.RoleName = &v
+	return s
+}
+
+type DeleteRolePolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteRolePolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteRolePolicyOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteSAMLProviderInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the SAML provider to delete.
+	//
+	// SAMLProviderArn is a required field
+	SAMLProviderArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteSAMLProviderInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSAMLProviderInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteSAMLProviderInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteSAMLProviderInput"}
+	if s.SAMLProviderArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("SAMLProviderArn"))
+	}
+	if s.SAMLProviderArn != nil && len(*s.SAMLProviderArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("SAMLProviderArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetSAMLProviderArn sets the SAMLProviderArn field's value.
+func (s *DeleteSAMLProviderInput) SetSAMLProviderArn(v string) *DeleteSAMLProviderInput {
+	s.SAMLProviderArn = &v
+	return s
+}
+
+type DeleteSAMLProviderOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSAMLProviderOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSAMLProviderOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteSSHPublicKeyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The unique identifier for the SSH public key.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// SSHPublicKeyId is a required field
+	SSHPublicKeyId *string `min:"20" type:"string" required:"true"`
+
+	// The name of the IAM user associated with the SSH public key.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteSSHPublicKeyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSSHPublicKeyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteSSHPublicKeyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteSSHPublicKeyInput"}
+	if s.SSHPublicKeyId == nil {
+		invalidParams.Add(request.NewErrParamRequired("SSHPublicKeyId"))
+	}
+	if s.SSHPublicKeyId != nil && len(*s.SSHPublicKeyId) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("SSHPublicKeyId", 20))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetSSHPublicKeyId sets the SSHPublicKeyId field's value.
+func (s *DeleteSSHPublicKeyInput) SetSSHPublicKeyId(v string) *DeleteSSHPublicKeyInput {
+	s.SSHPublicKeyId = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DeleteSSHPublicKeyInput) SetUserName(v string) *DeleteSSHPublicKeyInput {
+	s.UserName = &v
+	return s
+}
+
+type DeleteSSHPublicKeyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSSHPublicKeyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSSHPublicKeyOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteServerCertificateInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the server certificate you want to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// ServerCertificateName is a required field
+	ServerCertificateName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteServerCertificateInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteServerCertificateInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteServerCertificateInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteServerCertificateInput"}
+	if s.ServerCertificateName == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServerCertificateName"))
+	}
+	if s.ServerCertificateName != nil && len(*s.ServerCertificateName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ServerCertificateName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetServerCertificateName sets the ServerCertificateName field's value.
+func (s *DeleteServerCertificateInput) SetServerCertificateName(v string) *DeleteServerCertificateInput {
+	s.ServerCertificateName = &v
+	return s
+}
+
+type DeleteServerCertificateOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteServerCertificateOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteServerCertificateOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteServiceLinkedRoleInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the service-linked role to be deleted.
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteServiceLinkedRoleInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteServiceLinkedRoleInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteServiceLinkedRoleInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteServiceLinkedRoleInput"}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *DeleteServiceLinkedRoleInput) SetRoleName(v string) *DeleteServiceLinkedRoleInput {
+	s.RoleName = &v
+	return s
+}
+
+type DeleteServiceLinkedRoleOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The deletion task identifier that you can use to check the status of the
+	// deletion. This identifier is returned in the format task/aws-service-role/<service-principal-name>/<role-name>/<task-uuid>.
+	//
+	// DeletionTaskId is a required field
+	DeletionTaskId *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteServiceLinkedRoleOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteServiceLinkedRoleOutput) GoString() string {
+	return s.String()
+}
+
+// SetDeletionTaskId sets the DeletionTaskId field's value.
+func (s *DeleteServiceLinkedRoleOutput) SetDeletionTaskId(v string) *DeleteServiceLinkedRoleOutput {
+	s.DeletionTaskId = &v
+	return s
+}
+
+type DeleteServiceSpecificCredentialInput struct {
+	_ struct{} `type:"structure"`
+
+	// The unique identifier of the service-specific credential. You can get this
+	// value by calling ListServiceSpecificCredentials.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// ServiceSpecificCredentialId is a required field
+	ServiceSpecificCredentialId *string `min:"20" type:"string" required:"true"`
+
+	// The name of the IAM user associated with the service-specific credential.
+	// If this value is not specified, then the operation assumes the user whose
+	// credentials are used to call the operation.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s DeleteServiceSpecificCredentialInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteServiceSpecificCredentialInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteServiceSpecificCredentialInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteServiceSpecificCredentialInput"}
+	if s.ServiceSpecificCredentialId == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServiceSpecificCredentialId"))
+	}
+	if s.ServiceSpecificCredentialId != nil && len(*s.ServiceSpecificCredentialId) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("ServiceSpecificCredentialId", 20))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetServiceSpecificCredentialId sets the ServiceSpecificCredentialId field's value.
+func (s *DeleteServiceSpecificCredentialInput) SetServiceSpecificCredentialId(v string) *DeleteServiceSpecificCredentialInput {
+	s.ServiceSpecificCredentialId = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DeleteServiceSpecificCredentialInput) SetUserName(v string) *DeleteServiceSpecificCredentialInput {
+	s.UserName = &v
+	return s
+}
+
+type DeleteServiceSpecificCredentialOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteServiceSpecificCredentialOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteServiceSpecificCredentialOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteSigningCertificateInput struct {
+	_ struct{} `type:"structure"`
+
+	// The ID of the signing certificate to delete.
+	//
+	// The format of this parameter, as described by its regex (http://wikipedia.org/wiki/regex)
+	// pattern, is a string of characters that can be upper- or lower-cased letters
+	// or digits.
+	//
+	// CertificateId is a required field
+	CertificateId *string `min:"24" type:"string" required:"true"`
+
+	// The name of the user the signing certificate belongs to.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s DeleteSigningCertificateInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSigningCertificateInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteSigningCertificateInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteSigningCertificateInput"}
+	if s.CertificateId == nil {
+		invalidParams.Add(request.NewErrParamRequired("CertificateId"))
+	}
+	if s.CertificateId != nil && len(*s.CertificateId) < 24 {
+		invalidParams.Add(request.NewErrParamMinLen("CertificateId", 24))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetCertificateId sets the CertificateId field's value.
+func (s *DeleteSigningCertificateInput) SetCertificateId(v string) *DeleteSigningCertificateInput {
+	s.CertificateId = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DeleteSigningCertificateInput) SetUserName(v string) *DeleteSigningCertificateInput {
+	s.UserName = &v
+	return s
+}
+
+type DeleteSigningCertificateOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteSigningCertificateOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteSigningCertificateOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteUserInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the user to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteUserInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteUserInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteUserInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteUserInput"}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DeleteUserInput) SetUserName(v string) *DeleteUserInput {
+	s.UserName = &v
+	return s
+}
+
+type DeleteUserOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteUserOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteUserOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteUserPermissionsBoundaryInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name (friendly name, not ARN) of the IAM user from which you want to
+	// remove the permissions boundary.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteUserPermissionsBoundaryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteUserPermissionsBoundaryInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteUserPermissionsBoundaryInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteUserPermissionsBoundaryInput"}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DeleteUserPermissionsBoundaryInput) SetUserName(v string) *DeleteUserPermissionsBoundaryInput {
+	s.UserName = &v
+	return s
+}
+
+type DeleteUserPermissionsBoundaryOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteUserPermissionsBoundaryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteUserPermissionsBoundaryOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteUserPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name identifying the policy document to delete.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+
+	// The name (friendly name, not ARN) identifying the user that the policy is
+	// embedded in.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteUserPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteUserPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteUserPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteUserPolicyInput"}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *DeleteUserPolicyInput) SetPolicyName(v string) *DeleteUserPolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DeleteUserPolicyInput) SetUserName(v string) *DeleteUserPolicyInput {
+	s.UserName = &v
+	return s
+}
+
+type DeleteUserPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteUserPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteUserPolicyOutput) GoString() string {
+	return s.String()
+}
+
+type DeleteVirtualMFADeviceInput struct {
+	_ struct{} `type:"structure"`
+
+	// The serial number that uniquely identifies the MFA device. For virtual MFA
+	// devices, the serial number is the same as the ARN.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: =,.@:/-
+	//
+	// SerialNumber is a required field
+	SerialNumber *string `min:"9" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DeleteVirtualMFADeviceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVirtualMFADeviceInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DeleteVirtualMFADeviceInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DeleteVirtualMFADeviceInput"}
+	if s.SerialNumber == nil {
+		invalidParams.Add(request.NewErrParamRequired("SerialNumber"))
+	}
+	if s.SerialNumber != nil && len(*s.SerialNumber) < 9 {
+		invalidParams.Add(request.NewErrParamMinLen("SerialNumber", 9))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetSerialNumber sets the SerialNumber field's value.
+func (s *DeleteVirtualMFADeviceInput) SetSerialNumber(v string) *DeleteVirtualMFADeviceInput {
+	s.SerialNumber = &v
+	return s
+}
+
+type DeleteVirtualMFADeviceOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DeleteVirtualMFADeviceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeleteVirtualMFADeviceOutput) GoString() string {
+	return s.String()
+}
+
+// The reason that the service-linked role deletion failed.
+//
+// This data type is used as a response element in the GetServiceLinkedRoleDeletionStatus
+// operation.
+type DeletionTaskFailureReasonType struct {
+	_ struct{} `type:"structure"`
+
+	// A short description of the reason that the service-linked role deletion failed.
+	Reason *string `type:"string"`
+
+	// A list of objects that contains details about the service-linked role deletion
+	// failure, if that information is returned by the service. If the service-linked
+	// role has active sessions or if any resources that were used by the role have
+	// not been deleted from the linked service, the role can't be deleted. This
+	// parameter includes a list of the resources that are associated with the role
+	// and the Region in which the resources are being used.
+	RoleUsageList []*RoleUsageType `type:"list"`
+}
+
+// String returns the string representation
+func (s DeletionTaskFailureReasonType) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DeletionTaskFailureReasonType) GoString() string {
+	return s.String()
+}
+
+// SetReason sets the Reason field's value.
+func (s *DeletionTaskFailureReasonType) SetReason(v string) *DeletionTaskFailureReasonType {
+	s.Reason = &v
+	return s
+}
+
+// SetRoleUsageList sets the RoleUsageList field's value.
+func (s *DeletionTaskFailureReasonType) SetRoleUsageList(v []*RoleUsageType) *DeletionTaskFailureReasonType {
+	s.RoleUsageList = v
+	return s
+}
+
+type DetachGroupPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name (friendly name, not ARN) of the IAM group to detach the policy from.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy you want to detach.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DetachGroupPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachGroupPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DetachGroupPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DetachGroupPolicyInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *DetachGroupPolicyInput) SetGroupName(v string) *DetachGroupPolicyInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *DetachGroupPolicyInput) SetPolicyArn(v string) *DetachGroupPolicyInput {
+	s.PolicyArn = &v
+	return s
+}
+
+type DetachGroupPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachGroupPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachGroupPolicyOutput) GoString() string {
+	return s.String()
+}
+
+type DetachRolePolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy you want to detach.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+
+	// The name (friendly name, not ARN) of the IAM role to detach the policy from.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DetachRolePolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachRolePolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DetachRolePolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DetachRolePolicyInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *DetachRolePolicyInput) SetPolicyArn(v string) *DetachRolePolicyInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *DetachRolePolicyInput) SetRoleName(v string) *DetachRolePolicyInput {
+	s.RoleName = &v
+	return s
+}
+
+type DetachRolePolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachRolePolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachRolePolicyOutput) GoString() string {
+	return s.String()
+}
+
+type DetachUserPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy you want to detach.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+
+	// The name (friendly name, not ARN) of the IAM user to detach the policy from.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s DetachUserPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachUserPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *DetachUserPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "DetachUserPolicyInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *DetachUserPolicyInput) SetPolicyArn(v string) *DetachUserPolicyInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *DetachUserPolicyInput) SetUserName(v string) *DetachUserPolicyInput {
+	s.UserName = &v
+	return s
+}
+
+type DetachUserPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s DetachUserPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s DetachUserPolicyOutput) GoString() string {
+	return s.String()
+}
+
+type EnableMFADeviceInput struct {
+	_ struct{} `type:"structure"`
+
+	// An authentication code emitted by the device.
+	//
+	// The format for this parameter is a string of six digits.
+	//
+	// Submit your request immediately after generating the authentication codes.
+	// If you generate the codes and then wait too long to submit the request, the
+	// MFA device successfully associates with the user but the MFA device becomes
+	// out of sync. This happens because time-based one-time passwords (TOTP) expire
+	// after a short period of time. If this happens, you can resync the device
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_sync.html).
+	//
+	// AuthenticationCode1 is a required field
+	AuthenticationCode1 *string `min:"6" type:"string" required:"true"`
+
+	// A subsequent authentication code emitted by the device.
+	//
+	// The format for this parameter is a string of six digits.
+	//
+	// Submit your request immediately after generating the authentication codes.
+	// If you generate the codes and then wait too long to submit the request, the
+	// MFA device successfully associates with the user but the MFA device becomes
+	// out of sync. This happens because time-based one-time passwords (TOTP) expire
+	// after a short period of time. If this happens, you can resync the device
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_sync.html).
+	//
+	// AuthenticationCode2 is a required field
+	AuthenticationCode2 *string `min:"6" type:"string" required:"true"`
+
+	// The serial number that uniquely identifies the MFA device. For virtual MFA
+	// devices, the serial number is the device ARN.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: =,.@:/-
+	//
+	// SerialNumber is a required field
+	SerialNumber *string `min:"9" type:"string" required:"true"`
+
+	// The name of the IAM user for whom you want to enable the MFA device.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s EnableMFADeviceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EnableMFADeviceInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *EnableMFADeviceInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "EnableMFADeviceInput"}
+	if s.AuthenticationCode1 == nil {
+		invalidParams.Add(request.NewErrParamRequired("AuthenticationCode1"))
+	}
+	if s.AuthenticationCode1 != nil && len(*s.AuthenticationCode1) < 6 {
+		invalidParams.Add(request.NewErrParamMinLen("AuthenticationCode1", 6))
+	}
+	if s.AuthenticationCode2 == nil {
+		invalidParams.Add(request.NewErrParamRequired("AuthenticationCode2"))
+	}
+	if s.AuthenticationCode2 != nil && len(*s.AuthenticationCode2) < 6 {
+		invalidParams.Add(request.NewErrParamMinLen("AuthenticationCode2", 6))
+	}
+	if s.SerialNumber == nil {
+		invalidParams.Add(request.NewErrParamRequired("SerialNumber"))
+	}
+	if s.SerialNumber != nil && len(*s.SerialNumber) < 9 {
+		invalidParams.Add(request.NewErrParamMinLen("SerialNumber", 9))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAuthenticationCode1 sets the AuthenticationCode1 field's value.
+func (s *EnableMFADeviceInput) SetAuthenticationCode1(v string) *EnableMFADeviceInput {
+	s.AuthenticationCode1 = &v
+	return s
+}
+
+// SetAuthenticationCode2 sets the AuthenticationCode2 field's value.
+func (s *EnableMFADeviceInput) SetAuthenticationCode2(v string) *EnableMFADeviceInput {
+	s.AuthenticationCode2 = &v
+	return s
+}
+
+// SetSerialNumber sets the SerialNumber field's value.
+func (s *EnableMFADeviceInput) SetSerialNumber(v string) *EnableMFADeviceInput {
+	s.SerialNumber = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *EnableMFADeviceInput) SetUserName(v string) *EnableMFADeviceInput {
+	s.UserName = &v
+	return s
+}
+
+type EnableMFADeviceOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s EnableMFADeviceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EnableMFADeviceOutput) GoString() string {
+	return s.String()
+}
+
+// An object that contains details about when the IAM entities (users or roles)
+// were last used in an attempt to access the specified AWS service.
+//
+// This data type is a response element in the GetServiceLastAccessedDetailsWithEntities
+// operation.
+type EntityDetails struct {
+	_ struct{} `type:"structure"`
+
+	// The EntityInfo object that contains details about the entity (user or role).
+	//
+	// EntityInfo is a required field
+	EntityInfo *EntityInfo `type:"structure" required:"true"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the authenticated entity last attempted to access AWS. AWS does not
+	// report unauthenticated requests.
+	//
+	// This field is null if no IAM entities attempted to access the service within
+	// the reporting period (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#service-last-accessed-reporting-period).
+	LastAuthenticated *time.Time `type:"timestamp"`
+}
+
+// String returns the string representation
+func (s EntityDetails) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EntityDetails) GoString() string {
+	return s.String()
+}
+
+// SetEntityInfo sets the EntityInfo field's value.
+func (s *EntityDetails) SetEntityInfo(v *EntityInfo) *EntityDetails {
+	s.EntityInfo = v
+	return s
+}
+
+// SetLastAuthenticated sets the LastAuthenticated field's value.
+func (s *EntityDetails) SetLastAuthenticated(v time.Time) *EntityDetails {
+	s.LastAuthenticated = &v
+	return s
+}
+
+// Contains details about the specified entity (user or role).
+//
+// This data type is an element of the EntityDetails object.
+type EntityInfo struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN). ARNs are unique identifiers for AWS resources.
+	//
+	// For more information about ARNs, go to Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// Arn is a required field
+	Arn *string `min:"20" type:"string" required:"true"`
+
+	// The identifier of the entity (user or role).
+	//
+	// Id is a required field
+	Id *string `min:"16" type:"string" required:"true"`
+
+	// The name of the entity (user or role).
+	//
+	// Name is a required field
+	Name *string `min:"1" type:"string" required:"true"`
+
+	// The path to the entity (user or role). For more information about paths,
+	// see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	Path *string `min:"1" type:"string"`
+
+	// The type of entity (user or role).
+	//
+	// Type is a required field
+	Type *string `type:"string" required:"true" enum:"policyOwnerEntityType"`
+}
+
+// String returns the string representation
+func (s EntityInfo) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EntityInfo) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *EntityInfo) SetArn(v string) *EntityInfo {
+	s.Arn = &v
+	return s
+}
+
+// SetId sets the Id field's value.
+func (s *EntityInfo) SetId(v string) *EntityInfo {
+	s.Id = &v
+	return s
+}
+
+// SetName sets the Name field's value.
+func (s *EntityInfo) SetName(v string) *EntityInfo {
+	s.Name = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *EntityInfo) SetPath(v string) *EntityInfo {
+	s.Path = &v
+	return s
+}
+
+// SetType sets the Type field's value.
+func (s *EntityInfo) SetType(v string) *EntityInfo {
+	s.Type = &v
+	return s
+}
+
+// Contains information about the reason that the operation failed.
+//
+// This data type is used as a response element in the GetOrganizationsAccessReport,
+// GetServiceLastAccessedDetails, and GetServiceLastAccessedDetailsWithEntities
+// operations.
+type ErrorDetails struct {
+	_ struct{} `type:"structure"`
+
+	// The error code associated with the operation failure.
+	//
+	// Code is a required field
+	Code *string `type:"string" required:"true"`
+
+	// Detailed information about the reason that the operation failed.
+	//
+	// Message is a required field
+	Message *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ErrorDetails) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ErrorDetails) GoString() string {
+	return s.String()
+}
+
+// SetCode sets the Code field's value.
+func (s *ErrorDetails) SetCode(v string) *ErrorDetails {
+	s.Code = &v
+	return s
+}
+
+// SetMessage sets the Message field's value.
+func (s *ErrorDetails) SetMessage(v string) *ErrorDetails {
+	s.Message = &v
+	return s
+}
+
+// Contains the results of a simulation.
+//
+// This data type is used by the return parameter of SimulateCustomPolicy and
+// SimulatePrincipalPolicy .
+type EvaluationResult struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the API operation tested on the indicated resource.
+	//
+	// EvalActionName is a required field
+	EvalActionName *string `min:"3" type:"string" required:"true"`
+
+	// The result of the simulation.
+	//
+	// EvalDecision is a required field
+	EvalDecision *string `type:"string" required:"true" enum:"PolicyEvaluationDecisionType"`
+
+	// Additional details about the results of the evaluation decision. When there
+	// are both IAM policies and resource policies, this parameter explains how
+	// each set of policies contributes to the final evaluation decision. When simulating
+	// cross-account access to a resource, both the resource-based policy and the
+	// caller's IAM policy must grant access. See How IAM Roles Differ from Resource-based
+	// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html)
+	EvalDecisionDetails map[string]*string `type:"map"`
+
+	// The ARN of the resource that the indicated API operation was tested on.
+	EvalResourceName *string `min:"1" type:"string"`
+
+	// A list of the statements in the input policies that determine the result
+	// for this scenario. Remember that even if multiple statements allow the operation
+	// on the resource, if only one statement denies that operation, then the explicit
+	// deny overrides any allow. In addition, the deny statement is the only entry
+	// included in the result.
+	MatchedStatements []*Statement `type:"list"`
+
+	// A list of context keys that are required by the included input policies but
+	// that were not provided by one of the input parameters. This list is used
+	// when the resource in a simulation is "*", either explicitly, or when the
+	// ResourceArns parameter blank. If you include a list of resources, then any
+	// missing context values are instead included under the ResourceSpecificResults
+	// section. To discover the context keys used by a set of policies, you can
+	// call GetContextKeysForCustomPolicy or GetContextKeysForPrincipalPolicy.
+	MissingContextValues []*string `type:"list"`
+
+	// A structure that details how Organizations and its service control policies
+	// affect the results of the simulation. Only applies if the simulated user's
+	// account is part of an organization.
+	OrganizationsDecisionDetail *OrganizationsDecisionDetail `type:"structure"`
+
+	// The individual results of the simulation of the API operation specified in
+	// EvalActionName on each resource.
+	ResourceSpecificResults []*ResourceSpecificResult `type:"list"`
+}
+
+// String returns the string representation
+func (s EvaluationResult) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s EvaluationResult) GoString() string {
+	return s.String()
+}
+
+// SetEvalActionName sets the EvalActionName field's value.
+func (s *EvaluationResult) SetEvalActionName(v string) *EvaluationResult {
+	s.EvalActionName = &v
+	return s
+}
+
+// SetEvalDecision sets the EvalDecision field's value.
+func (s *EvaluationResult) SetEvalDecision(v string) *EvaluationResult {
+	s.EvalDecision = &v
+	return s
+}
+
+// SetEvalDecisionDetails sets the EvalDecisionDetails field's value.
+func (s *EvaluationResult) SetEvalDecisionDetails(v map[string]*string) *EvaluationResult {
+	s.EvalDecisionDetails = v
+	return s
+}
+
+// SetEvalResourceName sets the EvalResourceName field's value.
+func (s *EvaluationResult) SetEvalResourceName(v string) *EvaluationResult {
+	s.EvalResourceName = &v
+	return s
+}
+
+// SetMatchedStatements sets the MatchedStatements field's value.
+func (s *EvaluationResult) SetMatchedStatements(v []*Statement) *EvaluationResult {
+	s.MatchedStatements = v
+	return s
+}
+
+// SetMissingContextValues sets the MissingContextValues field's value.
+func (s *EvaluationResult) SetMissingContextValues(v []*string) *EvaluationResult {
+	s.MissingContextValues = v
+	return s
+}
+
+// SetOrganizationsDecisionDetail sets the OrganizationsDecisionDetail field's value.
+func (s *EvaluationResult) SetOrganizationsDecisionDetail(v *OrganizationsDecisionDetail) *EvaluationResult {
+	s.OrganizationsDecisionDetail = v
+	return s
+}
+
+// SetResourceSpecificResults sets the ResourceSpecificResults field's value.
+func (s *EvaluationResult) SetResourceSpecificResults(v []*ResourceSpecificResult) *EvaluationResult {
+	s.ResourceSpecificResults = v
+	return s
+}
+
+type GenerateCredentialReportInput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s GenerateCredentialReportInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GenerateCredentialReportInput) GoString() string {
+	return s.String()
+}
+
+// Contains the response to a successful GenerateCredentialReport request.
+type GenerateCredentialReportOutput struct {
+	_ struct{} `type:"structure"`
+
+	// Information about the credential report.
+	Description *string `type:"string"`
+
+	// Information about the state of the credential report.
+	State *string `type:"string" enum:"ReportStateType"`
+}
+
+// String returns the string representation
+func (s GenerateCredentialReportOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GenerateCredentialReportOutput) GoString() string {
+	return s.String()
+}
+
+// SetDescription sets the Description field's value.
+func (s *GenerateCredentialReportOutput) SetDescription(v string) *GenerateCredentialReportOutput {
+	s.Description = &v
+	return s
+}
+
+// SetState sets the State field's value.
+func (s *GenerateCredentialReportOutput) SetState(v string) *GenerateCredentialReportOutput {
+	s.State = &v
+	return s
+}
+
+type GenerateOrganizationsAccessReportInput struct {
+	_ struct{} `type:"structure"`
+
+	// The path of the AWS Organizations entity (root, OU, or account). You can
+	// build an entity path using the known structure of your organization. For
+	// example, assume that your account ID is 123456789012 and its parent OU ID
+	// is ou-rge0-awsabcde. The organization root ID is r-f6g7h8i9j0example and
+	// your organization ID is o-a1b2c3d4e5. Your entity path is o-a1b2c3d4e5/r-f6g7h8i9j0example/ou-rge0-awsabcde/123456789012.
+	//
+	// EntityPath is a required field
+	EntityPath *string `min:"19" type:"string" required:"true"`
+
+	// The identifier of the AWS Organizations service control policy (SCP). This
+	// parameter is optional.
+	//
+	// This ID is used to generate information about when an account principal that
+	// is limited by the SCP attempted to access an AWS service.
+	OrganizationsPolicyId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s GenerateOrganizationsAccessReportInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GenerateOrganizationsAccessReportInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GenerateOrganizationsAccessReportInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GenerateOrganizationsAccessReportInput"}
+	if s.EntityPath == nil {
+		invalidParams.Add(request.NewErrParamRequired("EntityPath"))
+	}
+	if s.EntityPath != nil && len(*s.EntityPath) < 19 {
+		invalidParams.Add(request.NewErrParamMinLen("EntityPath", 19))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetEntityPath sets the EntityPath field's value.
+func (s *GenerateOrganizationsAccessReportInput) SetEntityPath(v string) *GenerateOrganizationsAccessReportInput {
+	s.EntityPath = &v
+	return s
+}
+
+// SetOrganizationsPolicyId sets the OrganizationsPolicyId field's value.
+func (s *GenerateOrganizationsAccessReportInput) SetOrganizationsPolicyId(v string) *GenerateOrganizationsAccessReportInput {
+	s.OrganizationsPolicyId = &v
+	return s
+}
+
+type GenerateOrganizationsAccessReportOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The job identifier that you can use in the GetOrganizationsAccessReport operation.
+	JobId *string `min:"36" type:"string"`
+}
+
+// String returns the string representation
+func (s GenerateOrganizationsAccessReportOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GenerateOrganizationsAccessReportOutput) GoString() string {
+	return s.String()
+}
+
+// SetJobId sets the JobId field's value.
+func (s *GenerateOrganizationsAccessReportOutput) SetJobId(v string) *GenerateOrganizationsAccessReportOutput {
+	s.JobId = &v
+	return s
+}
+
+type GenerateServiceLastAccessedDetailsInput struct {
+	_ struct{} `type:"structure"`
+
+	// The ARN of the IAM resource (user, group, role, or managed policy) used to
+	// generate information about when the resource was last used in an attempt
+	// to access an AWS service.
+	//
+	// Arn is a required field
+	Arn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GenerateServiceLastAccessedDetailsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GenerateServiceLastAccessedDetailsInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GenerateServiceLastAccessedDetailsInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GenerateServiceLastAccessedDetailsInput"}
+	if s.Arn == nil {
+		invalidParams.Add(request.NewErrParamRequired("Arn"))
+	}
+	if s.Arn != nil && len(*s.Arn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("Arn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetArn sets the Arn field's value.
+func (s *GenerateServiceLastAccessedDetailsInput) SetArn(v string) *GenerateServiceLastAccessedDetailsInput {
+	s.Arn = &v
+	return s
+}
+
+type GenerateServiceLastAccessedDetailsOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The job ID that you can use in the GetServiceLastAccessedDetails or GetServiceLastAccessedDetailsWithEntities
+	// operations.
+	JobId *string `min:"36" type:"string"`
+}
+
+// String returns the string representation
+func (s GenerateServiceLastAccessedDetailsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GenerateServiceLastAccessedDetailsOutput) GoString() string {
+	return s.String()
+}
+
+// SetJobId sets the JobId field's value.
+func (s *GenerateServiceLastAccessedDetailsOutput) SetJobId(v string) *GenerateServiceLastAccessedDetailsOutput {
+	s.JobId = &v
+	return s
+}
+
+type GetAccessKeyLastUsedInput struct {
+	_ struct{} `type:"structure"`
+
+	// The identifier of an access key.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// AccessKeyId is a required field
+	AccessKeyId *string `min:"16" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetAccessKeyLastUsedInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetAccessKeyLastUsedInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetAccessKeyLastUsedInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetAccessKeyLastUsedInput"}
+	if s.AccessKeyId == nil {
+		invalidParams.Add(request.NewErrParamRequired("AccessKeyId"))
+	}
+	if s.AccessKeyId != nil && len(*s.AccessKeyId) < 16 {
+		invalidParams.Add(request.NewErrParamMinLen("AccessKeyId", 16))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAccessKeyId sets the AccessKeyId field's value.
+func (s *GetAccessKeyLastUsedInput) SetAccessKeyId(v string) *GetAccessKeyLastUsedInput {
+	s.AccessKeyId = &v
+	return s
+}
+
+// Contains the response to a successful GetAccessKeyLastUsed request. It is
+// also returned as a member of the AccessKeyMetaData structure returned by
+// the ListAccessKeys action.
+type GetAccessKeyLastUsedOutput struct {
+	_ struct{} `type:"structure"`
+
+	// Contains information about the last time the access key was used.
+	AccessKeyLastUsed *AccessKeyLastUsed `type:"structure"`
+
+	// The name of the AWS IAM user that owns this access key.
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s GetAccessKeyLastUsedOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetAccessKeyLastUsedOutput) GoString() string {
+	return s.String()
+}
+
+// SetAccessKeyLastUsed sets the AccessKeyLastUsed field's value.
+func (s *GetAccessKeyLastUsedOutput) SetAccessKeyLastUsed(v *AccessKeyLastUsed) *GetAccessKeyLastUsedOutput {
+	s.AccessKeyLastUsed = v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *GetAccessKeyLastUsedOutput) SetUserName(v string) *GetAccessKeyLastUsedOutput {
+	s.UserName = &v
+	return s
+}
+
+type GetAccountAuthorizationDetailsInput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of entity types used to filter the results. Only the entities that
+	// match the types you specify are included in the output. Use the value LocalManagedPolicy
+	// to include customer managed policies.
+	//
+	// The format for this parameter is a comma-separated (if more than one) list
+	// of strings. Each string value in the list must be one of the valid values
+	// listed below.
+	Filter []*string `type:"list"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+}
+
+// String returns the string representation
+func (s GetAccountAuthorizationDetailsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetAccountAuthorizationDetailsInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetAccountAuthorizationDetailsInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetAccountAuthorizationDetailsInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetFilter sets the Filter field's value.
+func (s *GetAccountAuthorizationDetailsInput) SetFilter(v []*string) *GetAccountAuthorizationDetailsInput {
+	s.Filter = v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetAccountAuthorizationDetailsInput) SetMarker(v string) *GetAccountAuthorizationDetailsInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *GetAccountAuthorizationDetailsInput) SetMaxItems(v int64) *GetAccountAuthorizationDetailsInput {
+	s.MaxItems = &v
+	return s
+}
+
+// Contains the response to a successful GetAccountAuthorizationDetails request.
+type GetAccountAuthorizationDetailsOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list containing information about IAM groups.
+	GroupDetailList []*GroupDetail `type:"list"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list containing information about managed policies.
+	Policies []*ManagedPolicyDetail `type:"list"`
+
+	// A list containing information about IAM roles.
+	RoleDetailList []*RoleDetail `type:"list"`
+
+	// A list containing information about IAM users.
+	UserDetailList []*UserDetail `type:"list"`
+}
+
+// String returns the string representation
+func (s GetAccountAuthorizationDetailsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetAccountAuthorizationDetailsOutput) GoString() string {
+	return s.String()
+}
+
+// SetGroupDetailList sets the GroupDetailList field's value.
+func (s *GetAccountAuthorizationDetailsOutput) SetGroupDetailList(v []*GroupDetail) *GetAccountAuthorizationDetailsOutput {
+	s.GroupDetailList = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *GetAccountAuthorizationDetailsOutput) SetIsTruncated(v bool) *GetAccountAuthorizationDetailsOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetAccountAuthorizationDetailsOutput) SetMarker(v string) *GetAccountAuthorizationDetailsOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetPolicies sets the Policies field's value.
+func (s *GetAccountAuthorizationDetailsOutput) SetPolicies(v []*ManagedPolicyDetail) *GetAccountAuthorizationDetailsOutput {
+	s.Policies = v
+	return s
+}
+
+// SetRoleDetailList sets the RoleDetailList field's value.
+func (s *GetAccountAuthorizationDetailsOutput) SetRoleDetailList(v []*RoleDetail) *GetAccountAuthorizationDetailsOutput {
+	s.RoleDetailList = v
+	return s
+}
+
+// SetUserDetailList sets the UserDetailList field's value.
+func (s *GetAccountAuthorizationDetailsOutput) SetUserDetailList(v []*UserDetail) *GetAccountAuthorizationDetailsOutput {
+	s.UserDetailList = v
+	return s
+}
+
+type GetAccountPasswordPolicyInput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetAccountPasswordPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetAccountPasswordPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Contains the response to a successful GetAccountPasswordPolicy request.
+type GetAccountPasswordPolicyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure that contains details about the account's password policy.
+	//
+	// PasswordPolicy is a required field
+	PasswordPolicy *PasswordPolicy `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s GetAccountPasswordPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetAccountPasswordPolicyOutput) GoString() string {
+	return s.String()
+}
+
+// SetPasswordPolicy sets the PasswordPolicy field's value.
+func (s *GetAccountPasswordPolicyOutput) SetPasswordPolicy(v *PasswordPolicy) *GetAccountPasswordPolicyOutput {
+	s.PasswordPolicy = v
+	return s
+}
+
+type GetAccountSummaryInput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetAccountSummaryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetAccountSummaryInput) GoString() string {
+	return s.String()
+}
+
+// Contains the response to a successful GetAccountSummary request.
+type GetAccountSummaryOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A set of key–value pairs containing information about IAM entity usage
+	// and IAM quotas.
+	SummaryMap map[string]*int64 `type:"map"`
+}
+
+// String returns the string representation
+func (s GetAccountSummaryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetAccountSummaryOutput) GoString() string {
+	return s.String()
+}
+
+// SetSummaryMap sets the SummaryMap field's value.
+func (s *GetAccountSummaryOutput) SetSummaryMap(v map[string]*int64) *GetAccountSummaryOutput {
+	s.SummaryMap = v
+	return s
+}
+
+type GetContextKeysForCustomPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of policies for which you want the list of context keys referenced
+	// in those policies. Each document is specified as a string containing the
+	// complete, valid JSON text of an IAM policy.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// PolicyInputList is a required field
+	PolicyInputList []*string `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s GetContextKeysForCustomPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetContextKeysForCustomPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetContextKeysForCustomPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetContextKeysForCustomPolicyInput"}
+	if s.PolicyInputList == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyInputList"))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyInputList sets the PolicyInputList field's value.
+func (s *GetContextKeysForCustomPolicyInput) SetPolicyInputList(v []*string) *GetContextKeysForCustomPolicyInput {
+	s.PolicyInputList = v
+	return s
+}
+
+// Contains the response to a successful GetContextKeysForPrincipalPolicy or
+// GetContextKeysForCustomPolicy request.
+type GetContextKeysForPolicyResponse struct {
+	_ struct{} `type:"structure"`
+
+	// The list of context keys that are referenced in the input policies.
+	ContextKeyNames []*string `type:"list"`
+}
+
+// String returns the string representation
+func (s GetContextKeysForPolicyResponse) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetContextKeysForPolicyResponse) GoString() string {
+	return s.String()
+}
+
+// SetContextKeyNames sets the ContextKeyNames field's value.
+func (s *GetContextKeysForPolicyResponse) SetContextKeyNames(v []*string) *GetContextKeysForPolicyResponse {
+	s.ContextKeyNames = v
+	return s
+}
+
+type GetContextKeysForPrincipalPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// An optional list of additional policies for which you want the list of context
+	// keys that are referenced.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	PolicyInputList []*string `type:"list"`
+
+	// The ARN of a user, group, or role whose policies contain the context keys
+	// that you want listed. If you specify a user, the list includes context keys
+	// that are found in all policies that are attached to the user. The list also
+	// includes all groups that the user is a member of. If you pick a group or
+	// a role, then it includes only those context keys that are found in policies
+	// attached to that entity. Note that all parameters are shown in unencoded
+	// form here for clarity, but must be URL encoded to be included as a part of
+	// a real HTML request.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicySourceArn is a required field
+	PolicySourceArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetContextKeysForPrincipalPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetContextKeysForPrincipalPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetContextKeysForPrincipalPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetContextKeysForPrincipalPolicyInput"}
+	if s.PolicySourceArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicySourceArn"))
+	}
+	if s.PolicySourceArn != nil && len(*s.PolicySourceArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicySourceArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyInputList sets the PolicyInputList field's value.
+func (s *GetContextKeysForPrincipalPolicyInput) SetPolicyInputList(v []*string) *GetContextKeysForPrincipalPolicyInput {
+	s.PolicyInputList = v
+	return s
+}
+
+// SetPolicySourceArn sets the PolicySourceArn field's value.
+func (s *GetContextKeysForPrincipalPolicyInput) SetPolicySourceArn(v string) *GetContextKeysForPrincipalPolicyInput {
+	s.PolicySourceArn = &v
+	return s
+}
+
+type GetCredentialReportInput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetCredentialReportInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetCredentialReportInput) GoString() string {
+	return s.String()
+}
+
+// Contains the response to a successful GetCredentialReport request.
+type GetCredentialReportOutput struct {
+	_ struct{} `type:"structure"`
+
+	// Contains the credential report. The report is Base64-encoded.
+	//
+	// Content is automatically base64 encoded/decoded by the SDK.
+	Content []byte `type:"blob"`
+
+	// The date and time when the credential report was created, in ISO 8601 date-time
+	// format (http://www.iso.org/iso/iso8601).
+	GeneratedTime *time.Time `type:"timestamp"`
+
+	// The format (MIME type) of the credential report.
+	ReportFormat *string `type:"string" enum:"ReportFormatType"`
+}
+
+// String returns the string representation
+func (s GetCredentialReportOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetCredentialReportOutput) GoString() string {
+	return s.String()
+}
+
+// SetContent sets the Content field's value.
+func (s *GetCredentialReportOutput) SetContent(v []byte) *GetCredentialReportOutput {
+	s.Content = v
+	return s
+}
+
+// SetGeneratedTime sets the GeneratedTime field's value.
+func (s *GetCredentialReportOutput) SetGeneratedTime(v time.Time) *GetCredentialReportOutput {
+	s.GeneratedTime = &v
+	return s
+}
+
+// SetReportFormat sets the ReportFormat field's value.
+func (s *GetCredentialReportOutput) SetReportFormat(v string) *GetCredentialReportOutput {
+	s.ReportFormat = &v
+	return s
+}
+
+type GetGroupInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the group.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+}
+
+// String returns the string representation
+func (s GetGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetGroupInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetGroupInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetGroupInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *GetGroupInput) SetGroupName(v string) *GetGroupInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetGroupInput) SetMarker(v string) *GetGroupInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *GetGroupInput) SetMaxItems(v int64) *GetGroupInput {
+	s.MaxItems = &v
+	return s
+}
+
+// Contains the response to a successful GetGroup request.
+type GetGroupOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure that contains details about the group.
+	//
+	// Group is a required field
+	Group *Group `type:"structure" required:"true"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of users in the group.
+	//
+	// Users is a required field
+	Users []*User `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s GetGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetGroupOutput) GoString() string {
+	return s.String()
+}
+
+// SetGroup sets the Group field's value.
+func (s *GetGroupOutput) SetGroup(v *Group) *GetGroupOutput {
+	s.Group = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *GetGroupOutput) SetIsTruncated(v bool) *GetGroupOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetGroupOutput) SetMarker(v string) *GetGroupOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetUsers sets the Users field's value.
+func (s *GetGroupOutput) SetUsers(v []*User) *GetGroupOutput {
+	s.Users = v
+	return s
+}
+
+type GetGroupPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the group the policy is associated with.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The name of the policy document to get.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetGroupPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetGroupPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetGroupPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetGroupPolicyInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *GetGroupPolicyInput) SetGroupName(v string) *GetGroupPolicyInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *GetGroupPolicyInput) SetPolicyName(v string) *GetGroupPolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+// Contains the response to a successful GetGroupPolicy request.
+type GetGroupPolicyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The group the policy is associated with.
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The policy document.
+	//
+	// IAM stores policies in JSON format. However, resources that were created
+	// using AWS CloudFormation templates can be formatted in YAML. AWS CloudFormation
+	// always converts a YAML policy to JSON format before submitting it to IAM.
+	//
+	// PolicyDocument is a required field
+	PolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// The name of the policy.
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetGroupPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetGroupPolicyOutput) GoString() string {
+	return s.String()
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *GetGroupPolicyOutput) SetGroupName(v string) *GetGroupPolicyOutput {
+	s.GroupName = &v
+	return s
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *GetGroupPolicyOutput) SetPolicyDocument(v string) *GetGroupPolicyOutput {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *GetGroupPolicyOutput) SetPolicyName(v string) *GetGroupPolicyOutput {
+	s.PolicyName = &v
+	return s
+}
+
+type GetInstanceProfileInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the instance profile to get information about.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// InstanceProfileName is a required field
+	InstanceProfileName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetInstanceProfileInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetInstanceProfileInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetInstanceProfileInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetInstanceProfileInput"}
+	if s.InstanceProfileName == nil {
+		invalidParams.Add(request.NewErrParamRequired("InstanceProfileName"))
+	}
+	if s.InstanceProfileName != nil && len(*s.InstanceProfileName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("InstanceProfileName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetInstanceProfileName sets the InstanceProfileName field's value.
+func (s *GetInstanceProfileInput) SetInstanceProfileName(v string) *GetInstanceProfileInput {
+	s.InstanceProfileName = &v
+	return s
+}
+
+// Contains the response to a successful GetInstanceProfile request.
+type GetInstanceProfileOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the instance profile.
+	//
+	// InstanceProfile is a required field
+	InstanceProfile *InstanceProfile `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s GetInstanceProfileOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetInstanceProfileOutput) GoString() string {
+	return s.String()
+}
+
+// SetInstanceProfile sets the InstanceProfile field's value.
+func (s *GetInstanceProfileOutput) SetInstanceProfile(v *InstanceProfile) *GetInstanceProfileOutput {
+	s.InstanceProfile = v
+	return s
+}
+
+type GetLoginProfileInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the user whose login profile you want to retrieve.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetLoginProfileInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetLoginProfileInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetLoginProfileInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetLoginProfileInput"}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetUserName sets the UserName field's value.
+func (s *GetLoginProfileInput) SetUserName(v string) *GetLoginProfileInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful GetLoginProfile request.
+type GetLoginProfileOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing the user name and password create date for the user.
+	//
+	// LoginProfile is a required field
+	LoginProfile *LoginProfile `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s GetLoginProfileOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetLoginProfileOutput) GoString() string {
+	return s.String()
+}
+
+// SetLoginProfile sets the LoginProfile field's value.
+func (s *GetLoginProfileOutput) SetLoginProfile(v *LoginProfile) *GetLoginProfileOutput {
+	s.LoginProfile = v
+	return s
+}
+
+type GetOpenIDConnectProviderInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the OIDC provider resource object in IAM
+	// to get information for. You can get a list of OIDC provider resource ARNs
+	// by using the ListOpenIDConnectProviders operation.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// OpenIDConnectProviderArn is a required field
+	OpenIDConnectProviderArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetOpenIDConnectProviderInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetOpenIDConnectProviderInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetOpenIDConnectProviderInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetOpenIDConnectProviderInput"}
+	if s.OpenIDConnectProviderArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("OpenIDConnectProviderArn"))
+	}
+	if s.OpenIDConnectProviderArn != nil && len(*s.OpenIDConnectProviderArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("OpenIDConnectProviderArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetOpenIDConnectProviderArn sets the OpenIDConnectProviderArn field's value.
+func (s *GetOpenIDConnectProviderInput) SetOpenIDConnectProviderArn(v string) *GetOpenIDConnectProviderInput {
+	s.OpenIDConnectProviderArn = &v
+	return s
+}
+
+// Contains the response to a successful GetOpenIDConnectProvider request.
+type GetOpenIDConnectProviderOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of client IDs (also known as audiences) that are associated with the
+	// specified IAM OIDC provider resource object. For more information, see CreateOpenIDConnectProvider.
+	ClientIDList []*string `type:"list"`
+
+	// The date and time when the IAM OIDC provider resource object was created
+	// in the AWS account.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// A list of certificate thumbprints that are associated with the specified
+	// IAM OIDC provider resource object. For more information, see CreateOpenIDConnectProvider.
+	ThumbprintList []*string `type:"list"`
+
+	// The URL that the IAM OIDC provider resource object is associated with. For
+	// more information, see CreateOpenIDConnectProvider.
+	Url *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s GetOpenIDConnectProviderOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetOpenIDConnectProviderOutput) GoString() string {
+	return s.String()
+}
+
+// SetClientIDList sets the ClientIDList field's value.
+func (s *GetOpenIDConnectProviderOutput) SetClientIDList(v []*string) *GetOpenIDConnectProviderOutput {
+	s.ClientIDList = v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *GetOpenIDConnectProviderOutput) SetCreateDate(v time.Time) *GetOpenIDConnectProviderOutput {
+	s.CreateDate = &v
+	return s
+}
+
+// SetThumbprintList sets the ThumbprintList field's value.
+func (s *GetOpenIDConnectProviderOutput) SetThumbprintList(v []*string) *GetOpenIDConnectProviderOutput {
+	s.ThumbprintList = v
+	return s
+}
+
+// SetUrl sets the Url field's value.
+func (s *GetOpenIDConnectProviderOutput) SetUrl(v string) *GetOpenIDConnectProviderOutput {
+	s.Url = &v
+	return s
+}
+
+type GetOrganizationsAccessReportInput struct {
+	_ struct{} `type:"structure"`
+
+	// The identifier of the request generated by the GenerateOrganizationsAccessReport
+	// operation.
+	//
+	// JobId is a required field
+	JobId *string `min:"36" type:"string" required:"true"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The key that is used to sort the results. If you choose the namespace key,
+	// the results are returned in alphabetical order. If you choose the time key,
+	// the results are sorted numerically by the date and time.
+	SortKey *string `type:"string" enum:"sortKeyType"`
+}
+
+// String returns the string representation
+func (s GetOrganizationsAccessReportInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetOrganizationsAccessReportInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetOrganizationsAccessReportInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetOrganizationsAccessReportInput"}
+	if s.JobId == nil {
+		invalidParams.Add(request.NewErrParamRequired("JobId"))
+	}
+	if s.JobId != nil && len(*s.JobId) < 36 {
+		invalidParams.Add(request.NewErrParamMinLen("JobId", 36))
+	}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetJobId sets the JobId field's value.
+func (s *GetOrganizationsAccessReportInput) SetJobId(v string) *GetOrganizationsAccessReportInput {
+	s.JobId = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetOrganizationsAccessReportInput) SetMarker(v string) *GetOrganizationsAccessReportInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *GetOrganizationsAccessReportInput) SetMaxItems(v int64) *GetOrganizationsAccessReportInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetSortKey sets the SortKey field's value.
+func (s *GetOrganizationsAccessReportInput) SetSortKey(v string) *GetOrganizationsAccessReportInput {
+	s.SortKey = &v
+	return s
+}
+
+type GetOrganizationsAccessReportOutput struct {
+	_ struct{} `type:"structure"`
+
+	// An object that contains details about the most recent attempt to access the
+	// service.
+	AccessDetails []*AccessDetail `type:"list"`
+
+	// Contains information about the reason that the operation failed.
+	//
+	// This data type is used as a response element in the GetOrganizationsAccessReport,
+	// GetServiceLastAccessedDetails, and GetServiceLastAccessedDetailsWithEntities
+	// operations.
+	ErrorDetails *ErrorDetails `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the generated report job was completed or failed.
+	//
+	// This field is null if the job is still in progress, as indicated by a job
+	// status value of IN_PROGRESS.
+	JobCompletionDate *time.Time `type:"timestamp"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the report job was created.
+	//
+	// JobCreationDate is a required field
+	JobCreationDate *time.Time `type:"timestamp" required:"true"`
+
+	// The status of the job.
+	//
+	// JobStatus is a required field
+	JobStatus *string `type:"string" required:"true" enum:"jobStatusType"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `min:"1" type:"string"`
+
+	// The number of services that the applicable SCPs allow account principals
+	// to access.
+	NumberOfServicesAccessible *int64 `type:"integer"`
+
+	// The number of services that account principals are allowed but did not attempt
+	// to access.
+	NumberOfServicesNotAccessed *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s GetOrganizationsAccessReportOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetOrganizationsAccessReportOutput) GoString() string {
+	return s.String()
+}
+
+// SetAccessDetails sets the AccessDetails field's value.
+func (s *GetOrganizationsAccessReportOutput) SetAccessDetails(v []*AccessDetail) *GetOrganizationsAccessReportOutput {
+	s.AccessDetails = v
+	return s
+}
+
+// SetErrorDetails sets the ErrorDetails field's value.
+func (s *GetOrganizationsAccessReportOutput) SetErrorDetails(v *ErrorDetails) *GetOrganizationsAccessReportOutput {
+	s.ErrorDetails = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *GetOrganizationsAccessReportOutput) SetIsTruncated(v bool) *GetOrganizationsAccessReportOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetJobCompletionDate sets the JobCompletionDate field's value.
+func (s *GetOrganizationsAccessReportOutput) SetJobCompletionDate(v time.Time) *GetOrganizationsAccessReportOutput {
+	s.JobCompletionDate = &v
+	return s
+}
+
+// SetJobCreationDate sets the JobCreationDate field's value.
+func (s *GetOrganizationsAccessReportOutput) SetJobCreationDate(v time.Time) *GetOrganizationsAccessReportOutput {
+	s.JobCreationDate = &v
+	return s
+}
+
+// SetJobStatus sets the JobStatus field's value.
+func (s *GetOrganizationsAccessReportOutput) SetJobStatus(v string) *GetOrganizationsAccessReportOutput {
+	s.JobStatus = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetOrganizationsAccessReportOutput) SetMarker(v string) *GetOrganizationsAccessReportOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetNumberOfServicesAccessible sets the NumberOfServicesAccessible field's value.
+func (s *GetOrganizationsAccessReportOutput) SetNumberOfServicesAccessible(v int64) *GetOrganizationsAccessReportOutput {
+	s.NumberOfServicesAccessible = &v
+	return s
+}
+
+// SetNumberOfServicesNotAccessed sets the NumberOfServicesNotAccessed field's value.
+func (s *GetOrganizationsAccessReportOutput) SetNumberOfServicesNotAccessed(v int64) *GetOrganizationsAccessReportOutput {
+	s.NumberOfServicesNotAccessed = &v
+	return s
+}
+
+type GetPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the managed policy that you want information
+	// about.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetPolicyInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *GetPolicyInput) SetPolicyArn(v string) *GetPolicyInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// Contains the response to a successful GetPolicy request.
+type GetPolicyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the policy.
+	Policy *Policy `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetPolicyOutput) GoString() string {
+	return s.String()
+}
+
+// SetPolicy sets the Policy field's value.
+func (s *GetPolicyOutput) SetPolicy(v *Policy) *GetPolicyOutput {
+	s.Policy = v
+	return s
+}
+
+type GetPolicyVersionInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the managed policy that you want information
+	// about.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+
+	// Identifies the policy version to retrieve.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that consists of the lowercase letter 'v' followed
+	// by one or two digits, and optionally followed by a period '.' and a string
+	// of letters and digits.
+	//
+	// VersionId is a required field
+	VersionId *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetPolicyVersionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetPolicyVersionInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetPolicyVersionInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetPolicyVersionInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+	if s.VersionId == nil {
+		invalidParams.Add(request.NewErrParamRequired("VersionId"))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *GetPolicyVersionInput) SetPolicyArn(v string) *GetPolicyVersionInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *GetPolicyVersionInput) SetVersionId(v string) *GetPolicyVersionInput {
+	s.VersionId = &v
+	return s
+}
+
+// Contains the response to a successful GetPolicyVersion request.
+type GetPolicyVersionOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the policy version.
+	PolicyVersion *PolicyVersion `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetPolicyVersionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetPolicyVersionOutput) GoString() string {
+	return s.String()
+}
+
+// SetPolicyVersion sets the PolicyVersion field's value.
+func (s *GetPolicyVersionOutput) SetPolicyVersion(v *PolicyVersion) *GetPolicyVersionOutput {
+	s.PolicyVersion = v
+	return s
+}
+
+type GetRoleInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the IAM role to get information about.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetRoleInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetRoleInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetRoleInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetRoleInput"}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *GetRoleInput) SetRoleName(v string) *GetRoleInput {
+	s.RoleName = &v
+	return s
+}
+
+// Contains the response to a successful GetRole request.
+type GetRoleOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the IAM role.
+	//
+	// Role is a required field
+	Role *Role `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s GetRoleOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetRoleOutput) GoString() string {
+	return s.String()
+}
+
+// SetRole sets the Role field's value.
+func (s *GetRoleOutput) SetRole(v *Role) *GetRoleOutput {
+	s.Role = v
+	return s
+}
+
+type GetRolePolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the policy document to get.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+
+	// The name of the role associated with the policy.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetRolePolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetRolePolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetRolePolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetRolePolicyInput"}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *GetRolePolicyInput) SetPolicyName(v string) *GetRolePolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *GetRolePolicyInput) SetRoleName(v string) *GetRolePolicyInput {
+	s.RoleName = &v
+	return s
+}
+
+// Contains the response to a successful GetRolePolicy request.
+type GetRolePolicyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The policy document.
+	//
+	// IAM stores policies in JSON format. However, resources that were created
+	// using AWS CloudFormation templates can be formatted in YAML. AWS CloudFormation
+	// always converts a YAML policy to JSON format before submitting it to IAM.
+	//
+	// PolicyDocument is a required field
+	PolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// The name of the policy.
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+
+	// The role the policy is associated with.
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetRolePolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetRolePolicyOutput) GoString() string {
+	return s.String()
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *GetRolePolicyOutput) SetPolicyDocument(v string) *GetRolePolicyOutput {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *GetRolePolicyOutput) SetPolicyName(v string) *GetRolePolicyOutput {
+	s.PolicyName = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *GetRolePolicyOutput) SetRoleName(v string) *GetRolePolicyOutput {
+	s.RoleName = &v
+	return s
+}
+
+type GetSAMLProviderInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the SAML provider resource object in IAM
+	// to get information about.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// SAMLProviderArn is a required field
+	SAMLProviderArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetSAMLProviderInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetSAMLProviderInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetSAMLProviderInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetSAMLProviderInput"}
+	if s.SAMLProviderArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("SAMLProviderArn"))
+	}
+	if s.SAMLProviderArn != nil && len(*s.SAMLProviderArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("SAMLProviderArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetSAMLProviderArn sets the SAMLProviderArn field's value.
+func (s *GetSAMLProviderInput) SetSAMLProviderArn(v string) *GetSAMLProviderInput {
+	s.SAMLProviderArn = &v
+	return s
+}
+
+// Contains the response to a successful GetSAMLProvider request.
+type GetSAMLProviderOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The date and time when the SAML provider was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// The XML metadata document that includes information about an identity provider.
+	SAMLMetadataDocument *string `min:"1000" type:"string"`
+
+	// The expiration date and time for the SAML provider.
+	ValidUntil *time.Time `type:"timestamp"`
+}
+
+// String returns the string representation
+func (s GetSAMLProviderOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetSAMLProviderOutput) GoString() string {
+	return s.String()
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *GetSAMLProviderOutput) SetCreateDate(v time.Time) *GetSAMLProviderOutput {
+	s.CreateDate = &v
+	return s
+}
+
+// SetSAMLMetadataDocument sets the SAMLMetadataDocument field's value.
+func (s *GetSAMLProviderOutput) SetSAMLMetadataDocument(v string) *GetSAMLProviderOutput {
+	s.SAMLMetadataDocument = &v
+	return s
+}
+
+// SetValidUntil sets the ValidUntil field's value.
+func (s *GetSAMLProviderOutput) SetValidUntil(v time.Time) *GetSAMLProviderOutput {
+	s.ValidUntil = &v
+	return s
+}
+
+type GetSSHPublicKeyInput struct {
+	_ struct{} `type:"structure"`
+
+	// Specifies the public key encoding format to use in the response. To retrieve
+	// the public key in ssh-rsa format, use SSH. To retrieve the public key in
+	// PEM format, use PEM.
+	//
+	// Encoding is a required field
+	Encoding *string `type:"string" required:"true" enum:"encodingType"`
+
+	// The unique identifier for the SSH public key.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// SSHPublicKeyId is a required field
+	SSHPublicKeyId *string `min:"20" type:"string" required:"true"`
+
+	// The name of the IAM user associated with the SSH public key.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetSSHPublicKeyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetSSHPublicKeyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetSSHPublicKeyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetSSHPublicKeyInput"}
+	if s.Encoding == nil {
+		invalidParams.Add(request.NewErrParamRequired("Encoding"))
+	}
+	if s.SSHPublicKeyId == nil {
+		invalidParams.Add(request.NewErrParamRequired("SSHPublicKeyId"))
+	}
+	if s.SSHPublicKeyId != nil && len(*s.SSHPublicKeyId) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("SSHPublicKeyId", 20))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetEncoding sets the Encoding field's value.
+func (s *GetSSHPublicKeyInput) SetEncoding(v string) *GetSSHPublicKeyInput {
+	s.Encoding = &v
+	return s
+}
+
+// SetSSHPublicKeyId sets the SSHPublicKeyId field's value.
+func (s *GetSSHPublicKeyInput) SetSSHPublicKeyId(v string) *GetSSHPublicKeyInput {
+	s.SSHPublicKeyId = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *GetSSHPublicKeyInput) SetUserName(v string) *GetSSHPublicKeyInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful GetSSHPublicKey request.
+type GetSSHPublicKeyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the SSH public key.
+	SSHPublicKey *SSHPublicKey `type:"structure"`
+}
+
+// String returns the string representation
+func (s GetSSHPublicKeyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetSSHPublicKeyOutput) GoString() string {
+	return s.String()
+}
+
+// SetSSHPublicKey sets the SSHPublicKey field's value.
+func (s *GetSSHPublicKeyOutput) SetSSHPublicKey(v *SSHPublicKey) *GetSSHPublicKeyOutput {
+	s.SSHPublicKey = v
+	return s
+}
+
+type GetServerCertificateInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the server certificate you want to retrieve information about.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// ServerCertificateName is a required field
+	ServerCertificateName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetServerCertificateInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetServerCertificateInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetServerCertificateInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetServerCertificateInput"}
+	if s.ServerCertificateName == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServerCertificateName"))
+	}
+	if s.ServerCertificateName != nil && len(*s.ServerCertificateName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ServerCertificateName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetServerCertificateName sets the ServerCertificateName field's value.
+func (s *GetServerCertificateInput) SetServerCertificateName(v string) *GetServerCertificateInput {
+	s.ServerCertificateName = &v
+	return s
+}
+
+// Contains the response to a successful GetServerCertificate request.
+type GetServerCertificateOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the server certificate.
+	//
+	// ServerCertificate is a required field
+	ServerCertificate *ServerCertificate `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s GetServerCertificateOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetServerCertificateOutput) GoString() string {
+	return s.String()
+}
+
+// SetServerCertificate sets the ServerCertificate field's value.
+func (s *GetServerCertificateOutput) SetServerCertificate(v *ServerCertificate) *GetServerCertificateOutput {
+	s.ServerCertificate = v
+	return s
+}
+
+type GetServiceLastAccessedDetailsInput struct {
+	_ struct{} `type:"structure"`
+
+	// The ID of the request generated by the GenerateServiceLastAccessedDetails
+	// operation.
+	//
+	// JobId is a required field
+	JobId *string `min:"36" type:"string" required:"true"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+}
+
+// String returns the string representation
+func (s GetServiceLastAccessedDetailsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetServiceLastAccessedDetailsInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetServiceLastAccessedDetailsInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetServiceLastAccessedDetailsInput"}
+	if s.JobId == nil {
+		invalidParams.Add(request.NewErrParamRequired("JobId"))
+	}
+	if s.JobId != nil && len(*s.JobId) < 36 {
+		invalidParams.Add(request.NewErrParamMinLen("JobId", 36))
+	}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetJobId sets the JobId field's value.
+func (s *GetServiceLastAccessedDetailsInput) SetJobId(v string) *GetServiceLastAccessedDetailsInput {
+	s.JobId = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetServiceLastAccessedDetailsInput) SetMarker(v string) *GetServiceLastAccessedDetailsInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *GetServiceLastAccessedDetailsInput) SetMaxItems(v int64) *GetServiceLastAccessedDetailsInput {
+	s.MaxItems = &v
+	return s
+}
+
+type GetServiceLastAccessedDetailsOutput struct {
+	_ struct{} `type:"structure"`
+
+	// An object that contains details about the reason the operation failed.
+	Error *ErrorDetails `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the generated report job was completed or failed.
+	//
+	// This field is null if the job is still in progress, as indicated by a job
+	// status value of IN_PROGRESS.
+	//
+	// JobCompletionDate is a required field
+	JobCompletionDate *time.Time `type:"timestamp" required:"true"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the report job was created.
+	//
+	// JobCreationDate is a required field
+	JobCreationDate *time.Time `type:"timestamp" required:"true"`
+
+	// The status of the job.
+	//
+	// JobStatus is a required field
+	JobStatus *string `type:"string" required:"true" enum:"jobStatusType"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A ServiceLastAccessed object that contains details about the most recent
+	// attempt to access the service.
+	//
+	// ServicesLastAccessed is a required field
+	ServicesLastAccessed []*ServiceLastAccessed `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s GetServiceLastAccessedDetailsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetServiceLastAccessedDetailsOutput) GoString() string {
+	return s.String()
+}
+
+// SetError sets the Error field's value.
+func (s *GetServiceLastAccessedDetailsOutput) SetError(v *ErrorDetails) *GetServiceLastAccessedDetailsOutput {
+	s.Error = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *GetServiceLastAccessedDetailsOutput) SetIsTruncated(v bool) *GetServiceLastAccessedDetailsOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetJobCompletionDate sets the JobCompletionDate field's value.
+func (s *GetServiceLastAccessedDetailsOutput) SetJobCompletionDate(v time.Time) *GetServiceLastAccessedDetailsOutput {
+	s.JobCompletionDate = &v
+	return s
+}
+
+// SetJobCreationDate sets the JobCreationDate field's value.
+func (s *GetServiceLastAccessedDetailsOutput) SetJobCreationDate(v time.Time) *GetServiceLastAccessedDetailsOutput {
+	s.JobCreationDate = &v
+	return s
+}
+
+// SetJobStatus sets the JobStatus field's value.
+func (s *GetServiceLastAccessedDetailsOutput) SetJobStatus(v string) *GetServiceLastAccessedDetailsOutput {
+	s.JobStatus = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetServiceLastAccessedDetailsOutput) SetMarker(v string) *GetServiceLastAccessedDetailsOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetServicesLastAccessed sets the ServicesLastAccessed field's value.
+func (s *GetServiceLastAccessedDetailsOutput) SetServicesLastAccessed(v []*ServiceLastAccessed) *GetServiceLastAccessedDetailsOutput {
+	s.ServicesLastAccessed = v
+	return s
+}
+
+type GetServiceLastAccessedDetailsWithEntitiesInput struct {
+	_ struct{} `type:"structure"`
+
+	// The ID of the request generated by the GenerateServiceLastAccessedDetails
+	// operation.
+	//
+	// JobId is a required field
+	JobId *string `min:"36" type:"string" required:"true"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The service namespace for an AWS service. Provide the service namespace to
+	// learn when the IAM entity last attempted to access the specified service.
+	//
+	// To learn the service namespace for a service, go to Actions, Resources, and
+	// Condition Keys for AWS Services (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_actions-resources-contextkeys.html)
+	// in the IAM User Guide. Choose the name of the service to view details for
+	// that service. In the first paragraph, find the service prefix. For example,
+	// (service prefix: a4b). For more information about service namespaces, see
+	// AWS Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces)
+	// in the AWS General Reference.
+	//
+	// ServiceNamespace is a required field
+	ServiceNamespace *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetServiceLastAccessedDetailsWithEntitiesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetServiceLastAccessedDetailsWithEntitiesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetServiceLastAccessedDetailsWithEntitiesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetServiceLastAccessedDetailsWithEntitiesInput"}
+	if s.JobId == nil {
+		invalidParams.Add(request.NewErrParamRequired("JobId"))
+	}
+	if s.JobId != nil && len(*s.JobId) < 36 {
+		invalidParams.Add(request.NewErrParamMinLen("JobId", 36))
+	}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.ServiceNamespace == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServiceNamespace"))
+	}
+	if s.ServiceNamespace != nil && len(*s.ServiceNamespace) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ServiceNamespace", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetJobId sets the JobId field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesInput) SetJobId(v string) *GetServiceLastAccessedDetailsWithEntitiesInput {
+	s.JobId = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesInput) SetMarker(v string) *GetServiceLastAccessedDetailsWithEntitiesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesInput) SetMaxItems(v int64) *GetServiceLastAccessedDetailsWithEntitiesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetServiceNamespace sets the ServiceNamespace field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesInput) SetServiceNamespace(v string) *GetServiceLastAccessedDetailsWithEntitiesInput {
+	s.ServiceNamespace = &v
+	return s
+}
+
+type GetServiceLastAccessedDetailsWithEntitiesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// An EntityDetailsList object that contains details about when an IAM entity
+	// (user or role) used group or policy permissions in an attempt to access the
+	// specified AWS service.
+	//
+	// EntityDetailsList is a required field
+	EntityDetailsList []*EntityDetails `type:"list" required:"true"`
+
+	// An object that contains details about the reason the operation failed.
+	Error *ErrorDetails `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the generated report job was completed or failed.
+	//
+	// This field is null if the job is still in progress, as indicated by a job
+	// status value of IN_PROGRESS.
+	//
+	// JobCompletionDate is a required field
+	JobCompletionDate *time.Time `type:"timestamp" required:"true"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the report job was created.
+	//
+	// JobCreationDate is a required field
+	JobCreationDate *time.Time `type:"timestamp" required:"true"`
+
+	// The status of the job.
+	//
+	// JobStatus is a required field
+	JobStatus *string `type:"string" required:"true" enum:"jobStatusType"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s GetServiceLastAccessedDetailsWithEntitiesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetServiceLastAccessedDetailsWithEntitiesOutput) GoString() string {
+	return s.String()
+}
+
+// SetEntityDetailsList sets the EntityDetailsList field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesOutput) SetEntityDetailsList(v []*EntityDetails) *GetServiceLastAccessedDetailsWithEntitiesOutput {
+	s.EntityDetailsList = v
+	return s
+}
+
+// SetError sets the Error field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesOutput) SetError(v *ErrorDetails) *GetServiceLastAccessedDetailsWithEntitiesOutput {
+	s.Error = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesOutput) SetIsTruncated(v bool) *GetServiceLastAccessedDetailsWithEntitiesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetJobCompletionDate sets the JobCompletionDate field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesOutput) SetJobCompletionDate(v time.Time) *GetServiceLastAccessedDetailsWithEntitiesOutput {
+	s.JobCompletionDate = &v
+	return s
+}
+
+// SetJobCreationDate sets the JobCreationDate field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesOutput) SetJobCreationDate(v time.Time) *GetServiceLastAccessedDetailsWithEntitiesOutput {
+	s.JobCreationDate = &v
+	return s
+}
+
+// SetJobStatus sets the JobStatus field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesOutput) SetJobStatus(v string) *GetServiceLastAccessedDetailsWithEntitiesOutput {
+	s.JobStatus = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *GetServiceLastAccessedDetailsWithEntitiesOutput) SetMarker(v string) *GetServiceLastAccessedDetailsWithEntitiesOutput {
+	s.Marker = &v
+	return s
+}
+
+type GetServiceLinkedRoleDeletionStatusInput struct {
+	_ struct{} `type:"structure"`
+
+	// The deletion task identifier. This identifier is returned by the DeleteServiceLinkedRole
+	// operation in the format task/aws-service-role/<service-principal-name>/<role-name>/<task-uuid>.
+	//
+	// DeletionTaskId is a required field
+	DeletionTaskId *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetServiceLinkedRoleDeletionStatusInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetServiceLinkedRoleDeletionStatusInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetServiceLinkedRoleDeletionStatusInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetServiceLinkedRoleDeletionStatusInput"}
+	if s.DeletionTaskId == nil {
+		invalidParams.Add(request.NewErrParamRequired("DeletionTaskId"))
+	}
+	if s.DeletionTaskId != nil && len(*s.DeletionTaskId) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("DeletionTaskId", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetDeletionTaskId sets the DeletionTaskId field's value.
+func (s *GetServiceLinkedRoleDeletionStatusInput) SetDeletionTaskId(v string) *GetServiceLinkedRoleDeletionStatusInput {
+	s.DeletionTaskId = &v
+	return s
+}
+
+type GetServiceLinkedRoleDeletionStatusOutput struct {
+	_ struct{} `type:"structure"`
+
+	// An object that contains details about the reason the deletion failed.
+	Reason *DeletionTaskFailureReasonType `type:"structure"`
+
+	// The status of the deletion.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"DeletionTaskStatusType"`
+}
+
+// String returns the string representation
+func (s GetServiceLinkedRoleDeletionStatusOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetServiceLinkedRoleDeletionStatusOutput) GoString() string {
+	return s.String()
+}
+
+// SetReason sets the Reason field's value.
+func (s *GetServiceLinkedRoleDeletionStatusOutput) SetReason(v *DeletionTaskFailureReasonType) *GetServiceLinkedRoleDeletionStatusOutput {
+	s.Reason = v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *GetServiceLinkedRoleDeletionStatusOutput) SetStatus(v string) *GetServiceLinkedRoleDeletionStatusOutput {
+	s.Status = &v
+	return s
+}
+
+type GetUserInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the user to get information about.
+	//
+	// This parameter is optional. If it is not included, it defaults to the user
+	// making the request. This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s GetUserInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetUserInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetUserInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetUserInput"}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetUserName sets the UserName field's value.
+func (s *GetUserInput) SetUserName(v string) *GetUserInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful GetUser request.
+type GetUserOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure containing details about the IAM user.
+	//
+	// Due to a service issue, password last used data does not include password
+	// use from May 3, 2018 22:50 PDT to May 23, 2018 14:08 PDT. This affects last
+	// sign-in (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_finding-unused.html)
+	// dates shown in the IAM console and password last used dates in the IAM credential
+	// report (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_getting-report.html),
+	// and returned by this GetUser API. If users signed in during the affected
+	// time, the password last used date that is returned is the date the user last
+	// signed in before May 3, 2018. For users that signed in after May 23, 2018
+	// 14:08 PDT, the returned password last used date is accurate.
+	//
+	// You can use password last used information to identify unused credentials
+	// for deletion. For example, you might delete users who did not sign in to
+	// AWS in the last 90 days. In cases like this, we recommend that you adjust
+	// your evaluation window to include dates after May 23, 2018. Alternatively,
+	// if your users use access keys to access AWS programmatically you can refer
+	// to access key last used information because it is accurate for all dates.
+	//
+	// User is a required field
+	User *User `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s GetUserOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetUserOutput) GoString() string {
+	return s.String()
+}
+
+// SetUser sets the User field's value.
+func (s *GetUserOutput) SetUser(v *User) *GetUserOutput {
+	s.User = v
+	return s
+}
+
+type GetUserPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the policy document to get.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+
+	// The name of the user who the policy is associated with.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetUserPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetUserPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *GetUserPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "GetUserPolicyInput"}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *GetUserPolicyInput) SetPolicyName(v string) *GetUserPolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *GetUserPolicyInput) SetUserName(v string) *GetUserPolicyInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful GetUserPolicy request.
+type GetUserPolicyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The policy document.
+	//
+	// IAM stores policies in JSON format. However, resources that were created
+	// using AWS CloudFormation templates can be formatted in YAML. AWS CloudFormation
+	// always converts a YAML policy to JSON format before submitting it to IAM.
+	//
+	// PolicyDocument is a required field
+	PolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// The name of the policy.
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+
+	// The user the policy is associated with.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s GetUserPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GetUserPolicyOutput) GoString() string {
+	return s.String()
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *GetUserPolicyOutput) SetPolicyDocument(v string) *GetUserPolicyOutput {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *GetUserPolicyOutput) SetPolicyName(v string) *GetUserPolicyOutput {
+	s.PolicyName = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *GetUserPolicyOutput) SetUserName(v string) *GetUserPolicyOutput {
+	s.UserName = &v
+	return s
+}
+
+// Contains information about an IAM group entity.
+//
+// This data type is used as a response element in the following operations:
+//
+//    * CreateGroup
+//
+//    * GetGroup
+//
+//    * ListGroups
+type Group struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) specifying the group. For more information
+	// about ARNs and how to use them in policies, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// Arn is a required field
+	Arn *string `min:"20" type:"string" required:"true"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the group was created.
+	//
+	// CreateDate is a required field
+	CreateDate *time.Time `type:"timestamp" required:"true"`
+
+	// The stable and unique string identifying the group. For more information
+	// about IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// GroupId is a required field
+	GroupId *string `min:"16" type:"string" required:"true"`
+
+	// The friendly name that identifies the group.
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The path to the group. For more information about paths, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// Path is a required field
+	Path *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s Group) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Group) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *Group) SetArn(v string) *Group {
+	s.Arn = &v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *Group) SetCreateDate(v time.Time) *Group {
+	s.CreateDate = &v
+	return s
+}
+
+// SetGroupId sets the GroupId field's value.
+func (s *Group) SetGroupId(v string) *Group {
+	s.GroupId = &v
+	return s
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *Group) SetGroupName(v string) *Group {
+	s.GroupName = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *Group) SetPath(v string) *Group {
+	s.Path = &v
+	return s
+}
+
+// Contains information about an IAM group, including all of the group's policies.
+//
+// This data type is used as a response element in the GetAccountAuthorizationDetails
+// operation.
+type GroupDetail struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN). ARNs are unique identifiers for AWS resources.
+	//
+	// For more information about ARNs, go to Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	Arn *string `min:"20" type:"string"`
+
+	// A list of the managed policies attached to the group.
+	AttachedManagedPolicies []*AttachedPolicy `type:"list"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the group was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// The stable and unique string identifying the group. For more information
+	// about IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	GroupId *string `min:"16" type:"string"`
+
+	// The friendly name that identifies the group.
+	GroupName *string `min:"1" type:"string"`
+
+	// A list of the inline policies embedded in the group.
+	GroupPolicyList []*PolicyDetail `type:"list"`
+
+	// The path to the group. For more information about paths, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	Path *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s GroupDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s GroupDetail) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *GroupDetail) SetArn(v string) *GroupDetail {
+	s.Arn = &v
+	return s
+}
+
+// SetAttachedManagedPolicies sets the AttachedManagedPolicies field's value.
+func (s *GroupDetail) SetAttachedManagedPolicies(v []*AttachedPolicy) *GroupDetail {
+	s.AttachedManagedPolicies = v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *GroupDetail) SetCreateDate(v time.Time) *GroupDetail {
+	s.CreateDate = &v
+	return s
+}
+
+// SetGroupId sets the GroupId field's value.
+func (s *GroupDetail) SetGroupId(v string) *GroupDetail {
+	s.GroupId = &v
+	return s
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *GroupDetail) SetGroupName(v string) *GroupDetail {
+	s.GroupName = &v
+	return s
+}
+
+// SetGroupPolicyList sets the GroupPolicyList field's value.
+func (s *GroupDetail) SetGroupPolicyList(v []*PolicyDetail) *GroupDetail {
+	s.GroupPolicyList = v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *GroupDetail) SetPath(v string) *GroupDetail {
+	s.Path = &v
+	return s
+}
+
+// Contains information about an instance profile.
+//
+// This data type is used as a response element in the following operations:
+//
+//    * CreateInstanceProfile
+//
+//    * GetInstanceProfile
+//
+//    * ListInstanceProfiles
+//
+//    * ListInstanceProfilesForRole
+type InstanceProfile struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) specifying the instance profile. For more
+	// information about ARNs and how to use them in policies, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// Arn is a required field
+	Arn *string `min:"20" type:"string" required:"true"`
+
+	// The date when the instance profile was created.
+	//
+	// CreateDate is a required field
+	CreateDate *time.Time `type:"timestamp" required:"true"`
+
+	// The stable and unique string identifying the instance profile. For more information
+	// about IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// InstanceProfileId is a required field
+	InstanceProfileId *string `min:"16" type:"string" required:"true"`
+
+	// The name identifying the instance profile.
+	//
+	// InstanceProfileName is a required field
+	InstanceProfileName *string `min:"1" type:"string" required:"true"`
+
+	// The path to the instance profile. For more information about paths, see IAM
+	// Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// Path is a required field
+	Path *string `min:"1" type:"string" required:"true"`
+
+	// The role associated with the instance profile.
+	//
+	// Roles is a required field
+	Roles []*Role `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s InstanceProfile) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s InstanceProfile) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *InstanceProfile) SetArn(v string) *InstanceProfile {
+	s.Arn = &v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *InstanceProfile) SetCreateDate(v time.Time) *InstanceProfile {
+	s.CreateDate = &v
+	return s
+}
+
+// SetInstanceProfileId sets the InstanceProfileId field's value.
+func (s *InstanceProfile) SetInstanceProfileId(v string) *InstanceProfile {
+	s.InstanceProfileId = &v
+	return s
+}
+
+// SetInstanceProfileName sets the InstanceProfileName field's value.
+func (s *InstanceProfile) SetInstanceProfileName(v string) *InstanceProfile {
+	s.InstanceProfileName = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *InstanceProfile) SetPath(v string) *InstanceProfile {
+	s.Path = &v
+	return s
+}
+
+// SetRoles sets the Roles field's value.
+func (s *InstanceProfile) SetRoles(v []*Role) *InstanceProfile {
+	s.Roles = v
+	return s
+}
+
+type ListAccessKeysInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the user.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListAccessKeysInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAccessKeysInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListAccessKeysInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListAccessKeysInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAccessKeysInput) SetMarker(v string) *ListAccessKeysInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListAccessKeysInput) SetMaxItems(v int64) *ListAccessKeysInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ListAccessKeysInput) SetUserName(v string) *ListAccessKeysInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful ListAccessKeys request.
+type ListAccessKeysOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of objects containing metadata about the access keys.
+	//
+	// AccessKeyMetadata is a required field
+	AccessKeyMetadata []*AccessKeyMetadata `type:"list" required:"true"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListAccessKeysOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAccessKeysOutput) GoString() string {
+	return s.String()
+}
+
+// SetAccessKeyMetadata sets the AccessKeyMetadata field's value.
+func (s *ListAccessKeysOutput) SetAccessKeyMetadata(v []*AccessKeyMetadata) *ListAccessKeysOutput {
+	s.AccessKeyMetadata = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListAccessKeysOutput) SetIsTruncated(v bool) *ListAccessKeysOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAccessKeysOutput) SetMarker(v string) *ListAccessKeysOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListAccountAliasesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+}
+
+// String returns the string representation
+func (s ListAccountAliasesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAccountAliasesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListAccountAliasesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListAccountAliasesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAccountAliasesInput) SetMarker(v string) *ListAccountAliasesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListAccountAliasesInput) SetMaxItems(v int64) *ListAccountAliasesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// Contains the response to a successful ListAccountAliases request.
+type ListAccountAliasesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of aliases associated with the account. AWS supports only one alias
+	// per account.
+	//
+	// AccountAliases is a required field
+	AccountAliases []*string `type:"list" required:"true"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListAccountAliasesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAccountAliasesOutput) GoString() string {
+	return s.String()
+}
+
+// SetAccountAliases sets the AccountAliases field's value.
+func (s *ListAccountAliasesOutput) SetAccountAliases(v []*string) *ListAccountAliasesOutput {
+	s.AccountAliases = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListAccountAliasesOutput) SetIsTruncated(v bool) *ListAccountAliasesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAccountAliasesOutput) SetMarker(v string) *ListAccountAliasesOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListAttachedGroupPoliciesInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name (friendly name, not ARN) of the group to list attached policies
+	// for.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The path prefix for filtering the results. This parameter is optional. If
+	// it is not included, it defaults to a slash (/), listing all policies.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	PathPrefix *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListAttachedGroupPoliciesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAttachedGroupPoliciesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListAttachedGroupPoliciesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListAttachedGroupPoliciesInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *ListAttachedGroupPoliciesInput) SetGroupName(v string) *ListAttachedGroupPoliciesInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAttachedGroupPoliciesInput) SetMarker(v string) *ListAttachedGroupPoliciesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListAttachedGroupPoliciesInput) SetMaxItems(v int64) *ListAttachedGroupPoliciesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListAttachedGroupPoliciesInput) SetPathPrefix(v string) *ListAttachedGroupPoliciesInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// Contains the response to a successful ListAttachedGroupPolicies request.
+type ListAttachedGroupPoliciesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of the attached policies.
+	AttachedPolicies []*AttachedPolicy `type:"list"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListAttachedGroupPoliciesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAttachedGroupPoliciesOutput) GoString() string {
+	return s.String()
+}
+
+// SetAttachedPolicies sets the AttachedPolicies field's value.
+func (s *ListAttachedGroupPoliciesOutput) SetAttachedPolicies(v []*AttachedPolicy) *ListAttachedGroupPoliciesOutput {
+	s.AttachedPolicies = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListAttachedGroupPoliciesOutput) SetIsTruncated(v bool) *ListAttachedGroupPoliciesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAttachedGroupPoliciesOutput) SetMarker(v string) *ListAttachedGroupPoliciesOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListAttachedRolePoliciesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The path prefix for filtering the results. This parameter is optional. If
+	// it is not included, it defaults to a slash (/), listing all policies.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	PathPrefix *string `min:"1" type:"string"`
+
+	// The name (friendly name, not ARN) of the role to list attached policies for.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListAttachedRolePoliciesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAttachedRolePoliciesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListAttachedRolePoliciesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListAttachedRolePoliciesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAttachedRolePoliciesInput) SetMarker(v string) *ListAttachedRolePoliciesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListAttachedRolePoliciesInput) SetMaxItems(v int64) *ListAttachedRolePoliciesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListAttachedRolePoliciesInput) SetPathPrefix(v string) *ListAttachedRolePoliciesInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *ListAttachedRolePoliciesInput) SetRoleName(v string) *ListAttachedRolePoliciesInput {
+	s.RoleName = &v
+	return s
+}
+
+// Contains the response to a successful ListAttachedRolePolicies request.
+type ListAttachedRolePoliciesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of the attached policies.
+	AttachedPolicies []*AttachedPolicy `type:"list"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListAttachedRolePoliciesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAttachedRolePoliciesOutput) GoString() string {
+	return s.String()
+}
+
+// SetAttachedPolicies sets the AttachedPolicies field's value.
+func (s *ListAttachedRolePoliciesOutput) SetAttachedPolicies(v []*AttachedPolicy) *ListAttachedRolePoliciesOutput {
+	s.AttachedPolicies = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListAttachedRolePoliciesOutput) SetIsTruncated(v bool) *ListAttachedRolePoliciesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAttachedRolePoliciesOutput) SetMarker(v string) *ListAttachedRolePoliciesOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListAttachedUserPoliciesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The path prefix for filtering the results. This parameter is optional. If
+	// it is not included, it defaults to a slash (/), listing all policies.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	PathPrefix *string `min:"1" type:"string"`
+
+	// The name (friendly name, not ARN) of the user to list attached policies for.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListAttachedUserPoliciesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAttachedUserPoliciesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListAttachedUserPoliciesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListAttachedUserPoliciesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAttachedUserPoliciesInput) SetMarker(v string) *ListAttachedUserPoliciesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListAttachedUserPoliciesInput) SetMaxItems(v int64) *ListAttachedUserPoliciesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListAttachedUserPoliciesInput) SetPathPrefix(v string) *ListAttachedUserPoliciesInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ListAttachedUserPoliciesInput) SetUserName(v string) *ListAttachedUserPoliciesInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful ListAttachedUserPolicies request.
+type ListAttachedUserPoliciesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of the attached policies.
+	AttachedPolicies []*AttachedPolicy `type:"list"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListAttachedUserPoliciesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListAttachedUserPoliciesOutput) GoString() string {
+	return s.String()
+}
+
+// SetAttachedPolicies sets the AttachedPolicies field's value.
+func (s *ListAttachedUserPoliciesOutput) SetAttachedPolicies(v []*AttachedPolicy) *ListAttachedUserPoliciesOutput {
+	s.AttachedPolicies = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListAttachedUserPoliciesOutput) SetIsTruncated(v bool) *ListAttachedUserPoliciesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListAttachedUserPoliciesOutput) SetMarker(v string) *ListAttachedUserPoliciesOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListEntitiesForPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The entity type to use for filtering the results.
+	//
+	// For example, when EntityFilter is Role, only the roles that are attached
+	// to the specified policy are returned. This parameter is optional. If it is
+	// not included, all attached entities (users, groups, and roles) are returned.
+	// The argument for this parameter must be one of the valid values listed below.
+	EntityFilter *string `type:"string" enum:"EntityType"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The path prefix for filtering the results. This parameter is optional. If
+	// it is not included, it defaults to a slash (/), listing all entities.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	PathPrefix *string `min:"1" type:"string"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy for which you want the versions.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+
+	// The policy usage method to use for filtering the results.
+	//
+	// To list only permissions policies, set PolicyUsageFilter to PermissionsPolicy.
+	// To list only the policies used to set permissions boundaries, set the value
+	// to PermissionsBoundary.
+	//
+	// This parameter is optional. If it is not included, all policies are returned.
+	PolicyUsageFilter *string `type:"string" enum:"PolicyUsageType"`
+}
+
+// String returns the string representation
+func (s ListEntitiesForPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListEntitiesForPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListEntitiesForPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListEntitiesForPolicyInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetEntityFilter sets the EntityFilter field's value.
+func (s *ListEntitiesForPolicyInput) SetEntityFilter(v string) *ListEntitiesForPolicyInput {
+	s.EntityFilter = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListEntitiesForPolicyInput) SetMarker(v string) *ListEntitiesForPolicyInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListEntitiesForPolicyInput) SetMaxItems(v int64) *ListEntitiesForPolicyInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListEntitiesForPolicyInput) SetPathPrefix(v string) *ListEntitiesForPolicyInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *ListEntitiesForPolicyInput) SetPolicyArn(v string) *ListEntitiesForPolicyInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetPolicyUsageFilter sets the PolicyUsageFilter field's value.
+func (s *ListEntitiesForPolicyInput) SetPolicyUsageFilter(v string) *ListEntitiesForPolicyInput {
+	s.PolicyUsageFilter = &v
+	return s
+}
+
+// Contains the response to a successful ListEntitiesForPolicy request.
+type ListEntitiesForPolicyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of IAM groups that the policy is attached to.
+	PolicyGroups []*PolicyGroup `type:"list"`
+
+	// A list of IAM roles that the policy is attached to.
+	PolicyRoles []*PolicyRole `type:"list"`
+
+	// A list of IAM users that the policy is attached to.
+	PolicyUsers []*PolicyUser `type:"list"`
+}
+
+// String returns the string representation
+func (s ListEntitiesForPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListEntitiesForPolicyOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListEntitiesForPolicyOutput) SetIsTruncated(v bool) *ListEntitiesForPolicyOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListEntitiesForPolicyOutput) SetMarker(v string) *ListEntitiesForPolicyOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetPolicyGroups sets the PolicyGroups field's value.
+func (s *ListEntitiesForPolicyOutput) SetPolicyGroups(v []*PolicyGroup) *ListEntitiesForPolicyOutput {
+	s.PolicyGroups = v
+	return s
+}
+
+// SetPolicyRoles sets the PolicyRoles field's value.
+func (s *ListEntitiesForPolicyOutput) SetPolicyRoles(v []*PolicyRole) *ListEntitiesForPolicyOutput {
+	s.PolicyRoles = v
+	return s
+}
+
+// SetPolicyUsers sets the PolicyUsers field's value.
+func (s *ListEntitiesForPolicyOutput) SetPolicyUsers(v []*PolicyUser) *ListEntitiesForPolicyOutput {
+	s.PolicyUsers = v
+	return s
+}
+
+type ListGroupPoliciesInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the group to list policies for.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+}
+
+// String returns the string representation
+func (s ListGroupPoliciesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListGroupPoliciesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListGroupPoliciesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListGroupPoliciesInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *ListGroupPoliciesInput) SetGroupName(v string) *ListGroupPoliciesInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListGroupPoliciesInput) SetMarker(v string) *ListGroupPoliciesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListGroupPoliciesInput) SetMaxItems(v int64) *ListGroupPoliciesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// Contains the response to a successful ListGroupPolicies request.
+type ListGroupPoliciesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of policy names.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyNames is a required field
+	PolicyNames []*string `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListGroupPoliciesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListGroupPoliciesOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListGroupPoliciesOutput) SetIsTruncated(v bool) *ListGroupPoliciesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListGroupPoliciesOutput) SetMarker(v string) *ListGroupPoliciesOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetPolicyNames sets the PolicyNames field's value.
+func (s *ListGroupPoliciesOutput) SetPolicyNames(v []*string) *ListGroupPoliciesOutput {
+	s.PolicyNames = v
+	return s
+}
+
+type ListGroupsForUserInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the user to list groups for.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListGroupsForUserInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListGroupsForUserInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListGroupsForUserInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListGroupsForUserInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListGroupsForUserInput) SetMarker(v string) *ListGroupsForUserInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListGroupsForUserInput) SetMaxItems(v int64) *ListGroupsForUserInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ListGroupsForUserInput) SetUserName(v string) *ListGroupsForUserInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful ListGroupsForUser request.
+type ListGroupsForUserOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of groups.
+	//
+	// Groups is a required field
+	Groups []*Group `type:"list" required:"true"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListGroupsForUserOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListGroupsForUserOutput) GoString() string {
+	return s.String()
+}
+
+// SetGroups sets the Groups field's value.
+func (s *ListGroupsForUserOutput) SetGroups(v []*Group) *ListGroupsForUserOutput {
+	s.Groups = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListGroupsForUserOutput) SetIsTruncated(v bool) *ListGroupsForUserOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListGroupsForUserOutput) SetMarker(v string) *ListGroupsForUserOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListGroupsInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The path prefix for filtering the results. For example, the prefix /division_abc/subdivision_xyz/
+	// gets all groups whose path starts with /division_abc/subdivision_xyz/.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/), listing all groups. This parameter allows (through its regex pattern
+	// (http://wikipedia.org/wiki/regex)) a string of characters consisting of either
+	// a forward slash (/) by itself or a string that must begin and end with forward
+	// slashes. In addition, it can contain any ASCII character from the ! (\u0021)
+	// through the DEL character (\u007F), including most punctuation characters,
+	// digits, and upper and lowercased letters.
+	PathPrefix *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListGroupsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListGroupsInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListGroupsInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListGroupsInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListGroupsInput) SetMarker(v string) *ListGroupsInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListGroupsInput) SetMaxItems(v int64) *ListGroupsInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListGroupsInput) SetPathPrefix(v string) *ListGroupsInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// Contains the response to a successful ListGroups request.
+type ListGroupsOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of groups.
+	//
+	// Groups is a required field
+	Groups []*Group `type:"list" required:"true"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListGroupsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListGroupsOutput) GoString() string {
+	return s.String()
+}
+
+// SetGroups sets the Groups field's value.
+func (s *ListGroupsOutput) SetGroups(v []*Group) *ListGroupsOutput {
+	s.Groups = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListGroupsOutput) SetIsTruncated(v bool) *ListGroupsOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListGroupsOutput) SetMarker(v string) *ListGroupsOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListInstanceProfilesForRoleInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the role to list instance profiles for.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListInstanceProfilesForRoleInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListInstanceProfilesForRoleInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListInstanceProfilesForRoleInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListInstanceProfilesForRoleInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListInstanceProfilesForRoleInput) SetMarker(v string) *ListInstanceProfilesForRoleInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListInstanceProfilesForRoleInput) SetMaxItems(v int64) *ListInstanceProfilesForRoleInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *ListInstanceProfilesForRoleInput) SetRoleName(v string) *ListInstanceProfilesForRoleInput {
+	s.RoleName = &v
+	return s
+}
+
+// Contains the response to a successful ListInstanceProfilesForRole request.
+type ListInstanceProfilesForRoleOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of instance profiles.
+	//
+	// InstanceProfiles is a required field
+	InstanceProfiles []*InstanceProfile `type:"list" required:"true"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListInstanceProfilesForRoleOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListInstanceProfilesForRoleOutput) GoString() string {
+	return s.String()
+}
+
+// SetInstanceProfiles sets the InstanceProfiles field's value.
+func (s *ListInstanceProfilesForRoleOutput) SetInstanceProfiles(v []*InstanceProfile) *ListInstanceProfilesForRoleOutput {
+	s.InstanceProfiles = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListInstanceProfilesForRoleOutput) SetIsTruncated(v bool) *ListInstanceProfilesForRoleOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListInstanceProfilesForRoleOutput) SetMarker(v string) *ListInstanceProfilesForRoleOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListInstanceProfilesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The path prefix for filtering the results. For example, the prefix /application_abc/component_xyz/
+	// gets all instance profiles whose path starts with /application_abc/component_xyz/.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/), listing all instance profiles. This parameter allows (through its regex
+	// pattern (http://wikipedia.org/wiki/regex)) a string of characters consisting
+	// of either a forward slash (/) by itself or a string that must begin and end
+	// with forward slashes. In addition, it can contain any ASCII character from
+	// the ! (\u0021) through the DEL character (\u007F), including most punctuation
+	// characters, digits, and upper and lowercased letters.
+	PathPrefix *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListInstanceProfilesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListInstanceProfilesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListInstanceProfilesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListInstanceProfilesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListInstanceProfilesInput) SetMarker(v string) *ListInstanceProfilesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListInstanceProfilesInput) SetMaxItems(v int64) *ListInstanceProfilesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListInstanceProfilesInput) SetPathPrefix(v string) *ListInstanceProfilesInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// Contains the response to a successful ListInstanceProfiles request.
+type ListInstanceProfilesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of instance profiles.
+	//
+	// InstanceProfiles is a required field
+	InstanceProfiles []*InstanceProfile `type:"list" required:"true"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListInstanceProfilesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListInstanceProfilesOutput) GoString() string {
+	return s.String()
+}
+
+// SetInstanceProfiles sets the InstanceProfiles field's value.
+func (s *ListInstanceProfilesOutput) SetInstanceProfiles(v []*InstanceProfile) *ListInstanceProfilesOutput {
+	s.InstanceProfiles = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListInstanceProfilesOutput) SetIsTruncated(v bool) *ListInstanceProfilesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListInstanceProfilesOutput) SetMarker(v string) *ListInstanceProfilesOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListMFADevicesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the user whose MFA devices you want to list.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListMFADevicesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListMFADevicesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListMFADevicesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListMFADevicesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListMFADevicesInput) SetMarker(v string) *ListMFADevicesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListMFADevicesInput) SetMaxItems(v int64) *ListMFADevicesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ListMFADevicesInput) SetUserName(v string) *ListMFADevicesInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful ListMFADevices request.
+type ListMFADevicesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// A list of MFA devices.
+	//
+	// MFADevices is a required field
+	MFADevices []*MFADevice `type:"list" required:"true"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListMFADevicesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListMFADevicesOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListMFADevicesOutput) SetIsTruncated(v bool) *ListMFADevicesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMFADevices sets the MFADevices field's value.
+func (s *ListMFADevicesOutput) SetMFADevices(v []*MFADevice) *ListMFADevicesOutput {
+	s.MFADevices = v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListMFADevicesOutput) SetMarker(v string) *ListMFADevicesOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListOpenIDConnectProvidersInput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s ListOpenIDConnectProvidersInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListOpenIDConnectProvidersInput) GoString() string {
+	return s.String()
+}
+
+// Contains the response to a successful ListOpenIDConnectProviders request.
+type ListOpenIDConnectProvidersOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The list of IAM OIDC provider resource objects defined in the AWS account.
+	OpenIDConnectProviderList []*OpenIDConnectProviderListEntry `type:"list"`
+}
+
+// String returns the string representation
+func (s ListOpenIDConnectProvidersOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListOpenIDConnectProvidersOutput) GoString() string {
+	return s.String()
+}
+
+// SetOpenIDConnectProviderList sets the OpenIDConnectProviderList field's value.
+func (s *ListOpenIDConnectProvidersOutput) SetOpenIDConnectProviderList(v []*OpenIDConnectProviderListEntry) *ListOpenIDConnectProvidersOutput {
+	s.OpenIDConnectProviderList = v
+	return s
+}
+
+// Contains details about the permissions policies that are attached to the
+// specified identity (user, group, or role).
+//
+// This data type is used as a response element in the ListPoliciesGrantingServiceAccess
+// operation.
+type ListPoliciesGrantingServiceAccessEntry struct {
+	_ struct{} `type:"structure"`
+
+	// The PoliciesGrantingServiceAccess object that contains details about the
+	// policy.
+	Policies []*PolicyGrantingServiceAccess `type:"list"`
+
+	// The namespace of the service that was accessed.
+	//
+	// To learn the service namespace of a service, go to Actions, Resources, and
+	// Condition Keys for AWS Services (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_actions-resources-contextkeys.html)
+	// in the IAM User Guide. Choose the name of the service to view details for
+	// that service. In the first paragraph, find the service prefix. For example,
+	// (service prefix: a4b). For more information about service namespaces, see
+	// AWS Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces)
+	// in the AWS General Reference.
+	ServiceNamespace *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListPoliciesGrantingServiceAccessEntry) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListPoliciesGrantingServiceAccessEntry) GoString() string {
+	return s.String()
+}
+
+// SetPolicies sets the Policies field's value.
+func (s *ListPoliciesGrantingServiceAccessEntry) SetPolicies(v []*PolicyGrantingServiceAccess) *ListPoliciesGrantingServiceAccessEntry {
+	s.Policies = v
+	return s
+}
+
+// SetServiceNamespace sets the ServiceNamespace field's value.
+func (s *ListPoliciesGrantingServiceAccessEntry) SetServiceNamespace(v string) *ListPoliciesGrantingServiceAccessEntry {
+	s.ServiceNamespace = &v
+	return s
+}
+
+type ListPoliciesGrantingServiceAccessInput struct {
+	_ struct{} `type:"structure"`
+
+	// The ARN of the IAM identity (user, group, or role) whose policies you want
+	// to list.
+	//
+	// Arn is a required field
+	Arn *string `min:"20" type:"string" required:"true"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// The service namespace for the AWS services whose policies you want to list.
+	//
+	// To learn the service namespace for a service, go to Actions, Resources, and
+	// Condition Keys for AWS Services (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_actions-resources-contextkeys.html)
+	// in the IAM User Guide. Choose the name of the service to view details for
+	// that service. In the first paragraph, find the service prefix. For example,
+	// (service prefix: a4b). For more information about service namespaces, see
+	// AWS Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces)
+	// in the AWS General Reference.
+	//
+	// ServiceNamespaces is a required field
+	ServiceNamespaces []*string `min:"1" type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListPoliciesGrantingServiceAccessInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListPoliciesGrantingServiceAccessInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListPoliciesGrantingServiceAccessInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListPoliciesGrantingServiceAccessInput"}
+	if s.Arn == nil {
+		invalidParams.Add(request.NewErrParamRequired("Arn"))
+	}
+	if s.Arn != nil && len(*s.Arn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("Arn", 20))
+	}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.ServiceNamespaces == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServiceNamespaces"))
+	}
+	if s.ServiceNamespaces != nil && len(s.ServiceNamespaces) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ServiceNamespaces", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetArn sets the Arn field's value.
+func (s *ListPoliciesGrantingServiceAccessInput) SetArn(v string) *ListPoliciesGrantingServiceAccessInput {
+	s.Arn = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListPoliciesGrantingServiceAccessInput) SetMarker(v string) *ListPoliciesGrantingServiceAccessInput {
+	s.Marker = &v
+	return s
+}
+
+// SetServiceNamespaces sets the ServiceNamespaces field's value.
+func (s *ListPoliciesGrantingServiceAccessInput) SetServiceNamespaces(v []*string) *ListPoliciesGrantingServiceAccessInput {
+	s.ServiceNamespaces = v
+	return s
+}
+
+type ListPoliciesGrantingServiceAccessOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. We recommend that you check IsTruncated
+	// after every call to ensure that you receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A ListPoliciesGrantingServiceAccess object that contains details about the
+	// permissions policies attached to the specified identity (user, group, or
+	// role).
+	//
+	// PoliciesGrantingServiceAccess is a required field
+	PoliciesGrantingServiceAccess []*ListPoliciesGrantingServiceAccessEntry `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListPoliciesGrantingServiceAccessOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListPoliciesGrantingServiceAccessOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListPoliciesGrantingServiceAccessOutput) SetIsTruncated(v bool) *ListPoliciesGrantingServiceAccessOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListPoliciesGrantingServiceAccessOutput) SetMarker(v string) *ListPoliciesGrantingServiceAccessOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetPoliciesGrantingServiceAccess sets the PoliciesGrantingServiceAccess field's value.
+func (s *ListPoliciesGrantingServiceAccessOutput) SetPoliciesGrantingServiceAccess(v []*ListPoliciesGrantingServiceAccessEntry) *ListPoliciesGrantingServiceAccessOutput {
+	s.PoliciesGrantingServiceAccess = v
+	return s
+}
+
+type ListPoliciesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// A flag to filter the results to only the attached policies.
+	//
+	// When OnlyAttached is true, the returned list contains only the policies that
+	// are attached to an IAM user, group, or role. When OnlyAttached is false,
+	// or when the parameter is not included, all policies are returned.
+	OnlyAttached *bool `type:"boolean"`
+
+	// The path prefix for filtering the results. This parameter is optional. If
+	// it is not included, it defaults to a slash (/), listing all policies. This
+	// parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	PathPrefix *string `min:"1" type:"string"`
+
+	// The policy usage method to use for filtering the results.
+	//
+	// To list only permissions policies, set PolicyUsageFilter to PermissionsPolicy.
+	// To list only the policies used to set permissions boundaries, set the value
+	// to PermissionsBoundary.
+	//
+	// This parameter is optional. If it is not included, all policies are returned.
+	PolicyUsageFilter *string `type:"string" enum:"PolicyUsageType"`
+
+	// The scope to use for filtering the results.
+	//
+	// To list only AWS managed policies, set Scope to AWS. To list only the customer
+	// managed policies in your AWS account, set Scope to Local.
+	//
+	// This parameter is optional. If it is not included, or if it is set to All,
+	// all policies are returned.
+	Scope *string `type:"string" enum:"policyScopeType"`
+}
+
+// String returns the string representation
+func (s ListPoliciesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListPoliciesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListPoliciesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListPoliciesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListPoliciesInput) SetMarker(v string) *ListPoliciesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListPoliciesInput) SetMaxItems(v int64) *ListPoliciesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetOnlyAttached sets the OnlyAttached field's value.
+func (s *ListPoliciesInput) SetOnlyAttached(v bool) *ListPoliciesInput {
+	s.OnlyAttached = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListPoliciesInput) SetPathPrefix(v string) *ListPoliciesInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// SetPolicyUsageFilter sets the PolicyUsageFilter field's value.
+func (s *ListPoliciesInput) SetPolicyUsageFilter(v string) *ListPoliciesInput {
+	s.PolicyUsageFilter = &v
+	return s
+}
+
+// SetScope sets the Scope field's value.
+func (s *ListPoliciesInput) SetScope(v string) *ListPoliciesInput {
+	s.Scope = &v
+	return s
+}
+
+// Contains the response to a successful ListPolicies request.
+type ListPoliciesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of policies.
+	Policies []*Policy `type:"list"`
+}
+
+// String returns the string representation
+func (s ListPoliciesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListPoliciesOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListPoliciesOutput) SetIsTruncated(v bool) *ListPoliciesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListPoliciesOutput) SetMarker(v string) *ListPoliciesOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetPolicies sets the Policies field's value.
+func (s *ListPoliciesOutput) SetPolicies(v []*Policy) *ListPoliciesOutput {
+	s.Policies = v
+	return s
+}
+
+type ListPolicyVersionsInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy for which you want the versions.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListPolicyVersionsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListPolicyVersionsInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListPolicyVersionsInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListPolicyVersionsInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListPolicyVersionsInput) SetMarker(v string) *ListPolicyVersionsInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListPolicyVersionsInput) SetMaxItems(v int64) *ListPolicyVersionsInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *ListPolicyVersionsInput) SetPolicyArn(v string) *ListPolicyVersionsInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// Contains the response to a successful ListPolicyVersions request.
+type ListPolicyVersionsOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of policy versions.
+	//
+	// For more information about managed policy versions, see Versioning for Managed
+	// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html)
+	// in the IAM User Guide.
+	Versions []*PolicyVersion `type:"list"`
+}
+
+// String returns the string representation
+func (s ListPolicyVersionsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListPolicyVersionsOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListPolicyVersionsOutput) SetIsTruncated(v bool) *ListPolicyVersionsOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListPolicyVersionsOutput) SetMarker(v string) *ListPolicyVersionsOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetVersions sets the Versions field's value.
+func (s *ListPolicyVersionsOutput) SetVersions(v []*PolicyVersion) *ListPolicyVersionsOutput {
+	s.Versions = v
+	return s
+}
+
+type ListRolePoliciesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the role to list policies for.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListRolePoliciesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListRolePoliciesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListRolePoliciesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListRolePoliciesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListRolePoliciesInput) SetMarker(v string) *ListRolePoliciesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListRolePoliciesInput) SetMaxItems(v int64) *ListRolePoliciesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *ListRolePoliciesInput) SetRoleName(v string) *ListRolePoliciesInput {
+	s.RoleName = &v
+	return s
+}
+
+// Contains the response to a successful ListRolePolicies request.
+type ListRolePoliciesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of policy names.
+	//
+	// PolicyNames is a required field
+	PolicyNames []*string `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListRolePoliciesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListRolePoliciesOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListRolePoliciesOutput) SetIsTruncated(v bool) *ListRolePoliciesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListRolePoliciesOutput) SetMarker(v string) *ListRolePoliciesOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetPolicyNames sets the PolicyNames field's value.
+func (s *ListRolePoliciesOutput) SetPolicyNames(v []*string) *ListRolePoliciesOutput {
+	s.PolicyNames = v
+	return s
+}
+
+type ListRoleTagsInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// (Optional) Use this only when paginating results to indicate the maximum
+	// number of items that you want in the response. If additional items exist
+	// beyond the maximum that you specify, the IsTruncated response element is
+	// true.
+	//
+	// If you do not include this parameter, it defaults to 100. Note that IAM might
+	// return fewer results, even when more results are available. In that case,
+	// the IsTruncated response element returns true, and Marker contains a value
+	// to include in the subsequent call that tells the service where to continue
+	// from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the IAM role for which you want to see the list of tags.
+	//
+	// This parameter accepts (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that consist of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListRoleTagsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListRoleTagsInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListRoleTagsInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListRoleTagsInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListRoleTagsInput) SetMarker(v string) *ListRoleTagsInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListRoleTagsInput) SetMaxItems(v int64) *ListRoleTagsInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *ListRoleTagsInput) SetRoleName(v string) *ListRoleTagsInput {
+	s.RoleName = &v
+	return s
+}
+
+type ListRoleTagsOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can use the Marker request parameter to make a subsequent
+	// pagination request that retrieves more items. Note that IAM might return
+	// fewer than the MaxItems number of results even when more results are available.
+	// Check IsTruncated after every call to ensure that you receive all of your
+	// results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// The list of tags currently that is attached to the role. Each tag consists
+	// of a key name and an associated value. If no tags are attached to the specified
+	// role, the response contains an empty list.
+	//
+	// Tags is a required field
+	Tags []*Tag `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListRoleTagsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListRoleTagsOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListRoleTagsOutput) SetIsTruncated(v bool) *ListRoleTagsOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListRoleTagsOutput) SetMarker(v string) *ListRoleTagsOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *ListRoleTagsOutput) SetTags(v []*Tag) *ListRoleTagsOutput {
+	s.Tags = v
+	return s
+}
+
+type ListRolesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The path prefix for filtering the results. For example, the prefix /application_abc/component_xyz/
+	// gets all roles whose path starts with /application_abc/component_xyz/.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/), listing all roles. This parameter allows (through its regex pattern
+	// (http://wikipedia.org/wiki/regex)) a string of characters consisting of either
+	// a forward slash (/) by itself or a string that must begin and end with forward
+	// slashes. In addition, it can contain any ASCII character from the ! (\u0021)
+	// through the DEL character (\u007F), including most punctuation characters,
+	// digits, and upper and lowercased letters.
+	PathPrefix *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListRolesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListRolesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListRolesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListRolesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListRolesInput) SetMarker(v string) *ListRolesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListRolesInput) SetMaxItems(v int64) *ListRolesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListRolesInput) SetPathPrefix(v string) *ListRolesInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// Contains the response to a successful ListRoles request.
+type ListRolesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of roles.
+	//
+	// Roles is a required field
+	Roles []*Role `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListRolesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListRolesOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListRolesOutput) SetIsTruncated(v bool) *ListRolesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListRolesOutput) SetMarker(v string) *ListRolesOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetRoles sets the Roles field's value.
+func (s *ListRolesOutput) SetRoles(v []*Role) *ListRolesOutput {
+	s.Roles = v
+	return s
+}
+
+type ListSAMLProvidersInput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s ListSAMLProvidersInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListSAMLProvidersInput) GoString() string {
+	return s.String()
+}
+
+// Contains the response to a successful ListSAMLProviders request.
+type ListSAMLProvidersOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The list of SAML provider resource objects defined in IAM for this AWS account.
+	SAMLProviderList []*SAMLProviderListEntry `type:"list"`
+}
+
+// String returns the string representation
+func (s ListSAMLProvidersOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListSAMLProvidersOutput) GoString() string {
+	return s.String()
+}
+
+// SetSAMLProviderList sets the SAMLProviderList field's value.
+func (s *ListSAMLProvidersOutput) SetSAMLProviderList(v []*SAMLProviderListEntry) *ListSAMLProvidersOutput {
+	s.SAMLProviderList = v
+	return s
+}
+
+type ListSSHPublicKeysInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the IAM user to list SSH public keys for. If none is specified,
+	// the UserName field is determined implicitly based on the AWS access key used
+	// to sign the request.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListSSHPublicKeysInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListSSHPublicKeysInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListSSHPublicKeysInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListSSHPublicKeysInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListSSHPublicKeysInput) SetMarker(v string) *ListSSHPublicKeysInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListSSHPublicKeysInput) SetMaxItems(v int64) *ListSSHPublicKeysInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ListSSHPublicKeysInput) SetUserName(v string) *ListSSHPublicKeysInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful ListSSHPublicKeys request.
+type ListSSHPublicKeysOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of the SSH public keys assigned to IAM user.
+	SSHPublicKeys []*SSHPublicKeyMetadata `type:"list"`
+}
+
+// String returns the string representation
+func (s ListSSHPublicKeysOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListSSHPublicKeysOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListSSHPublicKeysOutput) SetIsTruncated(v bool) *ListSSHPublicKeysOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListSSHPublicKeysOutput) SetMarker(v string) *ListSSHPublicKeysOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetSSHPublicKeys sets the SSHPublicKeys field's value.
+func (s *ListSSHPublicKeysOutput) SetSSHPublicKeys(v []*SSHPublicKeyMetadata) *ListSSHPublicKeysOutput {
+	s.SSHPublicKeys = v
+	return s
+}
+
+type ListServerCertificatesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The path prefix for filtering the results. For example: /company/servercerts
+	// would get all server certificates for which the path starts with /company/servercerts.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/), listing all server certificates. This parameter allows (through its
+	// regex pattern (http://wikipedia.org/wiki/regex)) a string of characters consisting
+	// of either a forward slash (/) by itself or a string that must begin and end
+	// with forward slashes. In addition, it can contain any ASCII character from
+	// the ! (\u0021) through the DEL character (\u007F), including most punctuation
+	// characters, digits, and upper and lowercased letters.
+	PathPrefix *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListServerCertificatesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListServerCertificatesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListServerCertificatesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListServerCertificatesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListServerCertificatesInput) SetMarker(v string) *ListServerCertificatesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListServerCertificatesInput) SetMaxItems(v int64) *ListServerCertificatesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListServerCertificatesInput) SetPathPrefix(v string) *ListServerCertificatesInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// Contains the response to a successful ListServerCertificates request.
+type ListServerCertificatesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of server certificates.
+	//
+	// ServerCertificateMetadataList is a required field
+	ServerCertificateMetadataList []*ServerCertificateMetadata `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListServerCertificatesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListServerCertificatesOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListServerCertificatesOutput) SetIsTruncated(v bool) *ListServerCertificatesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListServerCertificatesOutput) SetMarker(v string) *ListServerCertificatesOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetServerCertificateMetadataList sets the ServerCertificateMetadataList field's value.
+func (s *ListServerCertificatesOutput) SetServerCertificateMetadataList(v []*ServerCertificateMetadata) *ListServerCertificatesOutput {
+	s.ServerCertificateMetadataList = v
+	return s
+}
+
+type ListServiceSpecificCredentialsInput struct {
+	_ struct{} `type:"structure"`
+
+	// Filters the returned results to only those for the specified AWS service.
+	// If not specified, then AWS returns service-specific credentials for all services.
+	ServiceName *string `type:"string"`
+
+	// The name of the user whose service-specific credentials you want information
+	// about. If this value is not specified, then the operation assumes the user
+	// whose credentials are used to call the operation.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListServiceSpecificCredentialsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListServiceSpecificCredentialsInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListServiceSpecificCredentialsInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListServiceSpecificCredentialsInput"}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetServiceName sets the ServiceName field's value.
+func (s *ListServiceSpecificCredentialsInput) SetServiceName(v string) *ListServiceSpecificCredentialsInput {
+	s.ServiceName = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ListServiceSpecificCredentialsInput) SetUserName(v string) *ListServiceSpecificCredentialsInput {
+	s.UserName = &v
+	return s
+}
+
+type ListServiceSpecificCredentialsOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of structures that each contain details about a service-specific credential.
+	ServiceSpecificCredentials []*ServiceSpecificCredentialMetadata `type:"list"`
+}
+
+// String returns the string representation
+func (s ListServiceSpecificCredentialsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListServiceSpecificCredentialsOutput) GoString() string {
+	return s.String()
+}
+
+// SetServiceSpecificCredentials sets the ServiceSpecificCredentials field's value.
+func (s *ListServiceSpecificCredentialsOutput) SetServiceSpecificCredentials(v []*ServiceSpecificCredentialMetadata) *ListServiceSpecificCredentialsOutput {
+	s.ServiceSpecificCredentials = v
+	return s
+}
+
+type ListSigningCertificatesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the IAM user whose signing certificates you want to examine.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListSigningCertificatesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListSigningCertificatesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListSigningCertificatesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListSigningCertificatesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListSigningCertificatesInput) SetMarker(v string) *ListSigningCertificatesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListSigningCertificatesInput) SetMaxItems(v int64) *ListSigningCertificatesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ListSigningCertificatesInput) SetUserName(v string) *ListSigningCertificatesInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful ListSigningCertificates request.
+type ListSigningCertificatesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of the user's signing certificate information.
+	//
+	// Certificates is a required field
+	Certificates []*SigningCertificate `type:"list" required:"true"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s ListSigningCertificatesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListSigningCertificatesOutput) GoString() string {
+	return s.String()
+}
+
+// SetCertificates sets the Certificates field's value.
+func (s *ListSigningCertificatesOutput) SetCertificates(v []*SigningCertificate) *ListSigningCertificatesOutput {
+	s.Certificates = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListSigningCertificatesOutput) SetIsTruncated(v bool) *ListSigningCertificatesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListSigningCertificatesOutput) SetMarker(v string) *ListSigningCertificatesOutput {
+	s.Marker = &v
+	return s
+}
+
+type ListUserPoliciesInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the user to list policies for.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListUserPoliciesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListUserPoliciesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListUserPoliciesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListUserPoliciesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListUserPoliciesInput) SetMarker(v string) *ListUserPoliciesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListUserPoliciesInput) SetMaxItems(v int64) *ListUserPoliciesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ListUserPoliciesInput) SetUserName(v string) *ListUserPoliciesInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful ListUserPolicies request.
+type ListUserPoliciesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of policy names.
+	//
+	// PolicyNames is a required field
+	PolicyNames []*string `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListUserPoliciesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListUserPoliciesOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListUserPoliciesOutput) SetIsTruncated(v bool) *ListUserPoliciesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListUserPoliciesOutput) SetMarker(v string) *ListUserPoliciesOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetPolicyNames sets the PolicyNames field's value.
+func (s *ListUserPoliciesOutput) SetPolicyNames(v []*string) *ListUserPoliciesOutput {
+	s.PolicyNames = v
+	return s
+}
+
+type ListUserTagsInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// (Optional) Use this only when paginating results to indicate the maximum
+	// number of items that you want in the response. If additional items exist
+	// beyond the maximum that you specify, the IsTruncated response element is
+	// true.
+	//
+	// If you do not include this parameter, it defaults to 100. Note that IAM might
+	// return fewer results, even when more results are available. In that case,
+	// the IsTruncated response element returns true, and Marker contains a value
+	// to include in the subsequent call that tells the service where to continue
+	// from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The name of the IAM user whose tags you want to see.
+	//
+	// This parameter accepts (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that consist of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: =,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ListUserTagsInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListUserTagsInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListUserTagsInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListUserTagsInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListUserTagsInput) SetMarker(v string) *ListUserTagsInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListUserTagsInput) SetMaxItems(v int64) *ListUserTagsInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ListUserTagsInput) SetUserName(v string) *ListUserTagsInput {
+	s.UserName = &v
+	return s
+}
+
+type ListUserTagsOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can use the Marker request parameter to make a subsequent
+	// pagination request that retrieves more items. Note that IAM might return
+	// fewer than the MaxItems number of results even when more results are available.
+	// Check IsTruncated after every call to ensure that you receive all of your
+	// results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// The list of tags that are currently attached to the user. Each tag consists
+	// of a key name and an associated value. If no tags are attached to the specified
+	// user, the response contains an empty list.
+	//
+	// Tags is a required field
+	Tags []*Tag `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListUserTagsOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListUserTagsOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListUserTagsOutput) SetIsTruncated(v bool) *ListUserTagsOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListUserTagsOutput) SetMarker(v string) *ListUserTagsOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *ListUserTagsOutput) SetTags(v []*Tag) *ListUserTagsOutput {
+	s.Tags = v
+	return s
+}
+
+type ListUsersInput struct {
+	_ struct{} `type:"structure"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// The path prefix for filtering the results. For example: /division_abc/subdivision_xyz/,
+	// which would get all user names whose path starts with /division_abc/subdivision_xyz/.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/), listing all user names. This parameter allows (through its regex pattern
+	// (http://wikipedia.org/wiki/regex)) a string of characters consisting of either
+	// a forward slash (/) by itself or a string that must begin and end with forward
+	// slashes. In addition, it can contain any ASCII character from the ! (\u0021)
+	// through the DEL character (\u007F), including most punctuation characters,
+	// digits, and upper and lowercased letters.
+	PathPrefix *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ListUsersInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListUsersInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListUsersInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListUsersInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PathPrefix != nil && len(*s.PathPrefix) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PathPrefix", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListUsersInput) SetMarker(v string) *ListUsersInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListUsersInput) SetMaxItems(v int64) *ListUsersInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPathPrefix sets the PathPrefix field's value.
+func (s *ListUsersInput) SetPathPrefix(v string) *ListUsersInput {
+	s.PathPrefix = &v
+	return s
+}
+
+// Contains the response to a successful ListUsers request.
+type ListUsersOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// A list of users.
+	//
+	// Users is a required field
+	Users []*User `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListUsersOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListUsersOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListUsersOutput) SetIsTruncated(v bool) *ListUsersOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListUsersOutput) SetMarker(v string) *ListUsersOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetUsers sets the Users field's value.
+func (s *ListUsersOutput) SetUsers(v []*User) *ListUsersOutput {
+	s.Users = v
+	return s
+}
+
+type ListVirtualMFADevicesInput struct {
+	_ struct{} `type:"structure"`
+
+	// The status (Unassigned or Assigned) of the devices to list. If you do not
+	// specify an AssignmentStatus, the operation defaults to Any, which lists both
+	// assigned and unassigned virtual MFA devices.,
+	AssignmentStatus *string `type:"string" enum:"assignmentStatusType"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+}
+
+// String returns the string representation
+func (s ListVirtualMFADevicesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListVirtualMFADevicesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ListVirtualMFADevicesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ListVirtualMFADevicesInput"}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAssignmentStatus sets the AssignmentStatus field's value.
+func (s *ListVirtualMFADevicesInput) SetAssignmentStatus(v string) *ListVirtualMFADevicesInput {
+	s.AssignmentStatus = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListVirtualMFADevicesInput) SetMarker(v string) *ListVirtualMFADevicesInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *ListVirtualMFADevicesInput) SetMaxItems(v int64) *ListVirtualMFADevicesInput {
+	s.MaxItems = &v
+	return s
+}
+
+// Contains the response to a successful ListVirtualMFADevices request.
+type ListVirtualMFADevicesOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+
+	// The list of virtual MFA devices in the current account that match the AssignmentStatus
+	// value that was passed in the request.
+	//
+	// VirtualMFADevices is a required field
+	VirtualMFADevices []*VirtualMFADevice `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s ListVirtualMFADevicesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ListVirtualMFADevicesOutput) GoString() string {
+	return s.String()
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *ListVirtualMFADevicesOutput) SetIsTruncated(v bool) *ListVirtualMFADevicesOutput {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *ListVirtualMFADevicesOutput) SetMarker(v string) *ListVirtualMFADevicesOutput {
+	s.Marker = &v
+	return s
+}
+
+// SetVirtualMFADevices sets the VirtualMFADevices field's value.
+func (s *ListVirtualMFADevicesOutput) SetVirtualMFADevices(v []*VirtualMFADevice) *ListVirtualMFADevicesOutput {
+	s.VirtualMFADevices = v
+	return s
+}
+
+// Contains the user name and password create date for a user.
+//
+// This data type is used as a response element in the CreateLoginProfile and
+// GetLoginProfile operations.
+type LoginProfile struct {
+	_ struct{} `type:"structure"`
+
+	// The date when the password for the user was created.
+	//
+	// CreateDate is a required field
+	CreateDate *time.Time `type:"timestamp" required:"true"`
+
+	// Specifies whether the user is required to set a new password on next sign-in.
+	PasswordResetRequired *bool `type:"boolean"`
+
+	// The name of the user, which can be used for signing in to the AWS Management
+	// Console.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s LoginProfile) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s LoginProfile) GoString() string {
+	return s.String()
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *LoginProfile) SetCreateDate(v time.Time) *LoginProfile {
+	s.CreateDate = &v
+	return s
+}
+
+// SetPasswordResetRequired sets the PasswordResetRequired field's value.
+func (s *LoginProfile) SetPasswordResetRequired(v bool) *LoginProfile {
+	s.PasswordResetRequired = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *LoginProfile) SetUserName(v string) *LoginProfile {
+	s.UserName = &v
+	return s
+}
+
+// Contains information about an MFA device.
+//
+// This data type is used as a response element in the ListMFADevices operation.
+type MFADevice struct {
+	_ struct{} `type:"structure"`
+
+	// The date when the MFA device was enabled for the user.
+	//
+	// EnableDate is a required field
+	EnableDate *time.Time `type:"timestamp" required:"true"`
+
+	// The serial number that uniquely identifies the MFA device. For virtual MFA
+	// devices, the serial number is the device ARN.
+	//
+	// SerialNumber is a required field
+	SerialNumber *string `min:"9" type:"string" required:"true"`
+
+	// The user with whom the MFA device is associated.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s MFADevice) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s MFADevice) GoString() string {
+	return s.String()
+}
+
+// SetEnableDate sets the EnableDate field's value.
+func (s *MFADevice) SetEnableDate(v time.Time) *MFADevice {
+	s.EnableDate = &v
+	return s
+}
+
+// SetSerialNumber sets the SerialNumber field's value.
+func (s *MFADevice) SetSerialNumber(v string) *MFADevice {
+	s.SerialNumber = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *MFADevice) SetUserName(v string) *MFADevice {
+	s.UserName = &v
+	return s
+}
+
+// Contains information about a managed policy, including the policy's ARN,
+// versions, and the number of principal entities (users, groups, and roles)
+// that the policy is attached to.
+//
+// This data type is used as a response element in the GetAccountAuthorizationDetails
+// operation.
+//
+// For more information about managed policies, see Managed Policies and Inline
+// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the Using IAM guide.
+type ManagedPolicyDetail struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN). ARNs are unique identifiers for AWS resources.
+	//
+	// For more information about ARNs, go to Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	Arn *string `min:"20" type:"string"`
+
+	// The number of principal entities (users, groups, and roles) that the policy
+	// is attached to.
+	AttachmentCount *int64 `type:"integer"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the policy was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// The identifier for the version of the policy that is set as the default (operative)
+	// version.
+	//
+	// For more information about policy versions, see Versioning for Managed Policies
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html)
+	// in the Using IAM guide.
+	DefaultVersionId *string `type:"string"`
+
+	// A friendly description of the policy.
+	Description *string `type:"string"`
+
+	// Specifies whether the policy can be attached to an IAM user, group, or role.
+	IsAttachable *bool `type:"boolean"`
+
+	// The path to the policy.
+	//
+	// For more information about paths, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	Path *string `min:"1" type:"string"`
+
+	// The number of entities (users and roles) for which the policy is used as
+	// the permissions boundary.
+	//
+	// For more information about permissions boundaries, see Permissions Boundaries
+	// for IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)
+	// in the IAM User Guide.
+	PermissionsBoundaryUsageCount *int64 `type:"integer"`
+
+	// The stable and unique string identifying the policy.
+	//
+	// For more information about IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	PolicyId *string `min:"16" type:"string"`
+
+	// The friendly name (not ARN) identifying the policy.
+	PolicyName *string `min:"1" type:"string"`
+
+	// A list containing information about the versions of the policy.
+	PolicyVersionList []*PolicyVersion `type:"list"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the policy was last updated.
+	//
+	// When a policy has only one version, this field contains the date and time
+	// when the policy was created. When a policy has more than one version, this
+	// field contains the date and time when the most recent policy version was
+	// created.
+	UpdateDate *time.Time `type:"timestamp"`
+}
+
+// String returns the string representation
+func (s ManagedPolicyDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ManagedPolicyDetail) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *ManagedPolicyDetail) SetArn(v string) *ManagedPolicyDetail {
+	s.Arn = &v
+	return s
+}
+
+// SetAttachmentCount sets the AttachmentCount field's value.
+func (s *ManagedPolicyDetail) SetAttachmentCount(v int64) *ManagedPolicyDetail {
+	s.AttachmentCount = &v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *ManagedPolicyDetail) SetCreateDate(v time.Time) *ManagedPolicyDetail {
+	s.CreateDate = &v
+	return s
+}
+
+// SetDefaultVersionId sets the DefaultVersionId field's value.
+func (s *ManagedPolicyDetail) SetDefaultVersionId(v string) *ManagedPolicyDetail {
+	s.DefaultVersionId = &v
+	return s
+}
+
+// SetDescription sets the Description field's value.
+func (s *ManagedPolicyDetail) SetDescription(v string) *ManagedPolicyDetail {
+	s.Description = &v
+	return s
+}
+
+// SetIsAttachable sets the IsAttachable field's value.
+func (s *ManagedPolicyDetail) SetIsAttachable(v bool) *ManagedPolicyDetail {
+	s.IsAttachable = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *ManagedPolicyDetail) SetPath(v string) *ManagedPolicyDetail {
+	s.Path = &v
+	return s
+}
+
+// SetPermissionsBoundaryUsageCount sets the PermissionsBoundaryUsageCount field's value.
+func (s *ManagedPolicyDetail) SetPermissionsBoundaryUsageCount(v int64) *ManagedPolicyDetail {
+	s.PermissionsBoundaryUsageCount = &v
+	return s
+}
+
+// SetPolicyId sets the PolicyId field's value.
+func (s *ManagedPolicyDetail) SetPolicyId(v string) *ManagedPolicyDetail {
+	s.PolicyId = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *ManagedPolicyDetail) SetPolicyName(v string) *ManagedPolicyDetail {
+	s.PolicyName = &v
+	return s
+}
+
+// SetPolicyVersionList sets the PolicyVersionList field's value.
+func (s *ManagedPolicyDetail) SetPolicyVersionList(v []*PolicyVersion) *ManagedPolicyDetail {
+	s.PolicyVersionList = v
+	return s
+}
+
+// SetUpdateDate sets the UpdateDate field's value.
+func (s *ManagedPolicyDetail) SetUpdateDate(v time.Time) *ManagedPolicyDetail {
+	s.UpdateDate = &v
+	return s
+}
+
+// Contains the Amazon Resource Name (ARN) for an IAM OpenID Connect provider.
+type OpenIDConnectProviderListEntry struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN). ARNs are unique identifiers for AWS resources.
+	//
+	// For more information about ARNs, go to Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	Arn *string `min:"20" type:"string"`
+}
+
+// String returns the string representation
+func (s OpenIDConnectProviderListEntry) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s OpenIDConnectProviderListEntry) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *OpenIDConnectProviderListEntry) SetArn(v string) *OpenIDConnectProviderListEntry {
+	s.Arn = &v
+	return s
+}
+
+// Contains information about the effect that Organizations has on a policy
+// simulation.
+type OrganizationsDecisionDetail struct {
+	_ struct{} `type:"structure"`
+
+	// Specifies whether the simulated operation is allowed by the Organizations
+	// service control policies that impact the simulated user's account.
+	AllowedByOrganizations *bool `type:"boolean"`
+}
+
+// String returns the string representation
+func (s OrganizationsDecisionDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s OrganizationsDecisionDetail) GoString() string {
+	return s.String()
+}
+
+// SetAllowedByOrganizations sets the AllowedByOrganizations field's value.
+func (s *OrganizationsDecisionDetail) SetAllowedByOrganizations(v bool) *OrganizationsDecisionDetail {
+	s.AllowedByOrganizations = &v
+	return s
+}
+
+// Contains information about the account password policy.
+//
+// This data type is used as a response element in the GetAccountPasswordPolicy
+// operation.
+type PasswordPolicy struct {
+	_ struct{} `type:"structure"`
+
+	// Specifies whether IAM users are allowed to change their own password.
+	AllowUsersToChangePassword *bool `type:"boolean"`
+
+	// Indicates whether passwords in the account expire. Returns true if MaxPasswordAge
+	// contains a value greater than 0. Returns false if MaxPasswordAge is 0 or
+	// not present.
+	ExpirePasswords *bool `type:"boolean"`
+
+	// Specifies whether IAM users are prevented from setting a new password after
+	// their password has expired.
+	HardExpiry *bool `type:"boolean"`
+
+	// The number of days that an IAM user password is valid.
+	MaxPasswordAge *int64 `min:"1" type:"integer"`
+
+	// Minimum length to require for IAM user passwords.
+	MinimumPasswordLength *int64 `min:"6" type:"integer"`
+
+	// Specifies the number of previous passwords that IAM users are prevented from
+	// reusing.
+	PasswordReusePrevention *int64 `min:"1" type:"integer"`
+
+	// Specifies whether to require lowercase characters for IAM user passwords.
+	RequireLowercaseCharacters *bool `type:"boolean"`
+
+	// Specifies whether to require numbers for IAM user passwords.
+	RequireNumbers *bool `type:"boolean"`
+
+	// Specifies whether to require symbols for IAM user passwords.
+	RequireSymbols *bool `type:"boolean"`
+
+	// Specifies whether to require uppercase characters for IAM user passwords.
+	RequireUppercaseCharacters *bool `type:"boolean"`
+}
+
+// String returns the string representation
+func (s PasswordPolicy) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PasswordPolicy) GoString() string {
+	return s.String()
+}
+
+// SetAllowUsersToChangePassword sets the AllowUsersToChangePassword field's value.
+func (s *PasswordPolicy) SetAllowUsersToChangePassword(v bool) *PasswordPolicy {
+	s.AllowUsersToChangePassword = &v
+	return s
+}
+
+// SetExpirePasswords sets the ExpirePasswords field's value.
+func (s *PasswordPolicy) SetExpirePasswords(v bool) *PasswordPolicy {
+	s.ExpirePasswords = &v
+	return s
+}
+
+// SetHardExpiry sets the HardExpiry field's value.
+func (s *PasswordPolicy) SetHardExpiry(v bool) *PasswordPolicy {
+	s.HardExpiry = &v
+	return s
+}
+
+// SetMaxPasswordAge sets the MaxPasswordAge field's value.
+func (s *PasswordPolicy) SetMaxPasswordAge(v int64) *PasswordPolicy {
+	s.MaxPasswordAge = &v
+	return s
+}
+
+// SetMinimumPasswordLength sets the MinimumPasswordLength field's value.
+func (s *PasswordPolicy) SetMinimumPasswordLength(v int64) *PasswordPolicy {
+	s.MinimumPasswordLength = &v
+	return s
+}
+
+// SetPasswordReusePrevention sets the PasswordReusePrevention field's value.
+func (s *PasswordPolicy) SetPasswordReusePrevention(v int64) *PasswordPolicy {
+	s.PasswordReusePrevention = &v
+	return s
+}
+
+// SetRequireLowercaseCharacters sets the RequireLowercaseCharacters field's value.
+func (s *PasswordPolicy) SetRequireLowercaseCharacters(v bool) *PasswordPolicy {
+	s.RequireLowercaseCharacters = &v
+	return s
+}
+
+// SetRequireNumbers sets the RequireNumbers field's value.
+func (s *PasswordPolicy) SetRequireNumbers(v bool) *PasswordPolicy {
+	s.RequireNumbers = &v
+	return s
+}
+
+// SetRequireSymbols sets the RequireSymbols field's value.
+func (s *PasswordPolicy) SetRequireSymbols(v bool) *PasswordPolicy {
+	s.RequireSymbols = &v
+	return s
+}
+
+// SetRequireUppercaseCharacters sets the RequireUppercaseCharacters field's value.
+func (s *PasswordPolicy) SetRequireUppercaseCharacters(v bool) *PasswordPolicy {
+	s.RequireUppercaseCharacters = &v
+	return s
+}
+
+// Contains information about a managed policy.
+//
+// This data type is used as a response element in the CreatePolicy, GetPolicy,
+// and ListPolicies operations.
+//
+// For more information about managed policies, refer to Managed Policies and
+// Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the Using IAM guide.
+type Policy struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN). ARNs are unique identifiers for AWS resources.
+	//
+	// For more information about ARNs, go to Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	Arn *string `min:"20" type:"string"`
+
+	// The number of entities (users, groups, and roles) that the policy is attached
+	// to.
+	AttachmentCount *int64 `type:"integer"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the policy was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// The identifier for the version of the policy that is set as the default version.
+	DefaultVersionId *string `type:"string"`
+
+	// A friendly description of the policy.
+	//
+	// This element is included in the response to the GetPolicy operation. It is
+	// not included in the response to the ListPolicies operation.
+	Description *string `type:"string"`
+
+	// Specifies whether the policy can be attached to an IAM user, group, or role.
+	IsAttachable *bool `type:"boolean"`
+
+	// The path to the policy.
+	//
+	// For more information about paths, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	Path *string `min:"1" type:"string"`
+
+	// The number of entities (users and roles) for which the policy is used to
+	// set the permissions boundary.
+	//
+	// For more information about permissions boundaries, see Permissions Boundaries
+	// for IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)
+	// in the IAM User Guide.
+	PermissionsBoundaryUsageCount *int64 `type:"integer"`
+
+	// The stable and unique string identifying the policy.
+	//
+	// For more information about IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	PolicyId *string `min:"16" type:"string"`
+
+	// The friendly name (not ARN) identifying the policy.
+	PolicyName *string `min:"1" type:"string"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the policy was last updated.
+	//
+	// When a policy has only one version, this field contains the date and time
+	// when the policy was created. When a policy has more than one version, this
+	// field contains the date and time when the most recent policy version was
+	// created.
+	UpdateDate *time.Time `type:"timestamp"`
+}
+
+// String returns the string representation
+func (s Policy) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Policy) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *Policy) SetArn(v string) *Policy {
+	s.Arn = &v
+	return s
+}
+
+// SetAttachmentCount sets the AttachmentCount field's value.
+func (s *Policy) SetAttachmentCount(v int64) *Policy {
+	s.AttachmentCount = &v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *Policy) SetCreateDate(v time.Time) *Policy {
+	s.CreateDate = &v
+	return s
+}
+
+// SetDefaultVersionId sets the DefaultVersionId field's value.
+func (s *Policy) SetDefaultVersionId(v string) *Policy {
+	s.DefaultVersionId = &v
+	return s
+}
+
+// SetDescription sets the Description field's value.
+func (s *Policy) SetDescription(v string) *Policy {
+	s.Description = &v
+	return s
+}
+
+// SetIsAttachable sets the IsAttachable field's value.
+func (s *Policy) SetIsAttachable(v bool) *Policy {
+	s.IsAttachable = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *Policy) SetPath(v string) *Policy {
+	s.Path = &v
+	return s
+}
+
+// SetPermissionsBoundaryUsageCount sets the PermissionsBoundaryUsageCount field's value.
+func (s *Policy) SetPermissionsBoundaryUsageCount(v int64) *Policy {
+	s.PermissionsBoundaryUsageCount = &v
+	return s
+}
+
+// SetPolicyId sets the PolicyId field's value.
+func (s *Policy) SetPolicyId(v string) *Policy {
+	s.PolicyId = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *Policy) SetPolicyName(v string) *Policy {
+	s.PolicyName = &v
+	return s
+}
+
+// SetUpdateDate sets the UpdateDate field's value.
+func (s *Policy) SetUpdateDate(v time.Time) *Policy {
+	s.UpdateDate = &v
+	return s
+}
+
+// Contains information about an IAM policy, including the policy document.
+//
+// This data type is used as a response element in the GetAccountAuthorizationDetails
+// operation.
+type PolicyDetail struct {
+	_ struct{} `type:"structure"`
+
+	// The policy document.
+	PolicyDocument *string `min:"1" type:"string"`
+
+	// The name of the policy.
+	PolicyName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s PolicyDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PolicyDetail) GoString() string {
+	return s.String()
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *PolicyDetail) SetPolicyDocument(v string) *PolicyDetail {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *PolicyDetail) SetPolicyName(v string) *PolicyDetail {
+	s.PolicyName = &v
+	return s
+}
+
+// Contains details about the permissions policies that are attached to the
+// specified identity (user, group, or role).
+//
+// This data type is an element of the ListPoliciesGrantingServiceAccessEntry
+// object.
+type PolicyGrantingServiceAccess struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the entity (user or role) to which the inline policy is attached.
+	//
+	// This field is null for managed policies. For more information about these
+	// policy types, see Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html)
+	// in the IAM User Guide.
+	EntityName *string `min:"1" type:"string"`
+
+	// The type of entity (user or role) that used the policy to access the service
+	// to which the inline policy is attached.
+	//
+	// This field is null for managed policies. For more information about these
+	// policy types, see Managed Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html)
+	// in the IAM User Guide.
+	EntityType *string `type:"string" enum:"policyOwnerEntityType"`
+
+	// The Amazon Resource Name (ARN). ARNs are unique identifiers for AWS resources.
+	//
+	// For more information about ARNs, go to Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	PolicyArn *string `min:"20" type:"string"`
+
+	// The policy name.
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+
+	// The policy type. For more information about these policy types, see Managed
+	// Policies and Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html)
+	// in the IAM User Guide.
+	//
+	// PolicyType is a required field
+	PolicyType *string `type:"string" required:"true" enum:"policyType"`
+}
+
+// String returns the string representation
+func (s PolicyGrantingServiceAccess) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PolicyGrantingServiceAccess) GoString() string {
+	return s.String()
+}
+
+// SetEntityName sets the EntityName field's value.
+func (s *PolicyGrantingServiceAccess) SetEntityName(v string) *PolicyGrantingServiceAccess {
+	s.EntityName = &v
+	return s
+}
+
+// SetEntityType sets the EntityType field's value.
+func (s *PolicyGrantingServiceAccess) SetEntityType(v string) *PolicyGrantingServiceAccess {
+	s.EntityType = &v
+	return s
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *PolicyGrantingServiceAccess) SetPolicyArn(v string) *PolicyGrantingServiceAccess {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *PolicyGrantingServiceAccess) SetPolicyName(v string) *PolicyGrantingServiceAccess {
+	s.PolicyName = &v
+	return s
+}
+
+// SetPolicyType sets the PolicyType field's value.
+func (s *PolicyGrantingServiceAccess) SetPolicyType(v string) *PolicyGrantingServiceAccess {
+	s.PolicyType = &v
+	return s
+}
+
+// Contains information about a group that a managed policy is attached to.
+//
+// This data type is used as a response element in the ListEntitiesForPolicy
+// operation.
+//
+// For more information about managed policies, refer to Managed Policies and
+// Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the Using IAM guide.
+type PolicyGroup struct {
+	_ struct{} `type:"structure"`
+
+	// The stable and unique string identifying the group. For more information
+	// about IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html)
+	// in the IAM User Guide.
+	GroupId *string `min:"16" type:"string"`
+
+	// The name (friendly name, not ARN) identifying the group.
+	GroupName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s PolicyGroup) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PolicyGroup) GoString() string {
+	return s.String()
+}
+
+// SetGroupId sets the GroupId field's value.
+func (s *PolicyGroup) SetGroupId(v string) *PolicyGroup {
+	s.GroupId = &v
+	return s
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *PolicyGroup) SetGroupName(v string) *PolicyGroup {
+	s.GroupName = &v
+	return s
+}
+
+// Contains information about a role that a managed policy is attached to.
+//
+// This data type is used as a response element in the ListEntitiesForPolicy
+// operation.
+//
+// For more information about managed policies, refer to Managed Policies and
+// Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the Using IAM guide.
+type PolicyRole struct {
+	_ struct{} `type:"structure"`
+
+	// The stable and unique string identifying the role. For more information about
+	// IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html)
+	// in the IAM User Guide.
+	RoleId *string `min:"16" type:"string"`
+
+	// The name (friendly name, not ARN) identifying the role.
+	RoleName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s PolicyRole) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PolicyRole) GoString() string {
+	return s.String()
+}
+
+// SetRoleId sets the RoleId field's value.
+func (s *PolicyRole) SetRoleId(v string) *PolicyRole {
+	s.RoleId = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *PolicyRole) SetRoleName(v string) *PolicyRole {
+	s.RoleName = &v
+	return s
+}
+
+// Contains information about a user that a managed policy is attached to.
+//
+// This data type is used as a response element in the ListEntitiesForPolicy
+// operation.
+//
+// For more information about managed policies, refer to Managed Policies and
+// Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the Using IAM guide.
+type PolicyUser struct {
+	_ struct{} `type:"structure"`
+
+	// The stable and unique string identifying the user. For more information about
+	// IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html)
+	// in the IAM User Guide.
+	UserId *string `min:"16" type:"string"`
+
+	// The name (friendly name, not ARN) identifying the user.
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s PolicyUser) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PolicyUser) GoString() string {
+	return s.String()
+}
+
+// SetUserId sets the UserId field's value.
+func (s *PolicyUser) SetUserId(v string) *PolicyUser {
+	s.UserId = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *PolicyUser) SetUserName(v string) *PolicyUser {
+	s.UserName = &v
+	return s
+}
+
+// Contains information about a version of a managed policy.
+//
+// This data type is used as a response element in the CreatePolicyVersion,
+// GetPolicyVersion, ListPolicyVersions, and GetAccountAuthorizationDetails
+// operations.
+//
+// For more information about managed policies, refer to Managed Policies and
+// Inline Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-vs-inline.html)
+// in the Using IAM guide.
+type PolicyVersion struct {
+	_ struct{} `type:"structure"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the policy version was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// The policy document.
+	//
+	// The policy document is returned in the response to the GetPolicyVersion and
+	// GetAccountAuthorizationDetails operations. It is not returned in the response
+	// to the CreatePolicyVersion or ListPolicyVersions operations.
+	//
+	// The policy document returned in this structure is URL-encoded compliant with
+	// RFC 3986 (https://tools.ietf.org/html/rfc3986). You can use a URL decoding
+	// method to convert the policy back to plain JSON text. For example, if you
+	// use Java, you can use the decode method of the java.net.URLDecoder utility
+	// class in the Java SDK. Other languages and SDKs provide similar functionality.
+	Document *string `min:"1" type:"string"`
+
+	// Specifies whether the policy version is set as the policy's default version.
+	IsDefaultVersion *bool `type:"boolean"`
+
+	// The identifier for the policy version.
+	//
+	// Policy version identifiers always begin with v (always lowercase). When a
+	// policy is created, the first policy version is v1.
+	VersionId *string `type:"string"`
+}
+
+// String returns the string representation
+func (s PolicyVersion) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PolicyVersion) GoString() string {
+	return s.String()
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *PolicyVersion) SetCreateDate(v time.Time) *PolicyVersion {
+	s.CreateDate = &v
+	return s
+}
+
+// SetDocument sets the Document field's value.
+func (s *PolicyVersion) SetDocument(v string) *PolicyVersion {
+	s.Document = &v
+	return s
+}
+
+// SetIsDefaultVersion sets the IsDefaultVersion field's value.
+func (s *PolicyVersion) SetIsDefaultVersion(v bool) *PolicyVersion {
+	s.IsDefaultVersion = &v
+	return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *PolicyVersion) SetVersionId(v string) *PolicyVersion {
+	s.VersionId = &v
+	return s
+}
+
+// Contains the row and column of a location of a Statement element in a policy
+// document.
+//
+// This data type is used as a member of the Statement type.
+type Position struct {
+	_ struct{} `type:"structure"`
+
+	// The column in the line containing the specified position in the document.
+	Column *int64 `type:"integer"`
+
+	// The line containing the specified position in the document.
+	Line *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s Position) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Position) GoString() string {
+	return s.String()
+}
+
+// SetColumn sets the Column field's value.
+func (s *Position) SetColumn(v int64) *Position {
+	s.Column = &v
+	return s
+}
+
+// SetLine sets the Line field's value.
+func (s *Position) SetLine(v int64) *Position {
+	s.Line = &v
+	return s
+}
+
+type PutGroupPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the group to associate the policy with.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-.
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The policy document.
+	//
+	// You must provide policies in JSON format in IAM. However, for AWS CloudFormation
+	// templates formatted in YAML, you can provide the policy in JSON or YAML format.
+	// AWS CloudFormation always converts a YAML policy to JSON format before submitting
+	// it to IAM.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// PolicyDocument is a required field
+	PolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// The name of the policy document.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s PutGroupPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutGroupPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutGroupPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "PutGroupPolicyInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.PolicyDocument == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyDocument"))
+	}
+	if s.PolicyDocument != nil && len(*s.PolicyDocument) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyDocument", 1))
+	}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *PutGroupPolicyInput) SetGroupName(v string) *PutGroupPolicyInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *PutGroupPolicyInput) SetPolicyDocument(v string) *PutGroupPolicyInput {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *PutGroupPolicyInput) SetPolicyName(v string) *PutGroupPolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+type PutGroupPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutGroupPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutGroupPolicyOutput) GoString() string {
+	return s.String()
+}
+
+type PutRolePermissionsBoundaryInput struct {
+	_ struct{} `type:"structure"`
+
+	// The ARN of the policy that is used to set the permissions boundary for the
+	// role.
+	//
+	// PermissionsBoundary is a required field
+	PermissionsBoundary *string `min:"20" type:"string" required:"true"`
+
+	// The name (friendly name, not ARN) of the IAM role for which you want to set
+	// the permissions boundary.
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s PutRolePermissionsBoundaryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutRolePermissionsBoundaryInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutRolePermissionsBoundaryInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "PutRolePermissionsBoundaryInput"}
+	if s.PermissionsBoundary == nil {
+		invalidParams.Add(request.NewErrParamRequired("PermissionsBoundary"))
+	}
+	if s.PermissionsBoundary != nil && len(*s.PermissionsBoundary) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PermissionsBoundary", 20))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPermissionsBoundary sets the PermissionsBoundary field's value.
+func (s *PutRolePermissionsBoundaryInput) SetPermissionsBoundary(v string) *PutRolePermissionsBoundaryInput {
+	s.PermissionsBoundary = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *PutRolePermissionsBoundaryInput) SetRoleName(v string) *PutRolePermissionsBoundaryInput {
+	s.RoleName = &v
+	return s
+}
+
+type PutRolePermissionsBoundaryOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutRolePermissionsBoundaryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutRolePermissionsBoundaryOutput) GoString() string {
+	return s.String()
+}
+
+type PutRolePolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The policy document.
+	//
+	// You must provide policies in JSON format in IAM. However, for AWS CloudFormation
+	// templates formatted in YAML, you can provide the policy in JSON or YAML format.
+	// AWS CloudFormation always converts a YAML policy to JSON format before submitting
+	// it to IAM.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// PolicyDocument is a required field
+	PolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// The name of the policy document.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+
+	// The name of the role to associate the policy with.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s PutRolePolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutRolePolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutRolePolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "PutRolePolicyInput"}
+	if s.PolicyDocument == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyDocument"))
+	}
+	if s.PolicyDocument != nil && len(*s.PolicyDocument) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyDocument", 1))
+	}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *PutRolePolicyInput) SetPolicyDocument(v string) *PutRolePolicyInput {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *PutRolePolicyInput) SetPolicyName(v string) *PutRolePolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *PutRolePolicyInput) SetRoleName(v string) *PutRolePolicyInput {
+	s.RoleName = &v
+	return s
+}
+
+type PutRolePolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutRolePolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutRolePolicyOutput) GoString() string {
+	return s.String()
+}
+
+type PutUserPermissionsBoundaryInput struct {
+	_ struct{} `type:"structure"`
+
+	// The ARN of the policy that is used to set the permissions boundary for the
+	// user.
+	//
+	// PermissionsBoundary is a required field
+	PermissionsBoundary *string `min:"20" type:"string" required:"true"`
+
+	// The name (friendly name, not ARN) of the IAM user for which you want to set
+	// the permissions boundary.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s PutUserPermissionsBoundaryInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutUserPermissionsBoundaryInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutUserPermissionsBoundaryInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "PutUserPermissionsBoundaryInput"}
+	if s.PermissionsBoundary == nil {
+		invalidParams.Add(request.NewErrParamRequired("PermissionsBoundary"))
+	}
+	if s.PermissionsBoundary != nil && len(*s.PermissionsBoundary) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PermissionsBoundary", 20))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPermissionsBoundary sets the PermissionsBoundary field's value.
+func (s *PutUserPermissionsBoundaryInput) SetPermissionsBoundary(v string) *PutUserPermissionsBoundaryInput {
+	s.PermissionsBoundary = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *PutUserPermissionsBoundaryInput) SetUserName(v string) *PutUserPermissionsBoundaryInput {
+	s.UserName = &v
+	return s
+}
+
+type PutUserPermissionsBoundaryOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutUserPermissionsBoundaryOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutUserPermissionsBoundaryOutput) GoString() string {
+	return s.String()
+}
+
+type PutUserPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The policy document.
+	//
+	// You must provide policies in JSON format in IAM. However, for AWS CloudFormation
+	// templates formatted in YAML, you can provide the policy in JSON or YAML format.
+	// AWS CloudFormation always converts a YAML policy to JSON format before submitting
+	// it to IAM.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// PolicyDocument is a required field
+	PolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// The name of the policy document.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// PolicyName is a required field
+	PolicyName *string `min:"1" type:"string" required:"true"`
+
+	// The name of the user to associate the policy with.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s PutUserPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutUserPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *PutUserPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "PutUserPolicyInput"}
+	if s.PolicyDocument == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyDocument"))
+	}
+	if s.PolicyDocument != nil && len(*s.PolicyDocument) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyDocument", 1))
+	}
+	if s.PolicyName == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyName"))
+	}
+	if s.PolicyName != nil && len(*s.PolicyName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyName", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *PutUserPolicyInput) SetPolicyDocument(v string) *PutUserPolicyInput {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetPolicyName sets the PolicyName field's value.
+func (s *PutUserPolicyInput) SetPolicyName(v string) *PutUserPolicyInput {
+	s.PolicyName = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *PutUserPolicyInput) SetUserName(v string) *PutUserPolicyInput {
+	s.UserName = &v
+	return s
+}
+
+type PutUserPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s PutUserPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s PutUserPolicyOutput) GoString() string {
+	return s.String()
+}
+
+type RemoveClientIDFromOpenIDConnectProviderInput struct {
+	_ struct{} `type:"structure"`
+
+	// The client ID (also known as audience) to remove from the IAM OIDC provider
+	// resource. For more information about client IDs, see CreateOpenIDConnectProvider.
+	//
+	// ClientID is a required field
+	ClientID *string `min:"1" type:"string" required:"true"`
+
+	// The Amazon Resource Name (ARN) of the IAM OIDC provider resource to remove
+	// the client ID from. You can get a list of OIDC provider ARNs by using the
+	// ListOpenIDConnectProviders operation.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// OpenIDConnectProviderArn is a required field
+	OpenIDConnectProviderArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s RemoveClientIDFromOpenIDConnectProviderInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RemoveClientIDFromOpenIDConnectProviderInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *RemoveClientIDFromOpenIDConnectProviderInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "RemoveClientIDFromOpenIDConnectProviderInput"}
+	if s.ClientID == nil {
+		invalidParams.Add(request.NewErrParamRequired("ClientID"))
+	}
+	if s.ClientID != nil && len(*s.ClientID) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ClientID", 1))
+	}
+	if s.OpenIDConnectProviderArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("OpenIDConnectProviderArn"))
+	}
+	if s.OpenIDConnectProviderArn != nil && len(*s.OpenIDConnectProviderArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("OpenIDConnectProviderArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetClientID sets the ClientID field's value.
+func (s *RemoveClientIDFromOpenIDConnectProviderInput) SetClientID(v string) *RemoveClientIDFromOpenIDConnectProviderInput {
+	s.ClientID = &v
+	return s
+}
+
+// SetOpenIDConnectProviderArn sets the OpenIDConnectProviderArn field's value.
+func (s *RemoveClientIDFromOpenIDConnectProviderInput) SetOpenIDConnectProviderArn(v string) *RemoveClientIDFromOpenIDConnectProviderInput {
+	s.OpenIDConnectProviderArn = &v
+	return s
+}
+
+type RemoveClientIDFromOpenIDConnectProviderOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s RemoveClientIDFromOpenIDConnectProviderOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RemoveClientIDFromOpenIDConnectProviderOutput) GoString() string {
+	return s.String()
+}
+
+type RemoveRoleFromInstanceProfileInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the instance profile to update.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// InstanceProfileName is a required field
+	InstanceProfileName *string `min:"1" type:"string" required:"true"`
+
+	// The name of the role to remove.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s RemoveRoleFromInstanceProfileInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RemoveRoleFromInstanceProfileInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *RemoveRoleFromInstanceProfileInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "RemoveRoleFromInstanceProfileInput"}
+	if s.InstanceProfileName == nil {
+		invalidParams.Add(request.NewErrParamRequired("InstanceProfileName"))
+	}
+	if s.InstanceProfileName != nil && len(*s.InstanceProfileName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("InstanceProfileName", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetInstanceProfileName sets the InstanceProfileName field's value.
+func (s *RemoveRoleFromInstanceProfileInput) SetInstanceProfileName(v string) *RemoveRoleFromInstanceProfileInput {
+	s.InstanceProfileName = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *RemoveRoleFromInstanceProfileInput) SetRoleName(v string) *RemoveRoleFromInstanceProfileInput {
+	s.RoleName = &v
+	return s
+}
+
+type RemoveRoleFromInstanceProfileOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s RemoveRoleFromInstanceProfileOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RemoveRoleFromInstanceProfileOutput) GoString() string {
+	return s.String()
+}
+
+type RemoveUserFromGroupInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the group to update.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// The name of the user to remove.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s RemoveUserFromGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RemoveUserFromGroupInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *RemoveUserFromGroupInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "RemoveUserFromGroupInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *RemoveUserFromGroupInput) SetGroupName(v string) *RemoveUserFromGroupInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *RemoveUserFromGroupInput) SetUserName(v string) *RemoveUserFromGroupInput {
+	s.UserName = &v
+	return s
+}
+
+type RemoveUserFromGroupOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s RemoveUserFromGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RemoveUserFromGroupOutput) GoString() string {
+	return s.String()
+}
+
+type ResetServiceSpecificCredentialInput struct {
+	_ struct{} `type:"structure"`
+
+	// The unique identifier of the service-specific credential.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// ServiceSpecificCredentialId is a required field
+	ServiceSpecificCredentialId *string `min:"20" type:"string" required:"true"`
+
+	// The name of the IAM user associated with the service-specific credential.
+	// If this value is not specified, then the operation assumes the user whose
+	// credentials are used to call the operation.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s ResetServiceSpecificCredentialInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetServiceSpecificCredentialInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ResetServiceSpecificCredentialInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ResetServiceSpecificCredentialInput"}
+	if s.ServiceSpecificCredentialId == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServiceSpecificCredentialId"))
+	}
+	if s.ServiceSpecificCredentialId != nil && len(*s.ServiceSpecificCredentialId) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("ServiceSpecificCredentialId", 20))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetServiceSpecificCredentialId sets the ServiceSpecificCredentialId field's value.
+func (s *ResetServiceSpecificCredentialInput) SetServiceSpecificCredentialId(v string) *ResetServiceSpecificCredentialInput {
+	s.ServiceSpecificCredentialId = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ResetServiceSpecificCredentialInput) SetUserName(v string) *ResetServiceSpecificCredentialInput {
+	s.UserName = &v
+	return s
+}
+
+type ResetServiceSpecificCredentialOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure with details about the updated service-specific credential, including
+	// the new password.
+	//
+	// This is the only time that you can access the password. You cannot recover
+	// the password later, but you can reset it again.
+	ServiceSpecificCredential *ServiceSpecificCredential `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResetServiceSpecificCredentialOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResetServiceSpecificCredentialOutput) GoString() string {
+	return s.String()
+}
+
+// SetServiceSpecificCredential sets the ServiceSpecificCredential field's value.
+func (s *ResetServiceSpecificCredentialOutput) SetServiceSpecificCredential(v *ServiceSpecificCredential) *ResetServiceSpecificCredentialOutput {
+	s.ServiceSpecificCredential = v
+	return s
+}
+
+// Contains the result of the simulation of a single API operation call on a
+// single resource.
+//
+// This data type is used by a member of the EvaluationResult data type.
+type ResourceSpecificResult struct {
+	_ struct{} `type:"structure"`
+
+	// Additional details about the results of the evaluation decision. When there
+	// are both IAM policies and resource policies, this parameter explains how
+	// each set of policies contributes to the final evaluation decision. When simulating
+	// cross-account access to a resource, both the resource-based policy and the
+	// caller's IAM policy must grant access.
+	EvalDecisionDetails map[string]*string `type:"map"`
+
+	// The result of the simulation of the simulated API operation on the resource
+	// specified in EvalResourceName.
+	//
+	// EvalResourceDecision is a required field
+	EvalResourceDecision *string `type:"string" required:"true" enum:"PolicyEvaluationDecisionType"`
+
+	// The name of the simulated resource, in Amazon Resource Name (ARN) format.
+	//
+	// EvalResourceName is a required field
+	EvalResourceName *string `min:"1" type:"string" required:"true"`
+
+	// A list of the statements in the input policies that determine the result
+	// for this part of the simulation. Remember that even if multiple statements
+	// allow the operation on the resource, if any statement denies that operation,
+	// then the explicit deny overrides any allow. In addition, the deny statement
+	// is the only entry included in the result.
+	MatchedStatements []*Statement `type:"list"`
+
+	// A list of context keys that are required by the included input policies but
+	// that were not provided by one of the input parameters. This list is used
+	// when a list of ARNs is included in the ResourceArns parameter instead of
+	// "*". If you do not specify individual resources, by setting ResourceArns
+	// to "*" or by not including the ResourceArns parameter, then any missing context
+	// values are instead included under the EvaluationResults section. To discover
+	// the context keys used by a set of policies, you can call GetContextKeysForCustomPolicy
+	// or GetContextKeysForPrincipalPolicy.
+	MissingContextValues []*string `type:"list"`
+}
+
+// String returns the string representation
+func (s ResourceSpecificResult) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResourceSpecificResult) GoString() string {
+	return s.String()
+}
+
+// SetEvalDecisionDetails sets the EvalDecisionDetails field's value.
+func (s *ResourceSpecificResult) SetEvalDecisionDetails(v map[string]*string) *ResourceSpecificResult {
+	s.EvalDecisionDetails = v
+	return s
+}
+
+// SetEvalResourceDecision sets the EvalResourceDecision field's value.
+func (s *ResourceSpecificResult) SetEvalResourceDecision(v string) *ResourceSpecificResult {
+	s.EvalResourceDecision = &v
+	return s
+}
+
+// SetEvalResourceName sets the EvalResourceName field's value.
+func (s *ResourceSpecificResult) SetEvalResourceName(v string) *ResourceSpecificResult {
+	s.EvalResourceName = &v
+	return s
+}
+
+// SetMatchedStatements sets the MatchedStatements field's value.
+func (s *ResourceSpecificResult) SetMatchedStatements(v []*Statement) *ResourceSpecificResult {
+	s.MatchedStatements = v
+	return s
+}
+
+// SetMissingContextValues sets the MissingContextValues field's value.
+func (s *ResourceSpecificResult) SetMissingContextValues(v []*string) *ResourceSpecificResult {
+	s.MissingContextValues = v
+	return s
+}
+
+type ResyncMFADeviceInput struct {
+	_ struct{} `type:"structure"`
+
+	// An authentication code emitted by the device.
+	//
+	// The format for this parameter is a sequence of six digits.
+	//
+	// AuthenticationCode1 is a required field
+	AuthenticationCode1 *string `min:"6" type:"string" required:"true"`
+
+	// A subsequent authentication code emitted by the device.
+	//
+	// The format for this parameter is a sequence of six digits.
+	//
+	// AuthenticationCode2 is a required field
+	AuthenticationCode2 *string `min:"6" type:"string" required:"true"`
+
+	// Serial number that uniquely identifies the MFA device.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// SerialNumber is a required field
+	SerialNumber *string `min:"9" type:"string" required:"true"`
+
+	// The name of the user whose MFA device you want to resynchronize.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ResyncMFADeviceInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResyncMFADeviceInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *ResyncMFADeviceInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "ResyncMFADeviceInput"}
+	if s.AuthenticationCode1 == nil {
+		invalidParams.Add(request.NewErrParamRequired("AuthenticationCode1"))
+	}
+	if s.AuthenticationCode1 != nil && len(*s.AuthenticationCode1) < 6 {
+		invalidParams.Add(request.NewErrParamMinLen("AuthenticationCode1", 6))
+	}
+	if s.AuthenticationCode2 == nil {
+		invalidParams.Add(request.NewErrParamRequired("AuthenticationCode2"))
+	}
+	if s.AuthenticationCode2 != nil && len(*s.AuthenticationCode2) < 6 {
+		invalidParams.Add(request.NewErrParamMinLen("AuthenticationCode2", 6))
+	}
+	if s.SerialNumber == nil {
+		invalidParams.Add(request.NewErrParamRequired("SerialNumber"))
+	}
+	if s.SerialNumber != nil && len(*s.SerialNumber) < 9 {
+		invalidParams.Add(request.NewErrParamMinLen("SerialNumber", 9))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAuthenticationCode1 sets the AuthenticationCode1 field's value.
+func (s *ResyncMFADeviceInput) SetAuthenticationCode1(v string) *ResyncMFADeviceInput {
+	s.AuthenticationCode1 = &v
+	return s
+}
+
+// SetAuthenticationCode2 sets the AuthenticationCode2 field's value.
+func (s *ResyncMFADeviceInput) SetAuthenticationCode2(v string) *ResyncMFADeviceInput {
+	s.AuthenticationCode2 = &v
+	return s
+}
+
+// SetSerialNumber sets the SerialNumber field's value.
+func (s *ResyncMFADeviceInput) SetSerialNumber(v string) *ResyncMFADeviceInput {
+	s.SerialNumber = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ResyncMFADeviceInput) SetUserName(v string) *ResyncMFADeviceInput {
+	s.UserName = &v
+	return s
+}
+
+type ResyncMFADeviceOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s ResyncMFADeviceOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ResyncMFADeviceOutput) GoString() string {
+	return s.String()
+}
+
+// Contains information about an IAM role. This structure is returned as a response
+// element in several API operations that interact with roles.
+type Role struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) specifying the role. For more information
+	// about ARNs and how to use them in policies, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the IAM User Guide guide.
+	//
+	// Arn is a required field
+	Arn *string `min:"20" type:"string" required:"true"`
+
+	// The policy that grants an entity permission to assume the role.
+	AssumeRolePolicyDocument *string `min:"1" type:"string"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the role was created.
+	//
+	// CreateDate is a required field
+	CreateDate *time.Time `type:"timestamp" required:"true"`
+
+	// A description of the role that you provide.
+	Description *string `type:"string"`
+
+	// The maximum session duration (in seconds) for the specified role. Anyone
+	// who uses the AWS CLI, or API to assume the role can specify the duration
+	// using the optional DurationSeconds API parameter or duration-seconds CLI
+	// parameter.
+	MaxSessionDuration *int64 `min:"3600" type:"integer"`
+
+	// The path to the role. For more information about paths, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// Path is a required field
+	Path *string `min:"1" type:"string" required:"true"`
+
+	// The ARN of the policy used to set the permissions boundary for the role.
+	//
+	// For more information about permissions boundaries, see Permissions Boundaries
+	// for IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)
+	// in the IAM User Guide.
+	PermissionsBoundary *AttachedPermissionsBoundary `type:"structure"`
+
+	// The stable and unique string identifying the role. For more information about
+	// IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// RoleId is a required field
+	RoleId *string `min:"16" type:"string" required:"true"`
+
+	// The friendly name that identifies the role.
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+
+	// A list of tags that are attached to the specified role. For more information
+	// about tagging, see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+	// in the IAM User Guide.
+	Tags []*Tag `type:"list"`
+}
+
+// String returns the string representation
+func (s Role) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Role) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *Role) SetArn(v string) *Role {
+	s.Arn = &v
+	return s
+}
+
+// SetAssumeRolePolicyDocument sets the AssumeRolePolicyDocument field's value.
+func (s *Role) SetAssumeRolePolicyDocument(v string) *Role {
+	s.AssumeRolePolicyDocument = &v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *Role) SetCreateDate(v time.Time) *Role {
+	s.CreateDate = &v
+	return s
+}
+
+// SetDescription sets the Description field's value.
+func (s *Role) SetDescription(v string) *Role {
+	s.Description = &v
+	return s
+}
+
+// SetMaxSessionDuration sets the MaxSessionDuration field's value.
+func (s *Role) SetMaxSessionDuration(v int64) *Role {
+	s.MaxSessionDuration = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *Role) SetPath(v string) *Role {
+	s.Path = &v
+	return s
+}
+
+// SetPermissionsBoundary sets the PermissionsBoundary field's value.
+func (s *Role) SetPermissionsBoundary(v *AttachedPermissionsBoundary) *Role {
+	s.PermissionsBoundary = v
+	return s
+}
+
+// SetRoleId sets the RoleId field's value.
+func (s *Role) SetRoleId(v string) *Role {
+	s.RoleId = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *Role) SetRoleName(v string) *Role {
+	s.RoleName = &v
+	return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *Role) SetTags(v []*Tag) *Role {
+	s.Tags = v
+	return s
+}
+
+// Contains information about an IAM role, including all of the role's policies.
+//
+// This data type is used as a response element in the GetAccountAuthorizationDetails
+// operation.
+type RoleDetail struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN). ARNs are unique identifiers for AWS resources.
+	//
+	// For more information about ARNs, go to Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	Arn *string `min:"20" type:"string"`
+
+	// The trust policy that grants permission to assume the role.
+	AssumeRolePolicyDocument *string `min:"1" type:"string"`
+
+	// A list of managed policies attached to the role. These policies are the role's
+	// access (permissions) policies.
+	AttachedManagedPolicies []*AttachedPolicy `type:"list"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the role was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// A list of instance profiles that contain this role.
+	InstanceProfileList []*InstanceProfile `type:"list"`
+
+	// The path to the role. For more information about paths, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	Path *string `min:"1" type:"string"`
+
+	// The ARN of the policy used to set the permissions boundary for the role.
+	//
+	// For more information about permissions boundaries, see Permissions Boundaries
+	// for IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)
+	// in the IAM User Guide.
+	PermissionsBoundary *AttachedPermissionsBoundary `type:"structure"`
+
+	// The stable and unique string identifying the role. For more information about
+	// IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	RoleId *string `min:"16" type:"string"`
+
+	// The friendly name that identifies the role.
+	RoleName *string `min:"1" type:"string"`
+
+	// A list of inline policies embedded in the role. These policies are the role's
+	// access (permissions) policies.
+	RolePolicyList []*PolicyDetail `type:"list"`
+
+	// A list of tags that are attached to the specified role. For more information
+	// about tagging, see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+	// in the IAM User Guide.
+	Tags []*Tag `type:"list"`
+}
+
+// String returns the string representation
+func (s RoleDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RoleDetail) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *RoleDetail) SetArn(v string) *RoleDetail {
+	s.Arn = &v
+	return s
+}
+
+// SetAssumeRolePolicyDocument sets the AssumeRolePolicyDocument field's value.
+func (s *RoleDetail) SetAssumeRolePolicyDocument(v string) *RoleDetail {
+	s.AssumeRolePolicyDocument = &v
+	return s
+}
+
+// SetAttachedManagedPolicies sets the AttachedManagedPolicies field's value.
+func (s *RoleDetail) SetAttachedManagedPolicies(v []*AttachedPolicy) *RoleDetail {
+	s.AttachedManagedPolicies = v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *RoleDetail) SetCreateDate(v time.Time) *RoleDetail {
+	s.CreateDate = &v
+	return s
+}
+
+// SetInstanceProfileList sets the InstanceProfileList field's value.
+func (s *RoleDetail) SetInstanceProfileList(v []*InstanceProfile) *RoleDetail {
+	s.InstanceProfileList = v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *RoleDetail) SetPath(v string) *RoleDetail {
+	s.Path = &v
+	return s
+}
+
+// SetPermissionsBoundary sets the PermissionsBoundary field's value.
+func (s *RoleDetail) SetPermissionsBoundary(v *AttachedPermissionsBoundary) *RoleDetail {
+	s.PermissionsBoundary = v
+	return s
+}
+
+// SetRoleId sets the RoleId field's value.
+func (s *RoleDetail) SetRoleId(v string) *RoleDetail {
+	s.RoleId = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *RoleDetail) SetRoleName(v string) *RoleDetail {
+	s.RoleName = &v
+	return s
+}
+
+// SetRolePolicyList sets the RolePolicyList field's value.
+func (s *RoleDetail) SetRolePolicyList(v []*PolicyDetail) *RoleDetail {
+	s.RolePolicyList = v
+	return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *RoleDetail) SetTags(v []*Tag) *RoleDetail {
+	s.Tags = v
+	return s
+}
+
+// An object that contains details about how a service-linked role is used,
+// if that information is returned by the service.
+//
+// This data type is used as a response element in the GetServiceLinkedRoleDeletionStatus
+// operation.
+type RoleUsageType struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the Region where the service-linked role is being used.
+	Region *string `min:"1" type:"string"`
+
+	// The name of the resource that is using the service-linked role.
+	Resources []*string `type:"list"`
+}
+
+// String returns the string representation
+func (s RoleUsageType) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s RoleUsageType) GoString() string {
+	return s.String()
+}
+
+// SetRegion sets the Region field's value.
+func (s *RoleUsageType) SetRegion(v string) *RoleUsageType {
+	s.Region = &v
+	return s
+}
+
+// SetResources sets the Resources field's value.
+func (s *RoleUsageType) SetResources(v []*string) *RoleUsageType {
+	s.Resources = v
+	return s
+}
+
+// Contains the list of SAML providers for this account.
+type SAMLProviderListEntry struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the SAML provider.
+	Arn *string `min:"20" type:"string"`
+
+	// The date and time when the SAML provider was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// The expiration date and time for the SAML provider.
+	ValidUntil *time.Time `type:"timestamp"`
+}
+
+// String returns the string representation
+func (s SAMLProviderListEntry) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SAMLProviderListEntry) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *SAMLProviderListEntry) SetArn(v string) *SAMLProviderListEntry {
+	s.Arn = &v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *SAMLProviderListEntry) SetCreateDate(v time.Time) *SAMLProviderListEntry {
+	s.CreateDate = &v
+	return s
+}
+
+// SetValidUntil sets the ValidUntil field's value.
+func (s *SAMLProviderListEntry) SetValidUntil(v time.Time) *SAMLProviderListEntry {
+	s.ValidUntil = &v
+	return s
+}
+
+// Contains information about an SSH public key.
+//
+// This data type is used as a response element in the GetSSHPublicKey and UploadSSHPublicKey
+// operations.
+type SSHPublicKey struct {
+	_ struct{} `type:"structure"`
+
+	// The MD5 message digest of the SSH public key.
+	//
+	// Fingerprint is a required field
+	Fingerprint *string `min:"48" type:"string" required:"true"`
+
+	// The SSH public key.
+	//
+	// SSHPublicKeyBody is a required field
+	SSHPublicKeyBody *string `min:"1" type:"string" required:"true"`
+
+	// The unique identifier for the SSH public key.
+	//
+	// SSHPublicKeyId is a required field
+	SSHPublicKeyId *string `min:"20" type:"string" required:"true"`
+
+	// The status of the SSH public key. Active means that the key can be used for
+	// authentication with an AWS CodeCommit repository. Inactive means that the
+	// key cannot be used.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the SSH public key was uploaded.
+	UploadDate *time.Time `type:"timestamp"`
+
+	// The name of the IAM user associated with the SSH public key.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s SSHPublicKey) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SSHPublicKey) GoString() string {
+	return s.String()
+}
+
+// SetFingerprint sets the Fingerprint field's value.
+func (s *SSHPublicKey) SetFingerprint(v string) *SSHPublicKey {
+	s.Fingerprint = &v
+	return s
+}
+
+// SetSSHPublicKeyBody sets the SSHPublicKeyBody field's value.
+func (s *SSHPublicKey) SetSSHPublicKeyBody(v string) *SSHPublicKey {
+	s.SSHPublicKeyBody = &v
+	return s
+}
+
+// SetSSHPublicKeyId sets the SSHPublicKeyId field's value.
+func (s *SSHPublicKey) SetSSHPublicKeyId(v string) *SSHPublicKey {
+	s.SSHPublicKeyId = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *SSHPublicKey) SetStatus(v string) *SSHPublicKey {
+	s.Status = &v
+	return s
+}
+
+// SetUploadDate sets the UploadDate field's value.
+func (s *SSHPublicKey) SetUploadDate(v time.Time) *SSHPublicKey {
+	s.UploadDate = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *SSHPublicKey) SetUserName(v string) *SSHPublicKey {
+	s.UserName = &v
+	return s
+}
+
+// Contains information about an SSH public key, without the key's body or fingerprint.
+//
+// This data type is used as a response element in the ListSSHPublicKeys operation.
+type SSHPublicKeyMetadata struct {
+	_ struct{} `type:"structure"`
+
+	// The unique identifier for the SSH public key.
+	//
+	// SSHPublicKeyId is a required field
+	SSHPublicKeyId *string `min:"20" type:"string" required:"true"`
+
+	// The status of the SSH public key. Active means that the key can be used for
+	// authentication with an AWS CodeCommit repository. Inactive means that the
+	// key cannot be used.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the SSH public key was uploaded.
+	//
+	// UploadDate is a required field
+	UploadDate *time.Time `type:"timestamp" required:"true"`
+
+	// The name of the IAM user associated with the SSH public key.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s SSHPublicKeyMetadata) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SSHPublicKeyMetadata) GoString() string {
+	return s.String()
+}
+
+// SetSSHPublicKeyId sets the SSHPublicKeyId field's value.
+func (s *SSHPublicKeyMetadata) SetSSHPublicKeyId(v string) *SSHPublicKeyMetadata {
+	s.SSHPublicKeyId = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *SSHPublicKeyMetadata) SetStatus(v string) *SSHPublicKeyMetadata {
+	s.Status = &v
+	return s
+}
+
+// SetUploadDate sets the UploadDate field's value.
+func (s *SSHPublicKeyMetadata) SetUploadDate(v time.Time) *SSHPublicKeyMetadata {
+	s.UploadDate = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *SSHPublicKeyMetadata) SetUserName(v string) *SSHPublicKeyMetadata {
+	s.UserName = &v
+	return s
+}
+
+// Contains information about a server certificate.
+//
+// This data type is used as a response element in the GetServerCertificate
+// operation.
+type ServerCertificate struct {
+	_ struct{} `type:"structure"`
+
+	// The contents of the public key certificate.
+	//
+	// CertificateBody is a required field
+	CertificateBody *string `min:"1" type:"string" required:"true"`
+
+	// The contents of the public key certificate chain.
+	CertificateChain *string `min:"1" type:"string"`
+
+	// The meta information of the server certificate, such as its name, path, ID,
+	// and ARN.
+	//
+	// ServerCertificateMetadata is a required field
+	ServerCertificateMetadata *ServerCertificateMetadata `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s ServerCertificate) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ServerCertificate) GoString() string {
+	return s.String()
+}
+
+// SetCertificateBody sets the CertificateBody field's value.
+func (s *ServerCertificate) SetCertificateBody(v string) *ServerCertificate {
+	s.CertificateBody = &v
+	return s
+}
+
+// SetCertificateChain sets the CertificateChain field's value.
+func (s *ServerCertificate) SetCertificateChain(v string) *ServerCertificate {
+	s.CertificateChain = &v
+	return s
+}
+
+// SetServerCertificateMetadata sets the ServerCertificateMetadata field's value.
+func (s *ServerCertificate) SetServerCertificateMetadata(v *ServerCertificateMetadata) *ServerCertificate {
+	s.ServerCertificateMetadata = v
+	return s
+}
+
+// Contains information about a server certificate without its certificate body,
+// certificate chain, and private key.
+//
+// This data type is used as a response element in the UploadServerCertificate
+// and ListServerCertificates operations.
+type ServerCertificateMetadata struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) specifying the server certificate. For more
+	// information about ARNs and how to use them in policies, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// Arn is a required field
+	Arn *string `min:"20" type:"string" required:"true"`
+
+	// The date on which the certificate is set to expire.
+	Expiration *time.Time `type:"timestamp"`
+
+	// The path to the server certificate. For more information about paths, see
+	// IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// Path is a required field
+	Path *string `min:"1" type:"string" required:"true"`
+
+	// The stable and unique string identifying the server certificate. For more
+	// information about IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// ServerCertificateId is a required field
+	ServerCertificateId *string `min:"16" type:"string" required:"true"`
+
+	// The name that identifies the server certificate.
+	//
+	// ServerCertificateName is a required field
+	ServerCertificateName *string `min:"1" type:"string" required:"true"`
+
+	// The date when the server certificate was uploaded.
+	UploadDate *time.Time `type:"timestamp"`
+}
+
+// String returns the string representation
+func (s ServerCertificateMetadata) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ServerCertificateMetadata) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *ServerCertificateMetadata) SetArn(v string) *ServerCertificateMetadata {
+	s.Arn = &v
+	return s
+}
+
+// SetExpiration sets the Expiration field's value.
+func (s *ServerCertificateMetadata) SetExpiration(v time.Time) *ServerCertificateMetadata {
+	s.Expiration = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *ServerCertificateMetadata) SetPath(v string) *ServerCertificateMetadata {
+	s.Path = &v
+	return s
+}
+
+// SetServerCertificateId sets the ServerCertificateId field's value.
+func (s *ServerCertificateMetadata) SetServerCertificateId(v string) *ServerCertificateMetadata {
+	s.ServerCertificateId = &v
+	return s
+}
+
+// SetServerCertificateName sets the ServerCertificateName field's value.
+func (s *ServerCertificateMetadata) SetServerCertificateName(v string) *ServerCertificateMetadata {
+	s.ServerCertificateName = &v
+	return s
+}
+
+// SetUploadDate sets the UploadDate field's value.
+func (s *ServerCertificateMetadata) SetUploadDate(v time.Time) *ServerCertificateMetadata {
+	s.UploadDate = &v
+	return s
+}
+
+// Contains details about the most recent attempt to access the service.
+//
+// This data type is used as a response element in the GetServiceLastAccessedDetails
+// operation.
+type ServiceLastAccessed struct {
+	_ struct{} `type:"structure"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when an authenticated entity most recently attempted to access the service.
+	// AWS does not report unauthenticated requests.
+	//
+	// This field is null if no IAM entities attempted to access the service within
+	// the reporting period (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#service-last-accessed-reporting-period).
+	LastAuthenticated *time.Time `type:"timestamp"`
+
+	// The ARN of the authenticated entity (user or role) that last attempted to
+	// access the service. AWS does not report unauthenticated requests.
+	//
+	// This field is null if no IAM entities attempted to access the service within
+	// the reporting period (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#service-last-accessed-reporting-period).
+	LastAuthenticatedEntity *string `min:"20" type:"string"`
+
+	// The name of the service in which access was attempted.
+	//
+	// ServiceName is a required field
+	ServiceName *string `type:"string" required:"true"`
+
+	// The namespace of the service in which access was attempted.
+	//
+	// To learn the service namespace of a service, go to Actions, Resources, and
+	// Condition Keys for AWS Services (https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_actions-resources-contextkeys.html)
+	// in the IAM User Guide. Choose the name of the service to view details for
+	// that service. In the first paragraph, find the service prefix. For example,
+	// (service prefix: a4b). For more information about service namespaces, see
+	// AWS Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces)
+	// in the AWS General Reference.
+	//
+	// ServiceNamespace is a required field
+	ServiceNamespace *string `min:"1" type:"string" required:"true"`
+
+	// The total number of authenticated principals (root user, IAM users, or IAM
+	// roles) that have attempted to access the service.
+	//
+	// This field is null if no principals attempted to access the service within
+	// the reporting period (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_access-advisor.html#service-last-accessed-reporting-period).
+	TotalAuthenticatedEntities *int64 `type:"integer"`
+}
+
+// String returns the string representation
+func (s ServiceLastAccessed) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ServiceLastAccessed) GoString() string {
+	return s.String()
+}
+
+// SetLastAuthenticated sets the LastAuthenticated field's value.
+func (s *ServiceLastAccessed) SetLastAuthenticated(v time.Time) *ServiceLastAccessed {
+	s.LastAuthenticated = &v
+	return s
+}
+
+// SetLastAuthenticatedEntity sets the LastAuthenticatedEntity field's value.
+func (s *ServiceLastAccessed) SetLastAuthenticatedEntity(v string) *ServiceLastAccessed {
+	s.LastAuthenticatedEntity = &v
+	return s
+}
+
+// SetServiceName sets the ServiceName field's value.
+func (s *ServiceLastAccessed) SetServiceName(v string) *ServiceLastAccessed {
+	s.ServiceName = &v
+	return s
+}
+
+// SetServiceNamespace sets the ServiceNamespace field's value.
+func (s *ServiceLastAccessed) SetServiceNamespace(v string) *ServiceLastAccessed {
+	s.ServiceNamespace = &v
+	return s
+}
+
+// SetTotalAuthenticatedEntities sets the TotalAuthenticatedEntities field's value.
+func (s *ServiceLastAccessed) SetTotalAuthenticatedEntities(v int64) *ServiceLastAccessed {
+	s.TotalAuthenticatedEntities = &v
+	return s
+}
+
+// Contains the details of a service-specific credential.
+type ServiceSpecificCredential struct {
+	_ struct{} `type:"structure"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the service-specific credential were created.
+	//
+	// CreateDate is a required field
+	CreateDate *time.Time `type:"timestamp" required:"true"`
+
+	// The name of the service associated with the service-specific credential.
+	//
+	// ServiceName is a required field
+	ServiceName *string `type:"string" required:"true"`
+
+	// The generated password for the service-specific credential.
+	//
+	// ServicePassword is a required field
+	ServicePassword *string `type:"string" required:"true" sensitive:"true"`
+
+	// The unique identifier for the service-specific credential.
+	//
+	// ServiceSpecificCredentialId is a required field
+	ServiceSpecificCredentialId *string `min:"20" type:"string" required:"true"`
+
+	// The generated user name for the service-specific credential. This value is
+	// generated by combining the IAM user's name combined with the ID number of
+	// the AWS account, as in jane-at-123456789012, for example. This value cannot
+	// be configured by the user.
+	//
+	// ServiceUserName is a required field
+	ServiceUserName *string `min:"17" type:"string" required:"true"`
+
+	// The status of the service-specific credential. Active means that the key
+	// is valid for API calls, while Inactive means it is not.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The name of the IAM user associated with the service-specific credential.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ServiceSpecificCredential) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ServiceSpecificCredential) GoString() string {
+	return s.String()
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *ServiceSpecificCredential) SetCreateDate(v time.Time) *ServiceSpecificCredential {
+	s.CreateDate = &v
+	return s
+}
+
+// SetServiceName sets the ServiceName field's value.
+func (s *ServiceSpecificCredential) SetServiceName(v string) *ServiceSpecificCredential {
+	s.ServiceName = &v
+	return s
+}
+
+// SetServicePassword sets the ServicePassword field's value.
+func (s *ServiceSpecificCredential) SetServicePassword(v string) *ServiceSpecificCredential {
+	s.ServicePassword = &v
+	return s
+}
+
+// SetServiceSpecificCredentialId sets the ServiceSpecificCredentialId field's value.
+func (s *ServiceSpecificCredential) SetServiceSpecificCredentialId(v string) *ServiceSpecificCredential {
+	s.ServiceSpecificCredentialId = &v
+	return s
+}
+
+// SetServiceUserName sets the ServiceUserName field's value.
+func (s *ServiceSpecificCredential) SetServiceUserName(v string) *ServiceSpecificCredential {
+	s.ServiceUserName = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *ServiceSpecificCredential) SetStatus(v string) *ServiceSpecificCredential {
+	s.Status = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ServiceSpecificCredential) SetUserName(v string) *ServiceSpecificCredential {
+	s.UserName = &v
+	return s
+}
+
+// Contains additional details about a service-specific credential.
+type ServiceSpecificCredentialMetadata struct {
+	_ struct{} `type:"structure"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the service-specific credential were created.
+	//
+	// CreateDate is a required field
+	CreateDate *time.Time `type:"timestamp" required:"true"`
+
+	// The name of the service associated with the service-specific credential.
+	//
+	// ServiceName is a required field
+	ServiceName *string `type:"string" required:"true"`
+
+	// The unique identifier for the service-specific credential.
+	//
+	// ServiceSpecificCredentialId is a required field
+	ServiceSpecificCredentialId *string `min:"20" type:"string" required:"true"`
+
+	// The generated user name for the service-specific credential.
+	//
+	// ServiceUserName is a required field
+	ServiceUserName *string `min:"17" type:"string" required:"true"`
+
+	// The status of the service-specific credential. Active means that the key
+	// is valid for API calls, while Inactive means it is not.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The name of the IAM user associated with the service-specific credential.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s ServiceSpecificCredentialMetadata) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s ServiceSpecificCredentialMetadata) GoString() string {
+	return s.String()
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *ServiceSpecificCredentialMetadata) SetCreateDate(v time.Time) *ServiceSpecificCredentialMetadata {
+	s.CreateDate = &v
+	return s
+}
+
+// SetServiceName sets the ServiceName field's value.
+func (s *ServiceSpecificCredentialMetadata) SetServiceName(v string) *ServiceSpecificCredentialMetadata {
+	s.ServiceName = &v
+	return s
+}
+
+// SetServiceSpecificCredentialId sets the ServiceSpecificCredentialId field's value.
+func (s *ServiceSpecificCredentialMetadata) SetServiceSpecificCredentialId(v string) *ServiceSpecificCredentialMetadata {
+	s.ServiceSpecificCredentialId = &v
+	return s
+}
+
+// SetServiceUserName sets the ServiceUserName field's value.
+func (s *ServiceSpecificCredentialMetadata) SetServiceUserName(v string) *ServiceSpecificCredentialMetadata {
+	s.ServiceUserName = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *ServiceSpecificCredentialMetadata) SetStatus(v string) *ServiceSpecificCredentialMetadata {
+	s.Status = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *ServiceSpecificCredentialMetadata) SetUserName(v string) *ServiceSpecificCredentialMetadata {
+	s.UserName = &v
+	return s
+}
+
+type SetDefaultPolicyVersionInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM policy whose default version you
+	// want to set.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicyArn is a required field
+	PolicyArn *string `min:"20" type:"string" required:"true"`
+
+	// The version of the policy to set as the default (operative) version.
+	//
+	// For more information about managed policy versions, see Versioning for Managed
+	// Policies (https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-managed-versions.html)
+	// in the IAM User Guide.
+	//
+	// VersionId is a required field
+	VersionId *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s SetDefaultPolicyVersionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SetDefaultPolicyVersionInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *SetDefaultPolicyVersionInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "SetDefaultPolicyVersionInput"}
+	if s.PolicyArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyArn"))
+	}
+	if s.PolicyArn != nil && len(*s.PolicyArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyArn", 20))
+	}
+	if s.VersionId == nil {
+		invalidParams.Add(request.NewErrParamRequired("VersionId"))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyArn sets the PolicyArn field's value.
+func (s *SetDefaultPolicyVersionInput) SetPolicyArn(v string) *SetDefaultPolicyVersionInput {
+	s.PolicyArn = &v
+	return s
+}
+
+// SetVersionId sets the VersionId field's value.
+func (s *SetDefaultPolicyVersionInput) SetVersionId(v string) *SetDefaultPolicyVersionInput {
+	s.VersionId = &v
+	return s
+}
+
+type SetDefaultPolicyVersionOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s SetDefaultPolicyVersionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SetDefaultPolicyVersionOutput) GoString() string {
+	return s.String()
+}
+
+type SetSecurityTokenServicePreferencesInput struct {
+	_ struct{} `type:"structure"`
+
+	// The version of the global endpoint token. Version 1 tokens are valid only
+	// in AWS Regions that are available by default. These tokens do not work in
+	// manually enabled Regions, such as Asia Pacific (Hong Kong). Version 2 tokens
+	// are valid in all Regions. However, version 2 tokens are longer and might
+	// affect systems where you temporarily store tokens.
+	//
+	// For information, see Activating and Deactivating STS in an AWS Region (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
+	// in the IAM User Guide.
+	//
+	// GlobalEndpointTokenVersion is a required field
+	GlobalEndpointTokenVersion *string `type:"string" required:"true" enum:"globalEndpointTokenVersion"`
+}
+
+// String returns the string representation
+func (s SetSecurityTokenServicePreferencesInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SetSecurityTokenServicePreferencesInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *SetSecurityTokenServicePreferencesInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "SetSecurityTokenServicePreferencesInput"}
+	if s.GlobalEndpointTokenVersion == nil {
+		invalidParams.Add(request.NewErrParamRequired("GlobalEndpointTokenVersion"))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGlobalEndpointTokenVersion sets the GlobalEndpointTokenVersion field's value.
+func (s *SetSecurityTokenServicePreferencesInput) SetGlobalEndpointTokenVersion(v string) *SetSecurityTokenServicePreferencesInput {
+	s.GlobalEndpointTokenVersion = &v
+	return s
+}
+
+type SetSecurityTokenServicePreferencesOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s SetSecurityTokenServicePreferencesOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SetSecurityTokenServicePreferencesOutput) GoString() string {
+	return s.String()
+}
+
+// Contains information about an X.509 signing certificate.
+//
+// This data type is used as a response element in the UploadSigningCertificate
+// and ListSigningCertificates operations.
+type SigningCertificate struct {
+	_ struct{} `type:"structure"`
+
+	// The contents of the signing certificate.
+	//
+	// CertificateBody is a required field
+	CertificateBody *string `min:"1" type:"string" required:"true"`
+
+	// The ID for the signing certificate.
+	//
+	// CertificateId is a required field
+	CertificateId *string `min:"24" type:"string" required:"true"`
+
+	// The status of the signing certificate. Active means that the key is valid
+	// for API calls, while Inactive means it is not.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The date when the signing certificate was uploaded.
+	UploadDate *time.Time `type:"timestamp"`
+
+	// The name of the user the signing certificate is associated with.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s SigningCertificate) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SigningCertificate) GoString() string {
+	return s.String()
+}
+
+// SetCertificateBody sets the CertificateBody field's value.
+func (s *SigningCertificate) SetCertificateBody(v string) *SigningCertificate {
+	s.CertificateBody = &v
+	return s
+}
+
+// SetCertificateId sets the CertificateId field's value.
+func (s *SigningCertificate) SetCertificateId(v string) *SigningCertificate {
+	s.CertificateId = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *SigningCertificate) SetStatus(v string) *SigningCertificate {
+	s.Status = &v
+	return s
+}
+
+// SetUploadDate sets the UploadDate field's value.
+func (s *SigningCertificate) SetUploadDate(v time.Time) *SigningCertificate {
+	s.UploadDate = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *SigningCertificate) SetUserName(v string) *SigningCertificate {
+	s.UserName = &v
+	return s
+}
+
+type SimulateCustomPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of names of API operations to evaluate in the simulation. Each operation
+	// is evaluated against each resource. Each operation must include the service
+	// identifier, such as iam:CreateUser. This operation does not support using
+	// wildcards (*) in an action name.
+	//
+	// ActionNames is a required field
+	ActionNames []*string `type:"list" required:"true"`
+
+	// The ARN of the IAM user that you want to use as the simulated caller of the
+	// API operations. CallerArn is required if you include a ResourcePolicy so
+	// that the policy's Principal element has a value to use in evaluating the
+	// policy.
+	//
+	// You can specify only the ARN of an IAM user. You cannot specify the ARN of
+	// an assumed role, federated user, or a service principal.
+	CallerArn *string `min:"1" type:"string"`
+
+	// A list of context keys and corresponding values for the simulation to use.
+	// Whenever a context key is evaluated in one of the simulated IAM permissions
+	// policies, the corresponding value is supplied.
+	ContextEntries []*ContextEntry `type:"list"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// A list of policy documents to include in the simulation. Each document is
+	// specified as a string containing the complete, valid JSON text of an IAM
+	// policy. Do not include any resource-based policies in this parameter. Any
+	// resource-based policy must be submitted with the ResourcePolicy parameter.
+	// The policies cannot be "scope-down" policies, such as you could include in
+	// a call to GetFederationToken (https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetFederationToken.html)
+	// or one of the AssumeRole (https://docs.aws.amazon.com/IAM/latest/APIReference/API_AssumeRole.html)
+	// API operations. In other words, do not use policies designed to restrict
+	// what a user can do while using the temporary credentials.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// PolicyInputList is a required field
+	PolicyInputList []*string `type:"list" required:"true"`
+
+	// A list of ARNs of AWS resources to include in the simulation. If this parameter
+	// is not provided, then the value defaults to * (all resources). Each API in
+	// the ActionNames parameter is evaluated for each resource in this list. The
+	// simulation determines the access result (allowed or denied) of each combination
+	// and reports it in the response.
+	//
+	// The simulation does not automatically retrieve policies for the specified
+	// resources. If you want to include a resource policy in the simulation, then
+	// you must include the policy as a string in the ResourcePolicy parameter.
+	//
+	// If you include a ResourcePolicy, then it must be applicable to all of the
+	// resources included in the simulation or you receive an invalid input error.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	ResourceArns []*string `type:"list"`
+
+	// Specifies the type of simulation to run. Different API operations that support
+	// resource-based policies require different combinations of resources. By specifying
+	// the type of simulation to run, you enable the policy simulator to enforce
+	// the presence of the required resources to ensure reliable simulation results.
+	// If your simulation does not match one of the following scenarios, then you
+	// can omit this parameter. The following list shows each of the supported scenario
+	// values and the resources that you must define to run the simulation.
+	//
+	// Each of the EC2 scenarios requires that you specify instance, image, and
+	// security-group resources. If your scenario includes an EBS volume, then you
+	// must specify that volume as a resource. If the EC2 scenario includes VPC,
+	// then you must supply the network-interface resource. If it includes an IP
+	// subnet, then you must specify the subnet resource. For more information on
+	// the EC2 scenario options, see Supported Platforms (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-platforms.html)
+	// in the Amazon EC2 User Guide.
+	//
+	//    * EC2-Classic-InstanceStore instance, image, security-group
+	//
+	//    * EC2-Classic-EBS instance, image, security-group, volume
+	//
+	//    * EC2-VPC-InstanceStore instance, image, security-group, network-interface
+	//
+	//    * EC2-VPC-InstanceStore-Subnet instance, image, security-group, network-interface,
+	//    subnet
+	//
+	//    * EC2-VPC-EBS instance, image, security-group, network-interface, volume
+	//
+	//    * EC2-VPC-EBS-Subnet instance, image, security-group, network-interface,
+	//    subnet, volume
+	ResourceHandlingOption *string `min:"1" type:"string"`
+
+	// An ARN representing the AWS account ID that specifies the owner of any simulated
+	// resource that does not identify its owner in the resource ARN. Examples of
+	// resource ARNs include an S3 bucket or object. If ResourceOwner is specified,
+	// it is also used as the account owner of any ResourcePolicy included in the
+	// simulation. If the ResourceOwner parameter is not specified, then the owner
+	// of the resources and the resource policy defaults to the account of the identity
+	// provided in CallerArn. This parameter is required only if you specify a resource-based
+	// policy and account that owns the resource is different from the account that
+	// owns the simulated calling user CallerArn.
+	//
+	// The ARN for an account uses the following syntax: arn:aws:iam::AWS-account-ID:root.
+	// For example, to represent the account with the 112233445566 ID, use the following
+	// ARN: arn:aws:iam::112233445566-ID:root.
+	ResourceOwner *string `min:"1" type:"string"`
+
+	// A resource-based policy to include in the simulation provided as a string.
+	// Each resource in the simulation is treated as if it had this policy attached.
+	// You can include only one resource-based policy in a simulation.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	ResourcePolicy *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s SimulateCustomPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SimulateCustomPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *SimulateCustomPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "SimulateCustomPolicyInput"}
+	if s.ActionNames == nil {
+		invalidParams.Add(request.NewErrParamRequired("ActionNames"))
+	}
+	if s.CallerArn != nil && len(*s.CallerArn) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("CallerArn", 1))
+	}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PolicyInputList == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyInputList"))
+	}
+	if s.ResourceHandlingOption != nil && len(*s.ResourceHandlingOption) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ResourceHandlingOption", 1))
+	}
+	if s.ResourceOwner != nil && len(*s.ResourceOwner) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ResourceOwner", 1))
+	}
+	if s.ResourcePolicy != nil && len(*s.ResourcePolicy) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ResourcePolicy", 1))
+	}
+	if s.ContextEntries != nil {
+		for i, v := range s.ContextEntries {
+			if v == nil {
+				continue
+			}
+			if err := v.Validate(); err != nil {
+				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "ContextEntries", i), err.(request.ErrInvalidParams))
+			}
+		}
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetActionNames sets the ActionNames field's value.
+func (s *SimulateCustomPolicyInput) SetActionNames(v []*string) *SimulateCustomPolicyInput {
+	s.ActionNames = v
+	return s
+}
+
+// SetCallerArn sets the CallerArn field's value.
+func (s *SimulateCustomPolicyInput) SetCallerArn(v string) *SimulateCustomPolicyInput {
+	s.CallerArn = &v
+	return s
+}
+
+// SetContextEntries sets the ContextEntries field's value.
+func (s *SimulateCustomPolicyInput) SetContextEntries(v []*ContextEntry) *SimulateCustomPolicyInput {
+	s.ContextEntries = v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *SimulateCustomPolicyInput) SetMarker(v string) *SimulateCustomPolicyInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *SimulateCustomPolicyInput) SetMaxItems(v int64) *SimulateCustomPolicyInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPolicyInputList sets the PolicyInputList field's value.
+func (s *SimulateCustomPolicyInput) SetPolicyInputList(v []*string) *SimulateCustomPolicyInput {
+	s.PolicyInputList = v
+	return s
+}
+
+// SetResourceArns sets the ResourceArns field's value.
+func (s *SimulateCustomPolicyInput) SetResourceArns(v []*string) *SimulateCustomPolicyInput {
+	s.ResourceArns = v
+	return s
+}
+
+// SetResourceHandlingOption sets the ResourceHandlingOption field's value.
+func (s *SimulateCustomPolicyInput) SetResourceHandlingOption(v string) *SimulateCustomPolicyInput {
+	s.ResourceHandlingOption = &v
+	return s
+}
+
+// SetResourceOwner sets the ResourceOwner field's value.
+func (s *SimulateCustomPolicyInput) SetResourceOwner(v string) *SimulateCustomPolicyInput {
+	s.ResourceOwner = &v
+	return s
+}
+
+// SetResourcePolicy sets the ResourcePolicy field's value.
+func (s *SimulateCustomPolicyInput) SetResourcePolicy(v string) *SimulateCustomPolicyInput {
+	s.ResourcePolicy = &v
+	return s
+}
+
+// Contains the response to a successful SimulatePrincipalPolicy or SimulateCustomPolicy
+// request.
+type SimulatePolicyResponse struct {
+	_ struct{} `type:"structure"`
+
+	// The results of the simulation.
+	EvaluationResults []*EvaluationResult `type:"list"`
+
+	// A flag that indicates whether there are more items to return. If your results
+	// were truncated, you can make a subsequent pagination request using the Marker
+	// request parameter to retrieve more items. Note that IAM might return fewer
+	// than the MaxItems number of results even when there are more results available.
+	// We recommend that you check IsTruncated after every call to ensure that you
+	// receive all your results.
+	IsTruncated *bool `type:"boolean"`
+
+	// When IsTruncated is true, this element is present and contains the value
+	// to use for the Marker parameter in a subsequent pagination request.
+	Marker *string `type:"string"`
+}
+
+// String returns the string representation
+func (s SimulatePolicyResponse) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SimulatePolicyResponse) GoString() string {
+	return s.String()
+}
+
+// SetEvaluationResults sets the EvaluationResults field's value.
+func (s *SimulatePolicyResponse) SetEvaluationResults(v []*EvaluationResult) *SimulatePolicyResponse {
+	s.EvaluationResults = v
+	return s
+}
+
+// SetIsTruncated sets the IsTruncated field's value.
+func (s *SimulatePolicyResponse) SetIsTruncated(v bool) *SimulatePolicyResponse {
+	s.IsTruncated = &v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *SimulatePolicyResponse) SetMarker(v string) *SimulatePolicyResponse {
+	s.Marker = &v
+	return s
+}
+
+type SimulatePrincipalPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of names of API operations to evaluate in the simulation. Each operation
+	// is evaluated for each resource. Each operation must include the service identifier,
+	// such as iam:CreateUser.
+	//
+	// ActionNames is a required field
+	ActionNames []*string `type:"list" required:"true"`
+
+	// The ARN of the IAM user that you want to specify as the simulated caller
+	// of the API operations. If you do not specify a CallerArn, it defaults to
+	// the ARN of the user that you specify in PolicySourceArn, if you specified
+	// a user. If you include both a PolicySourceArn (for example, arn:aws:iam::123456789012:user/David)
+	// and a CallerArn (for example, arn:aws:iam::123456789012:user/Bob), the result
+	// is that you simulate calling the API operations as Bob, as if Bob had David's
+	// policies.
+	//
+	// You can specify only the ARN of an IAM user. You cannot specify the ARN of
+	// an assumed role, federated user, or a service principal.
+	//
+	// CallerArn is required if you include a ResourcePolicy and the PolicySourceArn
+	// is not the ARN for an IAM user. This is required so that the resource-based
+	// policy's Principal element has a value to use in evaluating the policy.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	CallerArn *string `min:"1" type:"string"`
+
+	// A list of context keys and corresponding values for the simulation to use.
+	// Whenever a context key is evaluated in one of the simulated IAM permissions
+	// policies, the corresponding value is supplied.
+	ContextEntries []*ContextEntry `type:"list"`
+
+	// Use this parameter only when paginating results and only after you receive
+	// a response indicating that the results are truncated. Set it to the value
+	// of the Marker element in the response that you received to indicate where
+	// the next call should start.
+	Marker *string `min:"1" type:"string"`
+
+	// Use this only when paginating results to indicate the maximum number of items
+	// you want in the response. If additional items exist beyond the maximum you
+	// specify, the IsTruncated response element is true.
+	//
+	// If you do not include this parameter, the number of items defaults to 100.
+	// Note that IAM might return fewer results, even when there are more results
+	// available. In that case, the IsTruncated response element returns true, and
+	// Marker contains a value to include in the subsequent call that tells the
+	// service where to continue from.
+	MaxItems *int64 `min:"1" type:"integer"`
+
+	// An optional list of additional policy documents to include in the simulation.
+	// Each document is specified as a string containing the complete, valid JSON
+	// text of an IAM policy.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	PolicyInputList []*string `type:"list"`
+
+	// The Amazon Resource Name (ARN) of a user, group, or role whose policies you
+	// want to include in the simulation. If you specify a user, group, or role,
+	// the simulation includes all policies that are associated with that entity.
+	// If you specify a user, the simulation also includes all policies that are
+	// attached to any groups the user belongs to.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// PolicySourceArn is a required field
+	PolicySourceArn *string `min:"20" type:"string" required:"true"`
+
+	// A list of ARNs of AWS resources to include in the simulation. If this parameter
+	// is not provided, then the value defaults to * (all resources). Each API in
+	// the ActionNames parameter is evaluated for each resource in this list. The
+	// simulation determines the access result (allowed or denied) of each combination
+	// and reports it in the response.
+	//
+	// The simulation does not automatically retrieve policies for the specified
+	// resources. If you want to include a resource policy in the simulation, then
+	// you must include the policy as a string in the ResourcePolicy parameter.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	ResourceArns []*string `type:"list"`
+
+	// Specifies the type of simulation to run. Different API operations that support
+	// resource-based policies require different combinations of resources. By specifying
+	// the type of simulation to run, you enable the policy simulator to enforce
+	// the presence of the required resources to ensure reliable simulation results.
+	// If your simulation does not match one of the following scenarios, then you
+	// can omit this parameter. The following list shows each of the supported scenario
+	// values and the resources that you must define to run the simulation.
+	//
+	// Each of the EC2 scenarios requires that you specify instance, image, and
+	// security group resources. If your scenario includes an EBS volume, then you
+	// must specify that volume as a resource. If the EC2 scenario includes VPC,
+	// then you must supply the network interface resource. If it includes an IP
+	// subnet, then you must specify the subnet resource. For more information on
+	// the EC2 scenario options, see Supported Platforms (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-platforms.html)
+	// in the Amazon EC2 User Guide.
+	//
+	//    * EC2-Classic-InstanceStore instance, image, security group
+	//
+	//    * EC2-Classic-EBS instance, image, security group, volume
+	//
+	//    * EC2-VPC-InstanceStore instance, image, security group, network interface
+	//
+	//    * EC2-VPC-InstanceStore-Subnet instance, image, security group, network
+	//    interface, subnet
+	//
+	//    * EC2-VPC-EBS instance, image, security group, network interface, volume
+	//
+	//    * EC2-VPC-EBS-Subnet instance, image, security group, network interface,
+	//    subnet, volume
+	ResourceHandlingOption *string `min:"1" type:"string"`
+
+	// An AWS account ID that specifies the owner of any simulated resource that
+	// does not identify its owner in the resource ARN. Examples of resource ARNs
+	// include an S3 bucket or object. If ResourceOwner is specified, it is also
+	// used as the account owner of any ResourcePolicy included in the simulation.
+	// If the ResourceOwner parameter is not specified, then the owner of the resources
+	// and the resource policy defaults to the account of the identity provided
+	// in CallerArn. This parameter is required only if you specify a resource-based
+	// policy and account that owns the resource is different from the account that
+	// owns the simulated calling user CallerArn.
+	ResourceOwner *string `min:"1" type:"string"`
+
+	// A resource-based policy to include in the simulation provided as a string.
+	// Each resource in the simulation is treated as if it had this policy attached.
+	// You can include only one resource-based policy in a simulation.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	ResourcePolicy *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s SimulatePrincipalPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s SimulatePrincipalPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *SimulatePrincipalPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "SimulatePrincipalPolicyInput"}
+	if s.ActionNames == nil {
+		invalidParams.Add(request.NewErrParamRequired("ActionNames"))
+	}
+	if s.CallerArn != nil && len(*s.CallerArn) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("CallerArn", 1))
+	}
+	if s.Marker != nil && len(*s.Marker) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Marker", 1))
+	}
+	if s.MaxItems != nil && *s.MaxItems < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxItems", 1))
+	}
+	if s.PolicySourceArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicySourceArn"))
+	}
+	if s.PolicySourceArn != nil && len(*s.PolicySourceArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicySourceArn", 20))
+	}
+	if s.ResourceHandlingOption != nil && len(*s.ResourceHandlingOption) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ResourceHandlingOption", 1))
+	}
+	if s.ResourceOwner != nil && len(*s.ResourceOwner) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ResourceOwner", 1))
+	}
+	if s.ResourcePolicy != nil && len(*s.ResourcePolicy) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ResourcePolicy", 1))
+	}
+	if s.ContextEntries != nil {
+		for i, v := range s.ContextEntries {
+			if v == nil {
+				continue
+			}
+			if err := v.Validate(); err != nil {
+				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "ContextEntries", i), err.(request.ErrInvalidParams))
+			}
+		}
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetActionNames sets the ActionNames field's value.
+func (s *SimulatePrincipalPolicyInput) SetActionNames(v []*string) *SimulatePrincipalPolicyInput {
+	s.ActionNames = v
+	return s
+}
+
+// SetCallerArn sets the CallerArn field's value.
+func (s *SimulatePrincipalPolicyInput) SetCallerArn(v string) *SimulatePrincipalPolicyInput {
+	s.CallerArn = &v
+	return s
+}
+
+// SetContextEntries sets the ContextEntries field's value.
+func (s *SimulatePrincipalPolicyInput) SetContextEntries(v []*ContextEntry) *SimulatePrincipalPolicyInput {
+	s.ContextEntries = v
+	return s
+}
+
+// SetMarker sets the Marker field's value.
+func (s *SimulatePrincipalPolicyInput) SetMarker(v string) *SimulatePrincipalPolicyInput {
+	s.Marker = &v
+	return s
+}
+
+// SetMaxItems sets the MaxItems field's value.
+func (s *SimulatePrincipalPolicyInput) SetMaxItems(v int64) *SimulatePrincipalPolicyInput {
+	s.MaxItems = &v
+	return s
+}
+
+// SetPolicyInputList sets the PolicyInputList field's value.
+func (s *SimulatePrincipalPolicyInput) SetPolicyInputList(v []*string) *SimulatePrincipalPolicyInput {
+	s.PolicyInputList = v
+	return s
+}
+
+// SetPolicySourceArn sets the PolicySourceArn field's value.
+func (s *SimulatePrincipalPolicyInput) SetPolicySourceArn(v string) *SimulatePrincipalPolicyInput {
+	s.PolicySourceArn = &v
+	return s
+}
+
+// SetResourceArns sets the ResourceArns field's value.
+func (s *SimulatePrincipalPolicyInput) SetResourceArns(v []*string) *SimulatePrincipalPolicyInput {
+	s.ResourceArns = v
+	return s
+}
+
+// SetResourceHandlingOption sets the ResourceHandlingOption field's value.
+func (s *SimulatePrincipalPolicyInput) SetResourceHandlingOption(v string) *SimulatePrincipalPolicyInput {
+	s.ResourceHandlingOption = &v
+	return s
+}
+
+// SetResourceOwner sets the ResourceOwner field's value.
+func (s *SimulatePrincipalPolicyInput) SetResourceOwner(v string) *SimulatePrincipalPolicyInput {
+	s.ResourceOwner = &v
+	return s
+}
+
+// SetResourcePolicy sets the ResourcePolicy field's value.
+func (s *SimulatePrincipalPolicyInput) SetResourcePolicy(v string) *SimulatePrincipalPolicyInput {
+	s.ResourcePolicy = &v
+	return s
+}
+
+// Contains a reference to a Statement element in a policy document that determines
+// the result of the simulation.
+//
+// This data type is used by the MatchedStatements member of the EvaluationResult
+// type.
+type Statement struct {
+	_ struct{} `type:"structure"`
+
+	// The row and column of the end of a Statement in an IAM policy.
+	EndPosition *Position `type:"structure"`
+
+	// The identifier of the policy that was provided as an input.
+	SourcePolicyId *string `type:"string"`
+
+	// The type of the policy.
+	SourcePolicyType *string `type:"string" enum:"PolicySourceType"`
+
+	// The row and column of the beginning of the Statement in an IAM policy.
+	StartPosition *Position `type:"structure"`
+}
+
+// String returns the string representation
+func (s Statement) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Statement) GoString() string {
+	return s.String()
+}
+
+// SetEndPosition sets the EndPosition field's value.
+func (s *Statement) SetEndPosition(v *Position) *Statement {
+	s.EndPosition = v
+	return s
+}
+
+// SetSourcePolicyId sets the SourcePolicyId field's value.
+func (s *Statement) SetSourcePolicyId(v string) *Statement {
+	s.SourcePolicyId = &v
+	return s
+}
+
+// SetSourcePolicyType sets the SourcePolicyType field's value.
+func (s *Statement) SetSourcePolicyType(v string) *Statement {
+	s.SourcePolicyType = &v
+	return s
+}
+
+// SetStartPosition sets the StartPosition field's value.
+func (s *Statement) SetStartPosition(v *Position) *Statement {
+	s.StartPosition = v
+	return s
+}
+
+// A structure that represents user-provided metadata that can be associated
+// with a resource such as an IAM user or role. For more information about tagging,
+// see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+// in the IAM User Guide.
+type Tag struct {
+	_ struct{} `type:"structure"`
+
+	// The key name that can be used to look up or retrieve the associated value.
+	// For example, Department or Cost Center are common choices.
+	//
+	// Key is a required field
+	Key *string `min:"1" type:"string" required:"true"`
+
+	// The value associated with this tag. For example, tags with a key name of
+	// Department could have values such as Human Resources, Accounting, and Support.
+	// Tags with a key name of Cost Center might have values that consist of the
+	// number associated with the different cost centers in your company. Typically,
+	// many resources have tags with the same key name but with different values.
+	//
+	// AWS always interprets the tag Value as a single string. If you need to store
+	// an array, you can store comma-separated values in the string. However, you
+	// must interpret the value in your code.
+	//
+	// Value is a required field
+	Value *string `type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s Tag) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s Tag) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *Tag) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "Tag"}
+	if s.Key == nil {
+		invalidParams.Add(request.NewErrParamRequired("Key"))
+	}
+	if s.Key != nil && len(*s.Key) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Key", 1))
+	}
+	if s.Value == nil {
+		invalidParams.Add(request.NewErrParamRequired("Value"))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetKey sets the Key field's value.
+func (s *Tag) SetKey(v string) *Tag {
+	s.Key = &v
+	return s
+}
+
+// SetValue sets the Value field's value.
+func (s *Tag) SetValue(v string) *Tag {
+	s.Value = &v
+	return s
+}
+
+type TagRoleInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the role that you want to add tags to.
+	//
+	// This parameter accepts (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that consist of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+
+	// The list of tags that you want to attach to the role. Each tag consists of
+	// a key name and an associated value. You can specify this with a JSON string.
+	//
+	// Tags is a required field
+	Tags []*Tag `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s TagRoleInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TagRoleInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *TagRoleInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "TagRoleInput"}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+	if s.Tags == nil {
+		invalidParams.Add(request.NewErrParamRequired("Tags"))
+	}
+	if s.Tags != nil {
+		for i, v := range s.Tags {
+			if v == nil {
+				continue
+			}
+			if err := v.Validate(); err != nil {
+				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
+			}
+		}
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *TagRoleInput) SetRoleName(v string) *TagRoleInput {
+	s.RoleName = &v
+	return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *TagRoleInput) SetTags(v []*Tag) *TagRoleInput {
+	s.Tags = v
+	return s
+}
+
+type TagRoleOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s TagRoleOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TagRoleOutput) GoString() string {
+	return s.String()
+}
+
+type TagUserInput struct {
+	_ struct{} `type:"structure"`
+
+	// The list of tags that you want to attach to the user. Each tag consists of
+	// a key name and an associated value.
+	//
+	// Tags is a required field
+	Tags []*Tag `type:"list" required:"true"`
+
+	// The name of the user that you want to add tags to.
+	//
+	// This parameter accepts (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that consist of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: =,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s TagUserInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TagUserInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *TagUserInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "TagUserInput"}
+	if s.Tags == nil {
+		invalidParams.Add(request.NewErrParamRequired("Tags"))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+	if s.Tags != nil {
+		for i, v := range s.Tags {
+			if v == nil {
+				continue
+			}
+			if err := v.Validate(); err != nil {
+				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(request.ErrInvalidParams))
+			}
+		}
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetTags sets the Tags field's value.
+func (s *TagUserInput) SetTags(v []*Tag) *TagUserInput {
+	s.Tags = v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *TagUserInput) SetUserName(v string) *TagUserInput {
+	s.UserName = &v
+	return s
+}
+
+type TagUserOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s TagUserOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s TagUserOutput) GoString() string {
+	return s.String()
+}
+
+type UntagRoleInput struct {
+	_ struct{} `type:"structure"`
+
+	// The name of the IAM role from which you want to remove tags.
+	//
+	// This parameter accepts (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that consist of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+
+	// A list of key names as a simple array of strings. The tags with matching
+	// keys are removed from the specified role.
+	//
+	// TagKeys is a required field
+	TagKeys []*string `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s UntagRoleInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UntagRoleInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UntagRoleInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UntagRoleInput"}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+	if s.TagKeys == nil {
+		invalidParams.Add(request.NewErrParamRequired("TagKeys"))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *UntagRoleInput) SetRoleName(v string) *UntagRoleInput {
+	s.RoleName = &v
+	return s
+}
+
+// SetTagKeys sets the TagKeys field's value.
+func (s *UntagRoleInput) SetTagKeys(v []*string) *UntagRoleInput {
+	s.TagKeys = v
+	return s
+}
+
+type UntagRoleOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UntagRoleOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UntagRoleOutput) GoString() string {
+	return s.String()
+}
+
+type UntagUserInput struct {
+	_ struct{} `type:"structure"`
+
+	// A list of key names as a simple array of strings. The tags with matching
+	// keys are removed from the specified user.
+	//
+	// TagKeys is a required field
+	TagKeys []*string `type:"list" required:"true"`
+
+	// The name of the IAM user from which you want to remove tags.
+	//
+	// This parameter accepts (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that consist of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: =,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UntagUserInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UntagUserInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UntagUserInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UntagUserInput"}
+	if s.TagKeys == nil {
+		invalidParams.Add(request.NewErrParamRequired("TagKeys"))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetTagKeys sets the TagKeys field's value.
+func (s *UntagUserInput) SetTagKeys(v []*string) *UntagUserInput {
+	s.TagKeys = v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UntagUserInput) SetUserName(v string) *UntagUserInput {
+	s.UserName = &v
+	return s
+}
+
+type UntagUserOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UntagUserOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UntagUserOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateAccessKeyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The access key ID of the secret access key you want to update.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// AccessKeyId is a required field
+	AccessKeyId *string `min:"16" type:"string" required:"true"`
+
+	// The status you want to assign to the secret access key. Active means that
+	// the key can be used for API calls to AWS, while Inactive means that the key
+	// cannot be used.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The name of the user whose key you want to update.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s UpdateAccessKeyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateAccessKeyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateAccessKeyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateAccessKeyInput"}
+	if s.AccessKeyId == nil {
+		invalidParams.Add(request.NewErrParamRequired("AccessKeyId"))
+	}
+	if s.AccessKeyId != nil && len(*s.AccessKeyId) < 16 {
+		invalidParams.Add(request.NewErrParamMinLen("AccessKeyId", 16))
+	}
+	if s.Status == nil {
+		invalidParams.Add(request.NewErrParamRequired("Status"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAccessKeyId sets the AccessKeyId field's value.
+func (s *UpdateAccessKeyInput) SetAccessKeyId(v string) *UpdateAccessKeyInput {
+	s.AccessKeyId = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *UpdateAccessKeyInput) SetStatus(v string) *UpdateAccessKeyInput {
+	s.Status = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UpdateAccessKeyInput) SetUserName(v string) *UpdateAccessKeyInput {
+	s.UserName = &v
+	return s
+}
+
+type UpdateAccessKeyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateAccessKeyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateAccessKeyOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateAccountPasswordPolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// Allows all IAM users in your account to use the AWS Management Console to
+	// change their own passwords. For more information, see Letting IAM Users Change
+	// Their Own Passwords (https://docs.aws.amazon.com/IAM/latest/UserGuide/HowToPwdIAMUser.html)
+	// in the IAM User Guide.
+	//
+	// If you do not specify a value for this parameter, then the operation uses
+	// the default value of false. The result is that IAM users in the account do
+	// not automatically have permissions to change their own password.
+	AllowUsersToChangePassword *bool `type:"boolean"`
+
+	// Prevents IAM users from setting a new password after their password has expired.
+	// The IAM user cannot be accessed until an administrator resets the password.
+	//
+	// If you do not specify a value for this parameter, then the operation uses
+	// the default value of false. The result is that IAM users can change their
+	// passwords after they expire and continue to sign in as the user.
+	HardExpiry *bool `type:"boolean"`
+
+	// The number of days that an IAM user password is valid.
+	//
+	// If you do not specify a value for this parameter, then the operation uses
+	// the default value of 0. The result is that IAM user passwords never expire.
+	MaxPasswordAge *int64 `min:"1" type:"integer"`
+
+	// The minimum number of characters allowed in an IAM user password.
+	//
+	// If you do not specify a value for this parameter, then the operation uses
+	// the default value of 6.
+	MinimumPasswordLength *int64 `min:"6" type:"integer"`
+
+	// Specifies the number of previous passwords that IAM users are prevented from
+	// reusing.
+	//
+	// If you do not specify a value for this parameter, then the operation uses
+	// the default value of 0. The result is that IAM users are not prevented from
+	// reusing previous passwords.
+	PasswordReusePrevention *int64 `min:"1" type:"integer"`
+
+	// Specifies whether IAM user passwords must contain at least one lowercase
+	// character from the ISO basic Latin alphabet (a to z).
+	//
+	// If you do not specify a value for this parameter, then the operation uses
+	// the default value of false. The result is that passwords do not require at
+	// least one lowercase character.
+	RequireLowercaseCharacters *bool `type:"boolean"`
+
+	// Specifies whether IAM user passwords must contain at least one numeric character
+	// (0 to 9).
+	//
+	// If you do not specify a value for this parameter, then the operation uses
+	// the default value of false. The result is that passwords do not require at
+	// least one numeric character.
+	RequireNumbers *bool `type:"boolean"`
+
+	// Specifies whether IAM user passwords must contain at least one of the following
+	// non-alphanumeric characters:
+	//
+	// ! @ # $ % ^ & * ( ) _ + - = [ ] { } | '
+	//
+	// If you do not specify a value for this parameter, then the operation uses
+	// the default value of false. The result is that passwords do not require at
+	// least one symbol character.
+	RequireSymbols *bool `type:"boolean"`
+
+	// Specifies whether IAM user passwords must contain at least one uppercase
+	// character from the ISO basic Latin alphabet (A to Z).
+	//
+	// If you do not specify a value for this parameter, then the operation uses
+	// the default value of false. The result is that passwords do not require at
+	// least one uppercase character.
+	RequireUppercaseCharacters *bool `type:"boolean"`
+}
+
+// String returns the string representation
+func (s UpdateAccountPasswordPolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateAccountPasswordPolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateAccountPasswordPolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateAccountPasswordPolicyInput"}
+	if s.MaxPasswordAge != nil && *s.MaxPasswordAge < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxPasswordAge", 1))
+	}
+	if s.MinimumPasswordLength != nil && *s.MinimumPasswordLength < 6 {
+		invalidParams.Add(request.NewErrParamMinValue("MinimumPasswordLength", 6))
+	}
+	if s.PasswordReusePrevention != nil && *s.PasswordReusePrevention < 1 {
+		invalidParams.Add(request.NewErrParamMinValue("PasswordReusePrevention", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetAllowUsersToChangePassword sets the AllowUsersToChangePassword field's value.
+func (s *UpdateAccountPasswordPolicyInput) SetAllowUsersToChangePassword(v bool) *UpdateAccountPasswordPolicyInput {
+	s.AllowUsersToChangePassword = &v
+	return s
+}
+
+// SetHardExpiry sets the HardExpiry field's value.
+func (s *UpdateAccountPasswordPolicyInput) SetHardExpiry(v bool) *UpdateAccountPasswordPolicyInput {
+	s.HardExpiry = &v
+	return s
+}
+
+// SetMaxPasswordAge sets the MaxPasswordAge field's value.
+func (s *UpdateAccountPasswordPolicyInput) SetMaxPasswordAge(v int64) *UpdateAccountPasswordPolicyInput {
+	s.MaxPasswordAge = &v
+	return s
+}
+
+// SetMinimumPasswordLength sets the MinimumPasswordLength field's value.
+func (s *UpdateAccountPasswordPolicyInput) SetMinimumPasswordLength(v int64) *UpdateAccountPasswordPolicyInput {
+	s.MinimumPasswordLength = &v
+	return s
+}
+
+// SetPasswordReusePrevention sets the PasswordReusePrevention field's value.
+func (s *UpdateAccountPasswordPolicyInput) SetPasswordReusePrevention(v int64) *UpdateAccountPasswordPolicyInput {
+	s.PasswordReusePrevention = &v
+	return s
+}
+
+// SetRequireLowercaseCharacters sets the RequireLowercaseCharacters field's value.
+func (s *UpdateAccountPasswordPolicyInput) SetRequireLowercaseCharacters(v bool) *UpdateAccountPasswordPolicyInput {
+	s.RequireLowercaseCharacters = &v
+	return s
+}
+
+// SetRequireNumbers sets the RequireNumbers field's value.
+func (s *UpdateAccountPasswordPolicyInput) SetRequireNumbers(v bool) *UpdateAccountPasswordPolicyInput {
+	s.RequireNumbers = &v
+	return s
+}
+
+// SetRequireSymbols sets the RequireSymbols field's value.
+func (s *UpdateAccountPasswordPolicyInput) SetRequireSymbols(v bool) *UpdateAccountPasswordPolicyInput {
+	s.RequireSymbols = &v
+	return s
+}
+
+// SetRequireUppercaseCharacters sets the RequireUppercaseCharacters field's value.
+func (s *UpdateAccountPasswordPolicyInput) SetRequireUppercaseCharacters(v bool) *UpdateAccountPasswordPolicyInput {
+	s.RequireUppercaseCharacters = &v
+	return s
+}
+
+type UpdateAccountPasswordPolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateAccountPasswordPolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateAccountPasswordPolicyOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateAssumeRolePolicyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The policy that grants an entity permission to assume the role.
+	//
+	// You must provide policies in JSON format in IAM. However, for AWS CloudFormation
+	// templates formatted in YAML, you can provide the policy in JSON or YAML format.
+	// AWS CloudFormation always converts a YAML policy to JSON format before submitting
+	// it to IAM.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// PolicyDocument is a required field
+	PolicyDocument *string `min:"1" type:"string" required:"true"`
+
+	// The name of the role to update with the new policy.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UpdateAssumeRolePolicyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateAssumeRolePolicyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateAssumeRolePolicyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateAssumeRolePolicyInput"}
+	if s.PolicyDocument == nil {
+		invalidParams.Add(request.NewErrParamRequired("PolicyDocument"))
+	}
+	if s.PolicyDocument != nil && len(*s.PolicyDocument) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PolicyDocument", 1))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPolicyDocument sets the PolicyDocument field's value.
+func (s *UpdateAssumeRolePolicyInput) SetPolicyDocument(v string) *UpdateAssumeRolePolicyInput {
+	s.PolicyDocument = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *UpdateAssumeRolePolicyInput) SetRoleName(v string) *UpdateAssumeRolePolicyInput {
+	s.RoleName = &v
+	return s
+}
+
+type UpdateAssumeRolePolicyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateAssumeRolePolicyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateAssumeRolePolicyOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateGroupInput struct {
+	_ struct{} `type:"structure"`
+
+	// Name of the IAM group to update. If you're changing the name of the group,
+	// this is the original name.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// GroupName is a required field
+	GroupName *string `min:"1" type:"string" required:"true"`
+
+	// New name for the IAM group. Only include this if changing the group's name.
+	//
+	// IAM user, group, role, and policy names must be unique within the account.
+	// Names are not distinguished by case. For example, you cannot create resources
+	// named both "MyResource" and "myresource".
+	NewGroupName *string `min:"1" type:"string"`
+
+	// New path for the IAM group. Only include this if changing the group's path.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	NewPath *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s UpdateGroupInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateGroupInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateGroupInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateGroupInput"}
+	if s.GroupName == nil {
+		invalidParams.Add(request.NewErrParamRequired("GroupName"))
+	}
+	if s.GroupName != nil && len(*s.GroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("GroupName", 1))
+	}
+	if s.NewGroupName != nil && len(*s.NewGroupName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("NewGroupName", 1))
+	}
+	if s.NewPath != nil && len(*s.NewPath) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("NewPath", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetGroupName sets the GroupName field's value.
+func (s *UpdateGroupInput) SetGroupName(v string) *UpdateGroupInput {
+	s.GroupName = &v
+	return s
+}
+
+// SetNewGroupName sets the NewGroupName field's value.
+func (s *UpdateGroupInput) SetNewGroupName(v string) *UpdateGroupInput {
+	s.NewGroupName = &v
+	return s
+}
+
+// SetNewPath sets the NewPath field's value.
+func (s *UpdateGroupInput) SetNewPath(v string) *UpdateGroupInput {
+	s.NewPath = &v
+	return s
+}
+
+type UpdateGroupOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateGroupOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateGroupOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateLoginProfileInput struct {
+	_ struct{} `type:"structure"`
+
+	// The new password for the specified IAM user.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// However, the format can be further restricted by the account administrator
+	// by setting a password policy on the AWS account. For more information, see
+	// UpdateAccountPasswordPolicy.
+	Password *string `min:"1" type:"string" sensitive:"true"`
+
+	// Allows this new password to be used only once by requiring the specified
+	// IAM user to set a new password on next sign-in.
+	PasswordResetRequired *bool `type:"boolean"`
+
+	// The name of the user whose password you want to update.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UpdateLoginProfileInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateLoginProfileInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateLoginProfileInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateLoginProfileInput"}
+	if s.Password != nil && len(*s.Password) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Password", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetPassword sets the Password field's value.
+func (s *UpdateLoginProfileInput) SetPassword(v string) *UpdateLoginProfileInput {
+	s.Password = &v
+	return s
+}
+
+// SetPasswordResetRequired sets the PasswordResetRequired field's value.
+func (s *UpdateLoginProfileInput) SetPasswordResetRequired(v bool) *UpdateLoginProfileInput {
+	s.PasswordResetRequired = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UpdateLoginProfileInput) SetUserName(v string) *UpdateLoginProfileInput {
+	s.UserName = &v
+	return s
+}
+
+type UpdateLoginProfileOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateLoginProfileOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateLoginProfileOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateOpenIDConnectProviderThumbprintInput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the IAM OIDC provider resource object for
+	// which you want to update the thumbprint. You can get a list of OIDC provider
+	// ARNs by using the ListOpenIDConnectProviders operation.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// OpenIDConnectProviderArn is a required field
+	OpenIDConnectProviderArn *string `min:"20" type:"string" required:"true"`
+
+	// A list of certificate thumbprints that are associated with the specified
+	// IAM OpenID Connect provider. For more information, see CreateOpenIDConnectProvider.
+	//
+	// ThumbprintList is a required field
+	ThumbprintList []*string `type:"list" required:"true"`
+}
+
+// String returns the string representation
+func (s UpdateOpenIDConnectProviderThumbprintInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateOpenIDConnectProviderThumbprintInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateOpenIDConnectProviderThumbprintInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateOpenIDConnectProviderThumbprintInput"}
+	if s.OpenIDConnectProviderArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("OpenIDConnectProviderArn"))
+	}
+	if s.OpenIDConnectProviderArn != nil && len(*s.OpenIDConnectProviderArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("OpenIDConnectProviderArn", 20))
+	}
+	if s.ThumbprintList == nil {
+		invalidParams.Add(request.NewErrParamRequired("ThumbprintList"))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetOpenIDConnectProviderArn sets the OpenIDConnectProviderArn field's value.
+func (s *UpdateOpenIDConnectProviderThumbprintInput) SetOpenIDConnectProviderArn(v string) *UpdateOpenIDConnectProviderThumbprintInput {
+	s.OpenIDConnectProviderArn = &v
+	return s
+}
+
+// SetThumbprintList sets the ThumbprintList field's value.
+func (s *UpdateOpenIDConnectProviderThumbprintInput) SetThumbprintList(v []*string) *UpdateOpenIDConnectProviderThumbprintInput {
+	s.ThumbprintList = v
+	return s
+}
+
+type UpdateOpenIDConnectProviderThumbprintOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateOpenIDConnectProviderThumbprintOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateOpenIDConnectProviderThumbprintOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateRoleDescriptionInput struct {
+	_ struct{} `type:"structure"`
+
+	// The new description that you want to apply to the specified role.
+	//
+	// Description is a required field
+	Description *string `type:"string" required:"true"`
+
+	// The name of the role that you want to modify.
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UpdateRoleDescriptionInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateRoleDescriptionInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateRoleDescriptionInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateRoleDescriptionInput"}
+	if s.Description == nil {
+		invalidParams.Add(request.NewErrParamRequired("Description"))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetDescription sets the Description field's value.
+func (s *UpdateRoleDescriptionInput) SetDescription(v string) *UpdateRoleDescriptionInput {
+	s.Description = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *UpdateRoleDescriptionInput) SetRoleName(v string) *UpdateRoleDescriptionInput {
+	s.RoleName = &v
+	return s
+}
+
+type UpdateRoleDescriptionOutput struct {
+	_ struct{} `type:"structure"`
+
+	// A structure that contains details about the modified role.
+	Role *Role `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateRoleDescriptionOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateRoleDescriptionOutput) GoString() string {
+	return s.String()
+}
+
+// SetRole sets the Role field's value.
+func (s *UpdateRoleDescriptionOutput) SetRole(v *Role) *UpdateRoleDescriptionOutput {
+	s.Role = v
+	return s
+}
+
+type UpdateRoleInput struct {
+	_ struct{} `type:"structure"`
+
+	// The new description that you want to apply to the specified role.
+	Description *string `type:"string"`
+
+	// The maximum session duration (in seconds) that you want to set for the specified
+	// role. If you do not specify a value for this setting, the default maximum
+	// of one hour is applied. This setting can have a value from 1 hour to 12 hours.
+	//
+	// Anyone who assumes the role from the AWS CLI or API can use the DurationSeconds
+	// API parameter or the duration-seconds CLI parameter to request a longer session.
+	// The MaxSessionDuration setting determines the maximum duration that can be
+	// requested using the DurationSeconds parameter. If users don't specify a value
+	// for the DurationSeconds parameter, their security credentials are valid for
+	// one hour by default. This applies when you use the AssumeRole* API operations
+	// or the assume-role* CLI operations but does not apply when you use those
+	// operations to create a console URL. For more information, see Using IAM Roles
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) in the
+	// IAM User Guide.
+	MaxSessionDuration *int64 `min:"3600" type:"integer"`
+
+	// The name of the role that you want to modify.
+	//
+	// RoleName is a required field
+	RoleName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UpdateRoleInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateRoleInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateRoleInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateRoleInput"}
+	if s.MaxSessionDuration != nil && *s.MaxSessionDuration < 3600 {
+		invalidParams.Add(request.NewErrParamMinValue("MaxSessionDuration", 3600))
+	}
+	if s.RoleName == nil {
+		invalidParams.Add(request.NewErrParamRequired("RoleName"))
+	}
+	if s.RoleName != nil && len(*s.RoleName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("RoleName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetDescription sets the Description field's value.
+func (s *UpdateRoleInput) SetDescription(v string) *UpdateRoleInput {
+	s.Description = &v
+	return s
+}
+
+// SetMaxSessionDuration sets the MaxSessionDuration field's value.
+func (s *UpdateRoleInput) SetMaxSessionDuration(v int64) *UpdateRoleInput {
+	s.MaxSessionDuration = &v
+	return s
+}
+
+// SetRoleName sets the RoleName field's value.
+func (s *UpdateRoleInput) SetRoleName(v string) *UpdateRoleInput {
+	s.RoleName = &v
+	return s
+}
+
+type UpdateRoleOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateRoleOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateRoleOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateSAMLProviderInput struct {
+	_ struct{} `type:"structure"`
+
+	// An XML document generated by an identity provider (IdP) that supports SAML
+	// 2.0. The document includes the issuer's name, expiration information, and
+	// keys that can be used to validate the SAML authentication response (assertions)
+	// that are received from the IdP. You must generate the metadata document using
+	// the identity management software that is used as your organization's IdP.
+	//
+	// SAMLMetadataDocument is a required field
+	SAMLMetadataDocument *string `min:"1000" type:"string" required:"true"`
+
+	// The Amazon Resource Name (ARN) of the SAML provider to update.
+	//
+	// For more information about ARNs, see Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	//
+	// SAMLProviderArn is a required field
+	SAMLProviderArn *string `min:"20" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UpdateSAMLProviderInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateSAMLProviderInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateSAMLProviderInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateSAMLProviderInput"}
+	if s.SAMLMetadataDocument == nil {
+		invalidParams.Add(request.NewErrParamRequired("SAMLMetadataDocument"))
+	}
+	if s.SAMLMetadataDocument != nil && len(*s.SAMLMetadataDocument) < 1000 {
+		invalidParams.Add(request.NewErrParamMinLen("SAMLMetadataDocument", 1000))
+	}
+	if s.SAMLProviderArn == nil {
+		invalidParams.Add(request.NewErrParamRequired("SAMLProviderArn"))
+	}
+	if s.SAMLProviderArn != nil && len(*s.SAMLProviderArn) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("SAMLProviderArn", 20))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetSAMLMetadataDocument sets the SAMLMetadataDocument field's value.
+func (s *UpdateSAMLProviderInput) SetSAMLMetadataDocument(v string) *UpdateSAMLProviderInput {
+	s.SAMLMetadataDocument = &v
+	return s
+}
+
+// SetSAMLProviderArn sets the SAMLProviderArn field's value.
+func (s *UpdateSAMLProviderInput) SetSAMLProviderArn(v string) *UpdateSAMLProviderInput {
+	s.SAMLProviderArn = &v
+	return s
+}
+
+// Contains the response to a successful UpdateSAMLProvider request.
+type UpdateSAMLProviderOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) of the SAML provider that was updated.
+	SAMLProviderArn *string `min:"20" type:"string"`
+}
+
+// String returns the string representation
+func (s UpdateSAMLProviderOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateSAMLProviderOutput) GoString() string {
+	return s.String()
+}
+
+// SetSAMLProviderArn sets the SAMLProviderArn field's value.
+func (s *UpdateSAMLProviderOutput) SetSAMLProviderArn(v string) *UpdateSAMLProviderOutput {
+	s.SAMLProviderArn = &v
+	return s
+}
+
+type UpdateSSHPublicKeyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The unique identifier for the SSH public key.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// SSHPublicKeyId is a required field
+	SSHPublicKeyId *string `min:"20" type:"string" required:"true"`
+
+	// The status to assign to the SSH public key. Active means that the key can
+	// be used for authentication with an AWS CodeCommit repository. Inactive means
+	// that the key cannot be used.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The name of the IAM user associated with the SSH public key.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UpdateSSHPublicKeyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateSSHPublicKeyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateSSHPublicKeyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateSSHPublicKeyInput"}
+	if s.SSHPublicKeyId == nil {
+		invalidParams.Add(request.NewErrParamRequired("SSHPublicKeyId"))
+	}
+	if s.SSHPublicKeyId != nil && len(*s.SSHPublicKeyId) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("SSHPublicKeyId", 20))
+	}
+	if s.Status == nil {
+		invalidParams.Add(request.NewErrParamRequired("Status"))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetSSHPublicKeyId sets the SSHPublicKeyId field's value.
+func (s *UpdateSSHPublicKeyInput) SetSSHPublicKeyId(v string) *UpdateSSHPublicKeyInput {
+	s.SSHPublicKeyId = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *UpdateSSHPublicKeyInput) SetStatus(v string) *UpdateSSHPublicKeyInput {
+	s.Status = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UpdateSSHPublicKeyInput) SetUserName(v string) *UpdateSSHPublicKeyInput {
+	s.UserName = &v
+	return s
+}
+
+type UpdateSSHPublicKeyOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateSSHPublicKeyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateSSHPublicKeyOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateServerCertificateInput struct {
+	_ struct{} `type:"structure"`
+
+	// The new path for the server certificate. Include this only if you are updating
+	// the server certificate's path.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	NewPath *string `min:"1" type:"string"`
+
+	// The new name for the server certificate. Include this only if you are updating
+	// the server certificate's name. The name of the certificate cannot contain
+	// any spaces.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	NewServerCertificateName *string `min:"1" type:"string"`
+
+	// The name of the server certificate that you want to update.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// ServerCertificateName is a required field
+	ServerCertificateName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UpdateServerCertificateInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateServerCertificateInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateServerCertificateInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateServerCertificateInput"}
+	if s.NewPath != nil && len(*s.NewPath) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("NewPath", 1))
+	}
+	if s.NewServerCertificateName != nil && len(*s.NewServerCertificateName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("NewServerCertificateName", 1))
+	}
+	if s.ServerCertificateName == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServerCertificateName"))
+	}
+	if s.ServerCertificateName != nil && len(*s.ServerCertificateName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ServerCertificateName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetNewPath sets the NewPath field's value.
+func (s *UpdateServerCertificateInput) SetNewPath(v string) *UpdateServerCertificateInput {
+	s.NewPath = &v
+	return s
+}
+
+// SetNewServerCertificateName sets the NewServerCertificateName field's value.
+func (s *UpdateServerCertificateInput) SetNewServerCertificateName(v string) *UpdateServerCertificateInput {
+	s.NewServerCertificateName = &v
+	return s
+}
+
+// SetServerCertificateName sets the ServerCertificateName field's value.
+func (s *UpdateServerCertificateInput) SetServerCertificateName(v string) *UpdateServerCertificateInput {
+	s.ServerCertificateName = &v
+	return s
+}
+
+type UpdateServerCertificateOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateServerCertificateOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateServerCertificateOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateServiceSpecificCredentialInput struct {
+	_ struct{} `type:"structure"`
+
+	// The unique identifier of the service-specific credential.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// ServiceSpecificCredentialId is a required field
+	ServiceSpecificCredentialId *string `min:"20" type:"string" required:"true"`
+
+	// The status to be assigned to the service-specific credential.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The name of the IAM user associated with the service-specific credential.
+	// If you do not specify this value, then the operation assumes the user whose
+	// credentials are used to call the operation.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s UpdateServiceSpecificCredentialInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateServiceSpecificCredentialInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateServiceSpecificCredentialInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateServiceSpecificCredentialInput"}
+	if s.ServiceSpecificCredentialId == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServiceSpecificCredentialId"))
+	}
+	if s.ServiceSpecificCredentialId != nil && len(*s.ServiceSpecificCredentialId) < 20 {
+		invalidParams.Add(request.NewErrParamMinLen("ServiceSpecificCredentialId", 20))
+	}
+	if s.Status == nil {
+		invalidParams.Add(request.NewErrParamRequired("Status"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetServiceSpecificCredentialId sets the ServiceSpecificCredentialId field's value.
+func (s *UpdateServiceSpecificCredentialInput) SetServiceSpecificCredentialId(v string) *UpdateServiceSpecificCredentialInput {
+	s.ServiceSpecificCredentialId = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *UpdateServiceSpecificCredentialInput) SetStatus(v string) *UpdateServiceSpecificCredentialInput {
+	s.Status = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UpdateServiceSpecificCredentialInput) SetUserName(v string) *UpdateServiceSpecificCredentialInput {
+	s.UserName = &v
+	return s
+}
+
+type UpdateServiceSpecificCredentialOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateServiceSpecificCredentialOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateServiceSpecificCredentialOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateSigningCertificateInput struct {
+	_ struct{} `type:"structure"`
+
+	// The ID of the signing certificate you want to update.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters that can consist of any upper or lowercased letter
+	// or digit.
+	//
+	// CertificateId is a required field
+	CertificateId *string `min:"24" type:"string" required:"true"`
+
+	// The status you want to assign to the certificate. Active means that the certificate
+	// can be used for API calls to AWS Inactive means that the certificate cannot
+	// be used.
+	//
+	// Status is a required field
+	Status *string `type:"string" required:"true" enum:"statusType"`
+
+	// The name of the IAM user the signing certificate belongs to.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s UpdateSigningCertificateInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateSigningCertificateInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateSigningCertificateInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateSigningCertificateInput"}
+	if s.CertificateId == nil {
+		invalidParams.Add(request.NewErrParamRequired("CertificateId"))
+	}
+	if s.CertificateId != nil && len(*s.CertificateId) < 24 {
+		invalidParams.Add(request.NewErrParamMinLen("CertificateId", 24))
+	}
+	if s.Status == nil {
+		invalidParams.Add(request.NewErrParamRequired("Status"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetCertificateId sets the CertificateId field's value.
+func (s *UpdateSigningCertificateInput) SetCertificateId(v string) *UpdateSigningCertificateInput {
+	s.CertificateId = &v
+	return s
+}
+
+// SetStatus sets the Status field's value.
+func (s *UpdateSigningCertificateInput) SetStatus(v string) *UpdateSigningCertificateInput {
+	s.Status = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UpdateSigningCertificateInput) SetUserName(v string) *UpdateSigningCertificateInput {
+	s.UserName = &v
+	return s
+}
+
+type UpdateSigningCertificateOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateSigningCertificateOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateSigningCertificateOutput) GoString() string {
+	return s.String()
+}
+
+type UpdateUserInput struct {
+	_ struct{} `type:"structure"`
+
+	// New path for the IAM user. Include this parameter only if you're changing
+	// the user's path.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	NewPath *string `min:"1" type:"string"`
+
+	// New name for the user. Include this parameter only if you're changing the
+	// user's name.
+	//
+	// IAM user, group, role, and policy names must be unique within the account.
+	// Names are not distinguished by case. For example, you cannot create resources
+	// named both "MyResource" and "myresource".
+	NewUserName *string `min:"1" type:"string"`
+
+	// Name of the user to update. If you're changing the name of the user, this
+	// is the original user name.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UpdateUserInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateUserInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UpdateUserInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UpdateUserInput"}
+	if s.NewPath != nil && len(*s.NewPath) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("NewPath", 1))
+	}
+	if s.NewUserName != nil && len(*s.NewUserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("NewUserName", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetNewPath sets the NewPath field's value.
+func (s *UpdateUserInput) SetNewPath(v string) *UpdateUserInput {
+	s.NewPath = &v
+	return s
+}
+
+// SetNewUserName sets the NewUserName field's value.
+func (s *UpdateUserInput) SetNewUserName(v string) *UpdateUserInput {
+	s.NewUserName = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UpdateUserInput) SetUserName(v string) *UpdateUserInput {
+	s.UserName = &v
+	return s
+}
+
+type UpdateUserOutput struct {
+	_ struct{} `type:"structure"`
+}
+
+// String returns the string representation
+func (s UpdateUserOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UpdateUserOutput) GoString() string {
+	return s.String()
+}
+
+type UploadSSHPublicKeyInput struct {
+	_ struct{} `type:"structure"`
+
+	// The SSH public key. The public key must be encoded in ssh-rsa format or PEM
+	// format. The minimum bit-length of the public key is 2048 bits. For example,
+	// you can generate a 2048-bit key, and the resulting PEM file is 1679 bytes
+	// long.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// SSHPublicKeyBody is a required field
+	SSHPublicKeyBody *string `min:"1" type:"string" required:"true"`
+
+	// The name of the IAM user to associate the SSH public key with.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UploadSSHPublicKeyInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadSSHPublicKeyInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UploadSSHPublicKeyInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UploadSSHPublicKeyInput"}
+	if s.SSHPublicKeyBody == nil {
+		invalidParams.Add(request.NewErrParamRequired("SSHPublicKeyBody"))
+	}
+	if s.SSHPublicKeyBody != nil && len(*s.SSHPublicKeyBody) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("SSHPublicKeyBody", 1))
+	}
+	if s.UserName == nil {
+		invalidParams.Add(request.NewErrParamRequired("UserName"))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetSSHPublicKeyBody sets the SSHPublicKeyBody field's value.
+func (s *UploadSSHPublicKeyInput) SetSSHPublicKeyBody(v string) *UploadSSHPublicKeyInput {
+	s.SSHPublicKeyBody = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UploadSSHPublicKeyInput) SetUserName(v string) *UploadSSHPublicKeyInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful UploadSSHPublicKey request.
+type UploadSSHPublicKeyOutput struct {
+	_ struct{} `type:"structure"`
+
+	// Contains information about the SSH public key.
+	SSHPublicKey *SSHPublicKey `type:"structure"`
+}
+
+// String returns the string representation
+func (s UploadSSHPublicKeyOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadSSHPublicKeyOutput) GoString() string {
+	return s.String()
+}
+
+// SetSSHPublicKey sets the SSHPublicKey field's value.
+func (s *UploadSSHPublicKeyOutput) SetSSHPublicKey(v *SSHPublicKey) *UploadSSHPublicKeyOutput {
+	s.SSHPublicKey = v
+	return s
+}
+
+type UploadServerCertificateInput struct {
+	_ struct{} `type:"structure"`
+
+	// The contents of the public key certificate in PEM-encoded format.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// CertificateBody is a required field
+	CertificateBody *string `min:"1" type:"string" required:"true"`
+
+	// The contents of the certificate chain. This is typically a concatenation
+	// of the PEM-encoded public key certificates of the chain.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	CertificateChain *string `min:"1" type:"string"`
+
+	// The path for the server certificate. For more information about paths, see
+	// IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the IAM User Guide.
+	//
+	// This parameter is optional. If it is not included, it defaults to a slash
+	// (/). This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of either a forward slash (/) by itself
+	// or a string that must begin and end with forward slashes. In addition, it
+	// can contain any ASCII character from the ! (\u0021) through the DEL character
+	// (\u007F), including most punctuation characters, digits, and upper and lowercased
+	// letters.
+	//
+	// If you are uploading a server certificate specifically for use with Amazon
+	// CloudFront distributions, you must specify a path using the path parameter.
+	// The path must begin with /cloudfront and must include a trailing slash (for
+	// example, /cloudfront/test/).
+	Path *string `min:"1" type:"string"`
+
+	// The contents of the private key in PEM-encoded format.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// PrivateKey is a required field
+	PrivateKey *string `min:"1" type:"string" required:"true" sensitive:"true"`
+
+	// The name for the server certificate. Do not include the path in this value.
+	// The name of the certificate cannot contain any spaces.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	//
+	// ServerCertificateName is a required field
+	ServerCertificateName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s UploadServerCertificateInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadServerCertificateInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UploadServerCertificateInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UploadServerCertificateInput"}
+	if s.CertificateBody == nil {
+		invalidParams.Add(request.NewErrParamRequired("CertificateBody"))
+	}
+	if s.CertificateBody != nil && len(*s.CertificateBody) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("CertificateBody", 1))
+	}
+	if s.CertificateChain != nil && len(*s.CertificateChain) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("CertificateChain", 1))
+	}
+	if s.Path != nil && len(*s.Path) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("Path", 1))
+	}
+	if s.PrivateKey == nil {
+		invalidParams.Add(request.NewErrParamRequired("PrivateKey"))
+	}
+	if s.PrivateKey != nil && len(*s.PrivateKey) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("PrivateKey", 1))
+	}
+	if s.ServerCertificateName == nil {
+		invalidParams.Add(request.NewErrParamRequired("ServerCertificateName"))
+	}
+	if s.ServerCertificateName != nil && len(*s.ServerCertificateName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("ServerCertificateName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetCertificateBody sets the CertificateBody field's value.
+func (s *UploadServerCertificateInput) SetCertificateBody(v string) *UploadServerCertificateInput {
+	s.CertificateBody = &v
+	return s
+}
+
+// SetCertificateChain sets the CertificateChain field's value.
+func (s *UploadServerCertificateInput) SetCertificateChain(v string) *UploadServerCertificateInput {
+	s.CertificateChain = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *UploadServerCertificateInput) SetPath(v string) *UploadServerCertificateInput {
+	s.Path = &v
+	return s
+}
+
+// SetPrivateKey sets the PrivateKey field's value.
+func (s *UploadServerCertificateInput) SetPrivateKey(v string) *UploadServerCertificateInput {
+	s.PrivateKey = &v
+	return s
+}
+
+// SetServerCertificateName sets the ServerCertificateName field's value.
+func (s *UploadServerCertificateInput) SetServerCertificateName(v string) *UploadServerCertificateInput {
+	s.ServerCertificateName = &v
+	return s
+}
+
+// Contains the response to a successful UploadServerCertificate request.
+type UploadServerCertificateOutput struct {
+	_ struct{} `type:"structure"`
+
+	// The meta information of the uploaded server certificate without its certificate
+	// body, certificate chain, and private key.
+	ServerCertificateMetadata *ServerCertificateMetadata `type:"structure"`
+}
+
+// String returns the string representation
+func (s UploadServerCertificateOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadServerCertificateOutput) GoString() string {
+	return s.String()
+}
+
+// SetServerCertificateMetadata sets the ServerCertificateMetadata field's value.
+func (s *UploadServerCertificateOutput) SetServerCertificateMetadata(v *ServerCertificateMetadata) *UploadServerCertificateOutput {
+	s.ServerCertificateMetadata = v
+	return s
+}
+
+type UploadSigningCertificateInput struct {
+	_ struct{} `type:"structure"`
+
+	// The contents of the signing certificate.
+	//
+	// The regex pattern (http://wikipedia.org/wiki/regex) used to validate this
+	// parameter is a string of characters consisting of the following:
+	//
+	//    * Any printable ASCII character ranging from the space character (\u0020)
+	//    through the end of the ASCII character range
+	//
+	//    * The printable characters in the Basic Latin and Latin-1 Supplement character
+	//    set (through \u00FF)
+	//
+	//    * The special characters tab (\u0009), line feed (\u000A), and carriage
+	//    return (\u000D)
+	//
+	// CertificateBody is a required field
+	CertificateBody *string `min:"1" type:"string" required:"true"`
+
+	// The name of the user the signing certificate is for.
+	//
+	// This parameter allows (through its regex pattern (http://wikipedia.org/wiki/regex))
+	// a string of characters consisting of upper and lowercase alphanumeric characters
+	// with no spaces. You can also include any of the following characters: _+=,.@-
+	UserName *string `min:"1" type:"string"`
+}
+
+// String returns the string representation
+func (s UploadSigningCertificateInput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadSigningCertificateInput) GoString() string {
+	return s.String()
+}
+
+// Validate inspects the fields of the type to determine if they are valid.
+func (s *UploadSigningCertificateInput) Validate() error {
+	invalidParams := request.ErrInvalidParams{Context: "UploadSigningCertificateInput"}
+	if s.CertificateBody == nil {
+		invalidParams.Add(request.NewErrParamRequired("CertificateBody"))
+	}
+	if s.CertificateBody != nil && len(*s.CertificateBody) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("CertificateBody", 1))
+	}
+	if s.UserName != nil && len(*s.UserName) < 1 {
+		invalidParams.Add(request.NewErrParamMinLen("UserName", 1))
+	}
+
+	if invalidParams.Len() > 0 {
+		return invalidParams
+	}
+	return nil
+}
+
+// SetCertificateBody sets the CertificateBody field's value.
+func (s *UploadSigningCertificateInput) SetCertificateBody(v string) *UploadSigningCertificateInput {
+	s.CertificateBody = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UploadSigningCertificateInput) SetUserName(v string) *UploadSigningCertificateInput {
+	s.UserName = &v
+	return s
+}
+
+// Contains the response to a successful UploadSigningCertificate request.
+type UploadSigningCertificateOutput struct {
+	_ struct{} `type:"structure"`
+
+	// Information about the certificate.
+	//
+	// Certificate is a required field
+	Certificate *SigningCertificate `type:"structure" required:"true"`
+}
+
+// String returns the string representation
+func (s UploadSigningCertificateOutput) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UploadSigningCertificateOutput) GoString() string {
+	return s.String()
+}
+
+// SetCertificate sets the Certificate field's value.
+func (s *UploadSigningCertificateOutput) SetCertificate(v *SigningCertificate) *UploadSigningCertificateOutput {
+	s.Certificate = v
+	return s
+}
+
+// Contains information about an IAM user entity.
+//
+// This data type is used as a response element in the following operations:
+//
+//    * CreateUser
+//
+//    * GetUser
+//
+//    * ListUsers
+type User struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN) that identifies the user. For more information
+	// about ARNs and how to use ARNs in policies, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// Arn is a required field
+	Arn *string `min:"20" type:"string" required:"true"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the user was created.
+	//
+	// CreateDate is a required field
+	CreateDate *time.Time `type:"timestamp" required:"true"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the user's password was last used to sign in to an AWS website. For
+	// a list of AWS websites that capture a user's last sign-in time, see the Credential
+	// Reports (https://docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html)
+	// topic in the Using IAM guide. If a password is used more than once in a five-minute
+	// span, only the first use is returned in this field. If the field is null
+	// (no value), then it indicates that they never signed in with a password.
+	// This can be because:
+	//
+	//    * The user never had a password.
+	//
+	//    * A password exists but has not been used since IAM started tracking this
+	//    information on October 20, 2014.
+	//
+	// A null value does not mean that the user never had a password. Also, if the
+	// user does not currently have a password, but had one in the past, then this
+	// field contains the date and time the most recent password was used.
+	//
+	// This value is returned only in the GetUser and ListUsers operations.
+	PasswordLastUsed *time.Time `type:"timestamp"`
+
+	// The path to the user. For more information about paths, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// Path is a required field
+	Path *string `min:"1" type:"string" required:"true"`
+
+	// The ARN of the policy used to set the permissions boundary for the user.
+	//
+	// For more information about permissions boundaries, see Permissions Boundaries
+	// for IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)
+	// in the IAM User Guide.
+	PermissionsBoundary *AttachedPermissionsBoundary `type:"structure"`
+
+	// A list of tags that are associated with the specified user. For more information
+	// about tagging, see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+	// in the IAM User Guide.
+	Tags []*Tag `type:"list"`
+
+	// The stable and unique string identifying the user. For more information about
+	// IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	//
+	// UserId is a required field
+	UserId *string `min:"16" type:"string" required:"true"`
+
+	// The friendly name identifying the user.
+	//
+	// UserName is a required field
+	UserName *string `min:"1" type:"string" required:"true"`
+}
+
+// String returns the string representation
+func (s User) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s User) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *User) SetArn(v string) *User {
+	s.Arn = &v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *User) SetCreateDate(v time.Time) *User {
+	s.CreateDate = &v
+	return s
+}
+
+// SetPasswordLastUsed sets the PasswordLastUsed field's value.
+func (s *User) SetPasswordLastUsed(v time.Time) *User {
+	s.PasswordLastUsed = &v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *User) SetPath(v string) *User {
+	s.Path = &v
+	return s
+}
+
+// SetPermissionsBoundary sets the PermissionsBoundary field's value.
+func (s *User) SetPermissionsBoundary(v *AttachedPermissionsBoundary) *User {
+	s.PermissionsBoundary = v
+	return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *User) SetTags(v []*Tag) *User {
+	s.Tags = v
+	return s
+}
+
+// SetUserId sets the UserId field's value.
+func (s *User) SetUserId(v string) *User {
+	s.UserId = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *User) SetUserName(v string) *User {
+	s.UserName = &v
+	return s
+}
+
+// Contains information about an IAM user, including all the user's policies
+// and all the IAM groups the user is in.
+//
+// This data type is used as a response element in the GetAccountAuthorizationDetails
+// operation.
+type UserDetail struct {
+	_ struct{} `type:"structure"`
+
+	// The Amazon Resource Name (ARN). ARNs are unique identifiers for AWS resources.
+	//
+	// For more information about ARNs, go to Amazon Resource Names (ARNs) and AWS
+	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+	// in the AWS General Reference.
+	Arn *string `min:"20" type:"string"`
+
+	// A list of the managed policies attached to the user.
+	AttachedManagedPolicies []*AttachedPolicy `type:"list"`
+
+	// The date and time, in ISO 8601 date-time format (http://www.iso.org/iso/iso8601),
+	// when the user was created.
+	CreateDate *time.Time `type:"timestamp"`
+
+	// A list of IAM groups that the user is in.
+	GroupList []*string `type:"list"`
+
+	// The path to the user. For more information about paths, see IAM Identifiers
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	Path *string `min:"1" type:"string"`
+
+	// The ARN of the policy used to set the permissions boundary for the user.
+	//
+	// For more information about permissions boundaries, see Permissions Boundaries
+	// for IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)
+	// in the IAM User Guide.
+	PermissionsBoundary *AttachedPermissionsBoundary `type:"structure"`
+
+	// A list of tags that are associated with the specified user. For more information
+	// about tagging, see Tagging IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)
+	// in the IAM User Guide.
+	Tags []*Tag `type:"list"`
+
+	// The stable and unique string identifying the user. For more information about
+	// IDs, see IAM Identifiers (https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html)
+	// in the Using IAM guide.
+	UserId *string `min:"16" type:"string"`
+
+	// The friendly name identifying the user.
+	UserName *string `min:"1" type:"string"`
+
+	// A list of the inline policies embedded in the user.
+	UserPolicyList []*PolicyDetail `type:"list"`
+}
+
+// String returns the string representation
+func (s UserDetail) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s UserDetail) GoString() string {
+	return s.String()
+}
+
+// SetArn sets the Arn field's value.
+func (s *UserDetail) SetArn(v string) *UserDetail {
+	s.Arn = &v
+	return s
+}
+
+// SetAttachedManagedPolicies sets the AttachedManagedPolicies field's value.
+func (s *UserDetail) SetAttachedManagedPolicies(v []*AttachedPolicy) *UserDetail {
+	s.AttachedManagedPolicies = v
+	return s
+}
+
+// SetCreateDate sets the CreateDate field's value.
+func (s *UserDetail) SetCreateDate(v time.Time) *UserDetail {
+	s.CreateDate = &v
+	return s
+}
+
+// SetGroupList sets the GroupList field's value.
+func (s *UserDetail) SetGroupList(v []*string) *UserDetail {
+	s.GroupList = v
+	return s
+}
+
+// SetPath sets the Path field's value.
+func (s *UserDetail) SetPath(v string) *UserDetail {
+	s.Path = &v
+	return s
+}
+
+// SetPermissionsBoundary sets the PermissionsBoundary field's value.
+func (s *UserDetail) SetPermissionsBoundary(v *AttachedPermissionsBoundary) *UserDetail {
+	s.PermissionsBoundary = v
+	return s
+}
+
+// SetTags sets the Tags field's value.
+func (s *UserDetail) SetTags(v []*Tag) *UserDetail {
+	s.Tags = v
+	return s
+}
+
+// SetUserId sets the UserId field's value.
+func (s *UserDetail) SetUserId(v string) *UserDetail {
+	s.UserId = &v
+	return s
+}
+
+// SetUserName sets the UserName field's value.
+func (s *UserDetail) SetUserName(v string) *UserDetail {
+	s.UserName = &v
+	return s
+}
+
+// SetUserPolicyList sets the UserPolicyList field's value.
+func (s *UserDetail) SetUserPolicyList(v []*PolicyDetail) *UserDetail {
+	s.UserPolicyList = v
+	return s
+}
+
+// Contains information about a virtual MFA device.
+type VirtualMFADevice struct {
+	_ struct{} `type:"structure"`
+
+	// The base32 seed defined as specified in RFC3548 (https://tools.ietf.org/html/rfc3548.txt).
+	// The Base32StringSeed is base64-encoded.
+	//
+	// Base32StringSeed is automatically base64 encoded/decoded by the SDK.
+	Base32StringSeed []byte `type:"blob" sensitive:"true"`
+
+	// The date and time on which the virtual MFA device was enabled.
+	EnableDate *time.Time `type:"timestamp"`
+
+	// A QR code PNG image that encodes otpauth://totp/$virtualMFADeviceName@$AccountName?secret=$Base32String
+	// where $virtualMFADeviceName is one of the create call arguments. AccountName
+	// is the user name if set (otherwise, the account ID otherwise), and Base32String
+	// is the seed in base32 format. The Base32String value is base64-encoded.
+	//
+	// QRCodePNG is automatically base64 encoded/decoded by the SDK.
+	QRCodePNG []byte `type:"blob" sensitive:"true"`
+
+	// The serial number associated with VirtualMFADevice.
+	//
+	// SerialNumber is a required field
+	SerialNumber *string `min:"9" type:"string" required:"true"`
+
+	// The IAM user associated with this virtual MFA device.
+	User *User `type:"structure"`
+}
+
+// String returns the string representation
+func (s VirtualMFADevice) String() string {
+	return awsutil.Prettify(s)
+}
+
+// GoString returns the string representation
+func (s VirtualMFADevice) GoString() string {
+	return s.String()
+}
+
+// SetBase32StringSeed sets the Base32StringSeed field's value.
+func (s *VirtualMFADevice) SetBase32StringSeed(v []byte) *VirtualMFADevice {
+	s.Base32StringSeed = v
+	return s
+}
+
+// SetEnableDate sets the EnableDate field's value.
+func (s *VirtualMFADevice) SetEnableDate(v time.Time) *VirtualMFADevice {
+	s.EnableDate = &v
+	return s
+}
+
+// SetQRCodePNG sets the QRCodePNG field's value.
+func (s *VirtualMFADevice) SetQRCodePNG(v []byte) *VirtualMFADevice {
+	s.QRCodePNG = v
+	return s
+}
+
+// SetSerialNumber sets the SerialNumber field's value.
+func (s *VirtualMFADevice) SetSerialNumber(v string) *VirtualMFADevice {
+	s.SerialNumber = &v
+	return s
+}
+
+// SetUser sets the User field's value.
+func (s *VirtualMFADevice) SetUser(v *User) *VirtualMFADevice {
+	s.User = v
+	return s
+}
+
+const (
+	// ContextKeyTypeEnumString is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumString = "string"
+
+	// ContextKeyTypeEnumStringList is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumStringList = "stringList"
+
+	// ContextKeyTypeEnumNumeric is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumNumeric = "numeric"
+
+	// ContextKeyTypeEnumNumericList is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumNumericList = "numericList"
+
+	// ContextKeyTypeEnumBoolean is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumBoolean = "boolean"
+
+	// ContextKeyTypeEnumBooleanList is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumBooleanList = "booleanList"
+
+	// ContextKeyTypeEnumIp is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumIp = "ip"
+
+	// ContextKeyTypeEnumIpList is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumIpList = "ipList"
+
+	// ContextKeyTypeEnumBinary is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumBinary = "binary"
+
+	// ContextKeyTypeEnumBinaryList is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumBinaryList = "binaryList"
+
+	// ContextKeyTypeEnumDate is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumDate = "date"
+
+	// ContextKeyTypeEnumDateList is a ContextKeyTypeEnum enum value
+	ContextKeyTypeEnumDateList = "dateList"
+)
+
+const (
+	// DeletionTaskStatusTypeSucceeded is a DeletionTaskStatusType enum value
+	DeletionTaskStatusTypeSucceeded = "SUCCEEDED"
+
+	// DeletionTaskStatusTypeInProgress is a DeletionTaskStatusType enum value
+	DeletionTaskStatusTypeInProgress = "IN_PROGRESS"
+
+	// DeletionTaskStatusTypeFailed is a DeletionTaskStatusType enum value
+	DeletionTaskStatusTypeFailed = "FAILED"
+
+	// DeletionTaskStatusTypeNotStarted is a DeletionTaskStatusType enum value
+	DeletionTaskStatusTypeNotStarted = "NOT_STARTED"
+)
+
+const (
+	// EntityTypeUser is a EntityType enum value
+	EntityTypeUser = "User"
+
+	// EntityTypeRole is a EntityType enum value
+	EntityTypeRole = "Role"
+
+	// EntityTypeGroup is a EntityType enum value
+	EntityTypeGroup = "Group"
+
+	// EntityTypeLocalManagedPolicy is a EntityType enum value
+	EntityTypeLocalManagedPolicy = "LocalManagedPolicy"
+
+	// EntityTypeAwsmanagedPolicy is a EntityType enum value
+	EntityTypeAwsmanagedPolicy = "AWSManagedPolicy"
+)
+
+const (
+	// PermissionsBoundaryAttachmentTypePermissionsBoundaryPolicy is a PermissionsBoundaryAttachmentType enum value
+	PermissionsBoundaryAttachmentTypePermissionsBoundaryPolicy = "PermissionsBoundaryPolicy"
+)
+
+const (
+	// PolicyEvaluationDecisionTypeAllowed is a PolicyEvaluationDecisionType enum value
+	PolicyEvaluationDecisionTypeAllowed = "allowed"
+
+	// PolicyEvaluationDecisionTypeExplicitDeny is a PolicyEvaluationDecisionType enum value
+	PolicyEvaluationDecisionTypeExplicitDeny = "explicitDeny"
+
+	// PolicyEvaluationDecisionTypeImplicitDeny is a PolicyEvaluationDecisionType enum value
+	PolicyEvaluationDecisionTypeImplicitDeny = "implicitDeny"
+)
+
+const (
+	// PolicySourceTypeUser is a PolicySourceType enum value
+	PolicySourceTypeUser = "user"
+
+	// PolicySourceTypeGroup is a PolicySourceType enum value
+	PolicySourceTypeGroup = "group"
+
+	// PolicySourceTypeRole is a PolicySourceType enum value
+	PolicySourceTypeRole = "role"
+
+	// PolicySourceTypeAwsManaged is a PolicySourceType enum value
+	PolicySourceTypeAwsManaged = "aws-managed"
+
+	// PolicySourceTypeUserManaged is a PolicySourceType enum value
+	PolicySourceTypeUserManaged = "user-managed"
+
+	// PolicySourceTypeResource is a PolicySourceType enum value
+	PolicySourceTypeResource = "resource"
+
+	// PolicySourceTypeNone is a PolicySourceType enum value
+	PolicySourceTypeNone = "none"
+)
+
+// The policy usage type that indicates whether the policy is used as a permissions
+// policy or as the permissions boundary for an entity.
+//
+// For more information about permissions boundaries, see Permissions Boundaries
+// for IAM Identities (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html)
+// in the IAM User Guide.
+const (
+	// PolicyUsageTypePermissionsPolicy is a PolicyUsageType enum value
+	PolicyUsageTypePermissionsPolicy = "PermissionsPolicy"
+
+	// PolicyUsageTypePermissionsBoundary is a PolicyUsageType enum value
+	PolicyUsageTypePermissionsBoundary = "PermissionsBoundary"
+)
+
+const (
+	// ReportFormatTypeTextCsv is a ReportFormatType enum value
+	ReportFormatTypeTextCsv = "text/csv"
+)
+
+const (
+	// ReportStateTypeStarted is a ReportStateType enum value
+	ReportStateTypeStarted = "STARTED"
+
+	// ReportStateTypeInprogress is a ReportStateType enum value
+	ReportStateTypeInprogress = "INPROGRESS"
+
+	// ReportStateTypeComplete is a ReportStateType enum value
+	ReportStateTypeComplete = "COMPLETE"
+)
+
+const (
+	// AssignmentStatusTypeAssigned is a assignmentStatusType enum value
+	AssignmentStatusTypeAssigned = "Assigned"
+
+	// AssignmentStatusTypeUnassigned is a assignmentStatusType enum value
+	AssignmentStatusTypeUnassigned = "Unassigned"
+
+	// AssignmentStatusTypeAny is a assignmentStatusType enum value
+	AssignmentStatusTypeAny = "Any"
+)
+
+const (
+	// EncodingTypeSsh is a encodingType enum value
+	EncodingTypeSsh = "SSH"
+
+	// EncodingTypePem is a encodingType enum value
+	EncodingTypePem = "PEM"
+)
+
+const (
+	// GlobalEndpointTokenVersionV1token is a globalEndpointTokenVersion enum value
+	GlobalEndpointTokenVersionV1token = "v1Token"
+
+	// GlobalEndpointTokenVersionV2token is a globalEndpointTokenVersion enum value
+	GlobalEndpointTokenVersionV2token = "v2Token"
+)
+
+const (
+	// JobStatusTypeInProgress is a jobStatusType enum value
+	JobStatusTypeInProgress = "IN_PROGRESS"
+
+	// JobStatusTypeCompleted is a jobStatusType enum value
+	JobStatusTypeCompleted = "COMPLETED"
+
+	// JobStatusTypeFailed is a jobStatusType enum value
+	JobStatusTypeFailed = "FAILED"
+)
+
+const (
+	// PolicyOwnerEntityTypeUser is a policyOwnerEntityType enum value
+	PolicyOwnerEntityTypeUser = "USER"
+
+	// PolicyOwnerEntityTypeRole is a policyOwnerEntityType enum value
+	PolicyOwnerEntityTypeRole = "ROLE"
+
+	// PolicyOwnerEntityTypeGroup is a policyOwnerEntityType enum value
+	PolicyOwnerEntityTypeGroup = "GROUP"
+)
+
+const (
+	// PolicyScopeTypeAll is a policyScopeType enum value
+	PolicyScopeTypeAll = "All"
+
+	// PolicyScopeTypeAws is a policyScopeType enum value
+	PolicyScopeTypeAws = "AWS"
+
+	// PolicyScopeTypeLocal is a policyScopeType enum value
+	PolicyScopeTypeLocal = "Local"
+)
+
+const (
+	// PolicyTypeInline is a policyType enum value
+	PolicyTypeInline = "INLINE"
+
+	// PolicyTypeManaged is a policyType enum value
+	PolicyTypeManaged = "MANAGED"
+)
+
+const (
+	// SortKeyTypeServiceNamespaceAscending is a sortKeyType enum value
+	SortKeyTypeServiceNamespaceAscending = "SERVICE_NAMESPACE_ASCENDING"
+
+	// SortKeyTypeServiceNamespaceDescending is a sortKeyType enum value
+	SortKeyTypeServiceNamespaceDescending = "SERVICE_NAMESPACE_DESCENDING"
+
+	// SortKeyTypeLastAuthenticatedTimeAscending is a sortKeyType enum value
+	SortKeyTypeLastAuthenticatedTimeAscending = "LAST_AUTHENTICATED_TIME_ASCENDING"
+
+	// SortKeyTypeLastAuthenticatedTimeDescending is a sortKeyType enum value
+	SortKeyTypeLastAuthenticatedTimeDescending = "LAST_AUTHENTICATED_TIME_DESCENDING"
+)
+
+const (
+	// StatusTypeActive is a statusType enum value
+	StatusTypeActive = "Active"
+
+	// StatusTypeInactive is a statusType enum value
+	StatusTypeInactive = "Inactive"
+)
+
+const (
+	// SummaryKeyTypeUsers is a summaryKeyType enum value
+	SummaryKeyTypeUsers = "Users"
+
+	// SummaryKeyTypeUsersQuota is a summaryKeyType enum value
+	SummaryKeyTypeUsersQuota = "UsersQuota"
+
+	// SummaryKeyTypeGroups is a summaryKeyType enum value
+	SummaryKeyTypeGroups = "Groups"
+
+	// SummaryKeyTypeGroupsQuota is a summaryKeyType enum value
+	SummaryKeyTypeGroupsQuota = "GroupsQuota"
+
+	// SummaryKeyTypeServerCertificates is a summaryKeyType enum value
+	SummaryKeyTypeServerCertificates = "ServerCertificates"
+
+	// SummaryKeyTypeServerCertificatesQuota is a summaryKeyType enum value
+	SummaryKeyTypeServerCertificatesQuota = "ServerCertificatesQuota"
+
+	// SummaryKeyTypeUserPolicySizeQuota is a summaryKeyType enum value
+	SummaryKeyTypeUserPolicySizeQuota = "UserPolicySizeQuota"
+
+	// SummaryKeyTypeGroupPolicySizeQuota is a summaryKeyType enum value
+	SummaryKeyTypeGroupPolicySizeQuota = "GroupPolicySizeQuota"
+
+	// SummaryKeyTypeGroupsPerUserQuota is a summaryKeyType enum value
+	SummaryKeyTypeGroupsPerUserQuota = "GroupsPerUserQuota"
+
+	// SummaryKeyTypeSigningCertificatesPerUserQuota is a summaryKeyType enum value
+	SummaryKeyTypeSigningCertificatesPerUserQuota = "SigningCertificatesPerUserQuota"
+
+	// SummaryKeyTypeAccessKeysPerUserQuota is a summaryKeyType enum value
+	SummaryKeyTypeAccessKeysPerUserQuota = "AccessKeysPerUserQuota"
+
+	// SummaryKeyTypeMfadevices is a summaryKeyType enum value
+	SummaryKeyTypeMfadevices = "MFADevices"
+
+	// SummaryKeyTypeMfadevicesInUse is a summaryKeyType enum value
+	SummaryKeyTypeMfadevicesInUse = "MFADevicesInUse"
+
+	// SummaryKeyTypeAccountMfaenabled is a summaryKeyType enum value
+	SummaryKeyTypeAccountMfaenabled = "AccountMFAEnabled"
+
+	// SummaryKeyTypeAccountAccessKeysPresent is a summaryKeyType enum value
+	SummaryKeyTypeAccountAccessKeysPresent = "AccountAccessKeysPresent"
+
+	// SummaryKeyTypeAccountSigningCertificatesPresent is a summaryKeyType enum value
+	SummaryKeyTypeAccountSigningCertificatesPresent = "AccountSigningCertificatesPresent"
+
+	// SummaryKeyTypeAttachedPoliciesPerGroupQuota is a summaryKeyType enum value
+	SummaryKeyTypeAttachedPoliciesPerGroupQuota = "AttachedPoliciesPerGroupQuota"
+
+	// SummaryKeyTypeAttachedPoliciesPerRoleQuota is a summaryKeyType enum value
+	SummaryKeyTypeAttachedPoliciesPerRoleQuota = "AttachedPoliciesPerRoleQuota"
+
+	// SummaryKeyTypeAttachedPoliciesPerUserQuota is a summaryKeyType enum value
+	SummaryKeyTypeAttachedPoliciesPerUserQuota = "AttachedPoliciesPerUserQuota"
+
+	// SummaryKeyTypePolicies is a summaryKeyType enum value
+	SummaryKeyTypePolicies = "Policies"
+
+	// SummaryKeyTypePoliciesQuota is a summaryKeyType enum value
+	SummaryKeyTypePoliciesQuota = "PoliciesQuota"
+
+	// SummaryKeyTypePolicySizeQuota is a summaryKeyType enum value
+	SummaryKeyTypePolicySizeQuota = "PolicySizeQuota"
+
+	// SummaryKeyTypePolicyVersionsInUse is a summaryKeyType enum value
+	SummaryKeyTypePolicyVersionsInUse = "PolicyVersionsInUse"
+
+	// SummaryKeyTypePolicyVersionsInUseQuota is a summaryKeyType enum value
+	SummaryKeyTypePolicyVersionsInUseQuota = "PolicyVersionsInUseQuota"
+
+	// SummaryKeyTypeVersionsPerPolicyQuota is a summaryKeyType enum value
+	SummaryKeyTypeVersionsPerPolicyQuota = "VersionsPerPolicyQuota"
+
+	// SummaryKeyTypeGlobalEndpointTokenVersion is a summaryKeyType enum value
+	SummaryKeyTypeGlobalEndpointTokenVersion = "GlobalEndpointTokenVersion"
+)
diff --git a/vendor/github.com/aws/aws-sdk-go/service/iam/doc.go b/vendor/github.com/aws/aws-sdk-go/service/iam/doc.go
new file mode 100644
index 000000000..0d709cd27
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/iam/doc.go
@@ -0,0 +1,80 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+// Package iam provides the client and types for making API
+// requests to AWS Identity and Access Management.
+//
+// AWS Identity and Access Management (IAM) is a web service that you can use
+// to manage users and user permissions under your AWS account. This guide provides
+// descriptions of IAM actions that you can call programmatically. For general
+// information about IAM, see AWS Identity and Access Management (IAM) (http://aws.amazon.com/iam/).
+// For the user guide for IAM, see Using IAM (https://docs.aws.amazon.com/IAM/latest/UserGuide/).
+//
+// AWS provides SDKs that consist of libraries and sample code for various programming
+// languages and platforms (Java, Ruby, .NET, iOS, Android, etc.). The SDKs
+// provide a convenient way to create programmatic access to IAM and AWS. For
+// example, the SDKs take care of tasks such as cryptographically signing requests
+// (see below), managing errors, and retrying requests automatically. For information
+// about the AWS SDKs, including how to download and install them, see the Tools
+// for Amazon Web Services (http://aws.amazon.com/tools/) page.
+//
+// We recommend that you use the AWS SDKs to make programmatic API calls to
+// IAM. However, you can also use the IAM Query API to make direct calls to
+// the IAM web service. To learn more about the IAM Query API, see Making Query
+// Requests (https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html)
+// in the Using IAM guide. IAM supports GET and POST requests for all actions.
+// That is, the API does not require you to use GET for some actions and POST
+// for others. However, GET requests are subject to the limitation size of a
+// URL. Therefore, for operations that require larger sizes, use a POST request.
+//
+// Signing Requests
+//
+// Requests must be signed using an access key ID and a secret access key. We
+// strongly recommend that you do not use your AWS account access key ID and
+// secret access key for everyday work with IAM. You can use the access key
+// ID and secret access key for an IAM user or you can use the AWS Security
+// Token Service to generate temporary security credentials and use those to
+// sign requests.
+//
+// To sign requests, we recommend that you use Signature Version 4 (https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
+// If you have an existing application that uses Signature Version 2, you do
+// not have to update it to use Signature Version 4. However, some operations
+// now require Signature Version 4. The documentation for operations that require
+// version 4 indicate this requirement.
+//
+// Additional Resources
+//
+// For more information, see the following:
+//
+//    * AWS Security Credentials (https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html).
+//    This topic provides general information about the types of credentials
+//    used for accessing AWS.
+//
+//    * IAM Best Practices (https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPractices.html).
+//    This topic presents a list of suggestions for using the IAM service to
+//    help secure your AWS resources.
+//
+//    * Signing AWS API Requests (https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html).
+//    This set of topics walk you through the process of signing a request using
+//    an access key ID and secret access key.
+//
+// See https://docs.aws.amazon.com/goto/WebAPI/iam-2010-05-08 for more information on this service.
+//
+// See iam package documentation for more information.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/iam/
+//
+// Using the Client
+//
+// To contact AWS Identity and Access Management with the SDK use the New function to create
+// a new service client. With that client you can make API requests to the service.
+// These clients are safe to use concurrently.
+//
+// See the SDK's documentation for more information on how to use the SDK.
+// https://docs.aws.amazon.com/sdk-for-go/api/
+//
+// See aws.Config documentation for more information on configuring SDK clients.
+// https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config
+//
+// See the AWS Identity and Access Management client IAM for more
+// information on creating client for this service.
+// https://docs.aws.amazon.com/sdk-for-go/api/service/iam/#New
+package iam
diff --git a/vendor/github.com/aws/aws-sdk-go/service/iam/errors.go b/vendor/github.com/aws/aws-sdk-go/service/iam/errors.go
new file mode 100644
index 000000000..30a85b3b4
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/iam/errors.go
@@ -0,0 +1,200 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package iam
+
+const (
+
+	// ErrCodeConcurrentModificationException for service response error code
+	// "ConcurrentModification".
+	//
+	// The request was rejected because multiple requests to change this object
+	// were submitted simultaneously. Wait a few minutes and submit your request
+	// again.
+	ErrCodeConcurrentModificationException = "ConcurrentModification"
+
+	// ErrCodeCredentialReportExpiredException for service response error code
+	// "ReportExpired".
+	//
+	// The request was rejected because the most recent credential report has expired.
+	// To generate a new credential report, use GenerateCredentialReport. For more
+	// information about credential report expiration, see Getting Credential Reports
+	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/credential-reports.html)
+	// in the IAM User Guide.
+	ErrCodeCredentialReportExpiredException = "ReportExpired"
+
+	// ErrCodeCredentialReportNotPresentException for service response error code
+	// "ReportNotPresent".
+	//
+	// The request was rejected because the credential report does not exist. To
+	// generate a credential report, use GenerateCredentialReport.
+	ErrCodeCredentialReportNotPresentException = "ReportNotPresent"
+
+	// ErrCodeCredentialReportNotReadyException for service response error code
+	// "ReportInProgress".
+	//
+	// The request was rejected because the credential report is still being generated.
+	ErrCodeCredentialReportNotReadyException = "ReportInProgress"
+
+	// ErrCodeDeleteConflictException for service response error code
+	// "DeleteConflict".
+	//
+	// The request was rejected because it attempted to delete a resource that has
+	// attached subordinate entities. The error message describes these entities.
+	ErrCodeDeleteConflictException = "DeleteConflict"
+
+	// ErrCodeDuplicateCertificateException for service response error code
+	// "DuplicateCertificate".
+	//
+	// The request was rejected because the same certificate is associated with
+	// an IAM user in the account.
+	ErrCodeDuplicateCertificateException = "DuplicateCertificate"
+
+	// ErrCodeDuplicateSSHPublicKeyException for service response error code
+	// "DuplicateSSHPublicKey".
+	//
+	// The request was rejected because the SSH public key is already associated
+	// with the specified IAM user.
+	ErrCodeDuplicateSSHPublicKeyException = "DuplicateSSHPublicKey"
+
+	// ErrCodeEntityAlreadyExistsException for service response error code
+	// "EntityAlreadyExists".
+	//
+	// The request was rejected because it attempted to create a resource that already
+	// exists.
+	ErrCodeEntityAlreadyExistsException = "EntityAlreadyExists"
+
+	// ErrCodeEntityTemporarilyUnmodifiableException for service response error code
+	// "EntityTemporarilyUnmodifiable".
+	//
+	// The request was rejected because it referenced an entity that is temporarily
+	// unmodifiable, such as a user name that was deleted and then recreated. The
+	// error indicates that the request is likely to succeed if you try again after
+	// waiting several minutes. The error message describes the entity.
+	ErrCodeEntityTemporarilyUnmodifiableException = "EntityTemporarilyUnmodifiable"
+
+	// ErrCodeInvalidAuthenticationCodeException for service response error code
+	// "InvalidAuthenticationCode".
+	//
+	// The request was rejected because the authentication code was not recognized.
+	// The error message describes the specific error.
+	ErrCodeInvalidAuthenticationCodeException = "InvalidAuthenticationCode"
+
+	// ErrCodeInvalidCertificateException for service response error code
+	// "InvalidCertificate".
+	//
+	// The request was rejected because the certificate is invalid.
+	ErrCodeInvalidCertificateException = "InvalidCertificate"
+
+	// ErrCodeInvalidInputException for service response error code
+	// "InvalidInput".
+	//
+	// The request was rejected because an invalid or out-of-range value was supplied
+	// for an input parameter.
+	ErrCodeInvalidInputException = "InvalidInput"
+
+	// ErrCodeInvalidPublicKeyException for service response error code
+	// "InvalidPublicKey".
+	//
+	// The request was rejected because the public key is malformed or otherwise
+	// invalid.
+	ErrCodeInvalidPublicKeyException = "InvalidPublicKey"
+
+	// ErrCodeInvalidUserTypeException for service response error code
+	// "InvalidUserType".
+	//
+	// The request was rejected because the type of user for the transaction was
+	// incorrect.
+	ErrCodeInvalidUserTypeException = "InvalidUserType"
+
+	// ErrCodeKeyPairMismatchException for service response error code
+	// "KeyPairMismatch".
+	//
+	// The request was rejected because the public key certificate and the private
+	// key do not match.
+	ErrCodeKeyPairMismatchException = "KeyPairMismatch"
+
+	// ErrCodeLimitExceededException for service response error code
+	// "LimitExceeded".
+	//
+	// The request was rejected because it attempted to create resources beyond
+	// the current AWS account limits. The error message describes the limit exceeded.
+	ErrCodeLimitExceededException = "LimitExceeded"
+
+	// ErrCodeMalformedCertificateException for service response error code
+	// "MalformedCertificate".
+	//
+	// The request was rejected because the certificate was malformed or expired.
+	// The error message describes the specific error.
+	ErrCodeMalformedCertificateException = "MalformedCertificate"
+
+	// ErrCodeMalformedPolicyDocumentException for service response error code
+	// "MalformedPolicyDocument".
+	//
+	// The request was rejected because the policy document was malformed. The error
+	// message describes the specific error.
+	ErrCodeMalformedPolicyDocumentException = "MalformedPolicyDocument"
+
+	// ErrCodeNoSuchEntityException for service response error code
+	// "NoSuchEntity".
+	//
+	// The request was rejected because it referenced a resource entity that does
+	// not exist. The error message describes the resource.
+	ErrCodeNoSuchEntityException = "NoSuchEntity"
+
+	// ErrCodePasswordPolicyViolationException for service response error code
+	// "PasswordPolicyViolation".
+	//
+	// The request was rejected because the provided password did not meet the requirements
+	// imposed by the account password policy.
+	ErrCodePasswordPolicyViolationException = "PasswordPolicyViolation"
+
+	// ErrCodePolicyEvaluationException for service response error code
+	// "PolicyEvaluation".
+	//
+	// The request failed because a provided policy could not be successfully evaluated.
+	// An additional detailed message indicates the source of the failure.
+	ErrCodePolicyEvaluationException = "PolicyEvaluation"
+
+	// ErrCodePolicyNotAttachableException for service response error code
+	// "PolicyNotAttachable".
+	//
+	// The request failed because AWS service role policies can only be attached
+	// to the service-linked role for that service.
+	ErrCodePolicyNotAttachableException = "PolicyNotAttachable"
+
+	// ErrCodeReportGenerationLimitExceededException for service response error code
+	// "ReportGenerationLimitExceeded".
+	//
+	// The request failed because the maximum number of concurrent requests for
+	// this account are already running.
+	ErrCodeReportGenerationLimitExceededException = "ReportGenerationLimitExceeded"
+
+	// ErrCodeServiceFailureException for service response error code
+	// "ServiceFailure".
+	//
+	// The request processing has failed because of an unknown error, exception
+	// or failure.
+	ErrCodeServiceFailureException = "ServiceFailure"
+
+	// ErrCodeServiceNotSupportedException for service response error code
+	// "NotSupportedService".
+	//
+	// The specified service does not support service-specific credentials.
+	ErrCodeServiceNotSupportedException = "NotSupportedService"
+
+	// ErrCodeUnmodifiableEntityException for service response error code
+	// "UnmodifiableEntity".
+	//
+	// The request was rejected because only the service that depends on the service-linked
+	// role can modify or delete the role on your behalf. The error message includes
+	// the name of the service that depends on this service-linked role. You must
+	// request the change through that service.
+	ErrCodeUnmodifiableEntityException = "UnmodifiableEntity"
+
+	// ErrCodeUnrecognizedPublicKeyEncodingException for service response error code
+	// "UnrecognizedPublicKeyEncoding".
+	//
+	// The request was rejected because the public key encoding format is unsupported
+	// or unrecognized.
+	ErrCodeUnrecognizedPublicKeyEncodingException = "UnrecognizedPublicKeyEncoding"
+)
diff --git a/vendor/github.com/aws/aws-sdk-go/service/iam/service.go b/vendor/github.com/aws/aws-sdk-go/service/iam/service.go
new file mode 100644
index 000000000..940b4ce32
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/iam/service.go
@@ -0,0 +1,95 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package iam
+
+import (
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/client"
+	"github.com/aws/aws-sdk-go/aws/client/metadata"
+	"github.com/aws/aws-sdk-go/aws/request"
+	"github.com/aws/aws-sdk-go/aws/signer/v4"
+	"github.com/aws/aws-sdk-go/private/protocol/query"
+)
+
+// IAM provides the API operation methods for making requests to
+// AWS Identity and Access Management. See this package's package overview docs
+// for details on the service.
+//
+// IAM methods are safe to use concurrently. It is not safe to
+// modify mutate any of the struct's properties though.
+type IAM struct {
+	*client.Client
+}
+
+// Used for custom client initialization logic
+var initClient func(*client.Client)
+
+// Used for custom request initialization logic
+var initRequest func(*request.Request)
+
+// Service information constants
+const (
+	ServiceName = "iam"       // Name of service.
+	EndpointsID = ServiceName // ID to lookup a service endpoint with.
+	ServiceID   = "IAM"       // ServiceID is a unique identifer of a specific service.
+)
+
+// New creates a new instance of the IAM client with a session.
+// If additional configuration is needed for the client instance use the optional
+// aws.Config parameter to add your extra config.
+//
+// Example:
+//     // Create a IAM client from just a session.
+//     svc := iam.New(mySession)
+//
+//     // Create a IAM client with additional configuration
+//     svc := iam.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
+func New(p client.ConfigProvider, cfgs ...*aws.Config) *IAM {
+	c := p.ClientConfig(EndpointsID, cfgs...)
+	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName)
+}
+
+// newClient creates, initializes and returns a new service client instance.
+func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *IAM {
+	svc := &IAM{
+		Client: client.New(
+			cfg,
+			metadata.ClientInfo{
+				ServiceName:   ServiceName,
+				ServiceID:     ServiceID,
+				SigningName:   signingName,
+				SigningRegion: signingRegion,
+				Endpoint:      endpoint,
+				APIVersion:    "2010-05-08",
+			},
+			handlers,
+		),
+	}
+
+	// Handlers
+	svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler)
+	svc.Handlers.Build.PushBackNamed(query.BuildHandler)
+	svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler)
+	svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler)
+	svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler)
+
+	// Run custom client initialization if present
+	if initClient != nil {
+		initClient(svc.Client)
+	}
+
+	return svc
+}
+
+// newRequest creates a new request for a IAM operation and runs any
+// custom request initialization.
+func (c *IAM) newRequest(op *request.Operation, params, data interface{}) *request.Request {
+	req := c.NewRequest(op, params, data)
+
+	// Run custom request initialization if present
+	if initRequest != nil {
+		initRequest(req)
+	}
+
+	return req
+}
diff --git a/vendor/github.com/aws/aws-sdk-go/service/iam/waiters.go b/vendor/github.com/aws/aws-sdk-go/service/iam/waiters.go
new file mode 100644
index 000000000..4331ba37b
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go/service/iam/waiters.go
@@ -0,0 +1,214 @@
+// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.
+
+package iam
+
+import (
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/request"
+)
+
+// WaitUntilInstanceProfileExists uses the IAM API operation
+// GetInstanceProfile to wait for a condition to be met before returning.
+// If the condition is not met within the max attempt window, an error will
+// be returned.
+func (c *IAM) WaitUntilInstanceProfileExists(input *GetInstanceProfileInput) error {
+	return c.WaitUntilInstanceProfileExistsWithContext(aws.BackgroundContext(), input)
+}
+
+// WaitUntilInstanceProfileExistsWithContext is an extended version of WaitUntilInstanceProfileExists.
+// With the support for passing in a context and options to configure the
+// Waiter and the underlying request options.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) WaitUntilInstanceProfileExistsWithContext(ctx aws.Context, input *GetInstanceProfileInput, opts ...request.WaiterOption) error {
+	w := request.Waiter{
+		Name:        "WaitUntilInstanceProfileExists",
+		MaxAttempts: 40,
+		Delay:       request.ConstantWaiterDelay(1 * time.Second),
+		Acceptors: []request.WaiterAcceptor{
+			{
+				State:    request.SuccessWaiterState,
+				Matcher:  request.StatusWaiterMatch,
+				Expected: 200,
+			},
+			{
+				State:    request.RetryWaiterState,
+				Matcher:  request.StatusWaiterMatch,
+				Expected: 404,
+			},
+		},
+		Logger: c.Config.Logger,
+		NewRequest: func(opts []request.Option) (*request.Request, error) {
+			var inCpy *GetInstanceProfileInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.GetInstanceProfileRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+	w.ApplyOptions(opts...)
+
+	return w.WaitWithContext(ctx)
+}
+
+// WaitUntilPolicyExists uses the IAM API operation
+// GetPolicy to wait for a condition to be met before returning.
+// If the condition is not met within the max attempt window, an error will
+// be returned.
+func (c *IAM) WaitUntilPolicyExists(input *GetPolicyInput) error {
+	return c.WaitUntilPolicyExistsWithContext(aws.BackgroundContext(), input)
+}
+
+// WaitUntilPolicyExistsWithContext is an extended version of WaitUntilPolicyExists.
+// With the support for passing in a context and options to configure the
+// Waiter and the underlying request options.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) WaitUntilPolicyExistsWithContext(ctx aws.Context, input *GetPolicyInput, opts ...request.WaiterOption) error {
+	w := request.Waiter{
+		Name:        "WaitUntilPolicyExists",
+		MaxAttempts: 20,
+		Delay:       request.ConstantWaiterDelay(1 * time.Second),
+		Acceptors: []request.WaiterAcceptor{
+			{
+				State:    request.SuccessWaiterState,
+				Matcher:  request.StatusWaiterMatch,
+				Expected: 200,
+			},
+			{
+				State:    request.RetryWaiterState,
+				Matcher:  request.ErrorWaiterMatch,
+				Expected: "NoSuchEntity",
+			},
+		},
+		Logger: c.Config.Logger,
+		NewRequest: func(opts []request.Option) (*request.Request, error) {
+			var inCpy *GetPolicyInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.GetPolicyRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+	w.ApplyOptions(opts...)
+
+	return w.WaitWithContext(ctx)
+}
+
+// WaitUntilRoleExists uses the IAM API operation
+// GetRole to wait for a condition to be met before returning.
+// If the condition is not met within the max attempt window, an error will
+// be returned.
+func (c *IAM) WaitUntilRoleExists(input *GetRoleInput) error {
+	return c.WaitUntilRoleExistsWithContext(aws.BackgroundContext(), input)
+}
+
+// WaitUntilRoleExistsWithContext is an extended version of WaitUntilRoleExists.
+// With the support for passing in a context and options to configure the
+// Waiter and the underlying request options.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) WaitUntilRoleExistsWithContext(ctx aws.Context, input *GetRoleInput, opts ...request.WaiterOption) error {
+	w := request.Waiter{
+		Name:        "WaitUntilRoleExists",
+		MaxAttempts: 20,
+		Delay:       request.ConstantWaiterDelay(1 * time.Second),
+		Acceptors: []request.WaiterAcceptor{
+			{
+				State:    request.SuccessWaiterState,
+				Matcher:  request.StatusWaiterMatch,
+				Expected: 200,
+			},
+			{
+				State:    request.RetryWaiterState,
+				Matcher:  request.ErrorWaiterMatch,
+				Expected: "NoSuchEntity",
+			},
+		},
+		Logger: c.Config.Logger,
+		NewRequest: func(opts []request.Option) (*request.Request, error) {
+			var inCpy *GetRoleInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.GetRoleRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+	w.ApplyOptions(opts...)
+
+	return w.WaitWithContext(ctx)
+}
+
+// WaitUntilUserExists uses the IAM API operation
+// GetUser to wait for a condition to be met before returning.
+// If the condition is not met within the max attempt window, an error will
+// be returned.
+func (c *IAM) WaitUntilUserExists(input *GetUserInput) error {
+	return c.WaitUntilUserExistsWithContext(aws.BackgroundContext(), input)
+}
+
+// WaitUntilUserExistsWithContext is an extended version of WaitUntilUserExists.
+// With the support for passing in a context and options to configure the
+// Waiter and the underlying request options.
+//
+// The context must be non-nil and will be used for request cancellation. If
+// the context is nil a panic will occur. In the future the SDK may create
+// sub-contexts for http.Requests. See https://golang.org/pkg/context/
+// for more information on using Contexts.
+func (c *IAM) WaitUntilUserExistsWithContext(ctx aws.Context, input *GetUserInput, opts ...request.WaiterOption) error {
+	w := request.Waiter{
+		Name:        "WaitUntilUserExists",
+		MaxAttempts: 20,
+		Delay:       request.ConstantWaiterDelay(1 * time.Second),
+		Acceptors: []request.WaiterAcceptor{
+			{
+				State:    request.SuccessWaiterState,
+				Matcher:  request.StatusWaiterMatch,
+				Expected: 200,
+			},
+			{
+				State:    request.RetryWaiterState,
+				Matcher:  request.ErrorWaiterMatch,
+				Expected: "NoSuchEntity",
+			},
+		},
+		Logger: c.Config.Logger,
+		NewRequest: func(opts []request.Option) (*request.Request, error) {
+			var inCpy *GetUserInput
+			if input != nil {
+				tmp := *input
+				inCpy = &tmp
+			}
+			req, _ := c.GetUserRequest(inCpy)
+			req.SetContext(ctx)
+			req.ApplyOptions(opts...)
+			return req, nil
+		},
+	}
+	w.ApplyOptions(opts...)
+
+	return w.WaitWithContext(ctx)
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 70d7a6c98..c8d2a3995 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -131,6 +131,7 @@ github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
 github.com/aws/aws-sdk-go/service/ec2
 github.com/aws/aws-sdk-go/service/ec2/ec2iface
 github.com/aws/aws-sdk-go/service/ecr
+github.com/aws/aws-sdk-go/service/iam
 github.com/aws/aws-sdk-go/service/s3
 github.com/aws/aws-sdk-go/service/s3/s3iface
 github.com/aws/aws-sdk-go/service/s3/s3manager
diff --git a/website/source/partials/builder/amazon/common/_RunConfig-not-required.html.md b/website/source/partials/builder/amazon/common/_RunConfig-not-required.html.md
index fc9df4b9e..588f63fa5 100644
--- a/website/source/partials/builder/amazon/common/_RunConfig-not-required.html.md
+++ b/website/source/partials/builder/amazon/common/_RunConfig-not-required.html.md
@@ -64,6 +64,24 @@
     profile](https://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html)
     to launch the EC2 instance with.
     
+-   `temporary_iam_instance_profile_policy_document` (\*PolicyDocument) - Temporary IAM instance profile policy document
+    If IamInstanceProfile is specified it will be used instead. Example:
+    
+    ```json
+    {
+    	"Version": "2012-10-17",
+    	"Statement": [
+    		{
+    			"Action": [
+    			"logs:*"
+    			],
+    			"Effect": "Allow",
+    			"Resource": "*"
+    		}
+    	]
+    }
+    ```
+    
 -   `shutdown_behavior` (string) - Automatically terminate instances on
     shutdown in case Packer exits ungracefully. Possible values are stop and
     terminate. Defaults to stop.

From 65d1447b64762e7123f655b573125fc11880fe4d Mon Sep 17 00:00:00 2001
From: Bernard Baltrusaitis <bernard@runawaylover.info>
Date: Sat, 19 Oct 2019 21:33:58 +1100
Subject: [PATCH 147/155] adding formatting

---
 builder/amazon/common/run_config.go           |  2 +-
 .../common/step_iam_instance_profile.go       | 25 +++++++++----------
 2 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/builder/amazon/common/run_config.go b/builder/amazon/common/run_config.go
index 8021824bb..7509b7fb6 100644
--- a/builder/amazon/common/run_config.go
+++ b/builder/amazon/common/run_config.go
@@ -132,7 +132,7 @@ type RunConfig struct {
 	// The name of an [IAM instance
 	// profile](https://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html)
 	// to launch the EC2 instance with.
-	IamInstanceProfile                        string          `mapstructure:"iam_instance_profile" required:"false"`
+	IamInstanceProfile string `mapstructure:"iam_instance_profile" required:"false"`
 	// Temporary IAM instance profile policy document
 	// If IamInstanceProfile is specified it will be used instead. Example:
 	//
diff --git a/builder/amazon/common/step_iam_instance_profile.go b/builder/amazon/common/step_iam_instance_profile.go
index 75d84d3be..7221e08d4 100644
--- a/builder/amazon/common/step_iam_instance_profile.go
+++ b/builder/amazon/common/step_iam_instance_profile.go
@@ -3,16 +3,15 @@ package common
 import (
 	"context"
 	"fmt"
-	"log"
 	"github.com/aws/aws-sdk-go/aws"
+	"log"
 	"time"
 
+	"encoding/json"
+	"github.com/aws/aws-sdk-go/service/iam"
 	"github.com/hashicorp/packer/common/uuid"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
-	"github.com/aws/aws-sdk-go/service/iam"
-	"encoding/json"
-
 )
 
 type StepIamInstanceProfile struct {
@@ -87,8 +86,8 @@ func (s *StepIamInstanceProfile) Run(ctx context.Context, state multistep.StateB
 		ui.Say(fmt.Sprintf("Creating temporary role for this instance: %s", profileName))
 
 		roleResp, err := iamsvc.CreateRole(&iam.CreateRoleInput{
-			RoleName:   aws.String(profileName),
-			Description: aws.String("Temporary role for Packer"),
+			RoleName:                 aws.String(profileName),
+			Description:              aws.String("Temporary role for Packer"),
 			AssumeRolePolicyDocument: aws.String("{\"Version\": \"2012-10-17\",\"Statement\": [{\"Effect\": \"Allow\",\"Principal\": {\"Service\": \"ec2.amazonaws.com\"},\"Action\": \"sts:AssumeRole\"}]}"),
 		})
 		if err != nil {
@@ -115,8 +114,8 @@ func (s *StepIamInstanceProfile) Run(ctx context.Context, state multistep.StateB
 		ui.Say(fmt.Sprintf("Attaching policy to the temporary role: %s", profileName))
 
 		_, err = iamsvc.PutRolePolicy(&iam.PutRolePolicyInput{
-			RoleName: roleResp.Role.RoleName,
-			PolicyName:aws.String(profileName),
+			RoleName:       roleResp.Role.RoleName,
+			PolicyName:     aws.String(profileName),
 			PolicyDocument: aws.String(string(policy)),
 		})
 		if err != nil {
@@ -128,7 +127,7 @@ func (s *StepIamInstanceProfile) Run(ctx context.Context, state multistep.StateB
 		s.createdPolicyName = aws.StringValue(roleResp.Role.RoleName)
 
 		_, err = iamsvc.AddRoleToInstanceProfile(&iam.AddRoleToInstanceProfileInput{
-			RoleName: roleResp.Role.RoleName,
+			RoleName:            roleResp.Role.RoleName,
 			InstanceProfileName: profileResp.InstanceProfile.InstanceProfileName,
 		})
 		if err != nil {
@@ -140,7 +139,7 @@ func (s *StepIamInstanceProfile) Run(ctx context.Context, state multistep.StateB
 		s.roleIsAttached = true
 		state.Put("iamInstanceProfile", aws.StringValue(profileResp.InstanceProfile.InstanceProfileName))
 
-		time.Sleep(5*time.Second)
+		time.Sleep(5 * time.Second)
 	}
 
 	return multistep.ActionContinue
@@ -156,7 +155,7 @@ func (s *StepIamInstanceProfile) Cleanup(state multistep.StateBag) {
 
 		_, err := iamsvc.RemoveRoleFromInstanceProfile(&iam.RemoveRoleFromInstanceProfileInput{
 			InstanceProfileName: aws.String(s.createdInstanceProfileName),
-			RoleName: aws.String(s.createdRoleName),
+			RoleName:            aws.String(s.createdRoleName),
 		})
 		if err != nil {
 			ui.Error(fmt.Sprintf(
@@ -168,7 +167,7 @@ func (s *StepIamInstanceProfile) Cleanup(state multistep.StateBag) {
 		ui.Say("Removing policy from temporary role...")
 		iamsvc.DeleteRolePolicy(&iam.DeleteRolePolicyInput{
 			PolicyName: aws.String(s.createdPolicyName),
-			RoleName: aws.String(s.createdRoleName),
+			RoleName:   aws.String(s.createdRoleName),
 		})
 	}
 	if s.createdRoleName != "" {
@@ -192,4 +191,4 @@ func (s *StepIamInstanceProfile) Cleanup(state multistep.StateBag) {
 				"Error %s. Please delete the instance profile manually: %s", err.Error(), s.createdInstanceProfileName))
 		}
 	}
-}
\ No newline at end of file
+}

From 1b4ffe546f8980e9aa86144a896133355ee04f3c Mon Sep 17 00:00:00 2001
From: Marcin Bojko <marcinbojko.pl@gmail.com>
Date: Sat, 19 Oct 2019 12:46:34 +0200
Subject: [PATCH 148/155] hyper-v fix for compacting vhdx/vhd only

---
 common/powershell/hyperv/hyperv.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/powershell/hyperv/hyperv.go b/common/powershell/hyperv/hyperv.go
index e93a885eb..132c5d216 100644
--- a/common/powershell/hyperv/hyperv.go
+++ b/common/powershell/hyperv/hyperv.go
@@ -860,7 +860,7 @@ func CompactDisks(path string) (result string, err error) {
 	var script = `
 param([string]$srcPath)
 
-$disks = Get-ChildItem -Path $srcPath -Recurse -Filter *.vhd* -ErrorAction SilentlyContinue | % { $_.FullName }
+$disks = Get-ChildItem -Path $srcPath -Recurse -ErrorAction SilentlyContinue |where {$_.extension -in ".vhdx",".vhd"} |foreach { $_.FullName }
 # Failure to find any disks is treated as a 'soft' error. Simply print out
 # a warning and exit
 if ($disks.Length -eq 0) {

From 6fb8988d088160935495d1518b4f1b77e6a5d885 Mon Sep 17 00:00:00 2001
From: Li Kexian <doyenli@tencent.com>
Date: Mon, 21 Oct 2019 13:21:21 +0800
Subject: [PATCH 149/155] we added retry on remote api call to improve the user
 experience

---
 builder/tencentcloud/cvm/access_config.go     |  57 +-
 builder/tencentcloud/cvm/artifact.go          |  38 +-
 builder/tencentcloud/cvm/builder.go           |  17 +-
 builder/tencentcloud/cvm/common.go            | 140 +++-
 builder/tencentcloud/cvm/image_config.go      |  12 +-
 builder/tencentcloud/cvm/image_config_test.go |   1 -
 builder/tencentcloud/cvm/run_config.go        |  23 +-
 builder/tencentcloud/cvm/run_config_test.go   |   5 +
 .../cvm/step_check_source_image.go            |  30 +-
 .../tencentcloud/cvm/step_config_key_pair.go  |  84 +-
 .../cvm/step_config_security_group.go         |  90 +-
 .../tencentcloud/cvm/step_config_subnet.go    | 101 ++-
 builder/tencentcloud/cvm/step_config_vpc.go   |  86 +-
 builder/tencentcloud/cvm/step_copy_image.go   |  23 +-
 builder/tencentcloud/cvm/step_create_image.go |  84 +-
 .../cvm/step_detach_temp_key_pair.go          |  40 +-
 builder/tencentcloud/cvm/step_pre_validate.go |  36 +-
 builder/tencentcloud/cvm/step_run_instance.go |  84 +-
 builder/tencentcloud/cvm/step_share_image.go  |  62 +-
 .../tencentcloud/basic-with-data-disk.json    |  64 +-
 examples/tencentcloud/basic.json              |  52 +-
 examples/tencentcloud/centos.json             |  65 +-
 go.mod                                        |   2 +-
 go.sum                                        |   6 +-
 .../tencentcloud/common/client.go             |  35 +-
 .../tencentcloud/common/http/request.go       |  15 +-
 .../tencentcloud/common/http/response.go      |  17 +-
 .../common/profile/client_profile.go          |   8 +-
 .../common/profile/http_profile.go            |   6 +-
 .../tencentcloud/common/sign.go               |  19 +-
 .../tencentcloud/cvm/v20170312/client.go      |  83 +-
 .../tencentcloud/cvm/v20170312/models.go      | 357 +++++++-
 .../tencentcloud/vpc/v20170312/client.go      | 330 +++++++-
 .../tencentcloud/vpc/v20170312/models.go      | 772 +++++++++++++++++-
 vendor/modules.txt                            |   2 +-
 .../docs/builders/tencentcloud-cvm.html.md    |  89 +-
 ...TencentCloudRunConfig-not-required.html.md |   2 +-
 37 files changed, 2316 insertions(+), 621 deletions(-)

diff --git a/builder/tencentcloud/cvm/access_config.go b/builder/tencentcloud/cvm/access_config.go
index cb4790131..9dbe482e4 100644
--- a/builder/tencentcloud/cvm/access_config.go
+++ b/builder/tencentcloud/cvm/access_config.go
@@ -3,6 +3,7 @@
 package cvm
 
 import (
+	"context"
 	"fmt"
 	"os"
 
@@ -71,49 +72,67 @@ func (cf *TencentCloudAccessConfig) Client() (*cvm.Client, *vpc.Client, error) {
 		vpc_client *vpc.Client
 		resp       *cvm.DescribeZonesResponse
 	)
+
 	if err = cf.validateRegion(); err != nil {
 		return nil, nil, err
 	}
-	credential := common.NewCredential(
-		cf.SecretId, cf.SecretKey)
+
+	if cf.Zone == "" {
+		return nil, nil, fmt.Errorf("parameter zone must be set")
+	}
+
+	credential := common.NewCredential(cf.SecretId, cf.SecretKey)
 	cpf := profile.NewClientProfile()
+	cpf.HttpProfile.ReqMethod = "POST"
+	cpf.HttpProfile.ReqTimeout = 300
+	cpf.Language = "en-US"
+
 	if cvm_client, err = cvm.NewClient(credential, cf.Region, cpf); err != nil {
 		return nil, nil, err
 	}
+
 	if vpc_client, err = vpc.NewClient(credential, cf.Region, cpf); err != nil {
 		return nil, nil, err
 	}
-	if resp, err = cvm_client.DescribeZones(nil); err != nil {
+
+	ctx := context.TODO()
+	err = Retry(ctx, func(ctx context.Context) error {
+		var e error
+		resp, e = cvm_client.DescribeZones(nil)
+		return e
+	})
+	if err != nil {
 		return nil, nil, err
 	}
-	if cf.Zone != "" {
-		for _, zone := range resp.Response.ZoneSet {
-			if cf.Zone == *zone.Zone {
-				return cvm_client, vpc_client, nil
-			}
+
+	for _, zone := range resp.Response.ZoneSet {
+		if cf.Zone == *zone.Zone {
+			return cvm_client, vpc_client, nil
 		}
-		return nil, nil, fmt.Errorf("unknown zone: %s", cf.Zone)
-	} else {
-		return nil, nil, fmt.Errorf("zone must be set")
 	}
+
+	return nil, nil, fmt.Errorf("unknown zone: %s", cf.Zone)
 }
 
 func (cf *TencentCloudAccessConfig) Prepare(ctx *interpolate.Context) []error {
 	var errs []error
+
 	if err := cf.Config(); err != nil {
 		errs = append(errs, err)
 	}
 
 	if cf.Region == "" {
-		errs = append(errs, fmt.Errorf("region must be set"))
+		errs = append(errs, fmt.Errorf("parameter region must be set"))
 	} else if !cf.SkipValidation {
 		if err := cf.validateRegion(); err != nil {
 			errs = append(errs, err)
 		}
 	}
+
 	if len(errs) > 0 {
 		return errs
 	}
+
 	return nil
 }
 
@@ -121,20 +140,28 @@ func (cf *TencentCloudAccessConfig) Config() error {
 	if cf.SecretId == "" {
 		cf.SecretId = os.Getenv("TENCENTCLOUD_SECRET_ID")
 	}
+
 	if cf.SecretKey == "" {
 		cf.SecretKey = os.Getenv("TENCENTCLOUD_SECRET_KEY")
 	}
+
 	if cf.SecretId == "" || cf.SecretKey == "" {
-		return fmt.Errorf("TENCENTCLOUD_SECRET_ID and TENCENTCLOUD_SECRET_KEY must be set")
+		return fmt.Errorf("parameter secret_id and secret_key must be set")
 	}
+
 	return nil
 }
 
 func (cf *TencentCloudAccessConfig) validateRegion() error {
+	return validRegion(cf.Region)
+}
+
+func validRegion(region string) error {
 	for _, valid := range ValidRegions {
-		if valid == Region(cf.Region) {
+		if Region(region) == valid {
 			return nil
 		}
 	}
-	return fmt.Errorf("unknown region: %s", cf.Region)
+
+	return fmt.Errorf("unknown region: %s", region)
 }
diff --git a/builder/tencentcloud/cvm/artifact.go b/builder/tencentcloud/cvm/artifact.go
index 964f8c8a7..b5c38f579 100644
--- a/builder/tencentcloud/cvm/artifact.go
+++ b/builder/tencentcloud/cvm/artifact.go
@@ -1,6 +1,7 @@
 package cvm
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"sort"
@@ -29,8 +30,8 @@ func (a *Artifact) Id() string {
 	for region, imageId := range a.TencentCloudImages {
 		parts = append(parts, fmt.Sprintf("%s:%s", region, imageId))
 	}
-
 	sort.Strings(parts)
+
 	return strings.Join(parts, ",")
 }
 
@@ -40,7 +41,8 @@ func (a *Artifact) String() string {
 		parts = append(parts, fmt.Sprintf("%s: %s", region, imageId))
 	}
 	sort.Strings(parts)
-	return fmt.Sprintf("Tencentcloud images(%s) were created:\n\n", strings.Join(parts, "\n"))
+
+	return fmt.Sprintf("Tencentcloud images(%s) were created.\n\n", strings.Join(parts, "\n"))
 }
 
 func (a *Artifact) State(name string) interface{} {
@@ -53,6 +55,7 @@ func (a *Artifact) State(name string) interface{} {
 }
 
 func (a *Artifact) Destroy() error {
+	ctx := context.TODO()
 	errors := make([]error, 0)
 
 	for region, imageId := range a.TencentCloudImages {
@@ -60,22 +63,31 @@ func (a *Artifact) Destroy() error {
 
 		describeReq := cvm.NewDescribeImagesRequest()
 		describeReq.ImageIds = []*string{&imageId}
-
-		describeResp, err := a.Client.DescribeImages(describeReq)
+		var describeResp *cvm.DescribeImagesResponse
+		err := Retry(ctx, func(ctx context.Context) error {
+			var e error
+			describeResp, e = a.Client.DescribeImages(describeReq)
+			return e
+		})
 		if err != nil {
 			errors = append(errors, err)
 			continue
 		}
+
 		if *describeResp.Response.TotalCount == 0 {
 			errors = append(errors, fmt.Errorf(
 				"describe images failed, region(%s) ImageId(%s)", region, imageId))
 		}
 
+		var shareAccountIds []*string = nil
 		describeShareReq := cvm.NewDescribeImageSharePermissionRequest()
 		describeShareReq.ImageId = &imageId
-
-		describeShareResp, err := a.Client.DescribeImageSharePermission(describeShareReq)
-		var shareAccountIds []*string = nil
+		var describeShareResp *cvm.DescribeImageSharePermissionResponse
+		err = Retry(ctx, func(ctx context.Context) error {
+			var e error
+			describeShareResp, e = a.Client.DescribeImageSharePermission(describeShareReq)
+			return e
+		})
 		if err != nil {
 			errors = append(errors, err)
 		} else {
@@ -90,7 +102,10 @@ func (a *Artifact) Destroy() error {
 			cancelShareReq.AccountIds = shareAccountIds
 			CANCEL := "CANCEL"
 			cancelShareReq.Permission = &CANCEL
-			_, err := a.Client.ModifyImageSharePermission(cancelShareReq)
+			err := Retry(ctx, func(ctx context.Context) error {
+				_, e := a.Client.ModifyImageSharePermission(cancelShareReq)
+				return e
+			})
 			if err != nil {
 				errors = append(errors, err)
 			}
@@ -98,8 +113,10 @@ func (a *Artifact) Destroy() error {
 
 		deleteReq := cvm.NewDeleteImagesRequest()
 		deleteReq.ImageIds = []*string{&imageId}
-
-		_, err = a.Client.DeleteImages(deleteReq)
+		err = Retry(ctx, func(ctx context.Context) error {
+			_, e := a.Client.DeleteImages(deleteReq)
+			return e
+		})
 		if err != nil {
 			errors = append(errors, err)
 		}
@@ -120,5 +137,6 @@ func (a *Artifact) stateAtlasMetadata() interface{} {
 		k := fmt.Sprintf("region.%s", region)
 		metadata[k] = imageId
 	}
+
 	return metadata
 }
diff --git a/builder/tencentcloud/cvm/builder.go b/builder/tencentcloud/cvm/builder.go
index 9b05846b3..9fe8abb74 100644
--- a/builder/tencentcloud/cvm/builder.go
+++ b/builder/tencentcloud/cvm/builder.go
@@ -49,13 +49,13 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	errs = packer.MultiErrorAppend(errs, b.config.TencentCloudAccessConfig.Prepare(&b.config.ctx)...)
 	errs = packer.MultiErrorAppend(errs, b.config.TencentCloudImageConfig.Prepare(&b.config.ctx)...)
 	errs = packer.MultiErrorAppend(errs, b.config.TencentCloudRunConfig.Prepare(&b.config.ctx)...)
-
 	if errs != nil && len(errs.Errors) > 0 {
 		return nil, errs
 	}
 
 	packer.LogSecretFilter.Set(b.config.SecretId, b.config.SecretKey)
-	log.Println(b.config)
+	log.Printf("[DEBUG]packer config: %v", b.config)
+
 	return nil, nil
 }
 
@@ -64,17 +64,21 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	if err != nil {
 		return nil, err
 	}
+
 	state := new(multistep.BasicStateBag)
 	state.Put("config", &b.config)
 	state.Put("cvm_client", cvmClient)
 	state.Put("vpc_client", vpcClient)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
-	var steps []multistep.Step
 
 	// Build the steps
+	var steps []multistep.Step
 	steps = []multistep.Step{
-		&stepCheckSourceImage{b.config.SourceImageId},
+		&stepPreValidate{},
+		&stepCheckSourceImage{
+			b.config.SourceImageId,
+		},
 		&stepConfigKeyPair{
 			Debug:        b.config.PackerDebug,
 			Comm:         &b.config.Comm,
@@ -94,7 +98,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&stepConfigSecurityGroup{
 			SecurityGroupId:   b.config.SecurityGroupId,
 			SecurityGroupName: b.config.SecurityGroupName,
-			Description:       "a simple security group",
+			Description:       "securitygroup for packer",
 		},
 		&stepRunInstance{
 			InstanceType:             b.config.InstanceType,
@@ -119,7 +123,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		&common.StepCleanupTempKeys{
 			Comm: &b.config.TencentCloudRunConfig.Comm,
 		},
-		// We need this step to detach temporary key from instance, otherwise
+		// We need this step to detach keypair from instance, otherwise
 		// it always fails to delete the key.
 		&stepDetachTempKeyPair{},
 		&stepCreateImage{},
@@ -148,5 +152,6 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 		BuilderIdValue:     BuilderId,
 		Client:             cvmClient,
 	}
+
 	return artifact, nil
 }
diff --git a/builder/tencentcloud/cvm/common.go b/builder/tencentcloud/cvm/common.go
index 209ae6319..6b2f3b374 100644
--- a/builder/tencentcloud/cvm/common.go
+++ b/builder/tencentcloud/cvm/common.go
@@ -1,44 +1,35 @@
 package cvm
 
 import (
+	"context"
 	"fmt"
 	"regexp"
+	"strings"
 	"time"
 
+	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
 	"github.com/hashicorp/packer/packer"
+	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
 	cvm "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312"
 )
 
-func CheckResourceIdFormat(resource string, id string) bool {
-	regex := regexp.MustCompile(fmt.Sprintf("%s-[0-9a-z]{8}$", resource))
-	if !regex.MatchString(id) {
-		return false
-	}
-	return true
-}
-
-func MessageClean(state multistep.StateBag, module string) {
-	_, cancelled := state.GetOk(multistep.StateCancelled)
-	_, halted := state.GetOk(multistep.StateHalted)
-
-	ui := state.Get("ui").(packer.Ui)
-
-	if cancelled || halted {
-		ui.Say(fmt.Sprintf("Deleting %s because of cancellation or error...", module))
-	} else {
-		ui.Say(fmt.Sprintf("Cleaning up '%s'", module))
-	}
-
-}
-
+// DefaultWaitForInterval is sleep interval when wait statue
 const DefaultWaitForInterval = 5
 
+// WaitForInstance wait for instance reaches statue
 func WaitForInstance(client *cvm.Client, instanceId string, status string, timeout int) error {
+	ctx := context.TODO()
 	req := cvm.NewDescribeInstancesRequest()
 	req.InstanceIds = []*string{&instanceId}
+
 	for {
-		resp, err := client.DescribeInstances(req)
+		var resp *cvm.DescribeInstancesResponse
+		err := Retry(ctx, func(ctx context.Context) error {
+			var e error
+			resp, e = client.DescribeInstances(req)
+			return e
+		})
 		if err != nil {
 			return err
 		}
@@ -54,10 +45,13 @@ func WaitForInstance(client *cvm.Client, instanceId string, status string, timeo
 			return fmt.Errorf("wait instance(%s) status(%s) timeout", instanceId, status)
 		}
 	}
+
 	return nil
 }
 
+// WaitForImageReady wait for image reaches statue
 func WaitForImageReady(client *cvm.Client, imageName string, status string, timeout int) error {
+	ctx := context.TODO()
 	req := cvm.NewDescribeImagesRequest()
 	FILTER_IMAGE_NAME := "image-name"
 	req.Filters = []*cvm.Filter{
@@ -66,8 +60,14 @@ func WaitForImageReady(client *cvm.Client, imageName string, status string, time
 			Values: []*string{&imageName},
 		},
 	}
+
 	for {
-		resp, err := client.DescribeImages(req)
+		var resp *cvm.DescribeImagesResponse
+		err := Retry(ctx, func(ctx context.Context) error {
+			var e error
+			resp, e = client.DescribeImages(req)
+			return e
+		})
 		if err != nil {
 			return err
 		}
@@ -84,12 +84,22 @@ func WaitForImageReady(client *cvm.Client, imageName string, status string, time
 		time.Sleep(DefaultWaitForInterval * time.Second)
 		timeout = timeout - DefaultWaitForInterval
 		if timeout <= 0 {
-			return fmt.Errorf("wait image(%s) ready timeout", imageName)
+			return fmt.Errorf("wait image(%s) status(%s) timeout", imageName, status)
 		}
 	}
+
 	return nil
 }
 
+// CheckResourceIdFormat check resource id format
+func CheckResourceIdFormat(resource string, id string) bool {
+	regex := regexp.MustCompile(fmt.Sprintf("%s-[0-9a-z]{8}$", resource))
+	if !regex.MatchString(id) {
+		return false
+	}
+	return true
+}
+
 // SSHHost returns a function that can be given to the SSH communicator
 func SSHHost(pubilcIp bool) func(multistep.StateBag) (string, error) {
 	return func(state multistep.StateBag) (string, error) {
@@ -101,3 +111,83 @@ func SSHHost(pubilcIp bool) func(multistep.StateBag) (string, error) {
 		}
 	}
 }
+
+// Retry do retry on api request
+func Retry(ctx context.Context, fn func(context.Context) error) error {
+	return retry.Config{
+		Tries: 30,
+		ShouldRetry: func(err error) bool {
+			e, ok := err.(*errors.TencentCloudSDKError)
+			if !ok {
+				return false
+			}
+			if e.Code == "ClientError.NetworkError" || e.Code == "ClientError.HttpStatusCodeError" ||
+				e.Code == "InvalidKeyPair.NotSupported" || e.Code == "InvalidInstance.NotSupported" ||
+				strings.Contains(e.Code, "RequestLimitExceeded") || strings.Contains(e.Code, "InternalError") ||
+				strings.Contains(e.Code, "ResourceInUse") || strings.Contains(e.Code, "ResourceBusy") {
+				return true
+			}
+			return false
+		},
+		RetryDelay: (&retry.Backoff{
+			InitialBackoff: 1 * time.Second,
+			MaxBackoff:     5 * time.Second,
+			Multiplier:     2,
+		}).Linear,
+	}.Run(ctx, fn)
+}
+
+// SayClean tell you clean module message
+func SayClean(state multistep.StateBag, module string) {
+	_, halted := state.GetOk(multistep.StateHalted)
+	_, cancelled := state.GetOk(multistep.StateCancelled)
+	if halted {
+		Say(state, fmt.Sprintf("Deleting %s because of error...", module), "")
+	} else if cancelled {
+		Say(state, fmt.Sprintf("Deleting %s because of cancellation...", module), "")
+	} else {
+		Say(state, fmt.Sprintf("Cleaning up %s...", module), "")
+	}
+}
+
+// Say tell you a message
+func Say(state multistep.StateBag, message, prefix string) {
+	if prefix != "" {
+		message = fmt.Sprintf("%s: %s", prefix, message)
+	}
+
+	if strings.HasPrefix(message, "Trying to") {
+		message += "..."
+	}
+
+	ui := state.Get("ui").(packer.Ui)
+	ui.Say(message)
+}
+
+// Message print a message
+func Message(state multistep.StateBag, message, prefix string) {
+	if prefix != "" {
+		message = fmt.Sprintf("%s: %s", prefix, message)
+	}
+
+	ui := state.Get("ui").(packer.Ui)
+	ui.Message(message)
+}
+
+// Error print error message
+func Error(state multistep.StateBag, err error, prefix string) {
+	if prefix != "" {
+		err = fmt.Errorf("%s: %s", prefix, err)
+	}
+
+	ui := state.Get("ui").(packer.Ui)
+	ui.Error(err.Error())
+}
+
+// Halt print error message and exit
+func Halt(state multistep.StateBag, err error, prefix string) multistep.StepAction {
+	Error(state, err, prefix)
+	state.Put("error", err)
+
+	return multistep.ActionHalt
+}
diff --git a/builder/tencentcloud/cvm/image_config.go b/builder/tencentcloud/cvm/image_config.go
index 5311f4254..353675d0f 100644
--- a/builder/tencentcloud/cvm/image_config.go
+++ b/builder/tencentcloud/cvm/image_config.go
@@ -36,6 +36,7 @@ type TencentCloudImageConfig struct {
 
 func (cf *TencentCloudImageConfig) Prepare(ctx *interpolate.Context) []error {
 	var errs []error
+
 	cf.ForcePoweroff = true
 	if cf.ImageName == "" {
 		errs = append(errs, fmt.Errorf("image_name must be specified"))
@@ -68,17 +69,10 @@ func (cf *TencentCloudImageConfig) Prepare(ctx *interpolate.Context) []error {
 		}
 		cf.ImageCopyRegions = regions
 	}
+
 	if len(errs) > 0 {
 		return errs
 	}
+
 	return nil
 }
-
-func validRegion(region string) error {
-	for _, valid := range ValidRegions {
-		if Region(region) == valid {
-			return nil
-		}
-	}
-	return fmt.Errorf("unknown region: %s", region)
-}
diff --git a/builder/tencentcloud/cvm/image_config_test.go b/builder/tencentcloud/cvm/image_config_test.go
index 53f9240b7..505dcf3a5 100644
--- a/builder/tencentcloud/cvm/image_config_test.go
+++ b/builder/tencentcloud/cvm/image_config_test.go
@@ -31,5 +31,4 @@ func TestTencentCloudImageConfig_Prepare(t *testing.T) {
 	if err := cf.Prepare(nil); err != nil {
 		t.Fatalf("shouldn't have err:%v", err)
 	}
-
 }
diff --git a/builder/tencentcloud/cvm/run_config.go b/builder/tencentcloud/cvm/run_config.go
index 2e4bc3cfe..848566bde 100644
--- a/builder/tencentcloud/cvm/run_config.go
+++ b/builder/tencentcloud/cvm/run_config.go
@@ -5,6 +5,7 @@ package cvm
 import (
 	"fmt"
 	"os"
+	"strings"
 
 	"github.com/hashicorp/packer/common/uuid"
 	"github.com/hashicorp/packer/helper/communicator"
@@ -68,7 +69,7 @@ type TencentCloudRunConfig struct {
 	// Max bandwidth out your cvm will be launched by(in MB).
 	// values can be set between 1 ~ 100.
 	InternetMaxBandwidthOut int64 `mapstructure:"internet_max_bandwidth_out" required:"false"`
-	// Specify security group your cvm will be launched by.
+	// Specify securitygroup your cvm will be launched by.
 	SecurityGroupId string `mapstructure:"security_group_id" required:"false"`
 	// Specify security name you will create if security_group_id not set.
 	SecurityGroupName string `mapstructure:"security_group_name" required:"false"`
@@ -92,10 +93,11 @@ var ValidCBSType = []string{
 }
 
 func (cf *TencentCloudRunConfig) Prepare(ctx *interpolate.Context) []error {
+	packerId := fmt.Sprintf("packer_%s", uuid.TimeOrderedUUID()[:8])
 	if cf.Comm.SSHKeyPairName == "" && cf.Comm.SSHTemporaryKeyPairName == "" &&
 		cf.Comm.SSHPrivateKeyFile == "" && cf.Comm.SSHPassword == "" && cf.Comm.WinRMPassword == "" {
 		//tencentcloud support key pair name length max to 25
-		cf.Comm.SSHTemporaryKeyPairName = fmt.Sprintf("packer_%s", uuid.TimeOrderedUUID()[:8])
+		cf.Comm.SSHTemporaryKeyPairName = packerId
 	}
 
 	errs := cf.Comm.Prepare(ctx)
@@ -126,7 +128,7 @@ func (cf *TencentCloudRunConfig) Prepare(ctx *interpolate.Context) []error {
 
 	if cf.VpcId == "" {
 		if cf.VpcName == "" {
-			cf.VpcName = fmt.Sprintf("packer_%s", uuid.TimeOrderedUUID())
+			cf.VpcName = packerId
 		}
 		if cf.CidrBlock == "" {
 			cf.CidrBlock = "10.0.0.0/16"
@@ -135,9 +137,10 @@ func (cf *TencentCloudRunConfig) Prepare(ctx *interpolate.Context) []error {
 			errs = append(errs, errors.New("can't set subnet_id without set vpc_id"))
 		}
 	}
+
 	if cf.SubnetId == "" {
 		if cf.SubnetName == "" {
-			cf.SubnetName = fmt.Sprintf("packer_%s", uuid.TimeOrderedUUID())
+			cf.SubnetName = packerId
 		}
 		if cf.SubnectCidrBlock == "" {
 			cf.SubnectCidrBlock = "10.0.8.0/24"
@@ -145,7 +148,7 @@ func (cf *TencentCloudRunConfig) Prepare(ctx *interpolate.Context) []error {
 	}
 
 	if cf.SecurityGroupId == "" && cf.SecurityGroupName == "" {
-		cf.SecurityGroupName = fmt.Sprintf("packer_%s", uuid.TimeOrderedUUID())
+		cf.SecurityGroupName = packerId
 	}
 
 	if cf.DiskType != "" && !checkDiskType(cf.DiskType) {
@@ -163,13 +166,18 @@ func (cf *TencentCloudRunConfig) Prepare(ctx *interpolate.Context) []error {
 	}
 
 	if cf.InstanceName == "" {
-		cf.InstanceName = fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID())
+		cf.InstanceName = packerId
 	}
 
 	if cf.HostName == "" {
-		cf.HostName = cf.InstanceName[:15]
+		cf.HostName = cf.InstanceName
 	}
 
+	if len(cf.HostName) > 15 {
+		cf.HostName = cf.HostName[:15]
+	}
+	cf.HostName = strings.Replace(cf.HostName, "_", "-", -1)
+
 	if cf.RunTags == nil {
 		cf.RunTags = make(map[string]string)
 	}
@@ -183,5 +191,6 @@ func checkDiskType(diskType string) bool {
 			return true
 		}
 	}
+
 	return false
 }
diff --git a/builder/tencentcloud/cvm/run_config_test.go b/builder/tencentcloud/cvm/run_config_test.go
index d6ffb889b..8f62c9f90 100644
--- a/builder/tencentcloud/cvm/run_config_test.go
+++ b/builder/tencentcloud/cvm/run_config_test.go
@@ -60,6 +60,7 @@ func TestTencentCloudRunConfig_Prepare(t *testing.T) {
 
 func TestTencentCloudRunConfigPrepare_UserData(t *testing.T) {
 	cf := testConfig()
+
 	tf, err := ioutil.TempFile("", "packer")
 	if err != nil {
 		t.Fatalf("new temp file failed: %v", err)
@@ -76,6 +77,7 @@ func TestTencentCloudRunConfigPrepare_UserData(t *testing.T) {
 
 func TestTencentCloudRunConfigPrepare_UserDataFile(t *testing.T) {
 	cf := testConfig()
+
 	cf.UserDataFile = "not-exist-file"
 	if err := cf.Prepare(nil); err == nil {
 		t.Fatal("should have error")
@@ -117,13 +119,16 @@ func TestTencentCloudRunConfigPrepare_TemporaryKeyPairName(t *testing.T) {
 
 func TestTencentCloudRunConfigPrepare_SSHPrivateIp(t *testing.T) {
 	cf := testConfig()
+
 	if cf.SSHPrivateIp != false {
 		t.Fatalf("invalid ssh_private_ip value: %v", cf.SSHPrivateIp)
 	}
+
 	cf.SSHPrivateIp = true
 	if err := cf.Prepare(nil); err != nil {
 		t.Fatalf("shouldn't have error: %v", err)
 	}
+
 	if cf.SSHPrivateIp != true {
 		t.Fatalf("invalud ssh_private_ip value: %v", cf.SSHPrivateIp)
 	}
diff --git a/builder/tencentcloud/cvm/step_check_source_image.go b/builder/tencentcloud/cvm/step_check_source_image.go
index 342373885..f9af0bf24 100644
--- a/builder/tencentcloud/cvm/step_check_source_image.go
+++ b/builder/tencentcloud/cvm/step_check_source_image.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 	cvm "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312"
 )
 
@@ -14,32 +13,31 @@ type stepCheckSourceImage struct {
 }
 
 func (s *stepCheckSourceImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	client := state.Get("cvm_client").(*cvm.Client)
 	config := state.Get("config").(*Config)
-	ui := state.Get("ui").(packer.Ui)
+	client := state.Get("cvm_client").(*cvm.Client)
+
+	Say(state, config.SourceImageId, "Trying to check source image")
 
 	req := cvm.NewDescribeImagesRequest()
 	req.ImageIds = []*string{&config.SourceImageId}
 	req.InstanceType = &config.InstanceType
-
-	resp, err := client.DescribeImages(req)
+	var resp *cvm.DescribeImagesResponse
+	err := Retry(ctx, func(ctx context.Context) error {
+		var err error
+		resp, err = client.DescribeImages(req)
+		return err
+	})
 	if err != nil {
-		err := fmt.Errorf("querying image info failed: %s", err.Error())
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to get source image info")
 	}
 
-	if *resp.Response.TotalCount > 0 { // public image or private image.
+	if *resp.Response.TotalCount > 0 {
 		state.Put("source_image", resp.Response.ImageSet[0])
-		ui.Message(fmt.Sprintf("Image found: %s", *resp.Response.ImageSet[0].ImageId))
+		Message(state, *resp.Response.ImageSet[0].ImageName, "Image found")
 		return multistep.ActionContinue
 	}
-	// later market image will be included.
-	err = fmt.Errorf("no image founded under current instance_type(%s) restriction", config.InstanceType)
-	state.Put("error", err)
-	ui.Error(err.Error())
-	return multistep.ActionHalt
+
+	return Halt(state, fmt.Errorf("No image found under current instance_type(%s) restriction", config.InstanceType), "")
 }
 
 func (s *stepCheckSourceImage) Cleanup(bag multistep.StateBag) {}
diff --git a/builder/tencentcloud/cvm/step_config_key_pair.go b/builder/tencentcloud/cvm/step_config_key_pair.go
index dfaa97a0d..a4ae97159 100644
--- a/builder/tencentcloud/cvm/step_config_key_pair.go
+++ b/builder/tencentcloud/cvm/step_config_key_pair.go
@@ -6,12 +6,9 @@ import (
 	"io/ioutil"
 	"os"
 	"runtime"
-	"time"
 
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/communicator"
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 	cvm "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312"
 )
 
@@ -19,83 +16,79 @@ type stepConfigKeyPair struct {
 	Debug        bool
 	Comm         *communicator.Config
 	DebugKeyPath string
-
-	keyID string
+	keyID        string
 }
 
 func (s *stepConfigKeyPair) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
+	client := state.Get("cvm_client").(*cvm.Client)
 
 	if s.Comm.SSHPrivateKeyFile != "" {
-		ui.Say("Using existing SSH private key")
+		Say(state, "Using existing SSH private key", "")
 		privateKeyBytes, err := ioutil.ReadFile(s.Comm.SSHPrivateKeyFile)
 		if err != nil {
-			state.Put("error", fmt.Errorf(
-				"loading configured private key file failed: %s", err))
-			return multistep.ActionHalt
+			return Halt(state, err, fmt.Sprintf("Failed to load configured private key(%s)", s.Comm.SSHPrivateKeyFile))
 		}
-
 		s.Comm.SSHPrivateKey = privateKeyBytes
-
+		Message(state, fmt.Sprintf("Loaded %d bytes private key data", len(s.Comm.SSHPrivateKey)), "")
 		return multistep.ActionContinue
 	}
 
-	if s.Comm.SSHAgentAuth && s.Comm.SSHKeyPairName == "" {
-		ui.Say("Using SSH Agent with key pair in source image")
-		return multistep.ActionContinue
-	}
-
-	if s.Comm.SSHAgentAuth && s.Comm.SSHKeyPairName != "" {
-		ui.Say(fmt.Sprintf("Using SSH Agent for existing key pair %s", s.Comm.SSHKeyPairName))
+	if s.Comm.SSHAgentAuth {
+		if s.Comm.SSHKeyPairName == "" {
+			Say(state, "Using SSH agent with key pair in source image", "")
+			return multistep.ActionContinue
+		}
+		Say(state, fmt.Sprintf("Using SSH agent with exists key pair(%s)", s.Comm.SSHKeyPairName), "")
 		return multistep.ActionContinue
 	}
 
 	if s.Comm.SSHTemporaryKeyPairName == "" {
-		ui.Say("Not using temporary keypair")
+		Say(state, "Not to use temporary keypair", "")
 		s.Comm.SSHKeyPairName = ""
 		return multistep.ActionContinue
 	}
 
-	client := state.Get("cvm_client").(*cvm.Client)
-	ui.Say(fmt.Sprintf("Creating temporary keypair: %s", s.Comm.SSHTemporaryKeyPairName))
+	Say(state, s.Comm.SSHTemporaryKeyPairName, "Trying to create a new keypair")
+
 	req := cvm.NewCreateKeyPairRequest()
 	req.KeyName = &s.Comm.SSHTemporaryKeyPairName
 	defaultProjectId := int64(0)
 	req.ProjectId = &defaultProjectId
-	resp, err := client.CreateKeyPair(req)
+	var resp *cvm.CreateKeyPairResponse
+	err := Retry(ctx, func(ctx context.Context) error {
+		var e error
+		resp, e = client.CreateKeyPair(req)
+		return e
+	})
 	if err != nil {
-		state.Put("error", fmt.Errorf("creating temporary keypair failed: %s", err.Error()))
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to create keypair")
 	}
 
 	// set keyId to delete when Cleanup
 	s.keyID = *resp.Response.KeyPair.KeyId
-	state.Put("temporary_key_pair_id", resp.Response.KeyPair.KeyId)
+	state.Put("temporary_key_pair_id", s.keyID)
+	Message(state, s.keyID, "Keypair created")
 
 	s.Comm.SSHKeyPairName = *resp.Response.KeyPair.KeyId
 	s.Comm.SSHPrivateKey = []byte(*resp.Response.KeyPair.PrivateKey)
 
 	if s.Debug {
-		ui.Message(fmt.Sprintf("Saving key for debug purposes: %s", s.DebugKeyPath))
+		Message(state, fmt.Sprintf("Saving temporary key to %s for debug purposes", s.DebugKeyPath), "")
 		f, err := os.Create(s.DebugKeyPath)
 		if err != nil {
-			state.Put("error", fmt.Errorf("creating debug key file failed:%s", err.Error()))
-			return multistep.ActionHalt
+			return Halt(state, err, "Failed to saving debug key file")
 		}
 		defer f.Close()
-
 		if _, err := f.Write([]byte(*resp.Response.KeyPair.PrivateKey)); err != nil {
-			state.Put("error", fmt.Errorf("writing debug key file failed:%s", err.Error()))
-			return multistep.ActionHalt
+			return Halt(state, err, "Failed to writing debug key file")
 		}
-
 		if runtime.GOOS != "windows" {
 			if err := f.Chmod(0600); err != nil {
-				state.Put("error", fmt.Errorf("setting debug key file's permission failed:%s", err.Error()))
-				return multistep.ActionHalt
+				return Halt(state, err, "Failed to chmod debug key file")
 			}
 		}
 	}
+
 	return multistep.ActionContinue
 }
 
@@ -103,28 +96,25 @@ func (s *stepConfigKeyPair) Cleanup(state multistep.StateBag) {
 	if s.Comm.SSHPrivateKeyFile != "" || (s.Comm.SSHKeyPairName == "" && s.keyID == "") {
 		return
 	}
+
 	ctx := context.TODO()
-
 	client := state.Get("cvm_client").(*cvm.Client)
-	ui := state.Get("ui").(packer.Ui)
 
-	ui.Say("Deleting temporary keypair...")
+	SayClean(state, "keypair")
+
 	req := cvm.NewDeleteKeyPairsRequest()
 	req.KeyIds = []*string{&s.keyID}
-	err := retry.Config{
-		Tries:      60,
-		RetryDelay: (&retry.Backoff{InitialBackoff: 5 * time.Second, MaxBackoff: 5 * time.Second, Multiplier: 2}).Linear,
-	}.Run(ctx, func(ctx context.Context) error {
-		_, err := client.DeleteKeyPairs(req)
-		return err
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := client.DeleteKeyPairs(req)
+		return e
 	})
 	if err != nil {
-		ui.Error(fmt.Sprintf(
-			"delete keypair failed, please delete it manually, keyId: %s, err: %s", s.keyID, err.Error()))
+		Error(state, err, fmt.Sprintf("Failed to delete keypair(%s), please delete it manually", s.keyID))
 	}
+
 	if s.Debug {
 		if err := os.Remove(s.DebugKeyPath); err != nil {
-			ui.Error(fmt.Sprintf("delete debug key file %s failed: %s", s.DebugKeyPath, err.Error()))
+			Error(state, err, fmt.Sprintf("Failed to delete debug key file(%s), please delete it manually", s.DebugKeyPath))
 		}
 	}
 }
diff --git a/builder/tencentcloud/cvm/step_config_security_group.go b/builder/tencentcloud/cvm/step_config_security_group.go
index 2b107615a..97d70e3c1 100644
--- a/builder/tencentcloud/cvm/step_config_security_group.go
+++ b/builder/tencentcloud/cvm/step_config_security_group.go
@@ -2,14 +2,9 @@ package cvm
 
 import (
 	"context"
-	"time"
-
 	"fmt"
 
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/pkg/errors"
 	vpc "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312"
 )
 
@@ -22,42 +17,51 @@ type stepConfigSecurityGroup struct {
 
 func (s *stepConfigSecurityGroup) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	vpcClient := state.Get("vpc_client").(*vpc.Client)
-	ui := state.Get("ui").(packer.Ui)
 
-	if len(s.SecurityGroupId) != 0 { // use existing security group
+	if len(s.SecurityGroupId) != 0 {
+		Say(state, s.SecurityGroupId, "Trying to use existing securitygroup")
 		req := vpc.NewDescribeSecurityGroupsRequest()
 		req.SecurityGroupIds = []*string{&s.SecurityGroupId}
-		resp, err := vpcClient.DescribeSecurityGroups(req)
+		var resp *vpc.DescribeSecurityGroupsResponse
+		err := Retry(ctx, func(ctx context.Context) error {
+			var e error
+			resp, e = vpcClient.DescribeSecurityGroups(req)
+			return e
+		})
 		if err != nil {
-			ui.Error(fmt.Sprintf("query security group failed: %s", err.Error()))
-			state.Put("error", err)
-			return multistep.ActionHalt
+			return Halt(state, err, "Failed to get securitygroup info")
 		}
 		if *resp.Response.TotalCount > 0 {
-			state.Put("security_group_id", s.SecurityGroupId)
 			s.isCreate = false
+			state.Put("security_group_id", s.SecurityGroupId)
+			Message(state, *resp.Response.SecurityGroupSet[0].SecurityGroupName, "Securitygroup found")
 			return multistep.ActionContinue
 		}
-		message := fmt.Sprintf("the specified security group(%s) does not exist", s.SecurityGroupId)
-		ui.Error(message)
-		state.Put("error", errors.New(message))
-		return multistep.ActionHalt
+		return Halt(state, fmt.Errorf("The specified securitygroup(%s) does not exists", s.SecurityGroupId), "")
 	}
-	// create a new security group
+
+	Say(state, "Trying to create a new securitygroup", "")
+
 	req := vpc.NewCreateSecurityGroupRequest()
 	req.GroupName = &s.SecurityGroupName
 	req.GroupDescription = &s.Description
-	resp, err := vpcClient.CreateSecurityGroup(req)
+	var resp *vpc.CreateSecurityGroupResponse
+	err := Retry(ctx, func(ctx context.Context) error {
+		var e error
+		resp, e = vpcClient.CreateSecurityGroup(req)
+		return e
+	})
 	if err != nil {
-		ui.Error(fmt.Sprintf("create security group failed: %s", err.Error()))
-		state.Put("error", err)
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to create securitygroup")
 	}
+
+	s.isCreate = true
 	s.SecurityGroupId = *resp.Response.SecurityGroup.SecurityGroupId
 	state.Put("security_group_id", s.SecurityGroupId)
-	s.isCreate = true
+	Message(state, s.SecurityGroupId, "Securitygroup created")
 
-	// bind security group ingress police
+	// bind securitygroup ingress police
+	Say(state, "Trying to create securitygroup polices", "")
 	pReq := vpc.NewCreateSecurityGroupPoliciesRequest()
 	ACCEPT := "ACCEPT"
 	DEFAULT_CIDR := "0.0.0.0/0"
@@ -70,14 +74,15 @@ func (s *stepConfigSecurityGroup) Run(ctx context.Context, state multistep.State
 			},
 		},
 	}
-	_, err = vpcClient.CreateSecurityGroupPolicies(pReq)
+	err = Retry(ctx, func(ctx context.Context) error {
+		_, e := vpcClient.CreateSecurityGroupPolicies(pReq)
+		return e
+	})
 	if err != nil {
-		ui.Error(fmt.Sprintf("bind security group police failed: %s", err.Error()))
-		state.Put("error", err)
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to create securitygroup polices")
 	}
 
-	// bind security group engress police
+	// bind securitygroup engress police
 	pReq = vpc.NewCreateSecurityGroupPoliciesRequest()
 	pReq.SecurityGroupId = &s.SecurityGroupId
 	pReq.SecurityGroupPolicySet = &vpc.SecurityGroupPolicySet{
@@ -88,13 +93,16 @@ func (s *stepConfigSecurityGroup) Run(ctx context.Context, state multistep.State
 			},
 		},
 	}
-	_, err = vpcClient.CreateSecurityGroupPolicies(pReq)
+	err = Retry(ctx, func(ctx context.Context) error {
+		_, e := vpcClient.CreateSecurityGroupPolicies(pReq)
+		return e
+	})
 	if err != nil {
-		ui.Error(fmt.Sprintf("bind security group police failed: %s", err.Error()))
-		state.Put("error", err)
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to create securitygroup polices")
 	}
 
+	Message(state, "Securitygroup polices created", "")
+
 	return multistep.ActionContinue
 }
 
@@ -102,23 +110,19 @@ func (s *stepConfigSecurityGroup) Cleanup(state multistep.StateBag) {
 	if !s.isCreate {
 		return
 	}
+
 	ctx := context.TODO()
 	vpcClient := state.Get("vpc_client").(*vpc.Client)
-	ui := state.Get("ui").(packer.Ui)
 
-	MessageClean(state, "Security Group")
+	SayClean(state, "securitygroup")
+
 	req := vpc.NewDeleteSecurityGroupRequest()
 	req.SecurityGroupId = &s.SecurityGroupId
-	err := retry.Config{
-		Tries:      60,
-		RetryDelay: (&retry.Backoff{InitialBackoff: 5 * time.Second, MaxBackoff: 5 * time.Second, Multiplier: 2}).Linear,
-	}.Run(ctx, func(ctx context.Context) error {
-		_, err := vpcClient.DeleteSecurityGroup(req)
-		return err
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := vpcClient.DeleteSecurityGroup(req)
+		return e
 	})
 	if err != nil {
-		ui.Error(fmt.Sprintf("delete security group(%s) failed: %s, you need to delete it by hand",
-			s.SecurityGroupId, err.Error()))
-		return
+		Error(state, err, fmt.Sprintf("Failed to delete securitygroup(%s), please delete it manually", s.SecurityGroupId))
 	}
 }
diff --git a/builder/tencentcloud/cvm/step_config_subnet.go b/builder/tencentcloud/cvm/step_config_subnet.go
index a200591da..91ab42b7f 100644
--- a/builder/tencentcloud/cvm/step_config_subnet.go
+++ b/builder/tencentcloud/cvm/step_config_subnet.go
@@ -3,12 +3,8 @@ package cvm
 import (
 	"context"
 	"fmt"
-	"time"
 
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/pkg/errors"
 	vpc "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312"
 )
 
@@ -22,79 +18,76 @@ type stepConfigSubnet struct {
 
 func (s *stepConfigSubnet) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	vpcClient := state.Get("vpc_client").(*vpc.Client)
-	ui := state.Get("ui").(packer.Ui)
+
 	vpcId := state.Get("vpc_id").(string)
 
-	if len(s.SubnetId) != 0 { // exist subnet
-		ui.Say(fmt.Sprintf("Trying to use existing subnet(%s)", s.SubnetId))
+	if len(s.SubnetId) != 0 {
+		Say(state, s.SubnetId, "Trying to use existing subnet")
 		req := vpc.NewDescribeSubnetsRequest()
 		req.SubnetIds = []*string{&s.SubnetId}
-		resp, err := vpcClient.DescribeSubnets(req)
+		var resp *vpc.DescribeSubnetsResponse
+		err := Retry(ctx, func(ctx context.Context) error {
+			var e error
+			resp, e = vpcClient.DescribeSubnets(req)
+			return e
+		})
 		if err != nil {
-			ui.Error(fmt.Sprintf("query subnet failed: %s", err.Error()))
-			state.Put("error", err)
-			return multistep.ActionHalt
+			return Halt(state, err, "Failed to get subnet info")
 		}
 		if *resp.Response.TotalCount > 0 {
-			subnet0 := *resp.Response.SubnetSet[0]
-			if *subnet0.VpcId != vpcId {
-				message := fmt.Sprintf("the specified subnet(%s) does not belong to "+
-					"the specified vpc(%s)", s.SubnetId, vpcId)
-				ui.Error(message)
-				state.Put("error", errors.New(message))
-				return multistep.ActionHalt
-			}
-			state.Put("subnet_id", *subnet0.SubnetId)
 			s.isCreate = false
+			if *resp.Response.SubnetSet[0].VpcId != vpcId {
+				return Halt(state, fmt.Errorf("The specified subnet(%s) does not belong to the specified vpc(%s)", s.SubnetId, vpcId), "")
+			}
+			state.Put("subnet_id", *resp.Response.SubnetSet[0].SubnetId)
+			Message(state, *resp.Response.SubnetSet[0].SubnetName, "Subnet found")
 			return multistep.ActionContinue
 		}
-		message := fmt.Sprintf("the specified subnet(%s) does not exist", s.SubnetId)
-		state.Put("error", errors.New(message))
-		ui.Error(message)
-		return multistep.ActionHalt
-	} else { // create a new subnet, tencentcloud create subnet api is synchronous, no need to wait for create.
-		ui.Say(fmt.Sprintf("Trying to create a new subnet"))
-		req := vpc.NewCreateSubnetRequest()
-		req.VpcId = &vpcId
-		req.SubnetName = &s.SubnetName
-		req.CidrBlock = &s.SubnetCidrBlock
-		req.Zone = &s.Zone
-		resp, err := vpcClient.CreateSubnet(req)
-		if err != nil {
-			ui.Error(fmt.Sprintf("create subnet failed: %s", err.Error()))
-			state.Put("error", err)
-			return multistep.ActionHalt
-		}
-		subnet0 := *resp.Response.Subnet
-		state.Put("subnet_id", *subnet0.SubnetId)
-		s.SubnetId = *subnet0.SubnetId
-		s.isCreate = true
-		return multistep.ActionContinue
+		return Halt(state, fmt.Errorf("The specified subnet(%s) does not exist", s.SubnetId), "")
 	}
+
+	Say(state, "Trying to create a new subnet", "")
+
+	req := vpc.NewCreateSubnetRequest()
+	req.VpcId = &vpcId
+	req.SubnetName = &s.SubnetName
+	req.CidrBlock = &s.SubnetCidrBlock
+	req.Zone = &s.Zone
+	var resp *vpc.CreateSubnetResponse
+	err := Retry(ctx, func(ctx context.Context) error {
+		var e error
+		resp, e = vpcClient.CreateSubnet(req)
+		return e
+	})
+	if err != nil {
+		return Halt(state, err, "Failed to create subnet")
+	}
+
+	s.isCreate = true
+	s.SubnetId = *resp.Response.Subnet.SubnetId
+	state.Put("subnet_id", s.SubnetId)
+	Message(state, s.SubnetId, "Subnet created")
+
+	return multistep.ActionContinue
 }
 
 func (s *stepConfigSubnet) Cleanup(state multistep.StateBag) {
 	if !s.isCreate {
 		return
 	}
+
 	ctx := context.TODO()
-
 	vpcClient := state.Get("vpc_client").(*vpc.Client)
-	ui := state.Get("ui").(packer.Ui)
 
-	MessageClean(state, "SUBNET")
+	SayClean(state, "subnet")
+
 	req := vpc.NewDeleteSubnetRequest()
 	req.SubnetId = &s.SubnetId
-	err := retry.Config{
-		Tries:      60,
-		RetryDelay: (&retry.Backoff{InitialBackoff: 5 * time.Second, MaxBackoff: 5 * time.Second, Multiplier: 2}).Linear,
-	}.Run(ctx, func(ctx context.Context) error {
-		_, err := vpcClient.DeleteSubnet(req)
-		return err
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := vpcClient.DeleteSubnet(req)
+		return e
 	})
 	if err != nil {
-		ui.Error(fmt.Sprintf("delete subnet(%s) failed: %s, you need to delete it by hand",
-			s.SubnetId, err.Error()))
-		return
+		Error(state, err, fmt.Sprintf("Failed to delete subnet(%s), please delete it manually", s.SubnetId))
 	}
 }
diff --git a/builder/tencentcloud/cvm/step_config_vpc.go b/builder/tencentcloud/cvm/step_config_vpc.go
index 46630278a..707afb467 100644
--- a/builder/tencentcloud/cvm/step_config_vpc.go
+++ b/builder/tencentcloud/cvm/step_config_vpc.go
@@ -3,12 +3,8 @@ package cvm
 import (
 	"context"
 	"fmt"
-	"time"
 
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/pkg/errors"
 	vpc "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312"
 )
 
@@ -21,69 +17,69 @@ type stepConfigVPC struct {
 
 func (s *stepConfigVPC) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	vpcClient := state.Get("vpc_client").(*vpc.Client)
-	ui := state.Get("ui").(packer.Ui)
 
-	if len(s.VpcId) != 0 { // exist vpc
-		ui.Say(fmt.Sprintf("Trying to use existing vpc(%s)", s.VpcId))
+	if len(s.VpcId) != 0 {
+		Say(state, s.VpcId, "Trying to use existing vpc")
 		req := vpc.NewDescribeVpcsRequest()
 		req.VpcIds = []*string{&s.VpcId}
-		resp, err := vpcClient.DescribeVpcs(req)
+		var resp *vpc.DescribeVpcsResponse
+		err := Retry(ctx, func(ctx context.Context) error {
+			var e error
+			resp, e = vpcClient.DescribeVpcs(req)
+			return e
+		})
 		if err != nil {
-			ui.Error(fmt.Sprintf("query vpc failed: %s", err.Error()))
-			state.Put("error", err)
-			return multistep.ActionHalt
+			return Halt(state, err, "Failed to get vpc info")
 		}
 		if *resp.Response.TotalCount > 0 {
-			vpc0 := *resp.Response.VpcSet[0]
-			state.Put("vpc_id", *vpc0.VpcId)
 			s.isCreate = false
+			state.Put("vpc_id", *resp.Response.VpcSet[0].VpcId)
+			Message(state, *resp.Response.VpcSet[0].VpcName, "Vpc found")
 			return multistep.ActionContinue
 		}
-		message := fmt.Sprintf("the specified vpc(%s) does not exist", s.VpcId)
-		state.Put("error", errors.New(message))
-		ui.Error(message)
-		return multistep.ActionHalt
-	} else { // create a new vpc, tencentcloud create vpc api is synchronous, no need to wait for create.
-		ui.Say(fmt.Sprintf("Trying to create a new vpc"))
-		req := vpc.NewCreateVpcRequest()
-		req.VpcName = &s.VpcName
-		req.CidrBlock = &s.CidrBlock
-		resp, err := vpcClient.CreateVpc(req)
-		if err != nil {
-			ui.Error(fmt.Sprintf("create vpc failed: %s", err.Error()))
-			state.Put("error", err)
-			return multistep.ActionHalt
-		}
-		vpc0 := *resp.Response.Vpc
-		state.Put("vpc_id", *vpc0.VpcId)
-		s.VpcId = *vpc0.VpcId
-		s.isCreate = true
-		return multistep.ActionContinue
+		return Halt(state, fmt.Errorf("The specified vpc(%s) does not exist", s.VpcId), "")
 	}
+
+	Say(state, "Trying to create a new vpc", "")
+
+	req := vpc.NewCreateVpcRequest()
+	req.VpcName = &s.VpcName
+	req.CidrBlock = &s.CidrBlock
+	var resp *vpc.CreateVpcResponse
+	err := Retry(ctx, func(ctx context.Context) error {
+		var e error
+		resp, e = vpcClient.CreateVpc(req)
+		return e
+	})
+	if err != nil {
+		return Halt(state, err, "Failed to create vpc")
+	}
+
+	s.isCreate = true
+	s.VpcId = *resp.Response.Vpc.VpcId
+	state.Put("vpc_id", s.VpcId)
+	Message(state, s.VpcId, "Vpc created")
+
+	return multistep.ActionContinue
 }
 
 func (s *stepConfigVPC) Cleanup(state multistep.StateBag) {
 	if !s.isCreate {
 		return
 	}
+
 	ctx := context.TODO()
-
 	vpcClient := state.Get("vpc_client").(*vpc.Client)
-	ui := state.Get("ui").(packer.Ui)
 
-	MessageClean(state, "VPC")
+	SayClean(state, "vpc")
+
 	req := vpc.NewDeleteVpcRequest()
 	req.VpcId = &s.VpcId
-	err := retry.Config{
-		Tries:      60,
-		RetryDelay: (&retry.Backoff{InitialBackoff: 5 * time.Second, MaxBackoff: 5 * time.Second, Multiplier: 2}).Linear,
-	}.Run(ctx, func(ctx context.Context) error {
-		_, err := vpcClient.DeleteVpc(req)
-		return err
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := vpcClient.DeleteVpc(req)
+		return e
 	})
 	if err != nil {
-		ui.Error(fmt.Sprintf("delete vpc(%s) failed: %s, you need to delete it by hand",
-			s.VpcId, err.Error()))
-		return
+		Error(state, err, fmt.Sprintf("Failed to delete vpc(%s), please delete it manually", s.VpcId))
 	}
 }
diff --git a/builder/tencentcloud/cvm/step_copy_image.go b/builder/tencentcloud/cvm/step_copy_image.go
index e71a9f8cd..b8494f354 100644
--- a/builder/tencentcloud/cvm/step_copy_image.go
+++ b/builder/tencentcloud/cvm/step_copy_image.go
@@ -2,10 +2,9 @@ package cvm
 
 import (
 	"context"
-	"fmt"
+	"strings"
 
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 	cvm "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312"
 )
 
@@ -20,9 +19,11 @@ func (s *stepCopyImage) Run(ctx context.Context, state multistep.StateBag) multi
 	}
 
 	client := state.Get("cvm_client").(*cvm.Client)
-	ui := state.Get("ui").(packer.Ui)
+
 	imageId := state.Get("image").(*cvm.Image).ImageId
 
+	Say(state, strings.Join(s.DesinationRegions, ","), "Trying to copy image to")
+
 	req := cvm.NewSyncImagesRequest()
 	req.ImageIds = []*string{imageId}
 	copyRegions := make([]*string, 0, len(s.DesinationRegions))
@@ -33,15 +34,17 @@ func (s *stepCopyImage) Run(ctx context.Context, state multistep.StateBag) multi
 	}
 	req.DestinationRegions = copyRegions
 
-	_, err := client.SyncImages(req)
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := client.SyncImages(req)
+		return e
+	})
 	if err != nil {
-		state.Put("error", err)
-		ui.Error(fmt.Sprintf("copy image failed: %s", err.Error()))
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to copy image")
 	}
+
+	Message(state, "Image copied", "")
+
 	return multistep.ActionContinue
 }
 
-func (s *stepCopyImage) Cleanup(state multistep.StateBag) {
-	// just do nothing
-}
+func (s *stepCopyImage) Cleanup(state multistep.StateBag) {}
diff --git a/builder/tencentcloud/cvm/step_create_image.go b/builder/tencentcloud/cvm/step_create_image.go
index 1d162fa36..9c4b1e7b3 100644
--- a/builder/tencentcloud/cvm/step_create_image.go
+++ b/builder/tencentcloud/cvm/step_create_image.go
@@ -3,12 +3,8 @@ package cvm
 import (
 	"context"
 	"fmt"
-	"time"
 
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
-	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
 	cvm "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312"
 )
 
@@ -17,17 +13,18 @@ type stepCreateImage struct {
 }
 
 func (s *stepCreateImage) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
 	client := state.Get("cvm_client").(*cvm.Client)
-	ui := state.Get("ui").(packer.Ui)
+
+	config := state.Get("config").(*Config)
 	instance := state.Get("instance").(*cvm.Instance)
 
-	ui.Say(fmt.Sprintf("Creating image %s", config.ImageName))
+	Say(state, config.ImageName, "Trying to create a new image")
 
 	req := cvm.NewCreateImageRequest()
 	req.ImageName = &config.ImageName
 	req.ImageDescription = &config.ImageDescription
 	req.InstanceId = instance.InstanceId
+
 	// TODO: We should allow user to specify which data disk should be
 	// included into created image.
 	var dataDiskIds []*string
@@ -46,51 +43,24 @@ func (s *stepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
 		req.ForcePoweroff = &False
 	}
 
-	if config.Reboot {
-		req.Reboot = &True
-	} else {
-		req.Reboot = &False
-	}
-
 	if config.Sysprep {
 		req.Sysprep = &True
 	} else {
 		req.Sysprep = &False
 	}
 
-	err := retry.Config{
-		Tries: 60,
-		RetryDelay: (&retry.Backoff{
-			InitialBackoff: 5 * time.Second,
-			MaxBackoff:     5 * time.Second,
-			Multiplier:     2,
-		}).Linear,
-		ShouldRetry: func(err error) bool {
-			if e, ok := err.(*errors.TencentCloudSDKError); ok {
-				if e.Code == "InvalidImageName.Duplicate" {
-					return false
-				}
-			}
-			return true
-		},
-	}.Run(ctx, func(ctx context.Context) error {
-		_, err := client.CreateImage(req)
-		return err
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := client.CreateImage(req)
+		return e
 	})
-
 	if err != nil {
-		err := fmt.Errorf("create image failed: %s", err.Error())
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to create image")
 	}
 
+	Message(state, "Waiting for image ready", "")
 	err = WaitForImageReady(client, config.ImageName, "NORMAL", 3600)
 	if err != nil {
-		err := fmt.Errorf("create image failed: %s", err.Error())
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to wait for image ready")
 	}
 
 	describeReq := cvm.NewDescribeImagesRequest()
@@ -101,21 +71,24 @@ func (s *stepCreateImage) Run(ctx context.Context, state multistep.StateBag) mul
 			Values: []*string{&config.ImageName},
 		},
 	}
-	describeResp, err := client.DescribeImages(describeReq)
+
+	var describeResp *cvm.DescribeImagesResponse
+	err = Retry(ctx, func(ctx context.Context) error {
+		var e error
+		describeResp, e = client.DescribeImages(describeReq)
+		return e
+	})
 	if err != nil {
-		err := fmt.Errorf("wait image ready failed: %s", err.Error())
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to wait for image ready")
 	}
+
 	if *describeResp.Response.TotalCount == 0 {
-		err := fmt.Errorf("create image(%s) failed", config.ImageName)
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, fmt.Errorf("No image return"), "Failed to crate image")
 	}
+
 	s.imageId = *describeResp.Response.ImageSet[0].ImageId
 	state.Put("image", describeResp.Response.ImageSet[0])
+	Message(state, s.imageId, "Image created")
 
 	tencentCloudImages := make(map[string]string)
 	tencentCloudImages[config.Region] = s.imageId
@@ -128,20 +101,25 @@ func (s *stepCreateImage) Cleanup(state multistep.StateBag) {
 	if s.imageId == "" {
 		return
 	}
+
 	_, cancelled := state.GetOk(multistep.StateCancelled)
 	_, halted := state.GetOk(multistep.StateHalted)
 	if !cancelled && !halted {
 		return
 	}
 
+	ctx := context.TODO()
 	client := state.Get("cvm_client").(*cvm.Client)
-	ui := state.Get("ui").(packer.Ui)
 
-	ui.Say("Delete image because of cancellation or error...")
+	SayClean(state, "image")
+
 	req := cvm.NewDeleteImagesRequest()
 	req.ImageIds = []*string{&s.imageId}
-	_, err := client.DeleteImages(req)
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := client.DeleteImages(req)
+		return e
+	})
 	if err != nil {
-		ui.Error(fmt.Sprintf("delete image(%s) failed", s.imageId))
+		Error(state, err, fmt.Sprintf("Failed to delete image(%s), please delete it manually", s.imageId))
 	}
 }
diff --git a/builder/tencentcloud/cvm/step_detach_temp_key_pair.go b/builder/tencentcloud/cvm/step_detach_temp_key_pair.go
index ea1feff73..dd9bc5a1b 100644
--- a/builder/tencentcloud/cvm/step_detach_temp_key_pair.go
+++ b/builder/tencentcloud/cvm/step_detach_temp_key_pair.go
@@ -2,12 +2,8 @@ package cvm
 
 import (
 	"context"
-	"fmt"
-	"time"
 
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
 	cvm "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312"
 )
@@ -17,35 +13,31 @@ type stepDetachTempKeyPair struct {
 
 func (s *stepDetachTempKeyPair) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("cvm_client").(*cvm.Client)
-	instance := state.Get("instance").(*cvm.Instance)
+
 	if _, ok := state.GetOk("temporary_key_pair_id"); !ok {
 		return multistep.ActionContinue
 	}
-	keyId := state.Get("temporary_key_pair_id").(*string)
-	ui := state.Get("ui").(packer.Ui)
-	ui.Say(fmt.Sprintf("Detaching temporary key pair %s...", *keyId))
+
+	keyId := state.Get("temporary_key_pair_id").(string)
+	instance := state.Get("instance").(*cvm.Instance)
+
+	Say(state, keyId, "Trying to detach keypair")
+
 	req := cvm.NewDisassociateInstancesKeyPairsRequest()
-	req.KeyIds = []*string{keyId}
+	req.KeyIds = []*string{&keyId}
 	req.InstanceIds = []*string{instance.InstanceId}
 	req.ForceStop = common.BoolPtr(true)
-	err := retry.Config{
-		Tries: 60,
-		RetryDelay: (&retry.Backoff{
-			InitialBackoff: 5 * time.Second,
-			MaxBackoff:     5 * time.Second,
-			Multiplier:     2,
-		}).Linear,
-	}.Run(ctx, func(ctx context.Context) error {
-		_, err := client.DisassociateInstancesKeyPairs(req)
-		return err
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := client.DisassociateInstancesKeyPairs(req)
+		return e
 	})
 	if err != nil {
-		ui.Error(fmt.Sprintf("Fail to detach temporary key pair from instance! Error: %s", err))
-		state.Put("error", err)
-		return multistep.ActionHalt
+		return Halt(state, err, "Fail to detach keypair from instance")
 	}
+
+	Message(state, "Keypair detached", "")
+
 	return multistep.ActionContinue
 }
 
-func (s *stepDetachTempKeyPair) Cleanup(state multistep.StateBag) {
-}
+func (s *stepDetachTempKeyPair) Cleanup(state multistep.StateBag) {}
diff --git a/builder/tencentcloud/cvm/step_pre_validate.go b/builder/tencentcloud/cvm/step_pre_validate.go
index ede5293df..7bee5d9ea 100644
--- a/builder/tencentcloud/cvm/step_pre_validate.go
+++ b/builder/tencentcloud/cvm/step_pre_validate.go
@@ -2,19 +2,45 @@ package cvm
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
+	cvm "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312"
 )
 
 type stepPreValidate struct {
-	DestImageName string
-	ForceDelete   bool
 }
 
 func (s *stepPreValidate) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
-	ui := state.Get("ui").(packer.Ui)
-	ui.Say("TencentCloud support images with same name, image_name check is not required.")
+	config := state.Get("config").(*Config)
+	client := state.Get("cvm_client").(*cvm.Client)
+
+	Say(state, config.ImageName, "Trying to check image name")
+
+	req := cvm.NewDescribeImagesRequest()
+	req.Filters = []*cvm.Filter{
+		{
+			Name:   common.StringPtr("image-name"),
+			Values: []*string{&config.ImageName},
+		},
+	}
+	var resp *cvm.DescribeImagesResponse
+	err := Retry(ctx, func(ctx context.Context) error {
+		var err error
+		resp, err = client.DescribeImages(req)
+		return err
+	})
+	if err != nil {
+		return Halt(state, err, "Failed to get images info")
+	}
+
+	if *resp.Response.TotalCount > 0 {
+		return Halt(state, fmt.Errorf("Image name %s has exists", config.ImageName), "")
+	}
+
+	Message(state, "useable", "Image name")
+
 	return multistep.ActionContinue
 }
 
diff --git a/builder/tencentcloud/cvm/step_run_instance.go b/builder/tencentcloud/cvm/step_run_instance.go
index 224a62425..b43e1fbf6 100644
--- a/builder/tencentcloud/cvm/step_run_instance.go
+++ b/builder/tencentcloud/cvm/step_run_instance.go
@@ -6,11 +6,8 @@ import (
 	"fmt"
 	"io/ioutil"
 	"log"
-	"time"
 
-	"github.com/hashicorp/packer/common/retry"
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
 	cvm "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312"
 )
 
@@ -32,8 +29,8 @@ type stepRunInstance struct {
 
 func (s *stepRunInstance) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
 	client := state.Get("cvm_client").(*cvm.Client)
+
 	config := state.Get("config").(*Config)
-	ui := state.Get("ui").(packer.Ui)
 	source_image := state.Get("source_image").(*cvm.Image)
 	vpc_id := state.Get("vpc_id").(string)
 	subnet_id := state.Get("subnet_id").(string)
@@ -43,15 +40,14 @@ func (s *stepRunInstance) Run(ctx context.Context, state multistep.StateBag) mul
 	if password == "" && config.Comm.WinRMPassword != "" {
 		password = config.Comm.WinRMPassword
 	}
+
 	userData, err := s.getUserData(state)
 	if err != nil {
-		err := fmt.Errorf("get user_data failed: %s", err.Error())
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to get user_data")
 	}
 
-	ui.Say("Creating Instance.")
+	Say(state, "Trying to create a new instance", "")
+
 	// config RunInstances parameters
 	POSTPAID_BY_HOUR := "POSTPAID_BY_HOUR"
 	req := cvm.NewRunInstancesRequest()
@@ -71,7 +67,7 @@ func (s *stepRunInstance) Run(ctx context.Context, state multistep.StateBag) mul
 	// System disk snapshot is mandatory, so if there are additional data disks,
 	// length will be larger than 1.
 	if source_image.SnapshotSet != nil && len(source_image.SnapshotSet) > 1 {
-		ui.Say("Use source image snapshot data disks, ignore user data disk settings.")
+		Message(state, "Use source image snapshot data disks, ignore user data disk settings", "")
 		var dataDisks []*cvm.DataDisk
 		for _, snapshot := range source_image.SnapshotSet {
 			if *snapshot.DiskUsage == "DATA_DISK" {
@@ -144,44 +140,49 @@ func (s *stepRunInstance) Run(ctx context.Context, state multistep.StateBag) mul
 		}
 	}
 
-	resp, err := client.RunInstances(req)
+	var resp *cvm.RunInstancesResponse
+	err = Retry(ctx, func(ctx context.Context) error {
+		var e error
+		resp, e = client.RunInstances(req)
+		return e
+	})
 	if err != nil {
-		err := fmt.Errorf("create instance failed: %s", err.Error())
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to run instance")
 	}
+
 	if len(resp.Response.InstanceIdSet) != 1 {
-		err := fmt.Errorf("create instance failed: %d instance(s) created", len(resp.Response.InstanceIdSet))
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, fmt.Errorf("No instance return"), "Failed to run instance")
 	}
+
 	s.instanceId = *resp.Response.InstanceIdSet[0]
+	Message(state, "Waiting for instance ready", "")
 
 	err = WaitForInstance(client, s.instanceId, "RUNNING", 1800)
 	if err != nil {
-		err := fmt.Errorf("wait instance launch failed: %s", err.Error())
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to wait for instance ready")
 	}
 
 	describeReq := cvm.NewDescribeInstancesRequest()
 	describeReq.InstanceIds = []*string{&s.instanceId}
-	describeResp, err := client.DescribeInstances(describeReq)
+	var describeResp *cvm.DescribeInstancesResponse
+	err = Retry(ctx, func(ctx context.Context) error {
+		var e error
+		describeResp, e = client.DescribeInstances(describeReq)
+		return e
+	})
 	if err != nil {
-		err := fmt.Errorf("wait instance launch failed: %s", err.Error())
-		state.Put("error", err)
-		ui.Error(err.Error())
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to wait for instance ready")
 	}
+
 	state.Put("instance", describeResp.Response.InstanceSet[0])
+	Message(state, s.instanceId, "Instance created")
+
 	return multistep.ActionContinue
 }
 
 func (s *stepRunInstance) getUserData(state multistep.StateBag) (string, error) {
 	userData := s.UserData
+
 	if userData == "" && s.UserDataFile != "" {
 		data, err := ioutil.ReadFile(s.UserDataFile)
 		if err != nil {
@@ -189,8 +190,10 @@ func (s *stepRunInstance) getUserData(state multistep.StateBag) (string, error)
 		}
 		userData = string(data)
 	}
+
 	userData = base64.StdEncoding.EncodeToString([]byte(userData))
-	log.Printf(fmt.Sprintf("user_data: %s", userData))
+	log.Printf(fmt.Sprintf("[DEBUG]getUserData: user_data: %s", userData))
+
 	return userData, nil
 }
 
@@ -198,24 +201,19 @@ func (s *stepRunInstance) Cleanup(state multistep.StateBag) {
 	if s.instanceId == "" {
 		return
 	}
-	MessageClean(state, "Instance")
+
+	ctx := context.TODO()
 	client := state.Get("cvm_client").(*cvm.Client)
-	ui := state.Get("ui").(packer.Ui)
+
+	SayClean(state, "instance")
+
 	req := cvm.NewTerminateInstancesRequest()
 	req.InstanceIds = []*string{&s.instanceId}
-	ctx := context.TODO()
-	err := retry.Config{
-		Tries: 60,
-		RetryDelay: (&retry.Backoff{
-			InitialBackoff: 5 * time.Second,
-			MaxBackoff:     5 * time.Second,
-			Multiplier:     2,
-		}).Linear,
-	}.Run(ctx, func(ctx context.Context) error {
-		_, err := client.TerminateInstances(req)
-		return err
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := client.TerminateInstances(req)
+		return e
 	})
 	if err != nil {
-		ui.Error(fmt.Sprintf("terminate instance(%s) failed: %s", s.instanceId, err.Error()))
+		Error(state, err, fmt.Sprintf("Failed to terminate instance(%s), please delete it manually", s.instanceId))
 	}
 }
diff --git a/builder/tencentcloud/cvm/step_share_image.go b/builder/tencentcloud/cvm/step_share_image.go
index ffbe3ab9a..f5d4986b8 100644
--- a/builder/tencentcloud/cvm/step_share_image.go
+++ b/builder/tencentcloud/cvm/step_share_image.go
@@ -3,9 +3,10 @@ package cvm
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/hashicorp/packer/helper/multistep"
-	"github.com/hashicorp/packer/packer"
+	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common"
 	cvm "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312"
 )
 
@@ -19,50 +20,57 @@ func (s *stepShareImage) Run(ctx context.Context, state multistep.StateBag) mult
 	}
 
 	client := state.Get("cvm_client").(*cvm.Client)
-	ui := state.Get("ui").(packer.Ui)
+
 	imageId := state.Get("image").(*cvm.Image).ImageId
+	Say(state, strings.Join(s.ShareAccounts, ","), "Trying to share image to")
 
 	req := cvm.NewModifyImageSharePermissionRequest()
 	req.ImageId = imageId
-	SHARE := "SHARE"
-	req.Permission = &SHARE
+	req.Permission = common.StringPtr("SHARE")
 	accounts := make([]*string, 0, len(s.ShareAccounts))
 	for _, account := range s.ShareAccounts {
 		accounts = append(accounts, &account)
 	}
 	req.AccountIds = accounts
-
-	_, err := client.ModifyImageSharePermission(req)
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := client.ModifyImageSharePermission(req)
+		return e
+	})
 	if err != nil {
-		state.Put("error", err)
-		ui.Error(fmt.Sprintf("share image failed: %s", err.Error()))
-		return multistep.ActionHalt
+		return Halt(state, err, "Failed to share image")
 	}
+
+	Message(state, "Image shared", "")
+
 	return multistep.ActionContinue
 }
 
 func (s *stepShareImage) Cleanup(state multistep.StateBag) {
 	_, cancelled := state.GetOk(multistep.StateCancelled)
 	_, halted := state.GetOk(multistep.StateHalted)
-	if cancelled || halted {
-		ui := state.Get("ui").(packer.Ui)
-		client := state.Get("cvm_client").(*cvm.Client)
-		imageId := state.Get("image").(*cvm.Image).ImageId
-		ui.Say("Cancel share image due to action cancelled or halted.")
+	if !cancelled && !halted {
+		return
+	}
 
-		req := cvm.NewModifyImageSharePermissionRequest()
-		req.ImageId = imageId
-		CANCEL := "CANCEL"
-		req.Permission = &CANCEL
-		accounts := make([]*string, 0, len(s.ShareAccounts))
-		for _, account := range s.ShareAccounts {
-			accounts = append(accounts, &account)
-		}
-		req.AccountIds = accounts
+	ctx := context.TODO()
+	client := state.Get("cvm_client").(*cvm.Client)
 
-		_, err := client.ModifyImageSharePermission(req)
-		if err != nil {
-			ui.Error(fmt.Sprintf("Cancel share image failed: %s", err.Error()))
-		}
+	imageId := state.Get("image").(*cvm.Image).ImageId
+	SayClean(state, "image share")
+
+	req := cvm.NewModifyImageSharePermissionRequest()
+	req.ImageId = imageId
+	req.Permission = common.StringPtr("CANCEL")
+	accounts := make([]*string, 0, len(s.ShareAccounts))
+	for _, account := range s.ShareAccounts {
+		accounts = append(accounts, &account)
+	}
+	req.AccountIds = accounts
+	err := Retry(ctx, func(ctx context.Context) error {
+		_, e := client.ModifyImageSharePermission(req)
+		return e
+	})
+	if err != nil {
+		Error(state, err, fmt.Sprintf("Failed to cancel share image(%s), please delete it manually", *imageId))
 	}
 }
diff --git a/examples/tencentcloud/basic-with-data-disk.json b/examples/tencentcloud/basic-with-data-disk.json
index 695a68014..9f78afdbe 100644
--- a/examples/tencentcloud/basic-with-data-disk.json
+++ b/examples/tencentcloud/basic-with-data-disk.json
@@ -3,32 +3,38 @@
     "secret_id": "{{env `TENCENTCLOUD_ACCESS_KEY`}}",
     "secret_key": "{{env `TENCENTCLOUD_SECRET_KEY`}}"
   },
-  "builders": [{
-    "type": "tencentcloud-cvm",
-    "secret_id": "{{user `secret_id`}}",
-    "secret_key": "{{user `secret_key`}}",
-    "region": "ap-guangzhou",
-    "zone": "ap-guangzhou-4",
-    "instance_type": "S4.SMALL1",
-    "source_image_id": "img-oikl1tzv",
-    "ssh_username" : "root",
-    "image_name": "PackerTest",
-    "disk_type": "CLOUD_PREMIUM",
-    "packer_debug": true,
-    "associate_public_ip_address": true,
-    "run_tags": {
-      "good": "luck"
-    },
-    "data_disks": [{
-        "disk_type": "CLOUD_PREMIUM",
-	"disk_size": 50
-    }]
-  }],
-  "provisioners": [{
-    "type": "shell",
-    "inline": [
-      "sleep 30",
-      "yum install redis.x86_64 -y"
-    ]
-  }]
-}
+  "builders": [
+    {
+      "type": "tencentcloud-cvm",
+      "secret_id": "{{user `secret_id`}}",
+      "secret_key": "{{user `secret_key`}}",
+      "region": "ap-guangzhou",
+      "zone": "ap-guangzhou-4",
+      "instance_type": "S4.SMALL1",
+      "source_image_id": "img-oikl1tzv",
+      "ssh_username": "root",
+      "image_name": "PackerTest",
+      "disk_type": "CLOUD_PREMIUM",
+      "packer_debug": true,
+      "associate_public_ip_address": true,
+      "data_disks": [
+        {
+          "disk_type": "CLOUD_PREMIUM",
+          "disk_size": 50
+        }
+      ],
+      "run_tags": {
+        "good": "luck"
+      }
+    }
+  ],
+  "provisioners": [
+    {
+      "type": "shell",
+      "inline": [
+        "sleep 30",
+        "yum install redis.x86_64 -y"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/examples/tencentcloud/basic.json b/examples/tencentcloud/basic.json
index 4e90efd36..09663ebbc 100644
--- a/examples/tencentcloud/basic.json
+++ b/examples/tencentcloud/basic.json
@@ -3,28 +3,32 @@
     "secret_id": "{{env `TENCENTCLOUD_ACCESS_KEY`}}",
     "secret_key": "{{env `TENCENTCLOUD_SECRET_KEY`}}"
   },
-  "builders": [{
-    "type": "tencentcloud-cvm",
-    "secret_id": "{{user `secret_id`}}",
-    "secret_key": "{{user `secret_key`}}",
-    "region": "ap-guangzhou",
-    "zone": "ap-guangzhou-4",
-    "instance_type": "S4.SMALL1",
-    "source_image_id": "img-oikl1tzv",
-    "ssh_username" : "root",
-    "image_name": "PackerTest",
-    "disk_type": "CLOUD_PREMIUM",
-    "packer_debug": true,
-    "associate_public_ip_address": true,
-    "run_tags": {
-      "good": "luck"
+  "builders": [
+    {
+      "type": "tencentcloud-cvm",
+      "secret_id": "{{user `secret_id`}}",
+      "secret_key": "{{user `secret_key`}}",
+      "region": "ap-guangzhou",
+      "zone": "ap-guangzhou-4",
+      "instance_type": "S4.SMALL1",
+      "source_image_id": "img-oikl1tzv",
+      "ssh_username": "root",
+      "image_name": "PackerTest",
+      "disk_type": "CLOUD_PREMIUM",
+      "packer_debug": true,
+      "associate_public_ip_address": true,
+      "run_tags": {
+        "good": "luck"
+      }
     }
-  }],
-  "provisioners": [{
-    "type": "shell",
-    "inline": [
-      "sleep 30",
-      "yum install redis.x86_64 -y"
-    ]
-  }]
-}
+  ],
+  "provisioners": [
+    {
+      "type": "shell",
+      "inline": [
+        "sleep 30",
+        "yum install redis.x86_64 -y"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/examples/tencentcloud/centos.json b/examples/tencentcloud/centos.json
index 6b4d13bd5..1d55f3fe7 100644
--- a/examples/tencentcloud/centos.json
+++ b/examples/tencentcloud/centos.json
@@ -3,33 +3,40 @@
     "secret_id": "{{env `TENCENTCLOUD_ACCESS_KEY`}}",
     "secret_key": "{{env `TENCENTCLOUD_SECRET_KEY`}}"
   },
-  "builders": [{
-    "type": "tencentcloud-cvm",
-    "secret_id": "{{user `secret_id`}}",
-    "secret_key": "{{user `secret_key`}}",
-    "region": "ap-guangzhou",
-    "zone": "ap-guangzhou-3",
-    "instance_type": "S3.SMALL1",
-    "source_image_id": "img-oikl1tzv",
-    "vpc_id": "vpc-gjusx3kd",
-    "subnet_id": "subnet-pfditepm",
-    "internet_max_bandwidth_out": 2,
-    "security_group_id": "sg-rypoiksl",
-    "ssh_username" : "root",
-    "image_name": "packerTest",
-    "host_name": "packerTest",
-    "associate_public_ip_address": true,
-    "image_description": "centosPacker",
-    "image_copy_regions": ["ap-beijing"]
-  }],
-  "provisioners": [{
-    "execute_command": "echo '{{user `ssh_pass`}}' | {{ .Vars }} sudo -S -E sh '{{ .Path }}'",
-    "inline": [
-      "yum update -y",
-      "/usr/sbin/waagent -force -deprovision+user && export HISTSIZE=0 && sync"
-    ],
-    "inline_shebang": "/bin/sh -x",
-    "type": "shell",
-    "skip_clean": true
-  }]
+  "builders": [
+    {
+      "type": "tencentcloud-cvm",
+      "secret_id": "{{user `secret_id`}}",
+      "secret_key": "{{user `secret_key`}}",
+      "region": "ap-guangzhou",
+      "zone": "ap-guangzhou-3",
+      "instance_type": "S3.SMALL1",
+      "source_image_id": "img-oikl1tzv",
+      "disk_type": "CLOUD_PREMIUM",
+      "vpc_id": "vpc-h70b6b49",
+      "subnet_id": "subnet-1uwh63so",
+      "internet_max_bandwidth_out": 2,
+      "security_group_id": "sg-nltpbqg1",
+      "ssh_username": "root",
+      "image_name": "packerTest",
+      "host_name": "packerTest",
+      "associate_public_ip_address": true,
+      "image_description": "centosPacker",
+      "image_copy_regions": [
+        "ap-beijing"
+      ]
+    }
+  ],
+  "provisioners": [
+    {
+      "execute_command": "echo '{{user `ssh_pass`}}' | {{ .Vars }} sudo -S -E sh '{{ .Path }}'",
+      "inline": [
+        "yum update -y",
+        "/usr/sbin/waagent -force -deprovision+user && export HISTSIZE=0 && sync"
+      ],
+      "inline_shebang": "/bin/sh -x",
+      "type": "shell",
+      "skip_clean": true
+    }
+  ]
 }
\ No newline at end of file
diff --git a/go.mod b/go.mod
index f6fb13583..288e877b7 100644
--- a/go.mod
+++ b/go.mod
@@ -131,7 +131,7 @@ require (
 	github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c // indirect
 	github.com/stretchr/testify v1.4.0
 	github.com/temoto/robotstxt v1.1.1 // indirect
-	github.com/tencentcloud/tencentcloud-sdk-go v3.0.71+incompatible
+	github.com/tencentcloud/tencentcloud-sdk-go v3.0.94+incompatible
 	github.com/ucloud/ucloud-sdk-go v0.8.7
 	github.com/ugorji/go v0.0.0-20151218193438-646ae4a518c1
 	github.com/ulikunitz/xz v0.5.5
diff --git a/go.sum b/go.sum
index 227d12cb6..d5a823c15 100644
--- a/go.sum
+++ b/go.sum
@@ -57,8 +57,6 @@ github.com/armon/go-radix v1.0.0 h1:F4z6KzEeeQIMeLFa97iZU6vupzoecKdU5TX24SNppXI=
 github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
 github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3ATZkfNZeM=
 github.com/aws/aws-sdk-go v1.16.22/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
-github.com/aws/aws-sdk-go v1.22.2 h1:uYP58k2Cd9y1qBy8CxTe5ADmdi4kANm8Ul8ch3kkIcQ=
-github.com/aws/aws-sdk-go v1.22.2/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/aws/aws-sdk-go v1.24.1 h1:B2NRyTV1/+h+Dg8Bh7vnuvW6QZz/NBL+uzgC2uILDMI=
 github.com/aws/aws-sdk-go v1.24.1/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/azr/flock v0.0.0-20190823144736-958d66434653 h1:2H3Cu0cbG8iszfcgnANwC/cm0YkPJIQvaJ9/tSpwh9o=
@@ -396,8 +394,8 @@ github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJy
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/temoto/robotstxt v1.1.1 h1:Gh8RCs8ouX3hRSxxK7B1mO5RFByQ4CmJZDwgom++JaA=
 github.com/temoto/robotstxt v1.1.1/go.mod h1:+1AmkuG3IYkh1kv0d2qEB9Le88ehNO0zwOr3ujewlOo=
-github.com/tencentcloud/tencentcloud-sdk-go v3.0.71+incompatible h1:9sIWfe6ZC7xoSlshYWNGicPqomK7N+CsHMa1YFWBCWU=
-github.com/tencentcloud/tencentcloud-sdk-go v3.0.71+incompatible/go.mod h1:0PfYow01SHPMhKY31xa+EFz2RStxIqj6JFAJS+IkCi4=
+github.com/tencentcloud/tencentcloud-sdk-go v3.0.94+incompatible h1:G8i7dPMK1RCpbQz+VpfFp679vmVna38NI8tz5xsybXI=
+github.com/tencentcloud/tencentcloud-sdk-go v3.0.94+incompatible/go.mod h1:0PfYow01SHPMhKY31xa+EFz2RStxIqj6JFAJS+IkCi4=
 github.com/ucloud/ucloud-sdk-go v0.8.7 h1:BmXOb5RivI0Uu4oZRpjI6SQ9/y7n/H9wxTGR1txIE8o=
 github.com/ucloud/ucloud-sdk-go v0.8.7/go.mod h1:lM6fpI8y6iwACtlbHUav823/uKPdXsNBlnBpRF2fj3c=
 github.com/ugorji/go v0.0.0-20151218193438-646ae4a518c1 h1:U6ufy3mLDgg9RYupntOvAF7xCmNNquyKaYaaVHo1Nnk=
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/client.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/client.go
index 92b2d7175..96a9644b1 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/client.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/client.go
@@ -6,10 +6,12 @@ import (
 	"fmt"
 	"log"
 	"net/http"
+	"net/http/httputil"
 	"strconv"
 	"strings"
 	"time"
 
+	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
 	tchttp "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http"
 	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile"
 )
@@ -18,6 +20,7 @@ type Client struct {
 	region          string
 	httpClient      *http.Client
 	httpProfile     *profile.HttpProfile
+	profile         *profile.ClientProfile
 	credential      *Credential
 	signMethod      string
 	unsignedPayload bool
@@ -47,6 +50,8 @@ func (c *Client) Send(request tchttp.Request, response tchttp.Response) (err err
 }
 
 func (c *Client) sendWithSignatureV1(request tchttp.Request, response tchttp.Response) (err error) {
+	// TODO: not an elegant way, it should be done in common params, but finally it need to refactor
+	request.GetParams()["Language"] = c.profile.Language
 	err = tchttp.ConstructParams(request)
 	if err != nil {
 		return err
@@ -62,10 +67,18 @@ func (c *Client) sendWithSignatureV1(request tchttp.Request, response tchttp.Res
 	if request.GetHttpMethod() == "POST" {
 		httpRequest.Header["Content-Type"] = []string{"application/x-www-form-urlencoded"}
 	}
-	//log.Printf("[DEBUG] http request=%v", httpRequest)
+	if c.debug {
+		outbytes, err := httputil.DumpRequest(httpRequest, true)
+		if err != nil {
+			log.Printf("[ERROR] dump request failed because %s", err)
+			return err
+		}
+		log.Printf("[DEBUG] http request = %s", outbytes)
+	}
 	httpResponse, err := c.httpClient.Do(httpRequest)
 	if err != nil {
-		return err
+		msg := fmt.Sprintf("Fail to get response because %s", err)
+		return errors.NewTencentCloudSDKError("ClientError.NetworkError", msg, "")
 	}
 	err = tchttp.ParseFromHttpResponse(httpResponse, response)
 	return err
@@ -78,6 +91,7 @@ func (c *Client) sendWithSignatureV3(request tchttp.Request, response tchttp.Res
 		"X-TC-Version":       request.GetVersion(),
 		"X-TC-Timestamp":     request.GetParams()["Timestamp"],
 		"X-TC-RequestClient": request.GetParams()["RequestClient"],
+		"X-TC-Language":      c.profile.Language,
 	}
 	if c.region != "" {
 		headers["X-TC-Region"] = c.region
@@ -184,10 +198,18 @@ func (c *Client) sendWithSignatureV3(request tchttp.Request, response tchttp.Res
 	for k, v := range headers {
 		httpRequest.Header[k] = []string{v}
 	}
-	//log.Printf("[DEBUG] http request=%v, body=%v", httpRequest, requestPayload)
+	if c.debug {
+		outbytes, err := httputil.DumpRequest(httpRequest, true)
+		if err != nil {
+			log.Printf("[ERROR] dump request failed because %s", err)
+			return err
+		}
+		log.Printf("[DEBUG] http request = %s", outbytes)
+	}
 	httpResponse, err := c.httpClient.Do(httpRequest)
 	if err != nil {
-		return err
+		msg := fmt.Sprintf("Fail to get response because %s", err)
+		return errors.NewTencentCloudSDKError("ClientError.NetworkError", msg, "")
 	}
 	err = tchttp.ParseFromHttpResponse(httpResponse, response)
 	return err
@@ -200,7 +222,7 @@ func (c *Client) GetRegion() string {
 func (c *Client) Init(region string) *Client {
 	c.httpClient = &http.Client{}
 	c.region = region
-	c.signMethod = "HmacSHA256"
+	c.signMethod = "TC3-HMAC-SHA256"
 	c.debug = false
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
 	return c
@@ -217,6 +239,7 @@ func (c *Client) WithCredential(cred *Credential) *Client {
 }
 
 func (c *Client) WithProfile(clientProfile *profile.ClientProfile) *Client {
+	c.profile = clientProfile
 	c.signMethod = clientProfile.SignMethod
 	c.unsignedPayload = clientProfile.UnsignedPayload
 	c.httpProfile = clientProfile.HttpProfile
@@ -229,7 +252,7 @@ func (c *Client) WithSignatureMethod(method string) *Client {
 	return c
 }
 
-func (c *Client) WithHttpTransport (transport http.RoundTripper) *Client {
+func (c *Client) WithHttpTransport(transport http.RoundTripper) *Client {
 	c.httpClient.Transport = transport
 	return c
 }
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http/request.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http/request.go
index 4774013fa..cdfbe7ec1 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http/request.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http/request.go
@@ -152,7 +152,7 @@ func CompleteCommonParams(request Request, region string) {
 	params["Action"] = request.GetAction()
 	params["Timestamp"] = strconv.FormatInt(time.Now().Unix(), 10)
 	params["Nonce"] = strconv.Itoa(rand.Int())
-	params["RequestClient"] = "SDK_GO_3.0.71"
+	params["RequestClient"] = "SDK_GO_3.0.94"
 }
 
 func ConstructParams(req Request) (err error) {
@@ -195,8 +195,9 @@ func flatStructure(value reflect.Value, request Request, prefix string) (err err
 		} else if kind == reflect.Float64 {
 			request.GetParams()[key] = strconv.FormatFloat(field.Float(), 'f', -1, 64)
 		} else if kind == reflect.Slice {
-			for j := 0; j < field.Len(); j++ {
-				vj := field.Index(j)
+			list := value.Field(i)
+			for j := 0; j < list.Len(); j++ {
+				vj := list.Index(j)
 				key := prefix + nameTag + "." + strconv.Itoa(j)
 				kind = vj.Kind()
 				if kind == reflect.Ptr && vj.IsNil() {
@@ -217,11 +218,15 @@ func flatStructure(value reflect.Value, request Request, prefix string) (err err
 				} else if kind == reflect.Float64 {
 					request.GetParams()[key] = strconv.FormatFloat(vj.Float(), 'f', -1, 64)
 				} else {
-					return flatStructure(vj, request, key+".")
+					if err = flatStructure(vj, request, key+"."); err != nil {
+						return
+					}
 				}
 			}
 		} else {
-			return flatStructure(reflect.ValueOf(field.Interface()), request, prefix+nameTag+".")
+			if err = flatStructure(reflect.ValueOf(field.Interface()), request, prefix+nameTag+"."); err != nil {
+				return
+			}
 		}
 	}
 	return
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http/response.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http/response.go
index c8e27f7f5..288f21bdf 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http/response.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http/response.go
@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
-	"log"
+	//"log"
 	"net/http"
 
 	"github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors"
@@ -37,7 +37,8 @@ func (r *BaseResponse) ParseErrorFromHTTPResponse(body []byte) (err error) {
 	resp := &ErrorResponse{}
 	err = json.Unmarshal(body, resp)
 	if err != nil {
-		return
+		msg := fmt.Sprintf("Fail to parse json content: %s, because: %s", body, err)
+		return errors.NewTencentCloudSDKError("ClientError.ParseJsonError", msg, "")
 	}
 	if resp.Response.Error.Code != "" {
 		return errors.NewTencentCloudSDKError(resp.Response.Error.Code, resp.Response.Error.Message, resp.Response.RequestId)
@@ -46,7 +47,8 @@ func (r *BaseResponse) ParseErrorFromHTTPResponse(body []byte) (err error) {
 	deprecated := &DeprecatedAPIErrorResponse{}
 	err = json.Unmarshal(body, deprecated)
 	if err != nil {
-		return
+		msg := fmt.Sprintf("Fail to parse json content: %s, because: %s", body, err)
+		return errors.NewTencentCloudSDKError("ClientError.ParseJsonError", msg, "")
 	}
 	if deprecated.Code != 0 {
 		return errors.NewTencentCloudSDKError(deprecated.CodeDesc, deprecated.Message, "")
@@ -58,10 +60,12 @@ func ParseFromHttpResponse(hr *http.Response, response Response) (err error) {
 	defer hr.Body.Close()
 	body, err := ioutil.ReadAll(hr.Body)
 	if err != nil {
-		return
+		msg := fmt.Sprintf("Fail to read response body because %s", err)
+		return errors.NewTencentCloudSDKError("ClientError.IOError", msg, "")
 	}
 	if hr.StatusCode != 200 {
-		return fmt.Errorf("Request fail with status: %s, with body: %s", hr.Status, body)
+		msg := fmt.Sprintf("Request fail with http status code: %s, with body: %s", hr.Status, body)
+		return errors.NewTencentCloudSDKError("ClientError.HttpStatusCodeError", msg, "")
 	}
 	//log.Printf("[DEBUG] Response Body=%s", body)
 	err = response.ParseErrorFromHTTPResponse(body)
@@ -70,7 +74,8 @@ func ParseFromHttpResponse(hr *http.Response, response Response) (err error) {
 	}
 	err = json.Unmarshal(body, &response)
 	if err != nil {
-		log.Printf("Unexpected Error occurs when parsing API response\n%s\n", string(body[:]))
+		msg := fmt.Sprintf("Fail to parse json content: %s, because: %s", body, err)
+		return errors.NewTencentCloudSDKError("ClientError.ParseJsonError", msg, "")
 	}
 	return
 }
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile/client_profile.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile/client_profile.go
index 0fc71750b..21069ff99 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile/client_profile.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile/client_profile.go
@@ -1,9 +1,14 @@
 package profile
 
 type ClientProfile struct {
-	HttpProfile     *HttpProfile
+	HttpProfile *HttpProfile
+	// Valid choices: HmacSHA1, HmacSHA256, TC3-HMAC-SHA256.
+	// Default value is TC3-HMAC-SHA256.
 	SignMethod      string
 	UnsignedPayload bool
+	// Valid choices: zh-CN, en-US.
+	// Default value is zh-CN.
+	Language string
 }
 
 func NewClientProfile() *ClientProfile {
@@ -11,5 +16,6 @@ func NewClientProfile() *ClientProfile {
 		HttpProfile:     NewHttpProfile(),
 		SignMethod:      "TC3-HMAC-SHA256",
 		UnsignedPayload: false,
+		Language:        "zh-CN",
 	}
 }
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile/http_profile.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile/http_profile.go
index 8d4bf8f57..cf633a8a0 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile/http_profile.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/profile/http_profile.go
@@ -4,7 +4,9 @@ type HttpProfile struct {
 	ReqMethod  string
 	ReqTimeout int
 	Endpoint   string
-	Protocol   string
+	// Deprecated, use Scheme instead
+	Protocol string
+	Scheme   string
 }
 
 func NewHttpProfile() *HttpProfile {
@@ -12,6 +14,6 @@ func NewHttpProfile() *HttpProfile {
 		ReqMethod:  "POST",
 		ReqTimeout: 60,
 		Endpoint:   "",
-		Protocol:   "HTTPS",
+		Scheme:     "HTTPS",
 	}
 }
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/sign.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/sign.go
index 63efd9227..0aa7b7355 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/sign.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/sign.go
@@ -1,14 +1,13 @@
 package common
 
 import (
+	"bytes"
 	"crypto/hmac"
 	"crypto/sha1"
 	"crypto/sha256"
 	"encoding/base64"
 	"encoding/hex"
-	"fmt"
 	"sort"
-	"strings"
 
 	tchttp "github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http"
 )
@@ -65,7 +64,11 @@ func getStringToSign(request tchttp.Request) string {
 	domain := request.GetDomain()
 	path := request.GetPath()
 
-	text := method + domain + path + "?"
+	var buf bytes.Buffer
+	buf.WriteString(method)
+	buf.WriteString(domain)
+	buf.WriteString(path)
+	buf.WriteString("?")
 
 	params := request.GetParams()
 	// sort params
@@ -77,11 +80,15 @@ func getStringToSign(request tchttp.Request) string {
 
 	for i := range keys {
 		k := keys[i]
+		// TODO: check if server side allows empty value in url.
 		if params[k] == "" {
 			continue
 		}
-		text += fmt.Sprintf("%v=%v&", strings.Replace(k, "_", ".", -1), params[k])
+		buf.WriteString(k)
+		buf.WriteString("=")
+		buf.WriteString(params[k])
+		buf.WriteString("&")
 	}
-	text = text[:len(text)-1]
-	return text
+	buf.Truncate(buf.Len() - 1)
+	return buf.String()
 }
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312/client.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312/client.go
index 3305127e1..24f87ebaf 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312/client.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312/client.go
@@ -743,6 +743,56 @@ func (c *Client) DescribeRegions(request *DescribeRegionsRequest) (response *Des
     return
 }
 
+func NewDescribeReservedInstancesRequest() (request *DescribeReservedInstancesRequest) {
+    request = &DescribeReservedInstancesRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("cvm", APIVersion, "DescribeReservedInstances")
+    return
+}
+
+func NewDescribeReservedInstancesResponse() (response *DescribeReservedInstancesResponse) {
+    response = &DescribeReservedInstancesResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口(DescribeReservedInstances)可提供列出用户已购买的预留实例
+func (c *Client) DescribeReservedInstances(request *DescribeReservedInstancesRequest) (response *DescribeReservedInstancesResponse, err error) {
+    if request == nil {
+        request = NewDescribeReservedInstancesRequest()
+    }
+    response = NewDescribeReservedInstancesResponse()
+    err = c.Send(request, response)
+    return
+}
+
+func NewDescribeReservedInstancesOfferingsRequest() (request *DescribeReservedInstancesOfferingsRequest) {
+    request = &DescribeReservedInstancesOfferingsRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("cvm", APIVersion, "DescribeReservedInstancesOfferings")
+    return
+}
+
+func NewDescribeReservedInstancesOfferingsResponse() (response *DescribeReservedInstancesOfferingsResponse) {
+    response = &DescribeReservedInstancesOfferingsResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口(DescribeReservedInstancesOfferings)供用户列出可购买的预留实例配置
+func (c *Client) DescribeReservedInstancesOfferings(request *DescribeReservedInstancesOfferingsRequest) (response *DescribeReservedInstancesOfferingsResponse, err error) {
+    if request == nil {
+        request = NewDescribeReservedInstancesOfferingsRequest()
+    }
+    response = NewDescribeReservedInstancesOfferingsResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewDescribeZoneInstanceConfigInfosRequest() (request *DescribeZoneInstanceConfigInfosRequest) {
     request = &DescribeZoneInstanceConfigInfosRequest{
         BaseRequest: &tchttp.BaseRequest{},
@@ -863,7 +913,7 @@ func NewImportImageResponse() (response *ImportImageResponse) {
     return
 }
 
-// 本接口(ImportImage)用于导入镜像，导入后的镜像可用于创建实例。
+// 本接口(ImportImage)用于导入镜像，导入后的镜像可用于创建实例。 
 func (c *Client) ImportImage(request *ImportImageRequest) (response *ImportImageResponse, err error) {
     if request == nil {
         request = NewImportImageRequest()
@@ -972,7 +1022,11 @@ func NewInquiryPriceResetInstanceResponse() (response *InquiryPriceResetInstance
     return
 }
 
-// 本接口 (InquiryPriceResetInstance) 用于重装实例询价。* 如果指定了`ImageId`参数，则使用指定的镜像进行重装询价；否则按照当前实例使用的镜像进行重装询价。* 目前只支持[系统盘类型](/document/api/213/9452#block_device)是`CLOUD_BASIC`、`CLOUD_PREMIUM`、`CLOUD_SSD`类型的实例使用该接口实现`Linux`和`Windows`操作系统切换的重装询价。* 目前不支持海外地域的实例使用该接口实现`Linux`和`Windows`操作系统切换的重装询价。
+// 本接口 (InquiryPriceResetInstance) 用于重装实例询价。
+// 
+// * 如果指定了`ImageId`参数，则使用指定的镜像进行重装询价；否则按照当前实例使用的镜像进行重装询价。
+// * 目前只支持[系统盘类型](/document/api/213/9452#block_device)是`CLOUD_BASIC`、`CLOUD_PREMIUM`、`CLOUD_SSD`类型的实例使用该接口实现`Linux`和`Windows`操作系统切换的重装询价。
+// * 目前不支持海外地域的实例使用该接口实现`Linux`和`Windows`操作系统切换的重装询价。
 func (c *Client) InquiryPriceResetInstance(request *InquiryPriceResetInstanceRequest) (response *InquiryPriceResetInstanceResponse, err error) {
     if request == nil {
         request = NewInquiryPriceResetInstanceRequest()
@@ -1374,6 +1428,31 @@ func (c *Client) ModifyKeyPairAttribute(request *ModifyKeyPairAttributeRequest)
     return
 }
 
+func NewPurchaseReservedInstancesOfferingRequest() (request *PurchaseReservedInstancesOfferingRequest) {
+    request = &PurchaseReservedInstancesOfferingRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("cvm", APIVersion, "PurchaseReservedInstancesOffering")
+    return
+}
+
+func NewPurchaseReservedInstancesOfferingResponse() (response *PurchaseReservedInstancesOfferingResponse) {
+    response = &PurchaseReservedInstancesOfferingResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口(PurchaseReservedInstancesOffering)用于用户购买一个或者多个指定配置的预留实例
+func (c *Client) PurchaseReservedInstancesOffering(request *PurchaseReservedInstancesOfferingRequest) (response *PurchaseReservedInstancesOfferingResponse, err error) {
+    if request == nil {
+        request = NewPurchaseReservedInstancesOfferingRequest()
+    }
+    response = NewPurchaseReservedInstancesOfferingResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewRebootInstancesRequest() (request *RebootInstancesRequest) {
     request = &RebootInstancesRequest{
         BaseRequest: &tchttp.BaseRequest{},
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312/models.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312/models.go
index aef3f7b30..d159bc4e2 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312/models.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/cvm/v20170312/models.go
@@ -243,19 +243,17 @@ type CreateImageRequest struct {
 	// 镜像描述
 	ImageDescription *string `json:"ImageDescription,omitempty" name:"ImageDescription"`
 
-	// 软关机失败时是否执行强制关机以制作镜像
+	// 是否执行强制关机以制作镜像。
+	// 取值范围：<br><li>TRUE：表示关机之后制作镜像<br><li>FALSE：表示开机状态制作镜像<br><br>默认取值：FALSE。<br><br>开机状态制作镜像，可能导致部分数据未备份，影响数据安全。
 	ForcePoweroff *string `json:"ForcePoweroff,omitempty" name:"ForcePoweroff"`
 
 	// 创建Windows镜像时是否启用Sysprep
 	Sysprep *string `json:"Sysprep,omitempty" name:"Sysprep"`
 
-	// 实例处于运行中时，是否允许关机执行制作镜像任务。
-	Reboot *string `json:"Reboot,omitempty" name:"Reboot"`
-
 	// 实例需要制作镜像的数据盘Id
 	DataDiskIds []*string `json:"DataDiskIds,omitempty" name:"DataDiskIds" list`
 
-	// 需要制作镜像的快照Id,必须包含一个系统盘快照
+	// 需要制作镜像的快照ID,必须包含一个系统盘快照
 	SnapshotIds []*string `json:"SnapshotIds,omitempty" name:"SnapshotIds" list`
 
 	// 检测请求的合法性，但不会对操作的资源产生任何影响
@@ -683,8 +681,11 @@ type DescribeImagesRequest struct {
 
 	// 过滤条件，每次请求的`Filters`的上限为0，`Filters.Values`的上限为5。参数不可以同时指定`ImageIds`和`Filters`。详细的过滤条件如下：
 	// <li> image-id - String - 是否必填： 否 - （过滤条件）按照镜像ID进行过滤</li>
-	// <li> image-type - String - 是否必填： 否 - （过滤条件）按照镜像类型进行过滤。取值范围：详见[镜像类型](https://cloud.tencent.com/document/product/213/9452#image_type)。</li>
-	// <li> image-state - String - 是否必填： 否 - （过滤条件）按照镜像状态进行过滤。取值范围：详见[镜像状态](https://cloud.tencent.com/document/product/213/9452#image_state)。</li>
+	// <li> image-type - String - 是否必填： 否 - （过滤条件）按照镜像类型进行过滤。取值范围：
+	//     PRIVATE_IMAGE: 私有镜像 (本帐户创建的镜像) 
+	//     PUBLIC_IMAGE: 公共镜像 (腾讯云官方镜像)
+	//     MARKET_IMAGE: 服务市场 (服务市场提供的镜像) 
+	//    SHARED_IMAGE: 共享镜像(其他账户共享给本帐户的镜像) 。</li>
 	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
 
 	// 偏移量，默认为0。关于Offset详见[API简介](/document/api/213/568#.E8.BE.93.E5.85.A5.E5.8F.82.E6.95.B0.E4.B8.8E.E8.BF.94.E5.9B.9E.E5.8F.82.E6.95.B0.E9.87.8A.E4.B9.89)。
@@ -1188,6 +1189,140 @@ func (r *DescribeRegionsResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type DescribeReservedInstancesOfferingsRequest struct {
+	*tchttp.BaseRequest
+
+	// 试运行, 默认为 false。
+	DryRun *bool `json:"DryRun,omitempty" name:"DryRun"`
+
+	// 偏移量，默认为0。关于`Offset`的更进一步介绍请参考 API [简介](https://cloud.tencent.com/document/api/213/15688)中的相关小节。
+	Offset *int64 `json:"Offset,omitempty" name:"Offset"`
+
+	// 返回数量，默认为20，最大值为100。关于`Limit`的更进一步介绍请参考 API [简介](https://cloud.tencent.com/document/api/213/15688)中的相关小节。
+	Limit *int64 `json:"Limit,omitempty" name:"Limit"`
+
+	// 以最大有效期作为过滤参数。
+	// 计量单位: 秒
+	// 默认为 94608000。
+	MaxDuration *int64 `json:"MaxDuration,omitempty" name:"MaxDuration"`
+
+	// 以最小有效期作为过滤参数。
+	// 计量单位: 秒
+	// 默认为 2592000。
+	MinDuration *int64 `json:"MinDuration,omitempty" name:"MinDuration"`
+
+	// <li><strong>zone</strong></li>
+	// <p style="padding-left: 30px;">按照预留实例计费可购买的【<strong>可用区</strong>】进行过滤。形如：ap-guangzhou-1。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：<a href="https://cloud.tencent.com/document/product/213/6091">可用区列表</a></p>
+	// <li><strong>duration</strong></li>
+	// <p style="padding-left: 30px;">按照预留实例计费【<strong>有效期</strong>】即预留实例计费购买时长进行过滤。形如：31536000。</p><p style="padding-left: 30px;">类型：Integer</p><p style="padding-left: 30px;">计量单位：秒</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：31536000 (1年) | 94608000（3年）</p>
+	// <li><strong>instance-type</strong></li>
+	// <p style="padding-left: 30px;">按照【<strong>预留实例计费类型</strong>】进行过滤。形如：S3.MEDIUM4。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：<a href="https://cloud.tencent.com/document/product/213/11518">预留实例计费类型列表</a></p>
+	// <li><strong>offering-type</strong></li>
+	// <p style="padding-left: 30px;">按照【<strong>付款类型</strong>】进行过滤。形如：All Upfront (预付全部费用)。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：All Upfront (预付全部费用)</p>
+	// <li><strong>product-description</strong></li>
+	// <p style="padding-left: 30px;">按照预留实例计费的【<strong>平台描述</strong>】（即操作系统）进行过滤。形如：linux。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：linux</p>
+	// <li><strong>reserved-instances-offering-id</strong></li>
+	// <p style="padding-left: 30px;">按照【<strong>预留实例计费配置ID</strong>】进行过滤。形如：650c138f-ae7e-4750-952a-96841d6e9fc1。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p>
+	// 每次请求的`Filters`的上限为10，`Filter.Values`的上限为5。
+	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
+}
+
+func (r *DescribeReservedInstancesOfferingsRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeReservedInstancesOfferingsRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DescribeReservedInstancesOfferingsResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 符合条件的预留实例计费数量。
+		TotalCount *int64 `json:"TotalCount,omitempty" name:"TotalCount"`
+
+		// 符合条件的预留实例计费列表。
+		ReservedInstancesOfferingsSet []*ReservedInstancesOffering `json:"ReservedInstancesOfferingsSet,omitempty" name:"ReservedInstancesOfferingsSet" list`
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *DescribeReservedInstancesOfferingsResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeReservedInstancesOfferingsResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DescribeReservedInstancesRequest struct {
+	*tchttp.BaseRequest
+
+	// 试运行。默认为 false。
+	DryRun *bool `json:"DryRun,omitempty" name:"DryRun"`
+
+	// 偏移量，默认为0。关于`Offset`的更进一步介绍请参考 API [简介](https://cloud.tencent.com/document/api/213/15688)中的相关小节。
+	Offset *int64 `json:"Offset,omitempty" name:"Offset"`
+
+	// 返回数量，默认为20，最大值为100。关于`Limit`的更进一步介绍请参考 API [简介](https://cloud.tencent.com/document/api/213/15688)中的相关小节。
+	Limit *int64 `json:"Limit,omitempty" name:"Limit"`
+
+	// <li><strong>zone</strong></li>
+	// <p style="padding-left: 30px;">按照预留实例计费可购买的【<strong>可用区</strong>】进行过滤。形如：ap-guangzhou-1。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：<a href="https://cloud.tencent.com/document/product/213/6091">可用区列表</a></p>
+	// <li><strong>duration</strong></li>
+	// <p style="padding-left: 30px;">按照预留实例计费【<strong>有效期</strong>】即预留实例计费购买时长进行过滤。形如：31536000。</p><p style="padding-left: 30px;">类型：Integer</p><p style="padding-left: 30px;">计量单位：秒</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：31536000 (1年) | 94608000（3年）</p>
+	// <li><strong>instance-type</strong></li>
+	// <p style="padding-left: 30px;">按照【<strong>预留实例计费类型</strong>】进行过滤。形如：S3.MEDIUM4。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：<a href="https://cloud.tencent.com/document/product/213/11518">预留实例计费类型列表</a></p>
+	// <li><strong>offering-type</strong></li>
+	// <p style="padding-left: 30px;">按照【<strong>付款类型</strong>】进行过滤。形如：All Upfront (预付全部费用)。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：All Upfront (预付全部费用)</p>
+	// <li><strong>product-description</strong></li>
+	// <p style="padding-left: 30px;">按照预留实例计费的【<strong>平台描述</strong>】（即操作系统）进行过滤。形如：linux。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：linux</p>
+	// <li><strong>reserved-instances-id</strong></li>
+	// <p style="padding-left: 30px;">按照已购买【<strong>预留实例计费ID</strong>】进行过滤。形如：650c138f-ae7e-4750-952a-96841d6e9fc1。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p>
+	// <li><strong>state</strong></li>
+	// <p style="padding-left: 30px;">按照已购买【<strong>预留实例计费状态</strong>】进行过滤。形如：active。</p><p style="padding-left: 30px;">类型：String</p><p style="padding-left: 30px;">必选：否</p><p style="padding-left: 30px;">可选项：active (以创建) | pending (等待被创建) | retired (过期)</p>
+	// 每次请求的`Filters`的上限为10，`Filter.Values`的上限为5。
+	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
+}
+
+func (r *DescribeReservedInstancesRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeReservedInstancesRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DescribeReservedInstancesResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 符合条件的预留实例计费数量。
+		TotalCount *int64 `json:"TotalCount,omitempty" name:"TotalCount"`
+
+		// 符合条件的预留实例计费列表。
+		ReservedInstancesSet []*ReservedInstances `json:"ReservedInstancesSet,omitempty" name:"ReservedInstancesSet" list`
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *DescribeReservedInstancesResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeReservedInstancesResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type DescribeZoneInstanceConfigInfosRequest struct {
 	*tchttp.BaseRequest
 
@@ -2010,7 +2145,7 @@ type Instance struct {
 	// 实例名称。
 	InstanceName *string `json:"InstanceName,omitempty" name:"InstanceName"`
 
-	// 实例计费模式。取值范围：<br><li>`PREPAID`：表示预付费，即包年包月<br><li>`POSTPAID_BY_HOUR`：表示后付费，即按量计费<br><li>`CDHPAID`：`CDH`付费，即只对`CDH`计费，不对`CDH`上的实例计费。
+	// 实例计费模式。取值范围：<br><li>`PREPAID`：表示预付费，即包年包月<br><li>`POSTPAID_BY_HOUR`：表示后付费，即按量计费<br><li>`CDHPAID`：`CDH`付费，即只对`CDH`计费，不对`CDH`上的实例计费。<br><li>`SPOTPAID`：表示竞价实例付费。
 	InstanceChargeType *string `json:"InstanceChargeType,omitempty" name:"InstanceChargeType"`
 
 	// 实例系统盘信息。
@@ -2062,6 +2197,24 @@ type Instance struct {
 	// 实例的关机计费模式。
 	// 取值范围：<br><li>KEEP_CHARGING：关机继续收费<br><li>STOP_CHARGING：关机停止收费<li>NOT_APPLICABLE：实例处于非关机状态或者不适用关机停止计费的条件<br>
 	StopChargingMode *string `json:"StopChargingMode,omitempty" name:"StopChargingMode"`
+
+	// 实例全局唯一ID
+	Uuid *string `json:"Uuid,omitempty" name:"Uuid"`
+
+	// 实例的最新操作。例：StopInstances、ResetInstance。
+	// 注意：此字段可能返回 null，表示取不到有效值。
+	LatestOperation *string `json:"LatestOperation,omitempty" name:"LatestOperation"`
+
+	// 实例的最新操作状态。取值范围：<br>
+	// <li>SUCCESS：表示操作成功<br>
+	// <li>OPERATING：表示操作执行中<br>
+	// <li>FAILED：表示操作失败
+	// 注意：此字段可能返回 null，表示取不到有效值。
+	LatestOperationState *string `json:"LatestOperationState,omitempty" name:"LatestOperationState"`
+
+	// 实例最新操作的唯一请求 ID。
+	// 注意：此字段可能返回 null，表示取不到有效值。
+	LatestOperationRequestId *string `json:"LatestOperationRequestId,omitempty" name:"LatestOperationRequestId"`
 }
 
 type InstanceChargePrepaid struct {
@@ -2139,7 +2292,7 @@ type InstanceTypeQuotaItem struct {
 	// 实例机型。
 	InstanceType *string `json:"InstanceType,omitempty" name:"InstanceType"`
 
-	// 实例计费模式。取值范围： <br><li>PREPAID：表示预付费，即包年包月<br><li>POSTPAID_BY_HOUR：表示后付费，即按量计费<br><li>CDHPAID：表示[CDH](https://cloud.tencent.com/document/product/416)付费，即只对CDH计费，不对CDH上的实例计费。
+	// 实例计费模式。取值范围： <br><li>PREPAID：表示预付费，即包年包月<br><li>POSTPAID_BY_HOUR：表示后付费，即按量计费<br><li>CDHPAID：表示[CDH](https://cloud.tencent.com/document/product/416)付费，即只对CDH计费，不对CDH上的实例计费。<br><li>`SPOTPAID`：表示竞价实例付费。
 	InstanceChargeType *string `json:"InstanceChargeType,omitempty" name:"InstanceChargeType"`
 
 	// 网卡类型，例如：25代表25G网卡
@@ -2179,10 +2332,10 @@ type InternetAccessible struct {
 	// 公网出带宽上限，单位：Mbps。默认值：0Mbps。不同机型带宽上限范围不一致，具体限制详见[购买网络带宽](/document/product/213/509)。
 	InternetMaxBandwidthOut *int64 `json:"InternetMaxBandwidthOut,omitempty" name:"InternetMaxBandwidthOut"`
 
-	// 是否分配公网IP。取值范围：<br><li>TRUE：表示分配公网IP<br><li>FALSE：表示不分配公网IP<br><br>当公网带宽大于0Mbps时，可自由选择开通与否，默认开通公网IP；当公网带宽为0，则不允许分配公网IP。
+	// 是否分配公网IP。取值范围：<br><li>TRUE：表示分配公网IP<br><li>FALSE：表示不分配公网IP<br><br>当公网带宽大于0Mbps时，可自由选择开通与否，默认开通公网IP；当公网带宽为0，则不允许分配公网IP。该参数仅在RunInstances接口中作为入参使用。
 	PublicIpAssigned *bool `json:"PublicIpAssigned,omitempty" name:"PublicIpAssigned"`
 
-	// 带宽包ID。可通过[`DescribeBandwidthPackages`](https://cloud.tencent.com/document/api/215/19209)接口返回值中的`BandwidthPackageId`获取。
+	// 带宽包ID。可通过[`DescribeBandwidthPackages`](https://cloud.tencent.com/document/api/215/19209)接口返回值中的`BandwidthPackageId`获取。该参数仅在RunInstances接口中作为入参使用。
 	BandwidthPackageId *string `json:"BandwidthPackageId,omitempty" name:"BandwidthPackageId"`
 }
 
@@ -2714,6 +2867,9 @@ type Placement struct {
 
 	// 实例所属的专用宿主机ID列表。如果您有购买专用宿主机并且指定了该参数，则您购买的实例就会随机的部署在这些专用宿主机上。
 	HostIds []*string `json:"HostIds,omitempty" name:"HostIds" list`
+
+	// 指定母机ip生产子机
+	HostIps []*string `json:"HostIps,omitempty" name:"HostIps" list`
 }
 
 type Price struct {
@@ -2725,6 +2881,52 @@ type Price struct {
 	BandwidthPrice *ItemPrice `json:"BandwidthPrice,omitempty" name:"BandwidthPrice"`
 }
 
+type PurchaseReservedInstancesOfferingRequest struct {
+	*tchttp.BaseRequest
+
+	// 购买预留实例计费数量
+	InstanceCount *int64 `json:"InstanceCount,omitempty" name:"InstanceCount"`
+
+	// 预留实例计费配置ID
+	ReservedInstancesOfferingId *string `json:"ReservedInstancesOfferingId,omitempty" name:"ReservedInstancesOfferingId"`
+
+	// 试运行
+	DryRun *bool `json:"DryRun,omitempty" name:"DryRun"`
+
+	// 用于保证请求幂等性的字符串。该字符串由客户生成，需保证不同请求之间唯一，最大值不超过64个ASCII字符。若不指定该参数，则无法保证请求的幂等性。<br>更多详细信息请参阅：如何保证幂等性
+	ClientToken *string `json:"ClientToken,omitempty" name:"ClientToken"`
+}
+
+func (r *PurchaseReservedInstancesOfferingRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *PurchaseReservedInstancesOfferingRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type PurchaseReservedInstancesOfferingResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 已购买预留实例计费ID
+		ReservedInstanceId *string `json:"ReservedInstanceId,omitempty" name:"ReservedInstanceId"`
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *PurchaseReservedInstancesOfferingResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *PurchaseReservedInstancesOfferingResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type RebootInstancesRequest struct {
 	*tchttp.BaseRequest
 
@@ -2733,6 +2935,9 @@ type RebootInstancesRequest struct {
 
 	// 是否在正常重启失败后选择强制重启实例。取值范围：<br><li>TRUE：表示在正常重启失败后进行强制重启<br><li>FALSE：表示在正常重启失败后不进行强制重启<br><br>默认取值：FALSE。
 	ForceReboot *bool `json:"ForceReboot,omitempty" name:"ForceReboot"`
+
+	// 关机类型。取值范围：<br><li>SOFT：表示软关机<br><li>HARD：表示硬关机<br><li>SOFT_FIRST：表示优先软关机，失败再执行硬关机<br><br>默认取值：SOFT。
+	StopType *string `json:"StopType,omitempty" name:"StopType"`
 }
 
 func (r *RebootInstancesRequest) ToJsonString() string {
@@ -2851,6 +3056,88 @@ func (r *RenewInstancesResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type ReservedInstances struct {
+
+	// 已购买的预留实例计费ID。形如：650c138f-ae7e-4750-952a-96841d6e9fc1。
+	ReservedInstancesId *string `json:"ReservedInstancesId,omitempty" name:"ReservedInstancesId"`
+
+	// 预留实例计费的类型。形如：S3.MEDIUM4。
+	// 返回项：<a href="https://cloud.tencent.com/document/product/213/11518">预留实例计费类型列表</a>
+	InstanceType *string `json:"InstanceType,omitempty" name:"InstanceType"`
+
+	// 预留实例计费可购买的可用区。形如：ap-guangzhou-1。
+	// 返回项：<a href="https://cloud.tencent.com/document/product/213/6091">可用区列表</a>
+	Zone *string `json:"Zone,omitempty" name:"Zone"`
+
+	// 预留实例计费开始时间。形如：1949-10-01 00:00:00
+	StartTime *string `json:"StartTime,omitempty" name:"StartTime"`
+
+	// 预留实例计费到期时间。形如：1949-10-01 00:00:00
+	EndTime *string `json:"EndTime,omitempty" name:"EndTime"`
+
+	// 预留实例计费【有效期】即预留实例计费购买时长。形如：31536000。
+	// 计量单位：秒。
+	Duration *int64 `json:"Duration,omitempty" name:"Duration"`
+
+	// 已购买的预留实例计费个数。形如：10。
+	InstanceCount *int64 `json:"InstanceCount,omitempty" name:"InstanceCount"`
+
+	// 描述预留实例计费的平台描述（即操作系统）。形如：linux。
+	// 返回项： linux 。
+	ProductDescription *string `json:"ProductDescription,omitempty" name:"ProductDescription"`
+
+	// 预留实例计费购买的状态。形如：active
+	// 返回项： active (以创建) | pending (等待被创建) | retired (过期)。
+	State *string `json:"State,omitempty" name:"State"`
+
+	// 可购买的预留实例计费类型的结算货币，使用ISO 4217标准货币代码。形如：USD。
+	// 返回项：USD（美元）。
+	CurrencyCode *string `json:"CurrencyCode,omitempty" name:"CurrencyCode"`
+
+	// 预留实例计费的付款类型。形如：All Upfront。
+	// 返回项： All Upfront (预付全部费用)。
+	OfferingType *string `json:"OfferingType,omitempty" name:"OfferingType"`
+}
+
+type ReservedInstancesOffering struct {
+
+	// 预留实例计费可购买的可用区。形如：ap-guangzhou-1。
+	// 返回项：<a href="https://cloud.tencent.com/document/product/213/6091">可用区列表</a>
+	Zone *string `json:"Zone,omitempty" name:"Zone"`
+
+	// 可购买的预留实例计费类型的结算货币，使用ISO 4217标准货币代码。
+	// 返回项：USD（美元）。
+	CurrencyCode *string `json:"CurrencyCode,omitempty" name:"CurrencyCode"`
+
+	// 预留实例计费【有效期】即预留实例计费购买时长。形如：31536000。
+	// 计量单位：秒
+	Duration *int64 `json:"Duration,omitempty" name:"Duration"`
+
+	// 预留实例计费的购买价格。形如：4000.0。
+	// 计量单位：与 currencyCode 一致，目前支持 USD（美元）
+	FixedPrice *float64 `json:"FixedPrice,omitempty" name:"FixedPrice"`
+
+	// 预留实例计费的实例类型。形如：S3.MEDIUM4。
+	// 返回项：<a href="https://cloud.tencent.com/product/cvm/instances">预留实例计费类型列表</a>
+	InstanceType *string `json:"InstanceType,omitempty" name:"InstanceType"`
+
+	// 预留实例计费的付款类型。形如：All Upfront。
+	// 返回项： All Upfront (预付全部费用)。
+	OfferingType *string `json:"OfferingType,omitempty" name:"OfferingType"`
+
+	// 可购买的预留实例计费配置ID。形如：650c138f-ae7e-4750-952a-96841d6e9fc1。
+	ReservedInstancesOfferingId *string `json:"ReservedInstancesOfferingId,omitempty" name:"ReservedInstancesOfferingId"`
+
+	// 预留实例计费的平台描述（即操作系统）。形如：linux。
+	// 返回项： linux 。
+	ProductDescription *string `json:"ProductDescription,omitempty" name:"ProductDescription"`
+
+	// 扣除预付费之后的使用价格 (按小时计费)。形如：0.0。
+	// 目前，因为只支持 All Upfront 付款类型，所以默认为 0元/小时。
+	// 计量单位：元/小时，货币单位与 currencyCode 一致，目前支持 USD（美元）
+	UsagePrice *float64 `json:"UsagePrice,omitempty" name:"UsagePrice"`
+}
+
 type ResetInstanceRequest struct {
 	*tchttp.BaseRequest
 
@@ -2950,7 +3237,9 @@ type ResetInstancesPasswordRequest struct {
 	// 一个或多个待操作的实例ID。可通过[`DescribeInstances`](https://cloud.tencent.com/document/api/213/15728) API返回值中的`InstanceId`获取。每次请求允许操作的实例数量上限是100。
 	InstanceIds []*string `json:"InstanceIds,omitempty" name:"InstanceIds" list`
 
-	// 实例登录密码。不同操作系统类型密码复杂度限制不一样，具体如下：<br><li>`Linux`实例密码必须8到16位，至少包括两项`[a-z，A-Z]、[0-9]`和`[( ) ~ ~ ! @ # $ % ^ & * - + = _ | { } [ ] : ; ' < > , . ? /]`中的符号。密码不允许以`/`符号开头。<br><li>`Windows`实例密码必须12到16位，至少包括三项`[a-z]，[A-Z]，[0-9]`和`[( ) ~ ~ ! @ # $ % ^ & * - + = _ | { } [ ] : ; ' < > , . ? /]`中的符号。密码不允许以`/`符号开头。<br><li>如果实例即包含`Linux`实例又包含`Windows`实例，则密码复杂度限制按照`Windows`实例的限制。
+	// 实例登录密码。不同操作系统类型密码复杂度限制不一样，具体如下：
+	// Linux实例密码必须8-30位，推荐使用12位以上密码，不能以“/”开头，至少包含以下字符中的三种不同字符，字符种类：<br><li>小写字母：[a-z]<br><li>大写字母：[A-Z]<br><li>数字：0-9<br><li>特殊字符： ()\`~!@#$%^&\*-+=\_|{}[]:;'<>,.?/:
+	// Windows实例密码必须12~30位，不能以“/”开头且不包括用户名，至少包含以下字符中的三种不同字符<br><li>小写字母：[a-z]<br><li>大写字母：[A-Z]<br><li>数字： 0-9<br><li>特殊字符：()\`~!@#$%^&\*-+=\_|{}[]:;' <>,.?/:<br><li>如果实例即包含`Linux`实例又包含`Windows`实例，则密码复杂度限制按照`Windows`实例的限制。
 	Password *string `json:"Password,omitempty" name:"Password"`
 
 	// 待重置密码的实例操作系统用户名。不得超过64个字符。
@@ -3133,6 +3422,13 @@ type RunInstancesRequest struct {
 
 	// 提供给实例使用的用户数据，需要以 base64 方式编码，支持的最大数据大小为 16KB。关于获取此参数的详细介绍，请参阅[Windows](https://cloud.tencent.com/document/product/213/17526)和[Linux](https://cloud.tencent.com/document/product/213/17525)启动时运行命令。
 	UserData *string `json:"UserData,omitempty" name:"UserData"`
+
+	// 是否只预检此次请求。
+	// true：发送检查请求，不会创建实例。检查项包括是否填写了必需参数，请求格式，业务限制和云服务器库存。
+	// 如果检查不通过，则返回对应错误码；
+	// 如果检查通过，则返回RequestId.
+	// false（默认）：发送正常请求，通过检查后直接创建实例
+	DryRun *bool `json:"DryRun,omitempty" name:"DryRun"`
 }
 
 func (r *RunInstancesRequest) ToJsonString() string {
@@ -3422,6 +3718,43 @@ type VirtualPrivateCloud struct {
 type ZoneInfo struct {
 
 	// 可用区名称，例如，ap-guangzhou-3
+	// 全网可用区名称如下：
+	// <li> ap-chongqing-1 </li>
+	// <li> ap-seoul-1 </li>
+	// <li> ap-chengdu-1 </li>
+	// <li> ap-chengdu-2 </li>
+	// <li> ap-hongkong-1 </li>
+	// <li> ap-hongkong-2 </li>
+	// <li> ap-shenzhen-fsi-1 </li>
+	// <li> ap-shenzhen-fsi-2 </li>
+	// <li> ap-shenzhen-fsi-3 </li>
+	// <li> ap-guangzhou-1（售罄）</li>
+	// <li> ap-guangzhou-2（售罄）</li>
+	// <li> ap-guangzhou-3 </li>
+	// <li> ap-guangzhou-4 </li>
+	// <li> ap-tokyo-1 </li>
+	// <li> ap-singapore-1 </li>
+	// <li> ap-shanghai-fsi-1 </li>
+	// <li> ap-shanghai-fsi-2 </li>
+	// <li> ap-shanghai-fsi-3 </li>
+	// <li> ap-bangkok-1 </li>
+	// <li> ap-shanghai-1（售罄） </li>
+	// <li> ap-shanghai-2 </li>
+	// <li> ap-shanghai-3 </li>
+	// <li> ap-shanghai-4 </li>
+	// <li> ap-mumbai-1 </li>
+	// <li> ap-mumbai-2 </li>
+	// <li> eu-moscow-1 </li>
+	// <li> ap-beijing-1 </li>
+	// <li> ap-beijing-2 </li>
+	// <li> ap-beijing-3 </li>
+	// <li> ap-beijing-4 </li>
+	// <li> na-siliconvalley-1 </li>
+	// <li> na-siliconvalley-2 </li>
+	// <li> eu-frankfurt-1 </li>
+	// <li> na-toronto-1 </li>
+	// <li> na-ashburn-1 </li>
+	// <li> na-ashburn-2 </li>
 	Zone *string `json:"Zone,omitempty" name:"Zone"`
 
 	// 可用区描述，例如，广州三区
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312/client.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312/client.go
index 6924ff091..5d878067f 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312/client.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312/client.go
@@ -137,8 +137,8 @@ func NewAllocateAddressesResponse() (response *AllocateAddressesResponse) {
 
 // 本接口 (AllocateAddresses) 用于申请一个或多个[弹性公网IP](https://cloud.tencent.com/document/product/213/1941)（简称 EIP）。
 // * EIP 是专为动态云计算设计的静态 IP 地址。借助 EIP，您可以快速将 EIP 重新映射到您的另一个实例上，从而屏蔽实例故障。
-// * 您的 EIP 与腾讯云账户相关联，而不是与某个实例相关联。在您选择显式释放该地址，或欠费超过七天之前，它会一直与您的腾讯云账户保持关联。
-// * 平台对用户每地域能申请的 EIP 最大配额有所限制，可参见 [EIP 产品简介](https://cloud.tencent.com/document/product/213/5733)，上述配额可通过 DescribeAddressQuota 接口获取。
+// * 您的 EIP 与腾讯云账户相关联，而不是与某个实例相关联。在您选择显式释放该地址，或欠费超过24小时之前，它会一直与您的腾讯云账户保持关联。
+// * 一个腾讯云账户在每个地域能申请的 EIP 最大配额有所限制，可参见 [EIP 产品简介](https://cloud.tencent.com/document/product/213/5733)，上述配额可通过 DescribeAddressQuota 接口获取。
 func (c *Client) AllocateAddresses(request *AllocateAddressesRequest) (response *AllocateAddressesResponse, err error) {
     if request == nil {
         request = NewAllocateAddressesRequest()
@@ -291,6 +291,31 @@ func (c *Client) AssociateAddress(request *AssociateAddressRequest) (response *A
     return
 }
 
+func NewAssociateNatGatewayAddressRequest() (request *AssociateNatGatewayAddressRequest) {
+    request = &AssociateNatGatewayAddressRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "AssociateNatGatewayAddress")
+    return
+}
+
+func NewAssociateNatGatewayAddressResponse() (response *AssociateNatGatewayAddressResponse) {
+    response = &AssociateNatGatewayAddressResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口(AssociateNatGatewayAddress)用于NAT网关绑定弹性IP（EIP）。
+func (c *Client) AssociateNatGatewayAddress(request *AssociateNatGatewayAddressRequest) (response *AssociateNatGatewayAddressResponse, err error) {
+    if request == nil {
+        request = NewAssociateNatGatewayAddressRequest()
+    }
+    response = NewAssociateNatGatewayAddressResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewAttachCcnInstancesRequest() (request *AttachCcnInstancesRequest) {
     request = &AttachCcnInstancesRequest{
         BaseRequest: &tchttp.BaseRequest{},
@@ -658,6 +683,56 @@ func (c *Client) CreateIp6Translators(request *CreateIp6TranslatorsRequest) (res
     return
 }
 
+func NewCreateNatGatewayRequest() (request *CreateNatGatewayRequest) {
+    request = &CreateNatGatewayRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "CreateNatGateway")
+    return
+}
+
+func NewCreateNatGatewayResponse() (response *CreateNatGatewayResponse) {
+    response = &CreateNatGatewayResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口(CreateNatGateway)用于创建NAT网关。
+func (c *Client) CreateNatGateway(request *CreateNatGatewayRequest) (response *CreateNatGatewayResponse, err error) {
+    if request == nil {
+        request = NewCreateNatGatewayRequest()
+    }
+    response = NewCreateNatGatewayResponse()
+    err = c.Send(request, response)
+    return
+}
+
+func NewCreateNatGatewayDestinationIpPortTranslationNatRuleRequest() (request *CreateNatGatewayDestinationIpPortTranslationNatRuleRequest) {
+    request = &CreateNatGatewayDestinationIpPortTranslationNatRuleRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "CreateNatGatewayDestinationIpPortTranslationNatRule")
+    return
+}
+
+func NewCreateNatGatewayDestinationIpPortTranslationNatRuleResponse() (response *CreateNatGatewayDestinationIpPortTranslationNatRuleResponse) {
+    response = &CreateNatGatewayDestinationIpPortTranslationNatRuleResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口(CreateNatGatewayDestinationIpPortTranslationNatRule)用于创建NAT网关端口转发规则。
+func (c *Client) CreateNatGatewayDestinationIpPortTranslationNatRule(request *CreateNatGatewayDestinationIpPortTranslationNatRuleRequest) (response *CreateNatGatewayDestinationIpPortTranslationNatRuleResponse, err error) {
+    if request == nil {
+        request = NewCreateNatGatewayDestinationIpPortTranslationNatRuleRequest()
+    }
+    response = NewCreateNatGatewayDestinationIpPortTranslationNatRuleResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewCreateNetworkInterfaceRequest() (request *CreateNetworkInterfaceRequest) {
     request = &CreateNetworkInterfaceRequest{
         BaseRequest: &tchttp.BaseRequest{},
@@ -1244,6 +1319,57 @@ func (c *Client) DeleteIp6Translators(request *DeleteIp6TranslatorsRequest) (res
     return
 }
 
+func NewDeleteNatGatewayRequest() (request *DeleteNatGatewayRequest) {
+    request = &DeleteNatGatewayRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "DeleteNatGateway")
+    return
+}
+
+func NewDeleteNatGatewayResponse() (response *DeleteNatGatewayResponse) {
+    response = &DeleteNatGatewayResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口（DeleteNatGateway）用于删除NAT网关。
+// 删除 NAT 网关后，系统会自动删除路由表中包含此 NAT 网关的路由项，同时也会解绑弹性公网IP（EIP）。
+func (c *Client) DeleteNatGateway(request *DeleteNatGatewayRequest) (response *DeleteNatGatewayResponse, err error) {
+    if request == nil {
+        request = NewDeleteNatGatewayRequest()
+    }
+    response = NewDeleteNatGatewayResponse()
+    err = c.Send(request, response)
+    return
+}
+
+func NewDeleteNatGatewayDestinationIpPortTranslationNatRuleRequest() (request *DeleteNatGatewayDestinationIpPortTranslationNatRuleRequest) {
+    request = &DeleteNatGatewayDestinationIpPortTranslationNatRuleRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "DeleteNatGatewayDestinationIpPortTranslationNatRule")
+    return
+}
+
+func NewDeleteNatGatewayDestinationIpPortTranslationNatRuleResponse() (response *DeleteNatGatewayDestinationIpPortTranslationNatRuleResponse) {
+    response = &DeleteNatGatewayDestinationIpPortTranslationNatRuleResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口（DeleteNatGatewayDestinationIpPortTranslationNatRule）用于删除NAT网关端口转发规则。
+func (c *Client) DeleteNatGatewayDestinationIpPortTranslationNatRule(request *DeleteNatGatewayDestinationIpPortTranslationNatRuleRequest) (response *DeleteNatGatewayDestinationIpPortTranslationNatRuleResponse, err error) {
+    if request == nil {
+        request = NewDeleteNatGatewayDestinationIpPortTranslationNatRuleRequest()
+    }
+    response = NewDeleteNatGatewayDestinationIpPortTranslationNatRuleResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewDeleteNetworkInterfaceRequest() (request *DeleteNetworkInterfaceRequest) {
     request = &DeleteNetworkInterfaceRequest{
         BaseRequest: &tchttp.BaseRequest{},
@@ -2082,6 +2208,81 @@ func (c *Client) DescribeIp6Translators(request *DescribeIp6TranslatorsRequest)
     return
 }
 
+func NewDescribeNatGatewayDestinationIpPortTranslationNatRulesRequest() (request *DescribeNatGatewayDestinationIpPortTranslationNatRulesRequest) {
+    request = &DescribeNatGatewayDestinationIpPortTranslationNatRulesRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "DescribeNatGatewayDestinationIpPortTranslationNatRules")
+    return
+}
+
+func NewDescribeNatGatewayDestinationIpPortTranslationNatRulesResponse() (response *DescribeNatGatewayDestinationIpPortTranslationNatRulesResponse) {
+    response = &DescribeNatGatewayDestinationIpPortTranslationNatRulesResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口（DescribeNatGatewayDestinationIpPortTranslationNatRules）用于查询NAT网关端口转发规则对象数组。
+func (c *Client) DescribeNatGatewayDestinationIpPortTranslationNatRules(request *DescribeNatGatewayDestinationIpPortTranslationNatRulesRequest) (response *DescribeNatGatewayDestinationIpPortTranslationNatRulesResponse, err error) {
+    if request == nil {
+        request = NewDescribeNatGatewayDestinationIpPortTranslationNatRulesRequest()
+    }
+    response = NewDescribeNatGatewayDestinationIpPortTranslationNatRulesResponse()
+    err = c.Send(request, response)
+    return
+}
+
+func NewDescribeNatGatewaysRequest() (request *DescribeNatGatewaysRequest) {
+    request = &DescribeNatGatewaysRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "DescribeNatGateways")
+    return
+}
+
+func NewDescribeNatGatewaysResponse() (response *DescribeNatGatewaysResponse) {
+    response = &DescribeNatGatewaysResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口（DescribeNatGateways）用于查询 NAT 网关。
+func (c *Client) DescribeNatGateways(request *DescribeNatGatewaysRequest) (response *DescribeNatGatewaysResponse, err error) {
+    if request == nil {
+        request = NewDescribeNatGatewaysRequest()
+    }
+    response = NewDescribeNatGatewaysResponse()
+    err = c.Send(request, response)
+    return
+}
+
+func NewDescribeNetworkInterfaceLimitRequest() (request *DescribeNetworkInterfaceLimitRequest) {
+    request = &DescribeNetworkInterfaceLimitRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "DescribeNetworkInterfaceLimit")
+    return
+}
+
+func NewDescribeNetworkInterfaceLimitResponse() (response *DescribeNetworkInterfaceLimitResponse) {
+    response = &DescribeNetworkInterfaceLimitResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口（DescribeNetworkInterfaceLimit）根据CVM实例ID查询弹性网卡配额，返回该CVM实例能绑定的弹性网卡配额，以及每个弹性网卡可以分配的ip配额
+func (c *Client) DescribeNetworkInterfaceLimit(request *DescribeNetworkInterfaceLimitRequest) (response *DescribeNetworkInterfaceLimitResponse, err error) {
+    if request == nil {
+        request = NewDescribeNetworkInterfaceLimitRequest()
+    }
+    response = NewDescribeNetworkInterfaceLimitResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewDescribeNetworkInterfacesRequest() (request *DescribeNetworkInterfacesRequest) {
     request = &DescribeNetworkInterfacesRequest{
         BaseRequest: &tchttp.BaseRequest{},
@@ -2307,6 +2508,31 @@ func (c *Client) DescribeSubnets(request *DescribeSubnetsRequest) (response *Des
     return
 }
 
+func NewDescribeTaskResultRequest() (request *DescribeTaskResultRequest) {
+    request = &DescribeTaskResultRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "DescribeTaskResult")
+    return
+}
+
+func NewDescribeTaskResultResponse() (response *DescribeTaskResultResponse) {
+    response = &DescribeTaskResultResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 查询EIP异步任务执行结果
+func (c *Client) DescribeTaskResult(request *DescribeTaskResultRequest) (response *DescribeTaskResultResponse, err error) {
+    if request == nil {
+        request = NewDescribeTaskResultRequest()
+    }
+    response = NewDescribeTaskResultResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewDescribeVpcIpv6AddressesRequest() (request *DescribeVpcIpv6AddressesRequest) {
     request = &DescribeVpcIpv6AddressesRequest{
         BaseRequest: &tchttp.BaseRequest{},
@@ -2589,6 +2815,31 @@ func (c *Client) DisassociateAddress(request *DisassociateAddressRequest) (respo
     return
 }
 
+func NewDisassociateNatGatewayAddressRequest() (request *DisassociateNatGatewayAddressRequest) {
+    request = &DisassociateNatGatewayAddressRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "DisassociateNatGatewayAddress")
+    return
+}
+
+func NewDisassociateNatGatewayAddressResponse() (response *DisassociateNatGatewayAddressResponse) {
+    response = &DisassociateNatGatewayAddressResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口（DisassociateNatGatewayAddress）用于NAT网关解绑弹性IP。
+func (c *Client) DisassociateNatGatewayAddress(request *DisassociateNatGatewayAddressRequest) (response *DisassociateNatGatewayAddressResponse, err error) {
+    if request == nil {
+        request = NewDisassociateNatGatewayAddressRequest()
+    }
+    response = NewDisassociateNatGatewayAddressResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewDownloadCustomerGatewayConfigurationRequest() (request *DownloadCustomerGatewayConfigurationRequest) {
     request = &DownloadCustomerGatewayConfigurationRequest{
         BaseRequest: &tchttp.BaseRequest{},
@@ -3171,6 +3422,56 @@ func (c *Client) ModifyIpv6AddressesAttribute(request *ModifyIpv6AddressesAttrib
     return
 }
 
+func NewModifyNatGatewayAttributeRequest() (request *ModifyNatGatewayAttributeRequest) {
+    request = &ModifyNatGatewayAttributeRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "ModifyNatGatewayAttribute")
+    return
+}
+
+func NewModifyNatGatewayAttributeResponse() (response *ModifyNatGatewayAttributeResponse) {
+    response = &ModifyNatGatewayAttributeResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口（ModifyNatGatewayAttribute）用于修改NAT网关的属性。
+func (c *Client) ModifyNatGatewayAttribute(request *ModifyNatGatewayAttributeRequest) (response *ModifyNatGatewayAttributeResponse, err error) {
+    if request == nil {
+        request = NewModifyNatGatewayAttributeRequest()
+    }
+    response = NewModifyNatGatewayAttributeResponse()
+    err = c.Send(request, response)
+    return
+}
+
+func NewModifyNatGatewayDestinationIpPortTranslationNatRuleRequest() (request *ModifyNatGatewayDestinationIpPortTranslationNatRuleRequest) {
+    request = &ModifyNatGatewayDestinationIpPortTranslationNatRuleRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "ModifyNatGatewayDestinationIpPortTranslationNatRule")
+    return
+}
+
+func NewModifyNatGatewayDestinationIpPortTranslationNatRuleResponse() (response *ModifyNatGatewayDestinationIpPortTranslationNatRuleResponse) {
+    response = &ModifyNatGatewayDestinationIpPortTranslationNatRuleResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口（ModifyNatGatewayDestinationIpPortTranslationNatRule）用于修改NAT网关端口转发规则。
+func (c *Client) ModifyNatGatewayDestinationIpPortTranslationNatRule(request *ModifyNatGatewayDestinationIpPortTranslationNatRuleRequest) (response *ModifyNatGatewayDestinationIpPortTranslationNatRuleResponse, err error) {
+    if request == nil {
+        request = NewModifyNatGatewayDestinationIpPortTranslationNatRuleRequest()
+    }
+    response = NewModifyNatGatewayDestinationIpPortTranslationNatRuleResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewModifyNetworkInterfaceAttributeRequest() (request *ModifyNetworkInterfaceAttributeRequest) {
     request = &ModifyNetworkInterfaceAttributeRequest{
         BaseRequest: &tchttp.BaseRequest{},
@@ -3710,6 +4011,31 @@ func (c *Client) ResetAttachCcnInstances(request *ResetAttachCcnInstancesRequest
     return
 }
 
+func NewResetNatGatewayConnectionRequest() (request *ResetNatGatewayConnectionRequest) {
+    request = &ResetNatGatewayConnectionRequest{
+        BaseRequest: &tchttp.BaseRequest{},
+    }
+    request.Init().WithApiInfo("vpc", APIVersion, "ResetNatGatewayConnection")
+    return
+}
+
+func NewResetNatGatewayConnectionResponse() (response *ResetNatGatewayConnectionResponse) {
+    response = &ResetNatGatewayConnectionResponse{
+        BaseResponse: &tchttp.BaseResponse{},
+    }
+    return
+}
+
+// 本接口（ResetNatGatewayConnection）用来NAT网关并发连接上限。
+func (c *Client) ResetNatGatewayConnection(request *ResetNatGatewayConnectionRequest) (response *ResetNatGatewayConnectionResponse, err error) {
+    if request == nil {
+        request = NewResetNatGatewayConnectionRequest()
+    }
+    response = NewResetNatGatewayConnectionResponse()
+    err = c.Send(request, response)
+    return
+}
+
 func NewResetRoutesRequest() (request *ResetRoutesRequest) {
     request = &ResetRoutesRequest{
         BaseRequest: &tchttp.BaseRequest{},
diff --git a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312/models.go b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312/models.go
index f12064b1b..7a7c1e8d4 100644
--- a/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312/models.go
+++ b/vendor/github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/vpc/v20170312/models.go
@@ -160,7 +160,7 @@ type Address struct {
 	// `EIP`名称。
 	AddressName *string `json:"AddressName,omitempty" name:"AddressName"`
 
-	// `EIP`状态。
+	// `EIP`状态，包含'CREATING'(创建中),'BINDING'(绑定中),'BIND'(已绑定),'UNBINDING'(解绑中),'UNBIND'(已解绑),'OFFLINING'(释放中),'BIND_ENI'(绑定悬空弹性网卡)
 	AddressStatus *string `json:"AddressStatus,omitempty" name:"AddressStatus"`
 
 	// 外网IP地址
@@ -236,8 +236,41 @@ type AddressTemplateSpecification struct {
 type AllocateAddressesRequest struct {
 	*tchttp.BaseRequest
 
-	// 申请 EIP 数量，默认值为1。
+	// EIP数量。默认值：1。
 	AddressCount *int64 `json:"AddressCount,omitempty" name:"AddressCount"`
+
+	// EIP线路类型。默认值：BGP。
+	// <ul style="margin:0"><li>已开通静态单线IP白名单的用户，可选值：<ul><li>CMCC：中国移动</li>
+	// <li>CTCC：中国电信</li>
+	// <li>CUCC：中国联通</li></ul>注意：仅部分地域支持静态单线IP。</li></ul>
+	InternetServiceProvider *string `json:"InternetServiceProvider,omitempty" name:"InternetServiceProvider"`
+
+	// EIP计费方式。
+	// <ul style="margin:0"><li>已开通带宽上移白名单的用户，可选值：<ul><li>BANDWIDTH_PACKAGE：[共享带宽包](https://cloud.tencent.com/document/product/684/15255)付费（需额外开通共享带宽包白名单）</li>
+	// <li>BANDWIDTH_POSTPAID_BY_HOUR：带宽按小时后付费</li>
+	// <li>TRAFFIC_POSTPAID_BY_HOUR：流量按小时后付费</li></ul>默认值：TRAFFIC_POSTPAID_BY_HOUR。</li>
+	// <li>未开通带宽上移白名单的用户，EIP计费方式与其绑定的实例的计费方式一致，无需传递此参数。</li></ul>
+	InternetChargeType *string `json:"InternetChargeType,omitempty" name:"InternetChargeType"`
+
+	// EIP出带宽上限，单位：Mbps。
+	// <ul style="margin:0"><li>已开通带宽上移白名单的用户，可选值范围取决于EIP计费方式：<ul><li>BANDWIDTH_PACKAGE：1 Mbps 至 1000 Mbps</li>
+	// <li>BANDWIDTH_POSTPAID_BY_HOUR：1 Mbps 至 100 Mbps</li>
+	// <li>TRAFFIC_POSTPAID_BY_HOUR：1 Mbps 至 100 Mbps</li></ul>默认值：1 Mbps。</li>
+	// <li>未开通带宽上移白名单的用户，EIP出带宽上限取决于与其绑定的实例的公网出带宽上限，无需传递此参数。</li></ul>
+	InternetMaxBandwidthOut *int64 `json:"InternetMaxBandwidthOut,omitempty" name:"InternetMaxBandwidthOut"`
+
+	// EIP类型。默认值：EIP。
+	// <ul style="margin:0"><li>已开通Anycast公网加速白名单的用户，可选值：<ul><li>AnycastEIP：加速IP，可参见 [Anycast 公网加速](https://cloud.tencent.com/document/product/644)</li></ul>注意：仅部分地域支持加速IP。</li></ul>
+	AddressType *string `json:"AddressType,omitempty" name:"AddressType"`
+
+	// Anycast发布域。
+	// <ul style="margin:0"><li>已开通Anycast公网加速白名单的用户，可选值：<ul><li>ANYCAST_ZONE_GLOBAL：全球发布域（需要额外开通Anycast全球加速白名单）</li><li>ANYCAST_ZONE_OVERSEAS：境外发布域</li></ul>默认值：ANYCAST_ZONE_OVERSEAS。</li></ul>
+	AnycastZone *string `json:"AnycastZone,omitempty" name:"AnycastZone"`
+
+	// AnycastEIP是否用于绑定负载均衡。
+	// <ul style="margin:0"><li>已开通Anycast公网加速白名单的用户，可选值：<ul><li>TRUE：AnycastEIP可绑定对象为负载均衡</li>
+	// <li>FALSE：AnycastEIP可绑定对象为云服务器、NAT网关、高可用虚拟IP等</li></ul>默认值：FALSE。</li></ul>
+	ApplicableForCLB *bool `json:"ApplicableForCLB,omitempty" name:"ApplicableForCLB"`
 }
 
 func (r *AllocateAddressesRequest) ToJsonString() string {
@@ -256,6 +289,9 @@ type AllocateAddressesResponse struct {
 		// 申请到的 EIP 的唯一 ID 列表。
 		AddressSet []*string `json:"AddressSet,omitempty" name:"AddressSet" list`
 
+		// 异步任务TaskId。可以使用[DescribeTaskResult](https://cloud.tencent.com/document/api/215/36271)接口查询任务状态。
+		TaskId *string `json:"TaskId,omitempty" name:"TaskId"`
+
 		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
 		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
 	} `json:"Response"`
@@ -399,7 +435,7 @@ type AssignPrivateIpAddressesRequest struct {
 	// 指定的内网IP信息，单次最多指定10个。
 	PrivateIpAddresses []*PrivateIpAddressSpecification `json:"PrivateIpAddresses,omitempty" name:"PrivateIpAddresses" list`
 
-	// 新申请的内网IP地址个数，内网IP地址个数总和不能超过配数。
+	// 新申请的内网IP地址个数，内网IP地址个数总和不能超过配额数，详见<a href="/document/product/576/18527">弹性网卡使用限制</a>。
 	SecondaryPrivateIpAddressCount *uint64 `json:"SecondaryPrivateIpAddressCount,omitempty" name:"SecondaryPrivateIpAddressCount"`
 }
 
@@ -433,6 +469,22 @@ func (r *AssignPrivateIpAddressesResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type AssistantCidr struct {
+
+	// `VPC`实例`ID`。形如：`vpc-6v2ht8q5`
+	VpcId *string `json:"VpcId,omitempty" name:"VpcId"`
+
+	// 辅助CIDR。形如：`172.16.0.0/16`
+	CidrBlock *string `json:"CidrBlock,omitempty" name:"CidrBlock"`
+
+	// 辅助CIDR类型（0：普通辅助CIDR，1：容器辅助CIDR），默认都是0。
+	AssistantType *int64 `json:"AssistantType,omitempty" name:"AssistantType"`
+
+	// 辅助CIDR拆分的子网。
+	// 注意：此字段可能返回 null，表示取不到有效值。
+	SubnetSet []*Subnet `json:"SubnetSet,omitempty" name:"SubnetSet" list`
+}
+
 type AssociateAddressRequest struct {
 	*tchttp.BaseRequest
 
@@ -462,6 +514,9 @@ type AssociateAddressResponse struct {
 	*tchttp.BaseResponse
 	Response *struct {
 
+		// 异步任务TaskId。可以使用[DescribeTaskResult](https://cloud.tencent.com/document/api/215/36271)接口查询任务状态。
+		TaskId *string `json:"TaskId,omitempty" name:"TaskId"`
+
 		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
 		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
 	} `json:"Response"`
@@ -476,6 +531,49 @@ func (r *AssociateAddressResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type AssociateNatGatewayAddressRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关的ID，形如：`nat-df45454`。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+
+	// 需要申请的弹性IP个数，系统会按您的要求生产N个弹性IP, 其中AddressCount和PublicAddresses至少传递一个。
+	AddressCount *uint64 `json:"AddressCount,omitempty" name:"AddressCount"`
+
+	// 绑定NAT网关的弹性IP数组，其中AddressCount和PublicAddresses至少传递一个。。
+	PublicIpAddresses []*string `json:"PublicIpAddresses,omitempty" name:"PublicIpAddresses" list`
+
+	// 弹性IP可以区，自动分配弹性IP时传递。
+	Zone *string `json:"Zone,omitempty" name:"Zone"`
+}
+
+func (r *AssociateNatGatewayAddressRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *AssociateNatGatewayAddressRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type AssociateNatGatewayAddressResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *AssociateNatGatewayAddressResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *AssociateNatGatewayAddressResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type AttachCcnInstancesRequest struct {
 	*tchttp.BaseRequest
 
@@ -910,6 +1008,12 @@ type CreateCcnRequest struct {
 
 	// CCN服务质量，'PT'：白金，'AU'：金，'AG'：银，默认为‘AU’。
 	QosLevel *string `json:"QosLevel,omitempty" name:"QosLevel"`
+
+	// 计费模式，PREPAID：表示预付费，即包年包月，POSTPAID：表示后付费，即按量计费。默认：POSTPAID。
+	InstanceChargeType *string `json:"InstanceChargeType,omitempty" name:"InstanceChargeType"`
+
+	// 限速类型，OUTER_REGION_LIMIT表示地域出口限速，INTER_REGION_LIMIT为地域间限速，默认为OUTER_REGION_LIMIT
+	BandwidthLimitType *string `json:"BandwidthLimitType,omitempty" name:"BandwidthLimitType"`
 }
 
 func (r *CreateCcnRequest) ToJsonString() string {
@@ -1254,6 +1358,101 @@ func (r *CreateIp6TranslatorsResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type CreateNatGatewayDestinationIpPortTranslationNatRuleRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关的ID，形如：`nat-df45454`。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+
+	// NAT网关的端口转换规则。
+	DestinationIpPortTranslationNatRules []*DestinationIpPortTranslationNatRule `json:"DestinationIpPortTranslationNatRules,omitempty" name:"DestinationIpPortTranslationNatRules" list`
+}
+
+func (r *CreateNatGatewayDestinationIpPortTranslationNatRuleRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *CreateNatGatewayDestinationIpPortTranslationNatRuleRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type CreateNatGatewayDestinationIpPortTranslationNatRuleResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *CreateNatGatewayDestinationIpPortTranslationNatRuleResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *CreateNatGatewayDestinationIpPortTranslationNatRuleResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type CreateNatGatewayRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关名称
+	NatGatewayName *string `json:"NatGatewayName,omitempty" name:"NatGatewayName"`
+
+	// VPC实例ID。可通过DescribeVpcs接口返回值中的VpcId获取。
+	VpcId *string `json:"VpcId,omitempty" name:"VpcId"`
+
+	// NAT网关最大外网出带宽(单位:Mbps)，支持的参数值：`20, 50, 100, 200, 500, 1000, 2000, 5000`，默认: `100Mbps`。
+	InternetMaxBandwidthOut *uint64 `json:"InternetMaxBandwidthOut,omitempty" name:"InternetMaxBandwidthOut"`
+
+	// NAT网关并发连接上限，支持参数值：`1000000、3000000、10000000`，默认值为`100000`。
+	MaxConcurrentConnection *uint64 `json:"MaxConcurrentConnection,omitempty" name:"MaxConcurrentConnection"`
+
+	// 需要申请的弹性IP个数，系统会按您的要求生产N个弹性IP，其中AddressCount和PublicAddresses至少传递一个。
+	AddressCount *uint64 `json:"AddressCount,omitempty" name:"AddressCount"`
+
+	// 绑定NAT网关的弹性IP数组，其中AddressCount和PublicAddresses至少传递一个。
+	PublicIpAddresses []*string `json:"PublicIpAddresses,omitempty" name:"PublicIpAddresses" list`
+
+	// 可用区，形如：`ap-guangzhou-1`。
+	Zone *string `json:"Zone,omitempty" name:"Zone"`
+}
+
+func (r *CreateNatGatewayRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *CreateNatGatewayRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type CreateNatGatewayResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// NAT网关对象数组。
+		NatGatewaySet []*NatGateway `json:"NatGatewaySet,omitempty" name:"NatGatewaySet" list`
+
+		// 符合条件的 NAT网关对象数量。
+		TotalCount *uint64 `json:"TotalCount,omitempty" name:"TotalCount"`
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *CreateNatGatewayResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *CreateNatGatewayResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type CreateNetworkInterfaceRequest struct {
 	*tchttp.BaseRequest
 
@@ -1644,7 +1843,7 @@ type CreateVpcRequest struct {
 	// vpc名称，最大长度不能超过60个字节。
 	VpcName *string `json:"VpcName,omitempty" name:"VpcName"`
 
-	// vpc的cidr，只能为10.0.0.0/16，172.16.0.0/12，192.168.0.0/16这三个内网网段内。
+	// vpc的cidr，只能为10.0.0.0/16，172.16.0.0/16，192.168.0.0/16这三个内网网段内。
 	CidrBlock *string `json:"CidrBlock,omitempty" name:"CidrBlock"`
 
 	// 是否开启组播。true: 开启, false: 不开启。
@@ -2179,6 +2378,77 @@ func (r *DeleteIp6TranslatorsResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type DeleteNatGatewayDestinationIpPortTranslationNatRuleRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关的ID，形如：`nat-df45454`。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+
+	// NAT网关的端口转换规则。
+	DestinationIpPortTranslationNatRules []*DestinationIpPortTranslationNatRule `json:"DestinationIpPortTranslationNatRules,omitempty" name:"DestinationIpPortTranslationNatRules" list`
+}
+
+func (r *DeleteNatGatewayDestinationIpPortTranslationNatRuleRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DeleteNatGatewayDestinationIpPortTranslationNatRuleRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DeleteNatGatewayDestinationIpPortTranslationNatRuleResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *DeleteNatGatewayDestinationIpPortTranslationNatRuleResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DeleteNatGatewayDestinationIpPortTranslationNatRuleResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DeleteNatGatewayRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关的ID，形如：`nat-df45454`。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+}
+
+func (r *DeleteNatGatewayRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DeleteNatGatewayRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DeleteNatGatewayResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *DeleteNatGatewayResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DeleteNatGatewayResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type DeleteNetworkInterfaceRequest struct {
 	*tchttp.BaseRequest
 
@@ -2736,7 +3006,7 @@ type DescribeAddressesRequest struct {
 	// <li> address-id - String - 是否必填：否 - （过滤条件）按照 EIP 的唯一 ID 过滤。EIP 唯一 ID 形如：eip-11112222。</li>
 	// <li> address-name - String - 是否必填：否 - （过滤条件）按照 EIP 名称过滤。不支持模糊过滤。</li>
 	// <li> address-ip - String - 是否必填：否 - （过滤条件）按照 EIP 的 IP 地址过滤。</li>
-	// <li> address-status - String - 是否必填：否 - （过滤条件）按照 EIP 的状态过滤。取值范围：[详见EIP状态列表](https://cloud.tencent.com/document/api/213/9452#eip_state)。</li>
+	// <li> address-status - String - 是否必填：否 - （过滤条件）按照 EIP 的状态过滤。状态包含：'CREATING'，'BINDING'，'BIND'，'UNBINDING'，'UNBIND'，'OFFLINING'，'BIND_ENI'。</li>
 	// <li> instance-id - String - 是否必填：否 - （过滤条件）按照 EIP 绑定的实例 ID 过滤。实例 ID 形如：ins-11112222。</li>
 	// <li> private-ip-address - String - 是否必填：否 - （过滤条件）按照 EIP 绑定的内网 IP 过滤。</li>
 	// <li> network-interface-id - String - 是否必填：否 - （过滤条件）按照 EIP 绑定的弹性网卡 ID 过滤。弹性网卡 ID 形如：eni-11112222。</li>
@@ -3037,6 +3307,8 @@ type DescribeCcnsRequest struct {
 	// <li>ccn-name - String - （过滤条件）CCN名称。</li>
 	// <li>ccn-description - String - （过滤条件）CCN描述。</li>
 	// <li>state - String - （过滤条件）实例状态， 'ISOLATED': 隔离中（欠费停服），'AVAILABLE'：运行中。</li>
+	// <li>tag-key - String -是否必填：否- （过滤条件）按照标签键进行过滤。</li>
+	// <li>tag:tag-key - String - 是否必填：否 - （过滤条件）按照标签键值对进行过滤。 tag-key使用具体的标签键进行替换。使用请参考示例：查询绑定了标签的CCN列表。</li>
 	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
 
 	// 偏移量
@@ -3648,6 +3920,155 @@ func (r *DescribeIp6TranslatorsResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type DescribeNatGatewayDestinationIpPortTranslationNatRulesRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关ID。
+	NatGatewayIds []*string `json:"NatGatewayIds,omitempty" name:"NatGatewayIds" list`
+
+	// 过滤条件:
+	// 参数不支持同时指定NatGatewayIds和Filters。
+	// <li> nat-gateway-id，NAT网关的ID，如`nat-0yi4hekt`</li>
+	// <li> vpc-id，私有网络VPC的ID，如`vpc-0yi4hekt`</li>
+	// <li> public-ip-address， 弹性IP，如`139.199.232.238`。</li>
+	// <li>public-port， 公网端口。</li>
+	// <li>private-ip-address， 内网IP，如`10.0.0.1`。</li>
+	// <li>private-port， 内网端口。</li>
+	// <li>description，规则描述。</li>
+	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
+
+	// 偏移量，默认为0。
+	Offset *uint64 `json:"Offset,omitempty" name:"Offset"`
+
+	// 返回数量，默认为20，最大值为100。
+	Limit *uint64 `json:"Limit,omitempty" name:"Limit"`
+}
+
+func (r *DescribeNatGatewayDestinationIpPortTranslationNatRulesRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeNatGatewayDestinationIpPortTranslationNatRulesRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DescribeNatGatewayDestinationIpPortTranslationNatRulesResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// NAT网关端口转发规则对象数组。
+		NatGatewayDestinationIpPortTranslationNatRuleSet []*NatGatewayDestinationIpPortTranslationNatRule `json:"NatGatewayDestinationIpPortTranslationNatRuleSet,omitempty" name:"NatGatewayDestinationIpPortTranslationNatRuleSet" list`
+
+		// 符合条件的NAT网关端口转发规则对象数目。
+		TotalCount *uint64 `json:"TotalCount,omitempty" name:"TotalCount"`
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *DescribeNatGatewayDestinationIpPortTranslationNatRulesResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeNatGatewayDestinationIpPortTranslationNatRulesResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DescribeNatGatewaysRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关统一 ID，形如：`nat-123xx454`。
+	NatGatewayIds []*string `json:"NatGatewayIds,omitempty" name:"NatGatewayIds" list`
+
+	// 过滤条件，参数不支持同时指定NatGatewayIds和Filters。
+	// <li>nat-gateway-id - String - （过滤条件）协议端口模板实例ID，形如：`nat-123xx454`。</li>
+	// <li>vpc-id - String - （过滤条件）私有网络 唯一ID，形如：`vpc-123xx454`。</li>
+	// <li>nat-gateway-name - String - （过滤条件）协议端口模板实例ID，形如：`test_nat`。</li>
+	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
+
+	// 偏移量，默认为0。
+	Offset *uint64 `json:"Offset,omitempty" name:"Offset"`
+
+	// 返回数量，默认为20，最大值为100。
+	Limit *uint64 `json:"Limit,omitempty" name:"Limit"`
+}
+
+func (r *DescribeNatGatewaysRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeNatGatewaysRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DescribeNatGatewaysResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// NAT网关对象数组。
+		NatGatewaySet []*NatGateway `json:"NatGatewaySet,omitempty" name:"NatGatewaySet" list`
+
+		// 符合条件的NAT网关对象个数。
+		TotalCount *uint64 `json:"TotalCount,omitempty" name:"TotalCount"`
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *DescribeNatGatewaysResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeNatGatewaysResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DescribeNetworkInterfaceLimitRequest struct {
+	*tchttp.BaseRequest
+
+	// 要查询的CVM实例ID
+	InstanceId *string `json:"InstanceId,omitempty" name:"InstanceId"`
+}
+
+func (r *DescribeNetworkInterfaceLimitRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeNetworkInterfaceLimitRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DescribeNetworkInterfaceLimitResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 弹性网卡配额
+		EniQuantity *int64 `json:"EniQuantity,omitempty" name:"EniQuantity"`
+
+		// 每个弹性网卡可以分配的ip配额
+		EniPrivateIpAddressQuantity *int64 `json:"EniPrivateIpAddressQuantity,omitempty" name:"EniPrivateIpAddressQuantity"`
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *DescribeNetworkInterfaceLimitResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeNetworkInterfaceLimitResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type DescribeNetworkInterfacesRequest struct {
 	*tchttp.BaseRequest
 
@@ -3662,6 +4083,9 @@ type DescribeNetworkInterfacesRequest struct {
 	// <li>groups.security-group-id - String - （过滤条件）绑定的安全组实例ID，例如：sg-f9ekbxeq。</li>
 	// <li>network-interface-name - String - （过滤条件）网卡实例名称。</li>
 	// <li>network-interface-description - String - （过滤条件）网卡实例描述。</li>
+	// <li>address-ip - String - （过滤条件）内网IPv4地址。</li>
+	// <li>tag-key - String -是否必填：否- （过滤条件）按照标签键进行过滤。使用请参考示例2</li>
+	// <li>tag:tag-key - String - 是否必填：否 - （过滤条件）按照标签键值对进行过滤。 tag-key使用具体的标签键进行替换。使用请参考示例3。</li>
 	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
 
 	// 偏移量，默认为0。
@@ -3755,6 +4179,8 @@ type DescribeRouteTablesRequest struct {
 	// <li>route-table-name - String - （过滤条件）路由表名称。</li>
 	// <li>vpc-id - String - （过滤条件）VPC实例ID，形如：vpc-f49l6u0z。</li>
 	// <li>association.main - String - （过滤条件）是否主路由表。</li>
+	// <li>tag-key - String -是否必填：否- （过滤条件）按照标签键进行过滤。</li>
+	// <li>tag:tag-key - String - 是否必填：否 - （过滤条件）按照标签键值对进行过滤。 tag-key使用具体的标签键进行替换。使用请参考示例2。</li>
 	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
 
 	// 偏移量。
@@ -3878,8 +4304,11 @@ type DescribeSecurityGroupsRequest struct {
 	SecurityGroupIds []*string `json:"SecurityGroupIds,omitempty" name:"SecurityGroupIds" list`
 
 	// 过滤条件，参数不支持同时指定SecurityGroupIds和Filters。
+	// <li>security-group-id - String - （过滤条件）安全组ID。</li>
 	// <li>project-id - Integer - （过滤条件）项目id。</li>
 	// <li>security-group-name - String - （过滤条件）安全组名称。</li>
+	// <li>tag-key - String -是否必填：否- （过滤条件）按照标签键进行过滤。使用请参考示例2。</li>
+	// <li>tag:tag-key - String - 是否必填：否 - （过滤条件）按照标签键值对进行过滤。 tag-key使用具体的标签键进行替换。使用请参考示例3。</li>
 	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
 
 	// 偏移量。
@@ -4032,6 +4461,8 @@ type DescribeSubnetsRequest struct {
 	// <li>is-remote-vpc-snat - Boolean - （过滤条件）是否为VPC SNAT地址池子网。</li>
 	// <li>subnet-name - String - （过滤条件）子网名称。</li>
 	// <li>zone - String - （过滤条件）可用区。</li>
+	// <li>tag-key - String -是否必填：否- （过滤条件）按照标签键进行过滤。</li>
+	// <li>tag:tag-key - String - 是否必填：否 - （过滤条件）按照标签键值对进行过滤。 tag-key使用具体的标签键进行替换。使用请参考示例2。</li>
 	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
 
 	// 偏移量
@@ -4074,6 +4505,49 @@ func (r *DescribeSubnetsResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type DescribeTaskResultRequest struct {
+	*tchttp.BaseRequest
+
+	// 异步任务ID
+	TaskId *uint64 `json:"TaskId,omitempty" name:"TaskId"`
+
+	// 计费订单号
+	DealName *string `json:"DealName,omitempty" name:"DealName"`
+}
+
+func (r *DescribeTaskResultRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeTaskResultRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DescribeTaskResultResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 任务ID
+		TaskId *uint64 `json:"TaskId,omitempty" name:"TaskId"`
+
+		// 执行结果，包括"SUCCESS", "FAILED", "RUNNING"
+		Result *string `json:"Result,omitempty" name:"Result"`
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *DescribeTaskResultResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DescribeTaskResultResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type DescribeVpcIpv6AddressesRequest struct {
 	*tchttp.BaseRequest
 
@@ -4174,6 +4648,8 @@ type DescribeVpcsRequest struct {
 	// <li>is-default - String - （过滤条件）是否默认VPC。</li>
 	// <li>vpc-id - String - （过滤条件）VPC实例ID形如：vpc-f49l6u0z。</li>
 	// <li>cidr-block - String - （过滤条件）vpc的cidr。</li>
+	// <li>tag-key - String -是否必填：否- （过滤条件）按照标签键进行过滤。</li>
+	// <li>tag:tag-key - String - 是否必填：否 - （过滤条件）按照标签键值对进行过滤。 tag-key使用具体的标签键进行替换。使用请参考示例2。</li>
 	Filters []*Filter `json:"Filters,omitempty" name:"Filters" list`
 
 	// 偏移量
@@ -4326,6 +4802,27 @@ func (r *DescribeVpnGatewaysResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type DestinationIpPortTranslationNatRule struct {
+
+	// 网络协议，可选值：`TCP`、`UDP`。
+	IpProtocol *string `json:"IpProtocol,omitempty" name:"IpProtocol"`
+
+	// 弹性IP。
+	PublicIpAddress *string `json:"PublicIpAddress,omitempty" name:"PublicIpAddress"`
+
+	// 公网端口。
+	PublicPort *uint64 `json:"PublicPort,omitempty" name:"PublicPort"`
+
+	// 内网地址。
+	PrivateIpAddress *string `json:"PrivateIpAddress,omitempty" name:"PrivateIpAddress"`
+
+	// 内网端口。
+	PrivatePort *uint64 `json:"PrivatePort,omitempty" name:"PrivatePort"`
+
+	// NAT网关转发规则描述。
+	Description *string `json:"Description,omitempty" name:"Description"`
+}
+
 type DetachCcnInstancesRequest struct {
 	*tchttp.BaseRequest
 
@@ -4480,6 +4977,9 @@ type DirectConnectGateway struct {
 
 	// 是否启用BGP。
 	EnableBGP *bool `json:"EnableBGP,omitempty" name:"EnableBGP"`
+
+	// 开启和关闭BGP的community属性。
+	EnableBGPCommunity *bool `json:"EnableBGPCommunity,omitempty" name:"EnableBGPCommunity"`
 }
 
 type DirectConnectGatewayCcnRoute struct {
@@ -4591,6 +5091,9 @@ type DisassociateAddressResponse struct {
 	*tchttp.BaseResponse
 	Response *struct {
 
+		// 异步任务TaskId。可以使用[DescribeTaskResult](https://cloud.tencent.com/document/api/215/36271)接口查询任务状态。
+		TaskId *string `json:"TaskId,omitempty" name:"TaskId"`
+
 		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
 		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
 	} `json:"Response"`
@@ -4605,6 +5108,43 @@ func (r *DisassociateAddressResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type DisassociateNatGatewayAddressRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关的ID，形如：`nat-df45454`。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+
+	// 绑定NAT网关的弹性IP数组。
+	PublicIpAddresses []*string `json:"PublicIpAddresses,omitempty" name:"PublicIpAddresses" list`
+}
+
+func (r *DisassociateNatGatewayAddressRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DisassociateNatGatewayAddressRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type DisassociateNatGatewayAddressResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *DisassociateNatGatewayAddressResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *DisassociateNatGatewayAddressResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type DownloadCustomerGatewayConfigurationRequest struct {
 	*tchttp.BaseRequest
 
@@ -5307,6 +5847,9 @@ type ModifyAddressAttributeRequest struct {
 
 	// 修改后的 EIP 名称。长度上限为20个字符。
 	AddressName *string `json:"AddressName,omitempty" name:"AddressName"`
+
+	// 设定EIP是否直通，"TRUE"表示直通，"FALSE"表示非直通。注意该参数仅对EIP直通功能可见的用户可以设定。
+	EipDirectConnection *string `json:"EipDirectConnection,omitempty" name:"EipDirectConnection"`
 }
 
 func (r *ModifyAddressAttributeRequest) ToJsonString() string {
@@ -5445,6 +5988,9 @@ type ModifyAddressesBandwidthResponse struct {
 	*tchttp.BaseResponse
 	Response *struct {
 
+		// 异步任务TaskId。可以使用[DescribeTaskResult](https://cloud.tencent.com/document/api/215/36271)接口查询任务状态。
+		TaskId *string `json:"TaskId,omitempty" name:"TaskId"`
+
 		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
 		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
 	} `json:"Response"`
@@ -5813,6 +6359,86 @@ func (r *ModifyIpv6AddressesAttributeResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type ModifyNatGatewayAttributeRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关的ID，形如：`nat-df45454`。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+
+	// NAT网关的名称，形如：`test_nat`。
+	NatGatewayName *string `json:"NatGatewayName,omitempty" name:"NatGatewayName"`
+
+	// NAT网关最大外网出带宽(单位:Mbps)。
+	InternetMaxBandwidthOut *uint64 `json:"InternetMaxBandwidthOut,omitempty" name:"InternetMaxBandwidthOut"`
+}
+
+func (r *ModifyNatGatewayAttributeRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *ModifyNatGatewayAttributeRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type ModifyNatGatewayAttributeResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *ModifyNatGatewayAttributeResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *ModifyNatGatewayAttributeResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type ModifyNatGatewayDestinationIpPortTranslationNatRuleRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关的ID，形如：`nat-df45454`。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+
+	// 源NAT网关的端口转换规则。
+	SourceNatRule *DestinationIpPortTranslationNatRule `json:"SourceNatRule,omitempty" name:"SourceNatRule"`
+
+	// 目的NAT网关的端口转换规则。
+	DestinationNatRule *DestinationIpPortTranslationNatRule `json:"DestinationNatRule,omitempty" name:"DestinationNatRule"`
+}
+
+func (r *ModifyNatGatewayDestinationIpPortTranslationNatRuleRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *ModifyNatGatewayDestinationIpPortTranslationNatRuleRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type ModifyNatGatewayDestinationIpPortTranslationNatRuleResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *ModifyNatGatewayDestinationIpPortTranslationNatRuleResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *ModifyNatGatewayDestinationIpPortTranslationNatRuleResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type ModifyNetworkInterfaceAttributeRequest struct {
 	*tchttp.BaseRequest
 
@@ -6262,6 +6888,89 @@ func (r *ModifyVpnGatewayAttributeResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type NatGateway struct {
+
+	// NAT网关的ID。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+
+	// NAT网关的名称。
+	NatGatewayName *string `json:"NatGatewayName,omitempty" name:"NatGatewayName"`
+
+	// NAT网关创建的时间。
+	CreatedTime *string `json:"CreatedTime,omitempty" name:"CreatedTime"`
+
+	// NAT网关的状态。
+	//  'PENDING'：生产中，'DELETING'：删除中，'AVAILABLE'：运行中，'UPDATING'：升级中，
+	// ‘FAILED’：失败。
+	State *string `json:"State,omitempty" name:"State"`
+
+	// 网关最大外网出带宽(单位:Mbps)。
+	InternetMaxBandwidthOut *uint64 `json:"InternetMaxBandwidthOut,omitempty" name:"InternetMaxBandwidthOut"`
+
+	// 网关并发连接上限。
+	MaxConcurrentConnection *uint64 `json:"MaxConcurrentConnection,omitempty" name:"MaxConcurrentConnection"`
+
+	// 绑定NAT网关的公网IP对象数组。
+	PublicIpAddressSet []*NatGatewayAddress `json:"PublicIpAddressSet,omitempty" name:"PublicIpAddressSet" list`
+
+	// NAT网关网络状态。“AVAILABLE”:运行中, “UNAVAILABLE”:不可用, “INSUFFICIENT”:欠费停服。
+	NetworkState *string `json:"NetworkState,omitempty" name:"NetworkState"`
+
+	// NAT网关的端口转发规则。
+	DestinationIpPortTranslationNatRuleSet []*DestinationIpPortTranslationNatRule `json:"DestinationIpPortTranslationNatRuleSet,omitempty" name:"DestinationIpPortTranslationNatRuleSet" list`
+
+	// VPC实例ID。
+	VpcId *string `json:"VpcId,omitempty" name:"VpcId"`
+
+	// NAT网关所在的可用区。
+	Zone *string `json:"Zone,omitempty" name:"Zone"`
+}
+
+type NatGatewayAddress struct {
+
+	// 弹性公网IP（EIP）的唯一 ID，形如：`eip-11112222`。
+	AddressId *string `json:"AddressId,omitempty" name:"AddressId"`
+
+	// 外网IP地址，形如：`123.121.34.33`。
+	PublicIpAddress *string `json:"PublicIpAddress,omitempty" name:"PublicIpAddress"`
+
+	// 资源封堵状态。true表示弹性ip处于封堵状态，false表示弹性ip处于未封堵状态。
+	IsBlocked *bool `json:"IsBlocked,omitempty" name:"IsBlocked"`
+}
+
+type NatGatewayDestinationIpPortTranslationNatRule struct {
+
+	// 网络协议，可选值：`TCP`、`UDP`。
+	IpProtocol *string `json:"IpProtocol,omitempty" name:"IpProtocol"`
+
+	// 弹性IP。
+	PublicIpAddress *string `json:"PublicIpAddress,omitempty" name:"PublicIpAddress"`
+
+	// 公网端口。
+	PublicPort *uint64 `json:"PublicPort,omitempty" name:"PublicPort"`
+
+	// 内网地址。
+	PrivateIpAddress *string `json:"PrivateIpAddress,omitempty" name:"PrivateIpAddress"`
+
+	// 内网端口。
+	PrivatePort *uint64 `json:"PrivatePort,omitempty" name:"PrivatePort"`
+
+	// NAT网关转发规则描述。
+	Description *string `json:"Description,omitempty" name:"Description"`
+
+	// NAT网关的ID。
+	// 注意：此字段可能返回 null，表示取不到有效值。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+
+	// 私有网络VPC的ID。
+	// 注意：此字段可能返回 null，表示取不到有效值。
+	VpcId *string `json:"VpcId,omitempty" name:"VpcId"`
+
+	// NAT网关转发规则创建时间。
+	// 注意：此字段可能返回 null，表示取不到有效值。
+	CreatedTime *string `json:"CreatedTime,omitempty" name:"CreatedTime"`
+}
+
 type NetworkInterface struct {
 
 	// 弹性网卡实例ID，例如：eni-f1xjkw1b。
@@ -6311,6 +7020,9 @@ type NetworkInterface struct {
 
 	// `IPv6`地址列表。
 	Ipv6AddressSet []*Ipv6Address `json:"Ipv6AddressSet,omitempty" name:"Ipv6AddressSet" list`
+
+	// 标签键值对。
+	TagSet []*Tag `json:"TagSet,omitempty" name:"TagSet" list`
 }
 
 type NetworkInterfaceAttachment struct {
@@ -6434,6 +7146,9 @@ type ReleaseAddressesResponse struct {
 	*tchttp.BaseResponse
 	Response *struct {
 
+		// 异步任务TaskId。可以使用[DescribeTaskResult](https://cloud.tencent.com/document/api/215/36271)接口查询任务状态。
+		TaskId *string `json:"TaskId,omitempty" name:"TaskId"`
+
 		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
 		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
 	} `json:"Response"`
@@ -6750,6 +7465,43 @@ func (r *ResetAttachCcnInstancesResponse) FromJsonString(s string) error {
     return json.Unmarshal([]byte(s), &r)
 }
 
+type ResetNatGatewayConnectionRequest struct {
+	*tchttp.BaseRequest
+
+	// NAT网关ID。
+	NatGatewayId *string `json:"NatGatewayId,omitempty" name:"NatGatewayId"`
+
+	// NAT网关并发连接上限，形如：1000000、3000000、10000000。
+	MaxConcurrentConnection *uint64 `json:"MaxConcurrentConnection,omitempty" name:"MaxConcurrentConnection"`
+}
+
+func (r *ResetNatGatewayConnectionRequest) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *ResetNatGatewayConnectionRequest) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
+type ResetNatGatewayConnectionResponse struct {
+	*tchttp.BaseResponse
+	Response *struct {
+
+		// 唯一请求 ID，每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
+		RequestId *string `json:"RequestId,omitempty" name:"RequestId"`
+	} `json:"Response"`
+}
+
+func (r *ResetNatGatewayConnectionResponse) ToJsonString() string {
+    b, _ := json.Marshal(r)
+    return string(b)
+}
+
+func (r *ResetNatGatewayConnectionResponse) FromJsonString(s string) error {
+    return json.Unmarshal([]byte(s), &r)
+}
+
 type ResetRoutesRequest struct {
 	*tchttp.BaseRequest
 
@@ -7021,6 +7773,9 @@ type SecurityGroupPolicy struct {
 	// 网段或IP(互斥)。
 	CidrBlock *string `json:"CidrBlock,omitempty" name:"CidrBlock"`
 
+	// 网段或IPv6(互斥)。
+	Ipv6CidrBlock *string `json:"Ipv6CidrBlock,omitempty" name:"Ipv6CidrBlock"`
+
 	// 安全组实例ID，例如：sg-ohuuioma。
 	SecurityGroupId *string `json:"SecurityGroupId,omitempty" name:"SecurityGroupId"`
 
@@ -7032,6 +7787,9 @@ type SecurityGroupPolicy struct {
 
 	// 安全组规则描述。
 	PolicyDescription *string `json:"PolicyDescription,omitempty" name:"PolicyDescription"`
+
+	// 安全组最近修改时间。
+	ModifyTime *string `json:"ModifyTime,omitempty" name:"ModifyTime"`
 }
 
 type SecurityGroupPolicySet struct {
@@ -7418,6 +8176,10 @@ type Vpc struct {
 
 	// 标签键值对
 	TagSet []*Tag `json:"TagSet,omitempty" name:"TagSet" list`
+
+	// 辅助CIDR
+	// 注意：此字段可能返回 null，表示取不到有效值。
+	AssistantCidrSet []*AssistantCidr `json:"AssistantCidrSet,omitempty" name:"AssistantCidrSet" list`
 }
 
 type VpcIpv6Address struct {
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 70d7a6c98..bcbddfcbb 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -475,7 +475,7 @@ github.com/stretchr/testify/assert
 github.com/stretchr/testify/require
 # github.com/temoto/robotstxt v1.1.1
 github.com/temoto/robotstxt
-# github.com/tencentcloud/tencentcloud-sdk-go v3.0.71+incompatible
+# github.com/tencentcloud/tencentcloud-sdk-go v3.0.94+incompatible
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/errors
 github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common/http
diff --git a/website/source/docs/builders/tencentcloud-cvm.html.md b/website/source/docs/builders/tencentcloud-cvm.html.md
index 72405ba90..1621fb5d9 100644
--- a/website/source/docs/builders/tencentcloud-cvm.html.md
+++ b/website/source/docs/builders/tencentcloud-cvm.html.md
@@ -18,8 +18,7 @@ customized images based on an existing base images.
 
 The following configuration options are available for building Tencentcloud images.
 In addition to the options listed here,
-a [communicator](/docs/templates/communicator.html) can be configured for this
-builder.
+a [communicator](/docs/templates/communicator.html) can be configured for this builder.
 
 ### Required:
 
@@ -31,15 +30,15 @@ builder.
 
 -   `region` (string) - The region where your cvm will be launch. You should
     reference [Region and Zone](https://intl.cloud.tencent.com/document/product/213/6091)
-     for parameter taking.
+    for parameter taking.
 
 -   `zone` (string) - The zone where your cvm will be launch. You should
     reference [Region and Zone](https://intl.cloud.tencent.com/document/product/213/6091)
-     for parameter taking.
+    for parameter taking.
 
 -   `instance_type` (string) - The instance type your cvm will be launched by.
     You should reference [Instace Type](https://intl.cloud.tencent.com/document/product/213/11518)
-     for parameter taking.
+    for parameter taking.
 
 -   `source_image_id` (string) - The base image id of Image you want to create
     your customized image from.
@@ -50,25 +49,20 @@ builder.
 
 ### Optional:
 
--   `force_poweroff` (boolean) - Whether to force power off cvm when create image.
-    Default value is `false`.
+-   `force_poweroff` (boolean) - Indicates whether to perform a forced shutdown to
+    create an image when soft shutdown fails. Default value is `false`.
 
-    Your cvm will try to shutdown normally; if shutdown failed and `force_poweroff`
-    set, your cvm will be powered off, otherwise task will fail.
+-   `image_description` (string) - Image description. It should no more than 60 characters.
 
--   `image_description` (string) - Image description.
-
--   `reboot` (boolean) - Whether shutdown cvm to create Image. Default value is
-    `false`.
-
-    If `reboot` is not set and cvm is running, create image task will fail.
+-   `reboot` (boolean, **deprecated**) - Whether shutdown cvm to create Image.
+    Please refer to parameter `force_poweroff`.
 
 -   `sysprep` (boolean) - Whether enable Sysprep during creating windows image.
 
--   `image_copy_regions` (array of strings) - regions that will be copied to after
+-   `image_copy_regions` (array of strings) - Regions that will be copied to after
     your image created.
 
--   `image_share_accounts` (array of strings) - accounts that will be shared to
+-   `image_share_accounts` (array of strings) - Accounts that will be shared to
     after your image created.
 
 -   `skip_region_validation` (boolean) - Do not check region and zone when validate.
@@ -78,6 +72,9 @@ builder.
 
     If not set, you could access your cvm from the same vpc.
 
+-   `internet_max_bandwidth_out` (number) - Max bandwidth out your cvm will be launched by(in MB).
+    values can be set between 1 ~ 100.
+
 -   `instance_name` (string) - Instance name.
 
 -   `disk_type` (string) - Root disk type your cvm will be launched by. you could
@@ -103,7 +100,7 @@ builder.
 -   `vpc_name` (string) - Specify vpc name you will create. if `vpc_id` is not set, packer will
     create a vpc for you named this parameter.
 
--   `cidr_block` (boolean) - Specify cider block of the vpc you will create if `vpc_id` not set
+-   `cidr_block` (boolean) - Specify cider block of the vpc you will create if `vpc_id` is not set.
 
 -   `subnet_id` (string) - Specify subnet your cvm will be launched by.
 
@@ -111,14 +108,11 @@ builder.
     create a subnet for you named this parameter.
 
 -   `subnect_cidr_block` (boolean) - Specify cider block of the subnet you will create if
-    `subnet_id` not set
-
--   `internet_max_bandwidth_out` (number) - Max bandwidth out your cvm will be launched by(in MB).
-    values can be set between 1 ~ 100.
+    `subnet_id` is not set.
 
 -   `security_group_id` (string) - Specify security group your cvm will be launched by.
 
--   `security_group_name` (string) - Specify security name you will create if `security_group_id` not set.
+-   `security_group_name` (string) - Specify security name you will create if `security_group_id` is not set.
 
 -   `user_data` (string) - userdata.
 
@@ -139,29 +133,34 @@ Here is a basic example for Tencentcloud.
     "secret_id": "{{env `TENCENTCLOUD_ACCESS_KEY`}}",
     "secret_key": "{{env `TENCENTCLOUD_SECRET_KEY`}}"
   },
-  "builders": [{
-    "type": "tencentcloud-cvm",
-    "secret_id": "{{user `secret_id`}}",
-    "secret_key": "{{user `secret_key`}}",
-    "region": "ap-guangzhou",
-    "zone": "ap-guangzhou-3",
-    "instance_type": "S3.SMALL1",
-    "source_image_id": "img-oikl1tzv",
-    "ssh_username" : "root",
-    "image_name": "packerTest2",
-    "packer_debug": true,
-    "associate_public_ip_address": true,
-    "run_tags": {
-      "good": "luck"
+  "builders": [
+    {
+      "type": "tencentcloud-cvm",
+      "secret_id": "{{user `secret_id`}}",
+      "secret_key": "{{user `secret_key`}}",
+      "region": "ap-guangzhou",
+      "zone": "ap-guangzhou-4",
+      "instance_type": "S4.SMALL1",
+      "source_image_id": "img-oikl1tzv",
+      "ssh_username": "root",
+      "image_name": "PackerTest",
+      "disk_type": "CLOUD_PREMIUM",
+      "packer_debug": true,
+      "associate_public_ip_address": true,
+      "run_tags": {
+        "good": "luck"
+      }
     }
-  }],
-  "provisioners": [{
-    "type": "shell",
-    "inline": [
-      "sleep 30",
-      "yum install redis.x86_64 -y"
-    ]
-  }]
+  ],
+  "provisioners": [
+    {
+      "type": "shell",
+      "inline": [
+        "sleep 30",
+        "yum install redis.x86_64 -y"
+      ]
+    }
+  ]
 }
 ```
 
diff --git a/website/source/partials/builder/tencentcloud/cvm/_TencentCloudRunConfig-not-required.html.md b/website/source/partials/builder/tencentcloud/cvm/_TencentCloudRunConfig-not-required.html.md
index 41ed4918f..3a6953e58 100644
--- a/website/source/partials/builder/tencentcloud/cvm/_TencentCloudRunConfig-not-required.html.md
+++ b/website/source/partials/builder/tencentcloud/cvm/_TencentCloudRunConfig-not-required.html.md
@@ -42,7 +42,7 @@
 -   `internet_max_bandwidth_out` (int64) - Max bandwidth out your cvm will be launched by(in MB).
     values can be set between 1 ~ 100.
     
--   `security_group_id` (string) - Specify security group your cvm will be launched by.
+-   `security_group_id` (string) - Specify securitygroup your cvm will be launched by.
     
 -   `security_group_name` (string) - Specify security name you will create if security_group_id not set.
     

From de360df259376d5d7966369a67e32c4ed5a6f106 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Mon, 21 Oct 2019 16:04:34 -0700
Subject: [PATCH 150/155] update website to hopefully make community builders
 and provisioners easier to find

---
 website/source/community-plugins.html.md      | 10 ++++----
 ...ls.html.md => community-tools.html.md.erb} | 23 ++-----------------
 .../builders/community-supported.html.md.erb  | 16 +++++++++++++
 .../community-supported.html.md.erb           | 16 +++++++++++++
 website/source/layouts/community.erb          |  2 +-
 website/source/layouts/docs.erb               |  6 +++++
 .../builders/_community_builders.html.md      | 11 +++++++++
 .../_community_provisioners.html.md           |  9 ++++++++
 8 files changed, 67 insertions(+), 26 deletions(-)
 rename website/source/{community-tools.html.md => community-tools.html.md.erb} (77%)
 create mode 100644 website/source/docs/builders/community-supported.html.md.erb
 create mode 100644 website/source/docs/provisioners/community-supported.html.md.erb
 create mode 100644 website/source/partials/builders/_community_builders.html.md
 create mode 100644 website/source/partials/provisioners/_community_provisioners.html.md

diff --git a/website/source/community-plugins.html.md b/website/source/community-plugins.html.md
index 537cdc3ca..e85778870 100644
--- a/website/source/community-plugins.html.md
+++ b/website/source/community-plugins.html.md
@@ -1,17 +1,19 @@
 ---
 layout: "community"
-page_title: "Community Maintained Plugins"
-sidebar_current: "community-plugins"
+page_title: "Community vs HashiCorp Maintained Plugins"
+sidebar_current: "community-or-hashicorp-plugins"
 description: |-
   Packer maintains these core plugins.
 ---
 
-# Community Maintained Plugins
+# HashiCorp Maintained Plugins
 
 The following plugins (i.e. Builders, Provisioners, and Post-Processors) are
 maintained by HashiCorp. Any plugins not on this list are maintained by the
 community, and not actively contributed to by HashiCorp, although they are
-still distributed with Packer.
+still distributed with Packer. If you are interested in seeing features or
+bugfixes to these plugins, please consider making a pull request, or asking the
+HashiCorp maintainters for advice on how to get started contributing.
 
 ## Builders
 
diff --git a/website/source/community-tools.html.md b/website/source/community-tools.html.md.erb
similarity index 77%
rename from website/source/community-tools.html.md
rename to website/source/community-tools.html.md.erb
index 1832281a2..31cee54eb 100644
--- a/website/source/community-tools.html.md
+++ b/website/source/community-tools.html.md.erb
@@ -27,28 +27,9 @@ If you have built a plugin and would like to add it to this community list,
 please make a pull request to the website so that we can document your
 contribution here!
 
-### Community Builders
+<%= partial "partials/builders/community_builders" %>
 
-- [ARM builder](https://github.com/solo-io/packer-builder-arm-image) - A builder
-  for creating ARM images
-
-- [vSphere builder](https://github.com/jetbrains-infra/packer-builder-vsphere) -
-  A builder for interacting directly with the vSphere API rather than the esx
-  host directly.
-
-- [Vultr builder](https://github.com/vultr/packer-builder-vultr) - A builder
-  for creating [Vultr](https://www.vultr.com/) snapshots.
-
-
-### Community Provisioners
-
-- [Comment Provisioner](https://github.com/SwampDragons/packer-provisioner-comment) -
-  Example provisioner that allows you to annotate your build with bubble-text
-  comments.
-
-- [Windows Update provisioner](https://github.com/rgl/packer-provisioner-windows-update) -
-  A provisioner for gracefully handling windows updates and the reboots they
-  cause.
+<%= partial "partials/provisioners/community_provisioners" %>
 
 ## Templates
 
diff --git a/website/source/docs/builders/community-supported.html.md.erb b/website/source/docs/builders/community-supported.html.md.erb
new file mode 100644
index 000000000..7c8c0ea44
--- /dev/null
+++ b/website/source/docs/builders/community-supported.html.md.erb
@@ -0,0 +1,16 @@
+---
+description: |
+    Community-maintained builders are not part of the core Packer binary, but
+    can run alongside Packer with minimal extra effort.
+layout: docs
+page_title: 'Community - Builders'
+sidebar_current: 'docs-builders-community'
+---
+
+# Community Builders
+
+The following builders are developed and maintained by various members of the
+Packer community, not by HashiCorp. For more information on how to use community
+builders, see our docs on [extending Packer](/docs/extending/index.html).
+
+<%= partial "partials/builders/community_builders" %>
\ No newline at end of file
diff --git a/website/source/docs/provisioners/community-supported.html.md.erb b/website/source/docs/provisioners/community-supported.html.md.erb
new file mode 100644
index 000000000..438151cb2
--- /dev/null
+++ b/website/source/docs/provisioners/community-supported.html.md.erb
@@ -0,0 +1,16 @@
+---
+description: |
+    Community-maintained provisioners are not part of the core Packer binary, but
+    can run alongside Packer with minimal extra effort.
+layout: docs
+page_title: 'Community - Provisioners'
+sidebar_current: 'docs-provisioners-community'
+---
+
+# Community Provisioners
+
+The following provisioners are developed and maintained by various members of the
+Packer community, not by HashiCorp. For more information on how to use community
+provisioners, see our docs on [extending Packer](/docs/extending/index.html).
+
+<%= partial "partials/provisioners/community_provisioners" %>
\ No newline at end of file
diff --git a/website/source/layouts/community.erb b/website/source/layouts/community.erb
index a5ab417c3..a9dbd140b 100644
--- a/website/source/layouts/community.erb
+++ b/website/source/layouts/community.erb
@@ -8,7 +8,7 @@
         <li<%= sidebar_current("community-tools") %>>
           <a href="/community-tools.html">Community Tools</a>
         </li>
-        <li<%= sidebar_current("community-plugins") %>>
+        <li<%= sidebar_current("community-or-hashicorp-plugins") %>>
           <a href="/community-plugins.html">Community Maintained Plugins</a>
         </li>
       </ul>
diff --git a/website/source/layouts/docs.erb b/website/source/layouts/docs.erb
index 878c6653a..cbce9c085 100644
--- a/website/source/layouts/docs.erb
+++ b/website/source/layouts/docs.erb
@@ -252,6 +252,9 @@
           <li<%= sidebar_current("docs-builders-custom") %>>
             <a href="/docs/builders/custom.html">Custom</a>
           </li>
+          <li<%= sidebar_current("docs-builders-community") %>>
+            <a href="/docs/builders/community-supported.html">Community-Supported</a>
+          </li>
         </ul>
       </li>
       <li<%= sidebar_current("docs-provisioners")%>>
@@ -308,6 +311,9 @@
           <li<%= sidebar_current("docs-provisioners-custom")%>>
             <a href="/docs/provisioners/custom.html">Custom</a>
           </li>
+          <li<%= sidebar_current("docs-provisioners-community") %>>
+            <a href="/docs/provisioners/community-supported.html">Community-Supported</a>
+          </li>
         </ul>
       </li>
       <li<%= sidebar_current("docs-post-processors") %>>
diff --git a/website/source/partials/builders/_community_builders.html.md b/website/source/partials/builders/_community_builders.html.md
new file mode 100644
index 000000000..be856af18
--- /dev/null
+++ b/website/source/partials/builders/_community_builders.html.md
@@ -0,0 +1,11 @@
+### Community Builders
+
+- [ARM builder](https://github.com/solo-io/packer-builder-arm-image) - A builder
+  for creating ARM images
+
+- [vSphere builder](https://github.com/jetbrains-infra/packer-builder-vsphere) -
+  A builder for interacting directly with the vSphere API rather than the esx
+  host directly.
+
+- [Vultr builder](https://github.com/vultr/packer-builder-vultr) - A builder
+  for creating [Vultr](https://www.vultr.com/) snapshots.
\ No newline at end of file
diff --git a/website/source/partials/provisioners/_community_provisioners.html.md b/website/source/partials/provisioners/_community_provisioners.html.md
new file mode 100644
index 000000000..e0cb7c84d
--- /dev/null
+++ b/website/source/partials/provisioners/_community_provisioners.html.md
@@ -0,0 +1,9 @@
+### Community Provisioners
+
+- [Comment Provisioner](https://github.com/SwampDragons/packer-provisioner-comment) -
+  Example provisioner that allows you to annotate your build with bubble-text
+  comments.
+
+- [Windows Update provisioner](https://github.com/rgl/packer-provisioner-windows-update) -
+  A provisioner for gracefully handling windows updates and the reboots they
+  cause.
\ No newline at end of file

From 00ebf690c2b543b0a47c83b037dc0fc0a33bdd27 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Mon, 21 Oct 2019 16:19:46 -0700
Subject: [PATCH 151/155] update changelog

---
 CHANGELOG.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9657e7047..3b4f5cc00 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,19 +3,29 @@
 ### IMPROVEMENTS:
 * builder/azure-arm: Allow specification of polling duration [GH-8226]
 * builder/azure-chroot: Add Azure chroot builder [GH-8185]
+* builder/azure: Deploy NSG if list of IP addresses is provided in config
+    [GH-8203]
 * builder/oracle-oci: Support defined tags for oci builder [GH-8172]
 * builder/proxmos: Add ability to select CPU type [GH-8201]
 * builder/proxmox: Add support for SCSI controller selection [GH-8199]
+* builder/tencent: Add retry on remote api call [GH-8250]
 * communicator/winrm: Prevent busy loop while waiting for WinRM connection
     [GH-8213]
 * core: Add strftime function in templates [GH-8208]
 
 ### BUG FIXES:
+* builder/amazon: Fix region copy for non-ebs amazon builders [GH-8212]
 * builder/amazon: Fix spot instance bug where builder would fail if one
     availability zone could not support the requested spot instance type, even
     if another AZ could do so. [GH-8184]
+* builder/azure: Fix build failure after a retry config generation error.
+    [GH-8209]
 * builder/docker: Use a unique temp dir for each build to prevent concurrent
     builds from stomping on each other [GH-8192]
+* builder/hyperv: Improve filter for determining which files to compact
+    [GH-8248]
+* builder/hyperv: Use first adapter, rather than failing, when multiple
+    adapters are attached to host OS's VM switch [GH-8234]
 * builder/openstack: Warn instead of failing on terminate if instance is
     already shut down [GH-8176]
 * post-processor/digitalocean-import: Fix panic when 'image_regions' not set

From ec1d70dc44ca8ac6b12fa9ef8aa1a43df1653b22 Mon Sep 17 00:00:00 2001
From: Bernard Baltrusaitis <bernard@runawaylover.info>
Date: Tue, 22 Oct 2019 21:40:18 +1100
Subject: [PATCH 152/155] adding required changes

---
 .../common/step_run_spot_instance_test.go     | 14 +++++++++++
 builder/amazon/ebssurrogate/builder.go        |  8 +++++++
 website/source/docs/builders/amazon.html.md   | 24 +++++++++++++++++++
 3 files changed, 46 insertions(+)

diff --git a/builder/amazon/common/step_run_spot_instance_test.go b/builder/amazon/common/step_run_spot_instance_test.go
index 1d0f28460..e39e05db9 100644
--- a/builder/amazon/common/step_run_spot_instance_test.go
+++ b/builder/amazon/common/step_run_spot_instance_test.go
@@ -2,6 +2,7 @@ package common
 
 import (
 	"bytes"
+	"fmt"
 	"testing"
 	"time"
 
@@ -125,6 +126,10 @@ func TestCreateTemplateData(t *testing.T) {
 		t.Fatalf("Template should have contained a networkInterface object: recieved %#v", template.NetworkInterfaces)
 	}
 
+	if *template.IamInstanceProfile.Name != state.Get("iamInstanceProfile") {
+		t.Fatalf("Template should have contained a InstanceProfile name: recieved %#v", template.IamInstanceProfile.Name)
+	}
+
 	// Rerun, this time testing that we set security group IDs
 	state.Put("subnet_id", "")
 	template = stepRunSpotInstance.CreateTemplateData(aws.String("userdata"), "az", state,
@@ -132,4 +137,13 @@ func TestCreateTemplateData(t *testing.T) {
 	if template.NetworkInterfaces != nil {
 		t.Fatalf("Template shouldn't contain network interfaces object if subnet_id is unset.")
 	}
+
+	// Rerun, this time testing that instance doesn't have instance profile is iamInstanceProfile is unset
+	state.Put("iamInstanceProfile", "")
+	template = stepRunSpotInstance.CreateTemplateData(aws.String("userdata"), "az", state,
+		&ec2.LaunchTemplateInstanceMarketOptionsRequest{})
+	fmt.Println(template.IamInstanceProfile)
+	if *template.IamInstanceProfile.Name != "" {
+		t.Fatalf("Template shouldn't contain instance profile if iamInstanceProfile is unset.")
+	}
 }
diff --git a/builder/amazon/ebssurrogate/builder.go b/builder/amazon/ebssurrogate/builder.go
index 7c7ce4b48..ce31e0d1d 100644
--- a/builder/amazon/ebssurrogate/builder.go
+++ b/builder/amazon/ebssurrogate/builder.go
@@ -8,6 +8,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/aws/aws-sdk-go/service/iam"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
 	awscommon "github.com/hashicorp/packer/builder/amazon/common"
@@ -164,7 +165,9 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	if err != nil {
 		return nil, err
 	}
+
 	ec2conn := ec2.New(session)
+	iam := iam.New(session)
 
 	// Setup the state bag and initial state for the steps
 	state := new(multistep.BasicStateBag)
@@ -172,6 +175,7 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 	state.Put("access_config", &b.config.AccessConfig)
 	state.Put("ami_config", &b.config.AMIConfig)
 	state.Put("ec2", ec2conn)
+	state.Put("iam", iam)
 	state.Put("awsSession", session)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
@@ -256,6 +260,10 @@ func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (pack
 			CommConfig:             &b.config.RunConfig.Comm,
 			TemporarySGSourceCidrs: b.config.TemporarySGSourceCidrs,
 		},
+		&awscommon.StepIamInstanceProfile{
+			IamInstanceProfile:                        b.config.IamInstanceProfile,
+			TemporaryIamInstanceProfilePolicyDocument: b.config.TemporaryIamInstanceProfilePolicyDocument,
+		},
 		&awscommon.StepCleanupVolumes{
 			LaunchMappings: b.config.LaunchMappings.Common(),
 		},
diff --git a/website/source/docs/builders/amazon.html.md b/website/source/docs/builders/amazon.html.md
index 0cfa0d98b..e29b0be0e 100644
--- a/website/source/docs/builders/amazon.html.md
+++ b/website/source/docs/builders/amazon.html.md
@@ -209,6 +209,30 @@ work, but specifics will depend on your use-case.
 }
 ```
 
+In case when you're creating a temporary instance profile you will require to have following
+IAM policies.
+
+``` json
+{
+    "Sid": "PackerIAMCreateRole",
+    "Effect": "Allow",
+    "Action": [
+        "iam:PassRole",
+        "iam:CreateInstanceProfile",
+        "iam:DeleteInstanceProfile",
+        "iam:GetRole",
+        "iam:GetInstanceProfile",
+        "iam:DeleteRolePolicy",
+        "iam:RemoveRoleFromInstanceProfile",
+        "iam:CreateRole",
+        "iam:DeleteRole",
+        "iam:PutRolePolicy",
+        "iam:AddRoleToInstanceProfile"
+    ],
+    "Resource": "*"
+}
+```
+
 ### Checking that system time is current
 
 Amazon uses the current time as part of the [request signing

From d3385032e9054f102e7423fea7bd88a72c33bed2 Mon Sep 17 00:00:00 2001
From: Shantanu Gadgil <shantanugadgil@users.noreply.github.com>
Date: Tue, 22 Oct 2019 19:20:14 +0530
Subject: [PATCH 153/155] proxmos -> proxmox

proxmos -> proxmox
---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b4f5cc00..4001c8465 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,7 @@
 * builder/azure: Deploy NSG if list of IP addresses is provided in config
     [GH-8203]
 * builder/oracle-oci: Support defined tags for oci builder [GH-8172]
-* builder/proxmos: Add ability to select CPU type [GH-8201]
+* builder/proxmox: Add ability to select CPU type [GH-8201]
 * builder/proxmox: Add support for SCSI controller selection [GH-8199]
 * builder/tencent: Add retry on remote api call [GH-8250]
 * communicator/winrm: Prevent busy loop while waiting for WinRM connection

From 5301f4613dab5337f450cb289661ef8a57de2979 Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Tue, 22 Oct 2019 09:54:33 -0700
Subject: [PATCH 154/155] update vagrant docs to explain that the builder and
 postprocessor are mutually exclusive

---
 website/source/docs/builders/vagrant.html.md        | 6 ++++++
 website/source/docs/post-processors/vagrant.html.md | 5 +++++
 2 files changed, 11 insertions(+)

diff --git a/website/source/docs/builders/vagrant.html.md b/website/source/docs/builders/vagrant.html.md
index 18d67a210..2f890548b 100644
--- a/website/source/docs/builders/vagrant.html.md
+++ b/website/source/docs/builders/vagrant.html.md
@@ -30,6 +30,12 @@ by setting the `skip package` option. You can also change the behavior so that
 rather than initializing a new Vagrant workspace, you use an already defined
 one, by using `global_id` instead of `source_box`.
 
+Please note that if you are using the Vagrant builder, then the Vagrant
+post-processor is unnecesary because the output of the Vagrant builder is
+already a Vagrant box; using that post-processor with the Vagrant builder will
+cause your build to fail. Similarly, since Vagrant boxes are already compressed,
+the Compress post-processor will not work with this builder.
+
 ## Configuration Reference
 ### Required:
 
diff --git a/website/source/docs/post-processors/vagrant.html.md b/website/source/docs/post-processors/vagrant.html.md
index d9168cfce..862f20017 100644
--- a/website/source/docs/post-processors/vagrant.html.md
+++ b/website/source/docs/post-processors/vagrant.html.md
@@ -45,6 +45,11 @@ providers.
 post-processor doesn't support creating boxes for a provider you care about,
 please help by contributing to Packer and adding support for it.
 
+Please note that if you are using the Vagrant builder, then the Vagrant
+post-processor is unnecesary because the output of the Vagrant builder is
+already a Vagrant box; using this post-processor with the Vagrant builder will
+cause your build to fail.
+
 ## Configuration
 
 The simplest way to use the post-processor is to just enable it. No

From 8ac97de8b248397c355f8449569c016e14a752cb Mon Sep 17 00:00:00 2001
From: Megan Marsh <megan@hashicorp.com>
Date: Tue, 22 Oct 2019 12:11:27 -0700
Subject: [PATCH 155/155] remove vnc config options from virtualbox docs;
 virtualbox does not implement the vncconfig struct

---
 website/source/docs/builders/virtualbox-iso.html.md.erb | 2 --
 website/source/docs/builders/virtualbox-ovf.html.md.erb | 2 --
 2 files changed, 4 deletions(-)

diff --git a/website/source/docs/builders/virtualbox-iso.html.md.erb b/website/source/docs/builders/virtualbox-iso.html.md.erb
index d8dec477c..127f54773 100644
--- a/website/source/docs/builders/virtualbox-iso.html.md.erb
+++ b/website/source/docs/builders/virtualbox-iso.html.md.erb
@@ -149,7 +149,6 @@ necessary for this build to succeed and can be found further down the page.
 ### Boot Configuration
 
 <%= partial "partials/common/bootcommand/BootConfig" %>
-<%= partial "partials/common/bootcommand/VNCConfig" %>
 
 The boot command is sent to the VM through the `VBoxManage` utility in as few
 invocations as possible. We send each character in groups of 25, with a default
@@ -171,7 +170,6 @@ contention. If you notice missing keys, you can tune this delay by specifying
 
 #### Optional:
 
-<%= partial "partials/common/bootcommand/VNCConfig-not-required" %>
 <%= partial "partials/common/bootcommand/BootConfig-not-required" %>
 
 <%= partial "partials/builders/boot-command" %>
diff --git a/website/source/docs/builders/virtualbox-ovf.html.md.erb b/website/source/docs/builders/virtualbox-ovf.html.md.erb
index af0a7432d..8847f994a 100644
--- a/website/source/docs/builders/virtualbox-ovf.html.md.erb
+++ b/website/source/docs/builders/virtualbox-ovf.html.md.erb
@@ -135,7 +135,6 @@ necessary for this build to succeed and can be found further down the page.
 ### Boot Configuration
 
 <%= partial "partials/common/bootcommand/BootConfig" %>
-<%= partial "partials/common/bootcommand/VNCConfig" %>
 
 The boot command is sent to the VM through the `VBoxManage` utility in as few
 invocations as possible. We send each character in groups of 25, with a default
@@ -157,7 +156,6 @@ contention. If you notice missing keys, you can tune this delay by specifying
 
 #### Optional:
 
-<%= partial "partials/common/bootcommand/VNCConfig-not-required" %>
 <%= partial "partials/common/bootcommand/BootConfig-not-required" %>
 
 <%= partial "partials/builders/boot-command" %>